fix build, add nonce helpers

Author: arcoraven

src/db/wallets/walletNonce.ts

@@ -6,6 +6,14 @@ import { thirdwebClient } from "../../utils/sdk";
 const nonceKey = (chainId: number, walletAddress: Address) =>
   `nonce:${chainId}:${walletAddress}`;
 
+/**
+ * Increment to get the next unused nonce.
+ * If a nonce is acquired this way, it must be used for an onchain transaction
+ * (or cancelled onchain).
+ * @param chainId
+ * @param walletAddress
+ * @returns number - The next unused nonce value for this wallet.
+ */
 export const incrWalletNonce = async (
   chainId: number,
   walletAddress: Address,
@@ -15,12 +23,12 @@ export const incrWalletNonce = async (
   if (nonce === 1) {
     // If INCR returned 1, the nonce was not set.
     // This may be a newly imported wallet. Sync and return the onchain nonce.
-    nonce = await syncWalletNonce(chainId, walletAddress);
+    nonce = await _syncWalletNonce(chainId, walletAddress);
   }
   return nonce;
 };
 
-export const syncWalletNonce = async (
+const _syncWalletNonce = async (
   chainId: number,
   walletAddress: Address,
 ): Promise<number> => {
@@ -38,3 +46,30 @@ export const syncWalletNonce = async (
   await redis.set(key, transactionCount);
   return transactionCount;
 };
+
+/**
+ * Returns the last used nonce.
+ * This function should be used to inspect nonce values only.
+ * Use `incrWalletNonce` if using this nonce to send a transaction.
+ * @param chainId
+ * @param walletAddress
+ * @returns number - The last used nonce value for this wallet.
+ */
+export const getWalletNonce = async (
+  chainId: number,
+  walletAddress: Address,
+) => {
+  const key = nonceKey(chainId, walletAddress);
+  const nonce = await redis.get(key);
+  return nonce ? parseInt(nonce) : 0;
+};
+
+/**
+ * Delete all wallet nonces. Useful when the get out of sync.
+ */
+export const deleteWalletNonces = async () => {
+  const keys = await redis.keys("nonce:*");
+  if (keys.length > 0) {
+    await redis.del(keys);
+  }
+};

src/server/routes/backend-wallet/getNonce.ts

@@ -0,0 +1,55 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { Address } from "thirdweb";
+import { getWalletNonce } from "../../../db/wallets/walletNonce";
+import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
+import { walletParamSchema } from "../../schemas/wallet";
+import { getChainIdFromChain } from "../../utils/chain";
+
+const requestSchema = walletParamSchema;
+
+const responseSchema = Type.Object({
+  result: Type.Object({
+    nonce: Type.Number(),
+  }),
+});
+
+responseSchema.example = {
+  result: {
+    nonce: 100,
+  },
+};
+
+export const getBackendWalletNonce = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof requestSchema>;
+    Reply: Static<typeof responseSchema>;
+  }>({
+    method: "GET",
+    url: "/backend-wallet/:chain/:walletAddress/get-nonce",
+    schema: {
+      summary: "Get nonce",
+      description:
+        "Get the last used nonce for this backend wallet. This value managed by Engine may differ from the onchain value. Use `/backend-wallet/reset-nonces` if this value looks incorrect while idle.",
+      tags: ["Backend Wallet"],
+      operationId: "getNonce",
+      params: requestSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (req, reply) => {
+      const { chain, walletAddress } = req.params;
+      const chainId = await getChainIdFromChain(chain);
+      const nonce = await getWalletNonce(chainId, walletAddress as Address);
+
+      reply.status(StatusCodes.OK).send({
+        result: {
+          nonce,
+        },
+      });
+    },
+  });
+};

src/server/routes/backend-wallet/resetNonces.ts

@@ -0,0 +1,46 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { deleteWalletNonces } from "../../../db/wallets/walletNonce";
+import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
+
+const responseSchema = Type.Object({
+  result: Type.Object({
+    status: Type.String(),
+  }),
+});
+
+responseSchema.example = {
+  result: {
+    status: "success",
+  },
+};
+
+export const resetBackendWalletNonces = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Reply: Static<typeof responseSchema>;
+  }>({
+    method: "POST",
+    url: "/backend-wallet/reset-nonces",
+    schema: {
+      summary: "Reset nonces",
+      description:
+        "Reset nonces for all backend wallets. This is for debugging purposes and does not impact held tokens.",
+      tags: ["Backend Wallet"],
+      operationId: "resetNonces",
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (req, reply) => {
+      await deleteWalletNonces();
+
+      reply.status(StatusCodes.OK).send({
+        result: {
+          status: "success",
+        },
+      });
+    },
+  });
+};

src/server/routes/index.ts

@@ -46,6 +46,7 @@ import { extractFunctions } from "./contract/metadata/functions";
 import { createBackendWallet } from "./backend-wallet/create";
 import { getAll } from "./backend-wallet/getAll";
 import { getBalance } from "./backend-wallet/getBalance";
+import { getBackendWalletNonce } from "./backend-wallet/getNonce";
 import { importBackendWallet } from "./backend-wallet/import";
 import { sendTransaction } from "./backend-wallet/sendTransaction";
 import { transfer } from "./backend-wallet/transfer";
@@ -107,6 +108,7 @@ import { revokeRelayer } from "./relayer/revoke";
 
 // System
 import { getAllTransactions } from "./backend-wallet/getTransactions";
+import { resetBackendWalletNonces } from "./backend-wallet/resetNonces";
 import { sendTransactionBatch } from "./backend-wallet/sendTransactionBatch";
 import { simulateTransaction } from "./backend-wallet/simulateTransaction";
 import { withdraw } from "./backend-wallet/withdraw";
@@ -152,6 +154,8 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(signMessage);
   await fastify.register(signTypedData);
   await fastify.register(getAllTransactions);
+  await fastify.register(resetBackendWalletNonces);
+  await fastify.register(getBackendWalletNonce);
   await fastify.register(simulateTransaction);
 
   // Configuration

src/server/schemas/wallet/index.ts

@@ -1,13 +1,13 @@
 import { Type } from "@sinclair/typebox";
+import { env } from "../../../utils/env";
 
 export const walletHeaderSchema = Type.Object({
   "x-backend-wallet-address": Type.String({
     description: "Backend wallet address",
   }),
   "x-idempotency-key": Type.Optional(
     Type.String({
-      description:
-        "A string that uniquely identifies this transaction. Submitting the same idempotency key will not enqueue a new transaction for 24 hours.",
+      description: `A string that uniquely identifies this transaction. Submitting the same idempotency key will not enqueue a new transaction for ${env.PRUNE_TRANSACTIONS} day(s).`,
     }),
   ),
 });

src/utils/transaction/insertTransaction.ts

@@ -63,13 +63,11 @@ export const insertTransaction = async (
   return queueId;
 };
 
+// This logic is more accurate in the worker, but withdraws are generally not used programmatically during high volume.
 const getWithdrawValue = async (
   queuedTransaction: QueuedTransaction,
 ): Promise<bigint> => {
-  const { chainId, from, to } = queuedTransaction;
-  if (!to) {
-    throw new Error('Missing "to".');
-  }
+  const { chainId, from } = queuedTransaction;
 
   const chain = await getChain(chainId);
 
@@ -82,15 +80,15 @@ const getWithdrawValue = async (
 
   // Estimate gas for a transfer.
   const transaction = prepareTransaction({
-    value: BigInt(1),
-    to,
     chain,
     client: thirdwebClient,
+    value: 1n, // dummy value
+    to: from, // dummy value
   });
   const { wei: transferCostWei } = await estimateGasCost({ transaction });
 
-  // Add a 20% buffer for gas variance.
-  const buffer = BigInt(Math.round(Number(transferCostWei) * 0.2));
+  // Add a +50% buffer for gas variance.
+  const buffer = transferCostWei / 2n;
 
   return balanceWei - transferCostWei - buffer;
 };

src/worker/tasks/mineTransactionWorker.ts

@@ -160,7 +160,9 @@ const _handleTransaction = async (
   }
 
   // If the transaction is not mined yet, throw to retry later.
-  job.log("Transaction is not mined yet. Check again later...");
+  job.log(
+    `Transaction is not mined yet (${sentTransactionHashes}). Check again later...`,
+  );
   throw new Error("NOT_CONFIRMED_YET");
 };
 

src/worker/tasks/purgeTransactionsWorker.ts

@@ -1,16 +1,16 @@
 import { Job, Processor, Worker } from "bullmq";
 import { TransactionDB } from "../../db/transactions/db";
+import { env } from "../../utils/env";
 import { redis } from "../../utils/redis/redis";
 import { PURGE_TRANSACTIONS_QUEUE_NAME } from "../queues/purgeTransactionsQueue";
 import { logWorkerEvents } from "../queues/queues";
 
 const handler: Processor<any, void, string> = async (job: Job<string>) => {
-  const purgeBeforeDate =
-    Date.now() - TransactionDB.COMPLETED_TRANSACTIONS_MAX_AGE_SECONDS * 1000;
+  // Purge transactions up to `PRUNE_TRANSACTIONS` days ago.
+  const to = new Date();
+  to.setDate(to.getDate() - env.PRUNE_TRANSACTIONS);
 
-  await TransactionDB.purgeTransactions({
-    to: new Date(purgeBeforeDate),
-  });
+  await TransactionDB.purgeTransactions({ to });
 };
 
 // Worker