Ethers.js – Unable to Send Transaction Using Ethers@^6.10.0

ethers.jshardhat

I'm currently trying to set up a script that sends Ethereum from one account to another. Using the hardhat framework, I provided the sender's private key from the local node and the receiver address. But after the transaction has been signed, I try to log out the receipt after sendTransaction() but I don't get any value.

I previously used ethers@^5.7.0, to set the transfer function, which worked successfully but due to incompatibility issues with the [email protected] and the hardhat version, I had to convert to [email protected]. But converting the transfer function to properly work with [email protected] has been the problem.

const ethers = require("ethers");

async function transfer(body) {
    try {
        const { senderPrivateKey, recipientAddress, amountInEth } = body;
    
        // Create a new wallet instance from the sender's private key
        const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545/");
        const signer = new ethers.Wallet(senderPrivateKey, provider);

        /**
        // Alternative method tried
        // const wallet = new ethers.Wallet(senderPrivateKey, provider);
        // const signer = new provider.getSigner(wallet.address) 
        // or 
        // const signer = new provider.getSigner();
        */
        // Get the current nonce for the sender's address
        const nonce = await signer.getNonce();
        console.log(nonce);
        
        // Create a transaction object
        const tx = {
            to: recipientAddress,
            value: ethers.parseEther(amountInEth),
            gasLimit: 21000,
            gasPrice: (await provider.getFeeData()).gasPrice,
            nonce: nonce
        };

        // Sign the transaction
        const signedTx = await signer.signTransaction(tx);
        console.log(signedTx);

        // Send the transaction
        const sent = await signer.sendTransaction(signedTx);
        const receipt = await sent.wait(1);
        console.log(receipt);

        // console.log(receipt);
    } catch (error) {
        return ({ status: 'error', error });
    }
};

And on my hardhat terminal I get a message:
eth_maxPriorityFeePerGas - Method not supported , but if I run it on a testnet I don't get any receipt logged or any message, apart from the logged signedTx.

Best Answer

After debugging the code meticulously. I noticed that in [email protected], there is no need for the signer.signTransaction(tx) because calling signer.sendTransaction(tx) will populate and sign the transaction before sending.

So the issue I had was signing the transaction and passing the signed transaction as a parameter to the signer.sendTransaction(signedTx). This led to an error in the population process of the sendTransaction method.

The correct code is below:

const ethers = require("ethers");

async function transfer(body) {
    try {
        const { senderPrivateKey, recipientAddress, amountInEth } = body;
    
        // Create a new wallet instance from the sender's private key
        const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545/");
        const signer = new ethers.Wallet(senderPrivateKey, provider);

        /**
        // Alternative method tried
        // const wallet = new ethers.Wallet(senderPrivateKey, provider);
        // const signer = new provider.getSigner(wallet.address) 
        // or 
        // const signer = new provider.getSigner();
        */
        // Get the current nonce for the sender's address
        const nonce = await signer.getNonce();
        console.log(nonce);
        
        // Create a transaction object
        const tx = {
            to: recipientAddress,
            value: ethers.parseEther(amountInEth),
            gasLimit: 21000,
            gasPrice: (await provider.getFeeData()).gasPrice,
            nonce: nonce
        };

        // Send the transaction
        const sent = await signer.sendTransaction(tx);
        const receipt = await sent.wait(1);
        console.log(receipt);

        // console.log(receipt);
    } catch (error) {
        return ({ status: 'error', error });
    }
};

Related Solutions

Solidity – How to Call a Smart Contract Function from Another Contract’s Address Using Hardhat Test

Hello Team Have Finally Resolved It

One Has To First

    
  await hre.network.provider.request({
  method: "hardhat_impersonateAccount",
  params: [market.address],
});

Then Get The Signer Using the Following

 const signer = await ethers.getSigner(market.address);

One Can Then Use the Signer In The Connect Of The Contract Call From Within Your Hardhat Test

await media.connect(signer).functionName(1,addr2.address);

and end impersonating the contract using the following

  await hre.network.provider.request({
  method: "hardhat_stopImpersonatingAccount",
  params: [market.address],
});

I Hope This Can Help Anyone Else Facing this Issue

Thank You

Hardhat – Does ethers Contract.deploy Automatically Handle Gas Estimation for Mainnet?

Note that the gas price can fluctuate rapidly, so it is always best to check the gas price before deploying your contract. You can do this using a gas price estimator such as EthGasStation or Etherscan.

To specify a gas price and gas limit when deploying a contract, you can use the gasPrice and gasLimit options when calling the deploy() method. For example:

const MyContract = await ethers.getContractFactory('MyContract', signer);
const mycontract = await MyContract.deploy({
  gasPrice: 1000000000000000000, // 100 Gwei
  gasLimit: 6660666,
});

The feeData object that you mentioned in your question is a new feature that was introduced in EIP-1559. It provides a more flexible way to specify the gas fees for a transaction.

To use the feeData object to deploy a contract, you can pass it as the options object to the deploy() method. For example:

const feeData = await provider.getFeeData();

const MyContract = await ethers.getContractFactory('MyContract', signer);
const mycontract = await MyContract.deploy(feeData);

The provider.getFeeData() method returns a FeeData object that contains the following information:

maxFeePerGas: The maximum fee per gas that the user is willing to pay. maxPriorityFeePerGas: The maximum priority fee per gas that the user is willing to pay.

gasPrice: The base fee per gas that will be paid to the miner. The maxFeePerGas and maxPriorityFeePerGas values are specified in Gwei. The gasPrice value is specified in Wei.

If you are using Hardhat, you can use the getFeeData() method from the ethers package. For example:

const { getFeeData } = require('ethers');

const feeData = await getFeeData();

Once you have the feeData object, you can pass it to the deploy() method when deploying your contract.

Which method you choose to use depends on your specific needs. If you are comfortable with EIP-1559, then I recommend using the feeData object. It provides a more flexible way to specify the gas fees for your transaction. However, if you are not comfortable with EIP-1559, then you can continue to use the gasPrice and gasLimit options.

Here is the two methods:

Method 1: Using the feeData object

// Get the fee data from the provider.
const feeData = await provider.getFeeData();

// Deploy the contract using the fee data.
const MyContract = await ethers.getContractFactory('MyContract', signer);
const mycontract = await MyContract.deploy(feeData);

Method 2: Using the gasPrice and gasLimit options

// Specify the gas price and gas limit.
const gasPrice = 1000000000000000000; // 100 Gwei
const gasLimit = 6660666;

// Deploy the contract using the gas price and gas limit options.
const MyContract = await ethers.getContractFactory('MyContract', signer);
const mycontract = await MyContract.deploy({
  gasPrice,
  gasLimit,
});

Best Answer

Related Solutions

Solidity – How to Call a Smart Contract Function from Another Contract’s Address Using Hardhat Test

Hardhat – Does ethers Contract.deploy Automatically Handle Gas Estimation for Mainnet?

Related Topic