NFT minting simulation

[benams]

Hey,
I use ganache in an attempt to simulate an NFT raw transaction:

const provider = ganache.provider({
        fork: { network: "mainnet", blockNumber: 16409358 },
        wallet: {
            unlockedAccounts: [
                "0x041d4f20857d5667a8ff0165fe5e492089becfb7"
            ]
        },
        chain: {
            chainId: 1
        }
});

await provider.on("connect", async () => {
        console.log('connected');
        provider.on("ganache:vm:tx:before", (event: any) => {
            console.log('Transaction about to start!')
        })
        provider.on("ganache:vm:tx:step", (event: any) => {
            console.log('Transaction step!')
        })
        provider.on("ganache:vm:tx:after", (event: any) => {
            console.log('Transaction done!')
        })
        // When connected, send the transaction to the provider
        const transactionHash = await provider.request({
            method: "eth_sendRawTransaction",
            params: ["0xf8aa148503c25e6b808302cdd8941cf41fca322df19af9a3433305dc901ab961a98380b844bc63f02e0000000000000000000000000000000000000000000000000000000000000032000000000000000000000000041d4f20857d5667a8ff0165fe5e492089becfb726a0ef35cf88512370c4e338458c538fcb82290dc44bfb41c2eceda8e143a7a47d87a01b1fb1c5c2953fa6fc9b673a23a9688e4043daa6669fe9283361595aa6ba75d0"]
        });
        console.log(`Transaction ${transactionHash} Done!`)
    });

It looks like the transaction is never started. The only logs I can see are:

connected
eth_sendRawTransaction

Did I miss something in the provider configuration? Can ganache event simulate an NFT transaction?

[MicaiahReid]

When I run your code sample, I get the following output:

connected
eth_sendRawTransaction
(node:1840877) UnhandledPromiseRejectionWarning: Error: the tx doesn't have the correct nonce. account has nonce of: 21 tx has nonce of: 20
    at TransactionPool.prepareTransaction (/home/micaiah/work/test-ganache/node_modules/ganache/dist/node/1.js:2:122021)
(Use `node --trace-warnings ...` to show where the warning was created)
(node:1840877) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1)
(node:1840877) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

Remember that a raw transaction has all of the information from the transaction embedded into it, including the nonce. The transaction is specified with a nonce, and the account has a nonce based off of the block you are forking from. In your example there is a discrepancy between them.

If the transaction nonce is greater than the account nonce, the transaction will go into the transaction pool and be executed when the nonce gap is filled.

If the transaction nonce is less than the account nonce (which is happening here), Ganache gives an error.

If the transaction nonce is equal to the account nonce, the transaction is immediately ready to be executed.

For a solution, you can:

1. Fork at a different block where the account's nonce is equal to the raw transaction's nonce
2. Send a different raw transaction or just use eth_sendTransaction so you can set the parameters how you want
3. Use the evm_setAccountNonce method before sending the transaction. Note, this method will result in an invalid state trie since you are overriding state, but it should allow you to execute the transaction:

await provider.send("evm_setAccountNonce", [
  "0x041d4f20857d5667a8ff0165fe5e492089becfb7",
  "0x14"
]);

[benams]

Sorry, the correct nonce should be 16409358 as far as I understand. I'll fix it in my original post.

[MicaiahReid]

I've used your updated code, and now I'm getting the same results as you. At that block number, the account has a nonce of 7 while the transaction has a nonce of 20, which is causing the transaction to be queued for future inclusion into a block.

However, there seems to be a bug in Ganache when a transaction that is not yet executable is sent to Ganache while running in eager mining mode. I'll write an issue on this and link it here, but the bug seems to be around this line:

ganache/src/chains/ethereum/ethereum/src/blockchain.ts

Line 1060 in b816de2

const { status, error } = await transaction.once("finalized");

As a workaround, you can find the fork block where the account's nonce equals the transaction nonce (20), or you can use the evm_setAccountNonce method to set the nonce.

[MicaiahReid]

The issue can be tracked at #4165