NonceManager does not handle overflow

[kevinforrestconnors]

If the nonce in the NonceManager exceeds Number.MAX_SAFE_INTEGER, the NonceManager does not loop around and stops working.

This makes it impossible to safely use a random number in setTransactionCount, and thus makes it difficult to use two NonceManagers in separate codebases, that represent the same contract, but which cannot interact with each other.

Suggested fix:
incrementTransactionCount should be modified to check if it will set this._deltaCount to an unsafe value, i.e.

    incrementTransactionCount(count?: number): void {
        if (this._deltaCount === Number.MAX_SAFE_INTEGER - 1) {
            this._deltaCount = 0;
        }
        this._deltaCount += (count ? count: 1);
    }

modify setTransactionCount to also verify that it is not overflowing the nonce passed to ethers.BigNumber.from

[ricmoo]

I don’t understand what you are trying to do?

Nonce must be sequential in Ethereum transactions, so you cannot set a random start value on different instances anyways. You must carry in from where you the last transaction was.

A IEEE 754 number is safe for transaction count in general, because there isn’t enough energy in the observable universe to ever reach that many transactions on the Ethereum network. :)

[kevinforrestconnors]

I'm trying to use the NonceManager in two different applications that call the same contract, and I am repeatedly getting nonce collisions which have to be handled in an exception. When the collision happens, I have to increment the nonce. I was thinking I could solve the collision issue by setting the initial nonce to a random number on both applications.

It appears I might not be understanding how the nonce works on a basic level - my understanding was that when you instantiate NonceManager, the nonce is 0, and then it increments by 1 every transaction, which would explain the collisions when using two different NonceManagers with the same contract. Is this not the case?

[ricmoo]

The NonceManager is a Signer, which wraps another Signer object. It first loads the current nonce for that Signer (using signer.getTeansactionCount()) and after each nonceManager.signTransaction(…), increments the internal transactionCount. The purpose of this is to send many transactions from the same Signer quickly; normally quickly sending many transactions from the same Signer runs the risk of not receiving the updated nonce from a .getTransactionCount("pending") due to the eventually consistent nature of blockchains and and the complexities surrounding the mempool.

Contracts generally do not have a concept of a nonce, so I’m not sure what you mean by that. If a specific contract is using a nonce for another purpose, it is likely unrelated (a contract does not have access to a Signer’s nonce) and so it will be more application specific as to what you are trying to do with it.

Does that make sense?

[kevinforrestconnors]

That makes sense and clears some stuff up.

I'm instantiating a nonce manager like:
managedSigner = new NonceManager(wallet.connect(rpcProvider))

and passing that to new ethers.Contract(contactAddress, contractABI, managedSigner)

Is there any way to prevent the collisions when doing this in multiple separate applications? One is a backend and the other is a cron job, so if the cron job is unaware of the backend's NonceManager state I suppose it collides.

[ricmoo]

If you need two different things to use the same signer, you need to coordinate between them, using something out-of-process that can manage across the various sources, such as:

• a file with atomic access using exclusive access, if you are on a file system that supports it
• a custom daemon that runs on a port
• something like MySQL which supports atomic access to a value

Most of the time it is much easier to just use two different signers though. Or use a Smart Contract wallet with 1 of 2 multisig, so either of 2 keys can sign messages on its behalf, then the CEO job would have a separate key from the backend. This also provides some debugging opportunities as you know which is responsible for a given transaction.

Other than that, there isn’t really a way to share a private key with services that are completely unaware of each other.

[kevinforrestconnors]

Thanks for all the help and information, I think I know how I can proceed.