Here is an article explaining the issue with eth.sign() returning null when called with Metamask set to localhost.
Problem: eth.sign() never returns or calls back
When using local Ganache with Metamask set to localhost, you may encounter issues signing transactions. Specifically, eth.sign() does not call the back function, which can prevent the transaction from being processed by the node.
Here is an article explaining how to resolve this issue:
Sign Transactions in Local Metamask Setup
In your code snippet, I see that you have a recursive call to sign(), but it does not return anything. The recursive call is unnecessary and causes the function to return null or undefined. This prevents the transaction from being signed by the Ethereum node.
Instead of calling back() on every iteration, we can simply handle any errors that may occur during signing.
Here is an example of how you could modify your code snippet:
async function sign() {
try {
const tx = await web3.eth.signTransaction({
from: '0x...',
to: '0x...',
value: '10000000000000000...', // Sample amount
Gas limit: 20000,
nonce: Math.floor((web3.eth.getTransactionCount('0x...')) * 2),
});
web3.eth.sendSignedTransaction(tx.rawTransaction).then((txHash) => {
console.log(Transaction signed successfully: ${txHash});
}).catch((error) => {
console.error(Error signing transaction: ${error.message});
});
} catch (error) {
console.error('Error signing transaction:', error);
}
}
In this modified version, we use web3.eth.signTransaction() to create a signed transaction object. Then, we call sendSignedTransaction() with the raw transaction as an argument.
Note that back() is not needed in this case, because sendSignedTransaction() will handle any errors that may occur during signing.
Why does eth.sign() never return or call?
When calling eth.signTransaction(), the node expects a function to call its blockchain, which can be useful for creating digital signatures. However, when using a local Ganache with Metamask set to localhost, this function is called internally by the Ethereum node.
The Ethereum node does not call eth.sign() immediately; instead, it schedules the transaction signing process in the background and returns a promise to wait for it to complete. This is where the problem arises: if we do not handle errors that may occur during signing, the transaction will never be processed by the node due to the recursive call.
By using catch blocks to handle any errors that may occur during signing, we can ensure that the transaction is signed successfully even with local Metamask settings.