fix: Updated minedTx flow + removed deleteAllNonce on start-up (#461)

* fix: Updated minedTx flow + removed deleteNonce on start-up

* Updated getSentTx() to use nonce

* added new error enum to usage reporting

Author: farhanW3

src/db/transactions/getSentTxs.ts

@@ -22,7 +22,7 @@ export const getSentTxs = async ({ pgtx }: GetSentTxsParams = {}): Promise<
     AND "minedAt" IS NULL
     AND "errorMessage" IS NULL
     AND "retryCount" < ${config.maxTxsToUpdate}
-    ORDER BY "sentAt" ASC
+    ORDER BY "nonce" ASC
     LIMIT ${config.maxTxsToUpdate}
     FOR UPDATE SKIP LOCKED
   `;

src/server/index.ts

@@ -3,7 +3,6 @@ import fastify, { FastifyInstance } from "fastify";
 import * as fs from "fs";
 import path from "path";
 import { URL } from "url";
-import { deleteAllWalletNonces } from "../db/wallets/deleteAllWalletNonces";
 import { clearCacheCron } from "../utils/cron/clearCacheCron";
 import { env } from "../utils/env";
 import { logger } from "../utils/logger";
@@ -34,10 +33,6 @@ interface HttpsObject {
 }
 
 export const initServer = async () => {
-  // Reset any server state that is safe to reset.
-  // This allows the server to start in a predictable state.
-  await deleteAllWalletNonces({});
-
   // Enables the server to run on https://localhost:PORT, if ENABLE_HTTPS is provided.
   let httpsObject: HttpsObject | undefined = undefined;
   if (env.ENABLE_HTTPS) {

src/utils/usage.ts

@@ -47,6 +47,7 @@ export enum UsageEventTxActionEnum {
   SendTx = "send_tx",
   CancelTx = "cancel_tx",
   APIRequest = "api_request",
+  ErrorTx = "error_tx",
 }
 
 interface UsageEventSchema extends Omit<UsageEvent, "action"> {

src/worker/tasks/retryTx.ts

@@ -98,7 +98,7 @@ export const retryTx = async () => {
               retryCount: tx.retryCount + 1 || 0,
               provider: provider.connection.url || undefined,
             },
-            action: UsageEventTxActionEnum.NotSendTx,
+            action: UsageEventTxActionEnum.ErrorTx,
           });
 
           reportUsage(reportUsageForQueueIds);

src/worker/tasks/updateMinedTx.ts

@@ -48,28 +48,57 @@ export const updateMinedTx = async () => {
                 const sentAt = new Date(tx.sentAt!);
                 const ageInMilliseconds = Date.now() - sentAt.getTime();
                 if (ageInMilliseconds > MEMPOOL_DURATION_TIMEOUT_MS) {
-                  await cancelTransactionAndUpdate({
-                    queueId: tx.id,
-                    pgtx,
-                  });
-
-                  sendWebhookForQueueIds.push({
-                    queueId: tx.id,
-                    status: TransactionStatusEnum.Cancelled,
-                  });
-
-                  reportUsageForQueueIds.push({
-                    input: {
-                      fromAddress: tx.fromAddress || undefined,
-                      toAddress: tx.toAddress || undefined,
-                      value: tx.value || undefined,
-                      chainId: tx.chainId || undefined,
-                      transactionHash: tx.transactionHash || undefined,
-                      provider: provider.connection.url || undefined,
-                      msSinceSend: Date.now() - tx.sentAt!.getTime(),
-                    },
-                    action: UsageEventTxActionEnum.CancelTx,
-                  });
+                  try {
+                    await cancelTransactionAndUpdate({
+                      queueId: tx.id,
+                      pgtx,
+                    });
+
+                    sendWebhookForQueueIds.push({
+                      queueId: tx.id,
+                      status: TransactionStatusEnum.Cancelled,
+                    });
+
+                    reportUsageForQueueIds.push({
+                      input: {
+                        fromAddress: tx.fromAddress || undefined,
+                        toAddress: tx.toAddress || undefined,
+                        value: tx.value || undefined,
+                        chainId: tx.chainId || undefined,
+                        transactionHash: tx.transactionHash || undefined,
+                        provider: provider.connection.url || undefined,
+                        msSinceSend: Date.now() - tx.sentAt!.getTime(),
+                      },
+                      action: UsageEventTxActionEnum.CancelTx,
+                    });
+                  } catch (error) {
+                    await updateTx({
+                      pgtx,
+                      queueId: tx.id,
+                      data: {
+                        status: TransactionStatusEnum.Errored,
+                        errorMessage: "Transaction timed out.",
+                      },
+                    });
+
+                    sendWebhookForQueueIds.push({
+                      queueId: tx.id,
+                      status: TransactionStatusEnum.Errored,
+                    });
+
+                    reportUsageForQueueIds.push({
+                      input: {
+                        fromAddress: tx.fromAddress || undefined,
+                        toAddress: tx.toAddress || undefined,
+                        value: tx.value || undefined,
+                        chainId: tx.chainId || undefined,
+                        transactionHash: tx.transactionHash || undefined,
+                        provider: provider.connection.url || undefined,
+                        msSinceSend: Date.now() - tx.sentAt!.getTime(),
+                      },
+                      action: UsageEventTxActionEnum.ErrorTx,
+                    });
+                  }
                 }
                 return;
               }