cleanup and comments

arcoraven · arcoraven · commit b2cec117c219 · 2024-07-26T15:30:58.000-07:00
diff --git a/.eslintrc.json b/.eslintrc.json
@@ -13,8 +13,6 @@
     "@typescript-eslint/no-unused-vars": [
       "error",
       { "argsIgnorePattern": "^_" }
-    ],
-    "require-await": "off",
-    "@typescript-eslint/require-await": "error"
+    ]
   }
 }
diff --git a/src/db/transactions/getSentUserOps.ts b/src/db/transactions/getSentUserOps.ts
diff --git a/src/db/transactions/queueTx.ts b/src/db/transactions/queueTx.ts
@@ -1,8 +1,8 @@
 import type { DeployTransaction, Transaction } from "@thirdweb-dev/sdk";
 import { ERC4337EthersSigner } from "@thirdweb-dev/wallets/dist/declarations/src/evm/connectors/smart-wallet/lib/erc4337-signer";
-import { Address } from "thirdweb";
+import { Address, ZERO_ADDRESS } from "thirdweb";
 import type { ContractExtension } from "../../schema/extension";
-import { maybeBigInt } from "../../utils/primitiveTypes";
+import { maybeBigInt, normalizeAddress } from "../../utils/primitiveTypes";
 import { insertTransaction } from "../../utils/transaction/insertTransaction";
 
 interface QueueTxParams {
@@ -49,50 +49,42 @@ export const queueTx = async ({
   const isUserOp = !!(tx.getSigner as ERC4337EthersSigner).erc4337provider;
 
   if (isUserOp) {
-    const signerAddress = (
-      await (tx.getSigner as ERC4337EthersSigner).originalSigner.getAddress()
-    ).toLowerCase() as Address;
-    const accountAddress = (
-      await tx.getSignerAddress()
-    ).toLowerCase() as Address;
-    const target = tx.getTarget().toLowerCase() as Address;
+    const signer = (tx.getSigner as ERC4337EthersSigner).originalSigner;
+    const signerAddress = normalizeAddress(await signer.getAddress());
 
-    const queueId = await insertTransaction({
+    return await insertTransaction({
       insertedTransaction: {
         ...baseTransaction,
         isUserOp: true,
         deployedContractAddress,
         deployedContractType,
+        from: signerAddress,
         signerAddress,
-        accountAddress,
-        target,
+        accountAddress: normalizeAddress(await tx.getSignerAddress()),
+        target: normalizeAddress(tx.getTarget()),
         gas: maybeBigInt(txOverrides?.gas),
         maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
         maxPriorityFeePerGas: maybeBigInt(txOverrides?.maxPriorityFeePerGas),
-        from: signerAddress,
       },
       idempotencyKey,
       shouldSimulate: simulateTx,
     });
-
-    return queueId;
   } else {
-    const fromAddress = await tx.getSignerAddress();
-    const toAddress =
-      tx.getTarget() === "0x0000000000000000000000000000000000000000" &&
+    const isPublishedContractDeploy =
+      tx.getTarget() === ZERO_ADDRESS &&
       functionName === "deploy" &&
-      extension === "deploy-published"
-        ? null
-        : tx.getTarget();
+      extension === "deploy-published";
 
     const queueId = await insertTransaction({
       insertedTransaction: {
         ...baseTransaction,
         isUserOp: false,
         deployedContractAddress,
         deployedContractType,
-        from: fromAddress.toLowerCase() as Address,
-        to: toAddress?.toLowerCase() as Address,
+        from: normalizeAddress(await tx.getSignerAddress()),
+        to: normalizeAddress(
+          isPublishedContractDeploy ? undefined : tx.getTarget(),
+        ),
         gas: maybeBigInt(txOverrides?.gas),
         maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
         maxPriorityFeePerGas: maybeBigInt(txOverrides?.maxPriorityFeePerGas),
diff --git a/src/db/wallets/walletNonce.ts b/src/db/wallets/walletNonce.ts
@@ -1,15 +1,22 @@
 import { Address, eth_getTransactionCount, getRpcClient } from "thirdweb";
 import { getChain } from "../../utils/chain";
+import { normalizeAddress } from "../../utils/primitiveTypes";
 import { redis } from "../../utils/redis/redis";
 import { thirdwebClient } from "../../utils/sdk";
 
-// Data type: String
+/**
+ * The "last used nonce" stores the last nonce submitted onchain.
+ * Example: "25"
+ */
 const lastUsedNonceKey = (chainId: number, walletAddress: Address) =>
-  `nonce:${chainId}:${walletAddress}`;
+  `nonce:${chainId}:${normalizeAddress(walletAddress)}`;
 
-// Data type: Array of String
+/**
+ * The "unused nonces" list stores unsorted nonces to be reused or cancelled.
+ * Example: [ "25", "23", "24" ]
+ */
 const unusedNoncesKey = (chainId: number, walletAddress: Address) =>
-  `nonce-unused:${chainId}:${walletAddress}`;
+  `nonce-unused:${chainId}:${normalizeAddress(walletAddress)}`;
 
 /**
  * Acquire an unused nonce.
@@ -89,7 +96,7 @@ const _syncNonce = async (
  * Use `incrWalletNonce` if using this nonce to send a transaction.
  * @param chainId
  * @param walletAddress
- * @returns number - The last used nonce value for this wallet.
+ * @returns number
  */
 export const inspectNonce = async (chainId: number, walletAddress: Address) => {
   const key = lastUsedNonceKey(chainId, walletAddress);
diff --git a/src/server/routes/backend-wallet/getTransactions.ts b/src/server/routes/backend-wallet/getTransactions.ts
@@ -2,6 +2,7 @@ import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { TransactionDB } from "../../../db/transactions/db";
+import { normalizeAddress } from "../../../utils/primitiveTypes";
 import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
 import {
   TransactionSchema,
@@ -39,7 +40,7 @@ export async function getAllTransactions(fastify: FastifyInstance) {
     handler: async (req, res) => {
       const { chain, walletAddress: _walletAddress } = req.params;
       const chainId = await getChainIdFromChain(chain);
-      const walletAddress = _walletAddress.toLowerCase();
+      const walletAddress = normalizeAddress(_walletAddress);
 
       // @TODO: This query is not optimized. Cap the results to the most recent 1000 total transactions for performance reasons.
       const { transactions } = await TransactionDB.listByStatus({
diff --git a/src/server/routes/backend-wallet/simulateTransaction.ts b/src/server/routes/backend-wallet/simulateTransaction.ts
@@ -88,7 +88,7 @@ export async function simulateTransaction(fastify: FastifyInstance) {
         status: "queued",
         queueId: randomUUID(),
         queuedAt: new Date(),
-        retryCount: 0,
+        resendCount: 0,
 
         chainId,
         from: walletAddress as Address,
diff --git a/src/server/routes/backend-wallet/transfer.ts b/src/server/routes/backend-wallet/transfer.ts
@@ -12,7 +12,7 @@ import {
 import { transfer as transferERC20 } from "thirdweb/extensions/erc20";
 import { isContractDeployed, resolvePromisedValue } from "thirdweb/utils";
 import { getChain } from "../../../utils/chain";
-import { maybeBigInt } from "../../../utils/primitiveTypes";
+import { maybeBigInt, normalizeAddress } from "../../../utils/primitiveTypes";
 import { thirdwebClient } from "../../../utils/sdk";
 import { insertTransaction } from "../../../utils/transaction/insertTransaction";
 import { InsertedTransaction } from "../../../utils/transaction/types";
@@ -87,7 +87,7 @@ export async function transfer(fastify: FastifyInstance) {
       const { simulateTx: shouldSimulate } = request.query;
 
       // Resolve inputs.
-      const currencyAddress = _currencyAddress.toLowerCase();
+      const currencyAddress = normalizeAddress(_currencyAddress);
       const chainId = await getChainIdFromChain(chain);
       const gasOverrides = {
         gas: maybeBigInt(txOverrides?.gas),
diff --git a/src/server/routes/transaction/cancel.ts b/src/server/routes/transaction/cancel.ts
@@ -93,11 +93,11 @@ export async function cancelTransaction(fastify: FastifyInstance) {
           // Remove all retries from the SEND_TRANSACTION queue.
           const config = await getConfig();
           for (
-            let retryCount = 0;
-            retryCount < config.maxRetriesPerTx;
-            retryCount++
+            let resendCount = 0;
+            resendCount < config.maxRetriesPerTx;
+            resendCount++
           ) {
-            await SendTransactionQueue.remove({ queueId, retryCount });
+            await SendTransactionQueue.remove({ queueId, resendCount });
           }
 
           cancelledTransaction = {
diff --git a/src/server/routes/transaction/retry.ts b/src/server/routes/transaction/retry.ts
@@ -80,7 +80,7 @@ export async function retryTransaction(fastify: FastifyInstance) {
       await TransactionDB.set(sentTransaction);
       await SendTransactionQueue.add({
         queueId: sentTransaction.queueId,
-        retryCount: sentTransaction.retryCount + 1,
+        resendCount: sentTransaction.resendCount + 1,
       });
 
       reply.status(StatusCodes.OK).send({
diff --git a/src/server/routes/transaction/syncRetry.ts b/src/server/routes/transaction/syncRetry.ts
@@ -102,7 +102,7 @@ export async function syncRetryTransaction(fastify: FastifyInstance) {
       // Update state if the send was successful.
       const sentTransaction: SentTransaction = {
         ...transaction,
-        retryCount: transaction.retryCount + 1,
+        resendCount: transaction.resendCount + 1,
         sentAt: new Date(),
         sentAtBlock: await getBlockNumberish(chainId),
         sentTransactionHashes: [
diff --git a/src/server/schemas/transaction/index.ts b/src/server/schemas/transaction/index.ts
@@ -287,7 +287,7 @@ export const toTransactionSchema = (
       "sentAtBlock" in transaction ? Number(transaction.sentAtBlock) : null,
     blockNumber:
       "minedAtBlock" in transaction ? Number(transaction.minedAtBlock) : null,
-    retryCount: "retryCount" in transaction ? transaction.retryCount : 0,
+    retryCount: "retryCount" in transaction ? transaction.resendCount : 0,
     onChainTxStatus: resolveOnchainStatus(),
     effectiveGasPrice:
       "effectiveGasPrice" in transaction
diff --git a/src/utils/primitiveTypes.ts b/src/utils/primitiveTypes.ts
@@ -1 +1,12 @@
+import { Address } from "thirdweb";
+
 export const maybeBigInt = (val?: string) => (val ? BigInt(val) : undefined);
+
+// These overloads hint TS at the response type (ex: Address if `val` is Address).
+export function normalizeAddress(val: Address): Address;
+export function normalizeAddress(val: Address | undefined): Address | undefined;
+export function normalizeAddress(val: string): Address;
+export function normalizeAddress(val: string | undefined): Address | undefined;
+export function normalizeAddress(val?: string | Address): Address | undefined {
+  return val ? (val.toLowerCase() as Address) : undefined;
+}
diff --git a/src/utils/transaction/insertTransaction.ts b/src/utils/transaction/insertTransaction.ts
@@ -1,8 +1,8 @@
 import { randomUUID } from "crypto";
-import { Address } from "thirdweb";
 import { TransactionDB } from "../../db/transactions/db";
 import { createCustomError } from "../../server/middleware/error";
 import { SendTransactionQueue } from "../../worker/queues/sendTransactionQueue";
+import { normalizeAddress } from "../primitiveTypes";
 import { reportUsage } from "../usage";
 import { simulateQueuedTransaction } from "./simulateQueuedTransaction";
 import { InsertedTransaction, QueuedTransaction } from "./types";
@@ -13,27 +13,42 @@ interface InsertTransactionData {
   shouldSimulate?: boolean;
 }
 
+/**
+ * Enqueue a transaction to be submitted onchain.
+ *
+ * @param args
+ * @returns queueId
+ */
 export const insertTransaction = async (
   args: InsertTransactionData,
 ): Promise<string> => {
   const { insertedTransaction, idempotencyKey, shouldSimulate = false } = args;
 
-  // The queueId is the idempotency key. Default to a random UUID (no idempotency).
-  const queueId = idempotencyKey ?? randomUUID();
-  if (await TransactionDB.exists(queueId)) {
-    // No-op. Return the existing queueId.
-    return queueId;
+  // The queueId uniquely represents an enqueued transaction.
+  // It's also used as the idempotency key (default = no idempotence).
+  let queueId: string = randomUUID();
+  if (idempotencyKey) {
+    queueId = idempotencyKey;
+    if (await TransactionDB.exists(queueId)) {
+      // No-op. Return the existing queueId.
+      return queueId;
+    }
   }
 
   const queuedTransaction: QueuedTransaction = {
     ...insertedTransaction,
     status: "queued",
     queueId,
     queuedAt: new Date(),
-    retryCount: 0,
+    resendCount: 0,
 
-    from: insertedTransaction.from.toLowerCase() as Address,
-    to: insertedTransaction.to?.toLowerCase() as Address | undefined,
+    // Standardize address formats.
+    from: normalizeAddress(insertedTransaction.from),
+    to: normalizeAddress(insertedTransaction.to),
+    signerAddress: normalizeAddress(insertedTransaction.signerAddress),
+    accountAddress: normalizeAddress(insertedTransaction.accountAddress),
+    target: normalizeAddress(insertedTransaction.target),
+    sender: normalizeAddress(insertedTransaction.sender),
     value: insertedTransaction.value ?? 0n,
   };
 
@@ -52,9 +67,9 @@ export const insertTransaction = async (
   await TransactionDB.set(queuedTransaction);
   await SendTransactionQueue.add({
     queueId: queuedTransaction.queueId,
-    retryCount: 0,
+    resendCount: 0,
   });
-
   reportUsage([{ action: "queue_tx", input: queuedTransaction }]);
+
   return queueId;
 };
diff --git a/src/utils/transaction/types.ts b/src/utils/transaction/types.ts
@@ -10,6 +10,7 @@ export type AnyTransaction =
 
 // InsertedTransaction is the raw input from the caller.
 export type InsertedTransaction = {
+  isUserOp: boolean;
   chainId: number;
   from: Address;
   to?: Address;
@@ -34,14 +35,13 @@ export type InsertedTransaction = {
   accountAddress?: Address;
   target?: Address;
   sender?: Address;
-  isUserOp: boolean;
 };
 
 // QueuedTransaction is a transaction added to the queue. No preparation has been done yet.
 export type QueuedTransaction = InsertedTransaction & {
   status: "queued";
 
-  retryCount: number;
+  resendCount: number;
   queueId: string;
   queuedAt: Date;
   value: bigint;
diff --git a/src/worker/queues/sendTransactionQueue.ts b/src/worker/queues/sendTransactionQueue.ts
@@ -5,7 +5,7 @@ import { defaultJobOptions } from "./queues";
 
 export type SendTransactionData = {
   queueId: string;
-  retryCount: number;
+  resendCount: number;
 };
 
 export class SendTransactionQueue {
@@ -21,7 +21,7 @@ export class SendTransactionQueue {
 
   // Allow enqueing the same queueId for multiple retries.
   private static _jobId = (data: SendTransactionData) =>
-    `${data.queueId}:${data.retryCount}`;
+    `${data.queueId}:${data.resendCount}`;
 
   static add = async (data: SendTransactionData) => {
     const serialized = superjson.stringify(data);
diff --git a/src/worker/tasks/mineTransactionWorker.ts b/src/worker/tasks/mineTransactionWorker.ts
diff --git a/src/worker/tasks/processEventLogsWorker.ts b/src/worker/tasks/processEventLogsWorker.ts
diff --git a/src/worker/tasks/processTransactionReceiptsWorker.ts b/src/worker/tasks/processTransactionReceiptsWorker.ts
diff --git a/src/worker/tasks/sendTransactionWorker.ts b/src/worker/tasks/sendTransactionWorker.ts

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,6 @@`
`13`	`13`	`"@typescript-eslint/no-unused-vars": [`
`14`	`14`	`"error",`
`15`	`15`	`{ "argsIgnorePattern": "^_" }`
`16`		`- ],`
`17`		`- "require-await": "off",`
`18`		`- "@typescript-eslint/require-await": "error"`
	`16`	`+ ]`
`19`	`17`	`}`
`20`	`18`	`}`