update gas retry logic

Author: arcoraven

src/tests/sendTransactionWorker.test.ts

@@ -0,0 +1,95 @@
+import { Hex } from "thirdweb";
+import { describe, expect, it } from "vitest";
+import { _updateGasFees } from "../worker/tasks/sendTransactionWorker";
+
+describe("_updateGasFees", () => {
+  const base = {
+    // Irrelevant values for testing.
+    chainId: 1,
+    data: "0x0" as Hex,
+    gas: 21000n,
+    to: undefined,
+    nonce: undefined,
+    accessList: undefined,
+    value: undefined,
+  };
+
+  //   const legacyTransaction: PopulatedTransaction = {
+  //     ...base,
+  //     gasPrice: 35000000000n,
+  //   };
+
+  //   const eip1559Transaction: PopulatedTransaction = {
+  //     ...base,
+  //     maxPriorityFeePerGas: 500000000n,
+  //     maxFeePerGas: 35000000000n,
+  //   };
+
+  it("returns the original transaction on first send (resendCount = 0)", () => {
+    let result = _updateGasFees({ ...base, gasPrice: 100n }, 0, undefined);
+    expect(result.gasPrice).toEqual(100n);
+
+    result = _updateGasFees(
+      { ...base, maxFeePerGas: 100n, maxPriorityFeePerGas: 10n },
+      0,
+      undefined,
+    );
+    expect(result.maxFeePerGas).toEqual(100n);
+    expect(result.maxPriorityFeePerGas).toEqual(10n);
+  });
+
+  it("doubles gasPrice for legacy transactions", () => {
+    const result = _updateGasFees({ ...base, gasPrice: 100n }, 1, {});
+    expect(result.gasPrice).toBe(200n);
+  });
+
+  it("caps gasPrice multiplier at 10x", () => {
+    const result = _updateGasFees({ ...base, gasPrice: 100n }, 10, {});
+    expect(result.gasPrice).toBe(1000n);
+  });
+
+  it("updates maxPriorityFeePerGas and maxFeePerGas for EIP-1559 transactions", () => {
+    const result = _updateGasFees(
+      { ...base, maxFeePerGas: 100n, maxPriorityFeePerGas: 10n },
+      3,
+      {},
+    );
+    expect(result.maxPriorityFeePerGas).toBe(60n);
+    expect(result.maxFeePerGas).toBe(260n);
+  });
+
+  it("respects overrides for maxPriorityFeePerGas", () => {
+    const result = _updateGasFees(
+      { ...base, maxFeePerGas: 100n, maxPriorityFeePerGas: 10n },
+      3,
+      { maxPriorityFeePerGas: 10n },
+    );
+    expect(result.maxPriorityFeePerGas).toBe(10n); // matches override
+    expect(result.maxFeePerGas).toBe(210n);
+  });
+
+  it("respects overrides for maxFeePerGas", () => {
+    const result = _updateGasFees(
+      { ...base, maxFeePerGas: 100n, maxPriorityFeePerGas: 10n },
+      3,
+      { maxFeePerGas: 100n },
+    );
+    expect(result.maxPriorityFeePerGas).toBe(60n);
+    expect(result.maxFeePerGas).toBe(100n); // matches override
+  });
+
+  it("returns correct values when only maxPriorityFeePerGas is set", () => {
+    const result = _updateGasFees(
+      { ...base, maxPriorityFeePerGas: 10n },
+      3,
+      {},
+    );
+    expect(result.maxPriorityFeePerGas).toBe(60n);
+    expect(result.maxFeePerGas).toBeUndefined();
+  });
+
+  it("returns correct values when only maxFeePerGas is set", () => {
+    const result = _updateGasFees({ ...base, maxFeePerGas: 80n }, 3, {});
+    expect(result.maxFeePerGas).toBe(160n);
+  });
+});

src/worker/tasks/sendTransactionWorker.ts

@@ -75,10 +75,15 @@ const handler: Processor<string, void, string> = async (job: Job<string>) => {
     return;
   }
 
-  // The transaction may be errored if it is manually retried.
-  // For example, the developer retried all failed transactions during an RPC outage.
-  // An errored queued transaction (resendCount = 0) is safe to retry: the transaction wasn't sent to RPC.
-  if (transaction.status === "errored" && resendCount === 0) {
+  // If the transaction is errored and has not yet been sent,
+  // reset it to a QueuedTransaction to try again.
+  // No transaction hashes means the transaction is not in-flight.
+  if (
+    transaction.status === "errored" &&
+    !transaction.isUserOp &&
+    "sentTransactionHashes" in transaction &&
+    transaction.sentTransactionHashes.length > 0
+  ) {
     const { errorMessage, ...omitted } = transaction;
     transaction = {
       ...omitted,
@@ -438,7 +443,7 @@ const _resendTransaction = async (
 
   // Populate the transaction with double gas.
   const { chainId, from, overrides, sentTransactionHashes } = sentTransaction;
-  const populatedTransaction = await toSerializableTransaction({
+  let populatedTransaction = await toSerializableTransaction({
     from: getChecksumAddress(from),
     transaction: {
       client: thirdwebClient,
@@ -452,21 +457,12 @@ const _resendTransaction = async (
     },
   });
 
-  // Double the gas fee settings each attempt up to 10x.
-  // Do not update gas if overrides were provided.
-  const gasMultiple = BigInt(clamp(job.attemptsMade * 2, { min: 2, max: 10 }));
-  if (populatedTransaction.gasPrice) {
-    populatedTransaction.gasPrice *= gasMultiple;
-  }
-  if (populatedTransaction.maxFeePerGas && !overrides?.maxFeePerGas) {
-    populatedTransaction.maxFeePerGas *= gasMultiple;
-  }
-  if (
-    populatedTransaction.maxPriorityFeePerGas &&
-    !overrides?.maxPriorityFeePerGas
-  ) {
-    populatedTransaction.maxPriorityFeePerGas *= gasMultiple;
-  }
+  // Increase gas fees for this resend attempt.
+  populatedTransaction = _updateGasFees(
+    populatedTransaction,
+    sentTransaction.resendCount + 1,
+    sentTransaction.overrides,
+  );
 
   job.log(`Populated transaction: ${stringify(populatedTransaction)}`);
 
@@ -577,6 +573,47 @@ const _hasExceededTimeout = (
 const _minutesFromNow = (minutes: number) =>
   new Date(Date.now() + minutes * 60_000);
 
+/**
+ * Computes the aggressive gas fees to use when resending a transaction.
+ *
+ * For legacy transactions (pre-EIP1559):
+ * - Set gas price to 2 * current attempt, capped at 10x.
+ *
+ * For transactions with maxFeePerGas + maxPriorityFeePerGas:
+ * - Set maxPriorityFeePerGas to 2x current attempt, capped at 10x.
+ * - Set maxFeePerGas to 2 * current max fee, plus the maxPriorityFeePerGas.
+ *
+ * @param populatedTransaction The transaction with estimated gas from RPC.
+ * @param resendCount The resend attempt #. Example: 2 = the transaction was initially sent, then resent once. This is the second resend attempt.
+ */
+export const _updateGasFees = (
+  populatedTransaction: PopulatedTransaction,
+  resendCount: number,
+  overrides: SentTransaction["overrides"],
+): PopulatedTransaction => {
+  if (resendCount === 0) {
+    return populatedTransaction;
+  }
+
+  const multiplier = BigInt(clamp(resendCount * 2, { min: 2, max: 10 }));
+
+  const updated = { ...populatedTransaction };
+  if (updated.gasPrice) {
+    updated.gasPrice *= multiplier;
+  }
+  // Don't update gas fees that are explicitly overridden.
+  if (updated.maxPriorityFeePerGas && !overrides?.maxPriorityFeePerGas) {
+    updated.maxPriorityFeePerGas *= multiplier;
+  }
+  // Don't update gas fees that are explicitly overridden.
+  if (updated.maxFeePerGas && !overrides?.maxFeePerGas) {
+    updated.maxFeePerGas =
+      updated.maxFeePerGas * 2n + (updated.maxPriorityFeePerGas ?? 0n);
+  }
+
+  return updated;
+};
+
 // Must be explicitly called for the worker to run on this host.
 export const initSendTransactionWorker = () => {
   const _worker = new Worker(SendTransactionQueue.q.name, handler, {