personal
APIs to manage accounts and private keys in the node.
The namespace personal
manages private keys in the key store.
personal_importRawKey
Imports the given unencrypted private key (hex string without leading '0x') or a Klaytn wallet key into the key store, encrypting it with the passphrase.
Returns the address of the imported account.
Console
personal.importRawKey(keydata, passphrase)
RPC
{"method": "personal_importRawKey", "params": [keydata, passphrase]}
Parameters
passphrase
string
The pass phrase for encryption.
Return Value
address
string
The address of the imported account.
Example
Console
HTTP RPC
personal_listAccounts
Returns all the Klaytn account addresses of all keys in the key store.
Console
personal.listAccounts
RPC
{"method": "personal_listAccounts", "params": []}
Parameters
None
Return Value
string
The list of all the Klaytn account addresses
None
Example
Console
HTTP RPC
personal_listWallets
Returns a list of wallets this node manages.
Console
personal.listWallets
RPC
{"method": "personal_listWallets", "params": []}
Parameters
None
Return Value
URL
string
Wallet url
Status
string
Locking status
Failure
string
Error condition
Accounts
string
The list of account addresses.
Example
Console
HTTP RPC
personal_openWallet
Initiates a hardware wallet opening procedure, establishing a USB connection and attempting to authenticate via the provided passphrase.
NOTE: The method may return an extra challenge requiring a second open (e.g., the Trezor PIN matrix challenge).
Console
personal.openWallet(url, passhrase)
RPC
{"method": "personal_openWallet", "params": [url, passphrase]}
Parameters
URL
string
Wallet url
Passphrase
string
passphrase for wallet
Return Value
Error
error
Error condition
Example
Console
HTTP RPC
personal_deriveAccount
Requests a HD wallet to derive a new account, optionally pinning it for later reuse.
Console
personal.deriveAccount(url, path, pin)
RPC
{"method": "personal_deriveAccount", "params": [url, path, pin]}
Parameters
URL
string
Wallet url
path
string
derivation path
pin
boolean
optionally pinning
Return Value
Account
string
The address of the new account.
Error
error
Error condition
Example
Console
HTTP RPC
personal_newAccount
Generates a new private key and stores it in the key store directory. The key file is encrypted with the given passphrase. Returns the address of the new account.
At the Klaytn console, newAccount
will prompt for a passphrase when it is not supplied as the argument.
Console
personal.newAccount(passphrase)
RPC
{"method": "personal_newAccount", "params": [passphrase]}
Parameters
passphrase
string
(optional) the pass phrase used for encryption.
Return Value
string
The address of the new account.
Example
Console
The passphrase can also be supplied as a string.
HTTP RPC
personal_lockAccount
Removes the private key with a given address from memory. The account can no longer be used to send transactions.
Console
personal.lockAccount(address)
RPC
{"method": "personal_lockAccount", "params": [address]}
Parameters
address
string
The account address to lock.
Return Value
bool
true
if the account was successfully locked, false
otherwise.
Example
Console
HTTP RPC
personal_unlockAccount
Decrypts the key with the given address from the key store.
Both passphrase and unlock duration are optional when using the JavaScript console. If the passphrase is not supplied as an argument, the console will prompt for the passphrase interactively.
The unencrypted key will be held in memory until the unlock duration expires. If the unlock duration defaults to 300 seconds. An explicit duration of zero seconds unlocks the key until the Klaytn local node exits.
The account can be used with klay_sign
and klay_sendTransaction
while it is unlocked.
Console
personal.unlockAccount(address, passphrase, duration)
RPC
{"method": "personal_unlockAccount", "params": [address, passphrase, duration]}
Parameters
address
string
The account address to unlock.
passphrase
string
the passphrase used for the encryption.
duration
int
(optional) the unlock duration (default to 300 seconds).
Return Value
bool
true
if unlocked, false
otherwise
Example
Console
Supplying the passphrase and unlock duration as arguments:
If you want to type in the passphrase and still override the default unlock duration, pass null
as the passphrase.
HTTP RPC
personal_replaceRawKey
Replaces the encrypted key file in the key store with the given unencrypted private key (hex string without leading '0x') or a Klaytn wallet key, encrypting it with the new passphrase. It also receives the old passphrase to decrypt the old private key before replacement. If it is failed to decrypt, or can not find the matching account, it throws an error.
Returns the address of the replaced account if successful.
Console
personal.replaceRawKey(keydata, oldPassphrase, newPassphrase)
RPC
{"method": "personal_replaceRawKey", "params": [keydata, oldPassphrase, newPassphrase]}
Parameters
oldPassphrase
string
The passphrase to decrypt the old private key.
newPassphrase
string
The passphrase to encrypt the new private key.
Return Value
address
string
The address of the replaced account.
Example
Console
HTTP RPC
personal_sendAccountUpdate
Validates the given passphrase and submits a TxTypeAccountUpdate transaction. The transaction object must have fields from
and key
. Other fields such as gas
, gasPrice
, and nonce
are se internally if unspecified. If the passphrase is able to decrypt the private key belonging to tx.from
and the transaction is verified, the transaction is signed and submitted onto the network. The account is not unlocked globally in the node and cannot be used in other RPC calls.
Console
personal.sendAccountUpdate(tx, passphrase)
RPC
{"method": "personal_sendAccountUpdate", "params": [tx, passphrase]}
Parameters
tx
string
A transaction object. from
and key
must be specified.
passphrase
string
The passphrase to decrypt the private key of tx.from
.
Return Value
32-byte string
a transaction hash if succeeded. Otherwise, an error is raised.
Example
Console
HTTP RPC
NOTE: The function klay.toPeb()
is not executable in HTTP RPC.
personal_sendTransaction
Validates the given passphrase and submits a TxTypeLegacy transaction. The transaction object must have from
and to
except the case of contract deployment. to
should be omitted if the transaction deploys a smart contract. If value
is not specified, it will be set to zero internally. Other fields such as gas
, gasPrice
, and nonce
are set to appropriate values internally if unspecified. If the passphrase is able to decrypt the private key belonging to tx.from
and the transaction is verified, the transaction is signed and submitted onto the network. The account is not unlocked globally in the node and cannot be used in other RPC calls.
Console
personal.sendTransaction(tx, passphrase)
RPC
{"method": "personal_sendTransaction", "params": [tx, passphrase]}
Parameters
tx
string
A transaction object. from
is a required field. to
, value
, gas
, gasPrice
and nonce
are optional fields.
passphrase
string
The passphrase to decrypt the private key of tx.from
.
Return Value
32-byte string
a transaction hash if succeeded. Otherwise, an error is raised.
Example
Console
HTTP RPC
NOTE: The function klay.toPeb()
is not executable in HTTP RPC.
personal_sendValueTransfer
Validates the given passphrase and submits a TxTypeValueTransfer transaction. The transaction object must have fields from
, to
, and value
. Other fields such as gas
, gasPrice
, and nonce
are set internally if unspecified. If the passphrase is able to decrypt the private key belonging to tx.from
and the transaction is verified, the transaction is signed and submitted onto the network. The account is not unlocked globally in the node and cannot be used in other RPC calls.
Console
personal.sendValueTransfer(tx, passphrase)
RPC
{"method": "personal_sendValueTransfer", "params": [tx, passphrase]}
Parameters
tx
string
A transaction object. from
, to
, and value
must be specified.
passphrase
string
The passphrase to decrypt the private key of tx.from
.
Return Value
32-byte string
a transaction hash if succeeded. Otherwise, an error is raised.
Example
Console
HTTP RPC
NOTE: The function klay.toPeb()
is not executable in HTTP RPC.
personal_sign
The sign
method calculates a Klaytn-specific signature with: sign(keccak256("\x19Klaytn Signed Message:\n" + len(message) + message)))
Adding a prefix to the message makes the calculated signature recognizable as a Klaytn-specific signature. This prevents misuse where a malicious DApp can sign arbitrary data (e.g., transaction) and use the signature to impersonate the victim.
See personal_ecRecover
to verify the signature.
Console
personal.sign(message, account, password)
RPC
{"method": "personal_sign", "params": [message, account, password]}
Parameters
message
string
A message to sign.
account
string
The account address.
password
string
The pass phrase used for signing.
Return Value
string
A signature.
Example
Console
HTTP RPC
personal_signTransaction
Sets default configuration and signs the given transaction.
NOTE: Sending your account password over an unsecured HTTP RPC connection is highly unsecure. Use klay_signTransaction.
Parameters
The required parameters depend on the transaction type. Check the proper parameters in Working with Klaytn Transaction Types.
Return Value
raw
Signed raw transaction
tx
Transaction object
password
Sender's password
personal_ecRecover
ecRecover
returns the address associated with the private key that was used to calculate the signature in personal_sign
.
Console
personal.ecRecover(message, signature)
RPC
{"method": "personal_ecRecover", "params": [message, signature]}
Parameters
message
string
A message.
signature
string
The signature.
Return Value
string
The account address.
Example
Console
HTTP RPC
Last updated