fix: Cancel tx if populating a tx to retry fails

src/db/transactions/cleanTxs.ts

@@ -15,16 +15,14 @@ export const cleanTxs = (
       sentAt: tx.sentAt?.toISOString() || null,
       minedAt: tx.minedAt?.toISOString() || null,
       cancelledAt: tx.cancelledAt?.toISOString() || null,
-      status: !!tx.errorMessage
+      status: tx.errorMessage
         ? "errored"
-        : !!tx.minedAt
+        : tx.minedAt
         ? "mined"
-        : !!tx.cancelledAt
+        : tx.cancelledAt
         ? "cancelled"
-        : !!tx.sentAt && tx.retryCount === 0
+        : tx.sentAt
         ? "sent"
-        : !!tx.sentAt && tx.retryCount > 0
-        ? "retried"
         : "queued",
     };
   });

src/server/schemas/transaction/index.ts

@@ -198,41 +198,3 @@ export enum TransactionStatus {
   // Tx was cancelled and will not be re-attempted.
   Cancelled = "cancelled",
 }
-
-export interface TransactionSchema {
-  identifier?: string;
-  walletAddress?: string;
-  contractAddress?: string;
-  chainId?: string;
-  extension?: string;
-  rawFunctionName?: string;
-  rawFunctionArgs?: string;
-  txProcessed?: boolean;
-  txSubmitted?: boolean;
-  txErrored?: boolean;
-  txMined?: boolean;
-  encodedInputData?: string;
-  txType?: number;
-  gasPrice?: string;
-  gasLimit?: string;
-  maxPriorityFeePerGas?: string;
-  maxFeePerGas?: string;
-  txHash?: string;
-  status?: string;
-  createdTimestamp?: Date;
-  txSubmittedTimestamp?: Date;
-  txProcessedTimestamp?: Date;
-  submittedTxNonce?: number;
-  deployedContractAddress?: string;
-  contractType?: string;
-  txValue?: string;
-  errorMessage?: string;
-  txMinedTimestamp?: Date;
-  blockNumber?: number;
-  toAddress?: string;
-  txSubmittedAtBlockNumber?: number;
-  numberOfRetries?: number;
-  overrideGasValuesForTx?: boolean;
-  overrideMaxFeePerGas?: string;
-  overrideMaxPriorityFeePerGas?: string;
-}

src/server/utils/transaction.ts

@@ -1,10 +1,11 @@
-import { getDefaultGasOverrides } from "@thirdweb-dev/sdk";
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+import { Transactions } from "@prisma/client";
 import { StatusCodes } from "http-status-codes";
-import { getTxById } from "../../db/transactions/getTxById";
+import { prisma } from "../../db/client";
 import { updateTx } from "../../db/transactions/updateTx";
 import { PrismaTransaction } from "../../schema/prisma";
 import { getSdk } from "../../utils/cache/getSdk";
-import { multiplyGasOverrides } from "../../utils/gas";
+import { getGasSettingsForRetry } from "../../utils/gas";
 import { createCustomError } from "../middleware/error";
 import { TransactionStatus } from "../schemas/transaction";
 
@@ -17,15 +18,29 @@ export const cancelTransactionAndUpdate = async ({
   queueId,
   pgtx,
 }: CancelTransactionAndUpdateParams) => {
-  const txData = await getTxById({ queueId, pgtx });
-  if (!txData) {
+  const tx = await prisma.transactions.findUnique({
+    where: {
+      id: queueId,
+    },
+  });
+  if (!tx) {
     return {
       message: `Transaction ${queueId} not found.`,
     };
   }
 
-  if (txData.signerAddress && txData.accountAddress) {
-    switch (txData.status) {
+  const status: TransactionStatus = tx.errorMessage
+    ? TransactionStatus.Errored
+    : tx.minedAt
+    ? TransactionStatus.Mined
+    : tx.cancelledAt
+    ? TransactionStatus.Cancelled
+    : tx.sentAt
+    ? TransactionStatus.Sent
+    : TransactionStatus.Queued;
+
+  if (tx.signerAddress && tx.accountAddress) {
+    switch (status) {
       case TransactionStatus.Errored:
         throw createCustomError(
           `Cannot cancel user operation because it already errored`,
@@ -62,14 +77,10 @@ export const cancelTransactionAndUpdate = async ({
         };
     }
   } else {
-    switch (txData.status) {
+    switch (status) {
       case TransactionStatus.Errored: {
-        if (txData.chainId && txData.fromAddress && txData.nonce) {
-          const { message, transactionHash } = await sendNullTransaction({
-            chainId: parseInt(txData.chainId),
-            walletAddress: txData.fromAddress,
-            nonce: txData.nonce,
-          });
+        if (tx.chainId && tx.fromAddress && tx.nonce) {
+          const { message, transactionHash } = await cancelTransaction(tx);
           if (transactionHash) {
             await updateTx({
               queueId,
@@ -84,7 +95,7 @@ export const cancelTransactionAndUpdate = async ({
         }
 
         throw createCustomError(
-          `Transaction has already errored: ${txData.errorMessage}`,
+          `Transaction has already errored: ${tx.errorMessage}`,
           StatusCodes.BAD_REQUEST,
           "TransactionErrored",
         );
@@ -113,12 +124,8 @@ export const cancelTransactionAndUpdate = async ({
           "TransactionAlreadyMined",
         );
       case TransactionStatus.Sent: {
-        if (txData.chainId && txData.fromAddress && txData.nonce) {
-          const { message, transactionHash } = await sendNullTransaction({
-            chainId: parseInt(txData.chainId),
-            walletAddress: txData.fromAddress,
-            nonce: txData.nonce,
-          });
+        if (tx.chainId && tx.fromAddress && tx.nonce) {
+          const { message, transactionHash } = await cancelTransaction(tx);
           if (transactionHash) {
             await updateTx({
               queueId,
@@ -138,37 +145,40 @@ export const cancelTransactionAndUpdate = async ({
   throw new Error("Unhandled cancellation state.");
 };
 
-const sendNullTransaction = async (args: {
-  chainId: number;
-  walletAddress: string;
-  nonce: number;
-  transactionHash?: string;
-}): Promise<{
+const cancelTransaction = async (
+  tx: Transactions,
+): Promise<{
   message: string;
   transactionHash?: string;
 }> => {
-  const { chainId, walletAddress, nonce, transactionHash } = args;
+  if (!tx.fromAddress || !tx.nonce) {
+    return { message: `Invalid transaction state to cancel. (${tx.id})` };
+  }
 
-  const sdk = await getSdk({ chainId, walletAddress });
-  const provider = sdk.getProvider();
+  const sdk = await getSdk({
+    chainId: parseInt(tx.chainId),
+    walletAddress: tx.fromAddress,
+  });
+  const provider = sdk.getProvider() as StaticJsonRpcProvider;
 
   // Skip if the transaction is already mined.
-  if (transactionHash) {
-    const receipt = await provider.getTransactionReceipt(transactionHash);
+  if (tx.transactionHash) {
+    const receipt = await provider.getTransactionReceipt(tx.transactionHash);
     if (receipt) {
       return { message: "Transaction already mined." };
     }
   }
 
   try {
-    const gasOverrides = await getDefaultGasOverrides(provider);
+    const gasOptions = await getGasSettingsForRetry(tx, provider);
+    // Send 0 currency to self.
     const { hash } = await sdk.wallet.sendRawTransaction({
-      to: walletAddress,
-      from: walletAddress,
+      to: tx.fromAddress,
+      from: tx.fromAddress,
       data: "0x",
       value: "0",
-      nonce,
-      ...multiplyGasOverrides(gasOverrides, 2),
+      nonce: tx.nonce,
+      ...gasOptions,
     });
 
     return {

src/worker/tasks/retryTx.ts

@@ -4,16 +4,13 @@ import { prisma } from "../../db/client";
 import { getTxToRetry } from "../../db/transactions/getTxToRetry";
 import { updateTx } from "../../db/transactions/updateTx";
 import { TransactionStatus } from "../../server/schemas/transaction";
+import { cancelTransactionAndUpdate } from "../../server/utils/transaction";
 import { getConfig } from "../../utils/cache/getConfig";
 import { getSdk } from "../../utils/cache/getSdk";
 import { parseTxError } from "../../utils/errors";
 import { getGasSettingsForRetry } from "../../utils/gas";
 import { logger } from "../../utils/logger";
-import {
-  ReportUsageParams,
-  UsageEventTxActionEnum,
-  reportUsage,
-} from "../../utils/usage";
+import { UsageEventTxActionEnum, reportUsage } from "../../utils/usage";
 
 export const retryTx = async () => {
   try {
@@ -26,13 +23,12 @@ export const retryTx = async () => {
         }
 
         const config = await getConfig();
-        const reportUsageForQueueIds: ReportUsageParams[] = [];
         const sdk = await getSdk({
           chainId: parseInt(tx.chainId!),
           walletAddress: tx.fromAddress!,
         });
         const provider = sdk.getProvider() as StaticJsonRpcBatchProvider;
-        const blockNumber = await sdk.getProvider().getBlockNumber();
+        const blockNumber = await provider.getBlockNumber();
 
         if (
           blockNumber - tx.sentAtBlockNumber! <=
@@ -58,26 +54,36 @@ export const retryTx = async () => {
         });
 
         const gasOverrides = await getGasSettingsForRetry(tx, provider);
-        let res: ethers.providers.TransactionResponse;
-        const txRequest = {
+        const transactionRequest = {
           to: tx.toAddress!,
           from: tx.fromAddress!,
           data: tx.data!,
           nonce: tx.nonce!,
           value: tx.value!,
           ...gasOverrides,
         };
+
+        // Send transaction.
+        let transactionResponse: ethers.providers.TransactionResponse;
         try {
-          res = await sdk.getSigner()!.sendTransaction(txRequest);
+          transactionResponse = await sdk
+            .getSigner()!
+            .sendTransaction(transactionRequest);
         } catch (err: any) {
+          // The RPC rejected this transaction.
           logger({
             service: "worker",
             level: "error",
             queueId: tx.id,
-            message: `Failed to retry`,
+            message: "Failed to retry",
             error: err,
           });
 
+          // Consume the nonce.
+          await cancelTransactionAndUpdate({
+            queueId: tx.id,
+            pgtx,
+          });
           await updateTx({
             pgtx,
             queueId: tx.id,
@@ -87,21 +93,21 @@ export const retryTx = async () => {
             },
           });
 
-          reportUsageForQueueIds.push({
-            input: {
-              fromAddress: tx.fromAddress || undefined,
-              toAddress: tx.toAddress || undefined,
-              value: tx.value || undefined,
-              chainId: tx.chainId || undefined,
-              functionName: tx.functionName || undefined,
-              extension: tx.extension || undefined,
-              retryCount: tx.retryCount + 1 || 0,
-              provider: provider.connection.url || undefined,
+          reportUsage([
+            {
+              input: {
+                fromAddress: tx.fromAddress || undefined,
+                toAddress: tx.toAddress || undefined,
+                value: tx.value || undefined,
+                chainId: tx.chainId,
+                functionName: tx.functionName || undefined,
+                extension: tx.extension || undefined,
+                retryCount: tx.retryCount + 1,
+                provider: provider.connection.url,
+              },
+              action: UsageEventTxActionEnum.ErrorTx,
             },
-            action: UsageEventTxActionEnum.ErrorTx,
-          });
-
-          reportUsage(reportUsageForQueueIds);
+          ]);
 
           return;
         }
@@ -112,35 +118,35 @@ export const retryTx = async () => {
           data: {
             sentAt: new Date(),
             status: TransactionStatus.Sent,
-            res: txRequest,
-            sentAtBlockNumber: await sdk.getProvider().getBlockNumber(),
+            res: transactionRequest,
+            sentAtBlockNumber: await provider.getBlockNumber(),
             retryCount: tx.retryCount + 1,
-            transactionHash: res.hash,
+            transactionHash: transactionResponse.hash,
           },
         });
 
-        reportUsageForQueueIds.push({
-          input: {
-            fromAddress: tx.fromAddress || undefined,
-            toAddress: tx.toAddress || undefined,
-            value: tx.value || undefined,
-            chainId: tx.chainId || undefined,
-            functionName: tx.functionName || undefined,
-            extension: tx.extension || undefined,
-            retryCount: tx.retryCount + 1,
-            transactionHash: res.hash || undefined,
-            provider: provider.connection.url || undefined,
+        reportUsage([
+          {
+            input: {
+              fromAddress: tx.fromAddress || undefined,
+              toAddress: tx.toAddress || undefined,
+              value: tx.value || undefined,
+              chainId: tx.chainId,
+              functionName: tx.functionName || undefined,
+              extension: tx.extension || undefined,
+              retryCount: tx.retryCount + 1,
+              transactionHash: transactionResponse.hash || undefined,
+              provider: provider.connection.url,
+            },
+            action: UsageEventTxActionEnum.SendTx,
           },
-          action: UsageEventTxActionEnum.SendTx,
-        });
-
-        reportUsage(reportUsageForQueueIds);
+        ]);
 
         logger({
           service: "worker",
           level: "info",
           queueId: tx.id,
-          message: `Retried with hash ${res.hash} for nonce ${res.nonce}`,
+          message: `Retried with hash ${transactionResponse.hash} for nonce ${transactionResponse.nonce}`,
         });
       },
       {

src/worker/tasks/updateMinedTx.ts

@@ -7,6 +7,7 @@ import { updateTx } from "../../db/transactions/updateTx";
 import { TransactionStatus } from "../../server/schemas/transaction";
 import { cancelTransactionAndUpdate } from "../../server/utils/transaction";
 import { getSdk } from "../../utils/cache/getSdk";
+import { msSince } from "../../utils/date";
 import { logger } from "../../utils/logger";
 import {
   ReportUsageParams,
@@ -65,7 +66,7 @@ export const updateMinedTx = async () => {
                         chainId: tx.chainId || undefined,
                         transactionHash: tx.transactionHash || undefined,
                         provider: provider.connection.url || undefined,
-                        msSinceSend: Date.now() - tx.sentAt!.getTime(),
+                        msSinceSend: msSince(tx.sentAt!),
                       },
                       action: UsageEventTxActionEnum.CancelTx,
                     });