feat: RAI-2581 - wallet nonce cache

Author: rouzwelt

.github/workflows/deploy-preview.yml

@@ -95,6 +95,7 @@ jobs:
           echo "TX_GAS=${{ vars.PREVIEW_TX_GAS }}" >> .env
           echo "DISPAIR=${{ vars.PREVIEW_DISPAIR }}" >> .env
           echo "MAX_CONCURRENCY=${{ vars.MAX_CONCURRENCY }}" >> .env
+          echo "BLOCK_TIME=${{ vars.PREVIEW_BLOCK_TIME || '2000' }}" >> .env
 
       - name: Run Rain Solver Docker Image
         run: docker run --rm --env-file .env $TAG_BASE:$CHANNEL

config.example.yaml

@@ -121,6 +121,7 @@ gasPriceMultiplier: 107
 
 # Time threshold (in ms) for a transaction mine time before it counts as a trigger to increase gas price multiplier for future transactions, default is 15000ms (15 seconds)
 # A timed out receipt wait does not count, only a mined transaction does. Set this to at least two block times, one missed block is normal.
+# A receipt wait times out after 3 block times, so set this below that, otherwise no transaction can count as slow.
 txTimeThreshold: 15000
 
 # Points added to the gas price multiplier on each step up, default is 10
@@ -135,7 +136,7 @@ gasIncreaseStepTime: 6
 # maxGasPriceMultiplier: 200
 
 # The average block time (in ms) of the operating chain, used as the polling interval of the block number watcher
-# and the transaction receipt wait, required
+# and the transaction receipt wait, a receipt wait times out after 3 block times, required
 blockTime: 2000
 
 # Optional block tag used for the order quote calls (eth_call) and the gas estimate calls (eth_estimateGas),
@@ -217,8 +218,8 @@ oracleMarketHours: 08:00-23:59
 # Option to multiply the gas limit estimation from the rpc as percentage, default is 100, ie no change
 gasLimitMultiplier: 100
 
-# Optional seconds to wait for the transaction to mine before disregarding it, default is 15
-timeout: 15
+# Optional timeout (in ms) of the rpc and subgraph requests, default is 15000
+timeout: 15000
 
 # Option to maximize maxIORatio, default true
 maxRatio: true

src/config/yaml.ts

@@ -82,7 +82,7 @@ export type AppOptions = {
     sleep: number;
     /** Gas coverage percentage for each transaction to be considered profitable to be submitted, default is 100 */
     gasCoveragePercentage: string;
-    /** Optional seconds to wait for the transaction to mine before disregarding it, default is 15 */
+    /** Optional timeout (in ms) of the rpc and subgraph requests, default is 15000 */
     timeout: number;
     /** Option to specify time (in minutes) between pools data resets, default is 0 minutes */
     poolUpdateInterval: number;
@@ -122,15 +122,15 @@ export type AppOptions = {
     convertToGasTime: number;
     /** Determines if multi wallets should be rotated at runtime, meaning new ones to replace older ones once they runs out of gas, default is false */
     rotateMultiWallet: boolean;
-    /** Time threshold (in ms) for a transaction mine time before it counts as a trigger to increase gas price multiplier for future transactions, default is 15 seconds */
+    /** Time threshold (in ms) for a transaction mine time before it counts as a trigger to increase gas price multiplier for future transactions, default is 15 seconds, must be below the receipt wait (3 block times) for a transaction to count as slow */
     txTimeThreshold: number;
     /** Points added to the gas price multiplier on each step up, default is 10 */
     gasIncreasePointsPerStep: number;
     /** Time (in minutes) of one gas price multiplier step, at most one step up per this time and one step down per this time once the last step up is that old, default is 6 */
     gasIncreaseStepTime: number;
     /** Optional ceiling of the gas price multiplier, never below gasPriceMultiplier, defaults to gasPriceMultiplier plus 1000 points (ten times the rpc gas price) when unset */
     maxGasPriceMultiplier?: number;
-    /** The average block time (in ms) of the operating chain, used as the polling interval of the block number watcher and the transaction receipt wait, required */
+    /** The average block time (in ms) of the operating chain, used as the polling interval of the block number watcher and the transaction receipt wait, a receipt wait times out after 3 block times, required */
     blockTime: number;
     /** Subscribes the block number watcher to flashblocks heads instead of new heads over the ws rpc, only supported on Base chain, requires wsRpc, default is false */
     flashblocks: boolean;

src/signer/actions.test.ts

@@ -9,7 +9,9 @@ import { describe, it, expect, vi, beforeEach, Mock } from "vitest";
 import {
     sendTx,
     getTxGas,
+    resetNonce,
     broadcastTx,
+    getNextNonce,
     hasExplicitGasParams,
     tryGetReceipt,
     waitUntilFree,
@@ -71,6 +73,7 @@ describe("Test sendTx", () => {
                     isSpecialL2: false,
                 },
                 l1GasPrice: undefined,
+                nonceCache: new Map(),
             },
             waitUntilFree: vi.fn().mockResolvedValue(undefined),
             getTransactionCount: vi.fn().mockResolvedValue(5),
@@ -378,6 +381,96 @@ describe("Test sendTx", () => {
             expect.anything(),
         );
     });
+
+    describe("nonce cache", () => {
+        it("should cache the next nonce and send the next tx without reading it over rpc", async () => {
+            (mockSigner.account as any).address = "0xSender";
+
+            await sendTx(mockSigner, { ...mockTx });
+            expect(mockSigner.state.nonceCache.get("0xsender")).toBe(6);
+
+            mockSigner.busy = false;
+            await sendTx(mockSigner, { ...mockTx });
+
+            // read over rpc only for the first tx
+            expect(mockSigner.getTransactionCount).toHaveBeenCalledTimes(1);
+            expect((mockSigner.account.signTransaction as Mock).mock.calls[0][0].nonce).toBe(5);
+            expect((mockSigner.account.signTransaction as Mock).mock.calls[1][0].nonce).toBe(6);
+            expect(mockSigner.state.nonceCache.get("0xsender")).toBe(7);
+        });
+
+        it("should cache the next nonce for a tx sent through viem sendTransaction", async () => {
+            (mockSigner.sendTransaction as Mock).mockResolvedValue("0xviemhash");
+            mockSigner.state.nonceCache.set("0xsender", 9);
+
+            await sendTx(mockSigner, { to: mockTx.to, value: 1n } as any);
+
+            expect(mockSigner.getTransactionCount).not.toHaveBeenCalled();
+            expect(mockSigner.sendTransaction).toHaveBeenCalledWith(
+                expect.objectContaining({ nonce: 9 }),
+            );
+            expect(mockSigner.state.nonceCache.get("0xsender")).toBe(10);
+        });
+
+        it("should drop a stale cached nonce on a failed send and retry with the rpc nonce", async () => {
+            mockSigner.state.nonceCache.set("0xsender", 3);
+            (mockSigner.sendRawTransaction as Mock)
+                .mockRejectedValueOnce(new Error("nonce too low"))
+                .mockResolvedValueOnce("0xhash");
+
+            const { hash } = await sendTx(mockSigner, mockTx, 10);
+
+            expect(hash).toBe("0xhash");
+            expect(mockSigner.getTransactionCount).toHaveBeenCalledTimes(1);
+            expect((mockSigner.account.signTransaction as Mock).mock.calls[0][0].nonce).toBe(3);
+            expect((mockSigner.account.signTransaction as Mock).mock.calls[1][0].nonce).toBe(5);
+            expect(mockSigner.state.nonceCache.get("0xsender")).toBe(6);
+        });
+
+        it("should leave no cached nonce when both attempts fail", async () => {
+            mockSigner.state.nonceCache.set("0xsender", 3);
+            mockSigner.sendRawTransaction = vi.fn().mockRejectedValue(new Error("failed"));
+
+            await expect(sendTx(mockSigner, mockTx, 10)).rejects.toThrow("failed");
+
+            expect(mockSigner.state.nonceCache.has("0xsender")).toBe(false);
+            expect(mockSigner.busy).toBe(false);
+        });
+    });
+});
+
+describe("Test getNextNonce and resetNonce", () => {
+    let mockSigner: RainSolverSigner;
+
+    beforeEach(() => {
+        mockSigner = {
+            account: { address: "0xSender" },
+            state: { nonceCache: new Map() },
+            getTransactionCount: vi.fn().mockResolvedValue(5),
+        } as unknown as RainSolverSigner;
+    });
+
+    it("should read the nonce over rpc when the cache does not hold one", async () => {
+        expect(await getNextNonce(mockSigner)).toBe(5);
+        expect(mockSigner.getTransactionCount).toHaveBeenCalledWith({
+            address: "0xSender",
+            blockTag: "latest",
+        });
+    });
+
+    it("should return the cached nonce by lowercase address without reading it over rpc", async () => {
+        mockSigner.state.nonceCache.set("0xsender", 0);
+        expect(await getNextNonce(mockSigner)).toBe(0);
+        expect(mockSigner.getTransactionCount).not.toHaveBeenCalled();
+    });
+
+    it("should drop only the signer's cached nonce", () => {
+        mockSigner.state.nonceCache.set("0xsender", 8);
+        mockSigner.state.nonceCache.set("0xother", 2);
+        resetNonce(mockSigner);
+        expect(mockSigner.state.nonceCache.has("0xsender")).toBe(false);
+        expect(mockSigner.state.nonceCache.get("0xother")).toBe(2);
+    });
 });
 
 describe("Test isAlreadyKnownTxError", () => {
@@ -978,6 +1071,63 @@ describe("Test getWriteSignerFrom", () => {
 
         spySigner.mockRestore();
     });
+
+    describe("shared busy state", () => {
+        let mockState: SharedState;
+        let signer: RainSolverSigner;
+
+        beforeEach(() => {
+            mockState = new SharedState({
+                rpcState: new RpcState([{ url: "https://example.com" }]),
+                writeRpcState: new RpcState([{ url: "https://example-write.com" }]),
+                chainConfig: {
+                    id: 1,
+                    isSpecialL2: false,
+                },
+            } as any);
+            signer = RainSolverSigner.create(account, mockState);
+        });
+
+        it("should share the busy state of the signer with each of its write signers", () => {
+            const writeSigner1 = getWriteSignerFrom(signer);
+            const writeSigner2 = getWriteSignerFrom(signer);
+            expect(writeSigner1).not.toBe(signer);
+
+            // a send through a write signer marks the wallet busy
+            writeSigner1.busy = true;
+            expect(signer.busy).toBe(true);
+            expect(writeSigner2.busy).toBe(true);
+
+            // the receipt wait frees the wallet through the signer
+            signer.busy = false;
+            expect(writeSigner1.busy).toBe(false);
+            expect(writeSigner2.busy).toBe(false);
+        });
+
+        it("should make a send through another write signer of the wallet wait until the wallet is free", async () => {
+            mockState.nonceCache.set(account.address.toLowerCase(), 5);
+            const sendTransaction = vi.fn().mockResolvedValue("0xhash");
+            const writeSigner1 = getWriteSignerFrom(signer);
+            const writeSigner2 = getWriteSignerFrom(signer);
+            (writeSigner1 as any).sendTransaction = sendTransaction;
+            (writeSigner2 as any).sendTransaction = sendTransaction;
+
+            await sendTx(writeSigner1, { to: account.address, value: 1n } as any);
+            expect(signer.busy).toBe(true);
+
+            // the second send waits while the first tx is not settled
+            const second = sendTx(writeSigner2, { to: account.address, value: 1n } as any);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(sendTransaction).toHaveBeenCalledTimes(1);
+
+            // the receipt wait of the first tx frees the wallet
+            signer.busy = false;
+            await second;
+            expect(sendTransaction).toHaveBeenCalledTimes(2);
+            expect(sendTransaction.mock.calls[0][0].nonce).toBe(5);
+            expect(sendTransaction.mock.calls[1][0].nonce).toBe(6);
+        });
+    });
 });
 
 describe("Test tryGetReceipt", () => {
@@ -988,6 +1138,7 @@ describe("Test tryGetReceipt", () => {
     beforeEach(() => {
         mockSigner = {
             busy: true,
+            account: { address: "0xSender" },
             state: {
                 appOptions: { blockTime: 150 },
                 blockNumber: 100n,
@@ -997,6 +1148,7 @@ describe("Test tryGetReceipt", () => {
                 gasManager: {
                     onTransactionMine: vi.fn(),
                 },
+                nonceCache: new Map([["0xsender", 7]]),
             },
         } as unknown as RainSolverSigner;
 
@@ -1042,7 +1194,7 @@ describe("Test tryGetReceipt", () => {
         expect(mockSigner.state.client.getTransactionReceipt).not.toHaveBeenCalled();
     });
 
-    it("should default the polling interval to the configured block time", async () => {
+    it("should default the polling interval to the block time and the timeout to 3 block times", async () => {
         (mockSigner.state.appOptions as any).blockTime = 500;
         (mockSigner.state.client.getTransactionReceipt as Mock).mockResolvedValue({
             status: "success",
@@ -1052,8 +1204,13 @@ describe("Test tryGetReceipt", () => {
         const start = Date.now();
         await tryGetReceipt(mockSigner, "0xhash");
 
-        // the tick is a fifth of the block time
+        // the tick is a fifth of the block time and the timeout is 3 block times
         expect(sleepSpy).toHaveBeenCalledWith(100);
+        expect(promiseTimeoutSpy).toHaveBeenCalledWith(
+            expect.any(Promise),
+            1_500,
+            expect.any(Object),
+        );
         expect(mockSigner.state.client.getTransactionReceipt).toHaveBeenCalledTimes(1);
         expect(Date.now() - start).toBeLessThan(400);
     });
@@ -1122,6 +1279,8 @@ describe("Test tryGetReceipt", () => {
             length: expect.any(Number),
         });
         expect(mockSigner.busy).toBe(false);
+        // a mined tx keeps the cached nonce
+        expect(mockSigner.state.nonceCache.get("0xsender")).toBe(7);
     });
 
     it("should hit timeout", async () => {
@@ -1151,5 +1310,7 @@ describe("Test tryGetReceipt", () => {
             length: expect.any(Number),
         });
         expect(mockSigner.busy).toBe(false);
+        // the tx may have been dropped, so the cached nonce is dropped too
+        expect(mockSigner.state.nonceCache.has("0xsender")).toBe(false);
     });
 });