Unlocking accounts and making transactions in web3.js

Question

This question is related to this one and this one. It also has a partial answer here and here.

In the third link the account is being unlocked for a period of time using web3.js:

web3.personal.unlockAccount("0x..", "<passs>", 1000);

The unlock period parameter is optional.

How is it possible to check if accounts are locked (prior to making transactions)?

Are there any functionality consequences of unlocking an already unlocked account?

Answer 1

There currently isn't a method for checking whether an account is locked or not in the web3 JS API.

However, from the code, if an account is already unlocked, then there's no problem calling unlock again.

// If the account address is already unlocked for a duration, TimedUnlock extends or
// shortens the active unlock timeout. If the address was previously unlocked
// indefinitely the timeout is not altered.
func (am *Manager) TimedUnlock(a Account, passphrase string, timeout time.Duration) error {

---

Why are we only looking at TimedUnlock(), which presumably only gets invoked if we pass the third parameter?

As you noted, the unlock period parameter is optional. If it isn't provided, then we call Unlock(), which is a wrapper around TimedUnlock(), but which passes 0 as the time period. Hence we only need consider the TimedUnlock() function in the explanation.

Answer 2

Here is a workaround to check if account is unlocked. It is not very beautiful but in most cases it works. Use it only for development purposes on testnet or private net!!! Because "this sends out an actual transaction for which you have to pay gas" Unlocking accounts and making transactions in web3.js

function isAccountLocked(account) {
    try {
        web3.eth.sendTransaction({
            from: account,
            to: account,
            value: 0
        });
        return false;
    } catch (err) {
        return (err.message == "authentication needed: password or unlock");
    }
}

function unlockAccountsIfNeeded(accounts, passwords, unlock_duration_sec) {
    if (typeof(unlock_duration_sec)==='undefined') unlock_duration_sec = 300;

    for (let i = 0; i < accounts.length; i++) {
        if (isAccountLocked(accounts[i])) {
            console.log("Account " + accounts[i] + " is locked. Unlocking")
            web3.personal.unlockAccount(accounts[i], passwords[i], unlock_duration_sec);
        }
    }
}

Answer 3

You can use web3.eth.sign and check if it fails.

async function isUnlocked (web3, address) {
    try {
        await web3.eth.sign("", address);
    } catch (e) {
        return false;
    }
    return true;
}

Answer 4

This is a possible method, directly calling the JSON RPC method personal_listWallets:

async function listWallets() {
    try {
        const result = await sendRPC_personal_listWallets();
        console.log(typeof result);
        return result;
    } catch (e) {
        return e;
    }
}

function sendRPC_personal_listWallets() {

    return new Promise((resolve, reject) => {

        web3.currentProvider.send({ method: "personal_listWallets", params: [], jsonrpc: "2.0", id: new Date().getTime() },
            function (error, result) { if (error) { reject(error); } else { resolve(result); } });
    }
    );
}
let wallets;
listWallets().then((r) => { console.log("ID:", r.id); wallets = r.result; console.log("Accounts:", wallets); });