typing...

arcoraven · arcoraven · commit 4f2132970ce2 · 2024-07-20T00:52:17.000-07:00
diff --git a/src/db/transactions/queueTx.ts b/src/db/transactions/queueTx.ts
@@ -59,6 +59,7 @@ export const queueTx = async ({
     const queueId = await insertTransaction({
       insertedTransaction: {
         ...baseTransaction,
+        isUserOp: true,
         deployedContractAddress,
         deployedContractType,
         signerAddress,
@@ -90,6 +91,7 @@ export const queueTx = async ({
     const queueId = await insertTransaction({
       insertedTransaction: {
         ...baseTransaction,
+        isUserOp: false,
         deployedContractAddress,
         deployedContractType,
         from: fromAddress.toLowerCase() as Address,
diff --git a/src/server/routes/backend-wallet/sendTransaction.ts b/src/server/routes/backend-wallet/sendTransaction.ts
@@ -85,6 +85,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
       } else {
         queueId = await insertTransaction({
           insertedTransaction: {
+            isUserOp: false,
             chainId,
             from: fromAddress as Address,
             to: toAddress as Address | undefined,
diff --git a/src/server/routes/backend-wallet/simulateTransaction.ts b/src/server/routes/backend-wallet/simulateTransaction.ts
@@ -100,21 +100,23 @@ export async function simulateTransaction(fastify: FastifyInstance) {
         functionArgs: args,
         data: data as Hex | undefined,
         value: value ? BigInt(value) : 0n,
-      };
 
-      if (accountAddress) {
-        queuedTransaction = {
-          ...queuedTransaction,
-          accountAddress: accountAddress as Address,
-          target: toAddress as Address,
-          signerAddress: walletAddress as Address,
-        };
-      }
+        ...(accountAddress
+          ? {
+              isUserOp: true,
+              accountAddress: accountAddress as Address,
+              target: toAddress as Address,
+              signerAddress: walletAddress as Address,
+            }
+          : {
+              isUserOp: false,
+            }),
+      };
 
-      const error = await simulateQueuedTransaction(queuedTransaction);
-      if (error) {
+      const simulateError = await simulateQueuedTransaction(queuedTransaction);
+      if (simulateError) {
         throw createCustomError(
-          error,
+          simulateError,
           StatusCodes.BAD_REQUEST,
           "FAILED_SIMULATION",
         );
diff --git a/src/server/routes/backend-wallet/transfer.ts b/src/server/routes/backend-wallet/transfer.ts
@@ -99,6 +99,7 @@ export async function transfer(fastify: FastifyInstance) {
         currencyAddress === NATIVE_TOKEN_ADDRESS
       ) {
         insertedTransaction = {
+          isUserOp: false,
           chainId,
           from: walletAddress as Address,
           to: to as Address,
@@ -129,6 +130,7 @@ export async function transfer(fastify: FastifyInstance) {
         const transaction = transferERC20({ contract, to, amount });
 
         insertedTransaction = {
+          isUserOp: false,
           chainId,
           from: walletAddress as Address,
           to: (await resolvePromisedValue(transaction.to)) as
diff --git a/src/server/routes/backend-wallet/withdraw.ts b/src/server/routes/backend-wallet/withdraw.ts
@@ -55,6 +55,7 @@ export async function withdraw(fastify: FastifyInstance) {
 
       const queueId = await insertTransaction({
         insertedTransaction: {
+          isUserOp: false,
           chainId,
           from: walletAddress as Address,
           to: toAddress as Address,
diff --git a/src/server/routes/transaction/cancel.ts b/src/server/routes/transaction/cancel.ts
@@ -1,7 +1,6 @@
 import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { Hex } from "thirdweb";
 import { TransactionDB } from "../../../db/transactions/db";
 import { getBlockNumberish } from "../../../utils/block";
 import { getConfig } from "../../../utils/cache/getConfig";
@@ -88,9 +87,9 @@ export async function cancelTransaction(fastify: FastifyInstance) {
       }
 
       let message = "Transaction successfully cancelled.";
-      let transactionHash: Hex = "0x";
-      switch (transaction.status) {
-        case "queued":
+      let cancelledTransaction: CancelledTransaction | null = null;
+      if (!transaction.isUserOp) {
+        if (transaction.status === "queued") {
           // Remove all retries from the SEND_TRANSACTION queue.
           const config = await getConfig();
           for (
@@ -100,42 +99,44 @@ export async function cancelTransaction(fastify: FastifyInstance) {
           ) {
             await SendTransactionQueue.remove({ queueId, retryCount });
           }
-          break;
-        case "sent":
+
+          cancelledTransaction = {
+            ...transaction,
+            status: "cancelled",
+            cancelledAt: new Date(),
+            sentAt: new Date(),
+            sentAtBlock: await getBlockNumberish(transaction.chainId),
+
+            isUserOp: false,
+            nonce: -1,
+            sentTransactionHashes: [],
+          };
+        } else if (transaction.status === "sent") {
           // Cancel a sent transaction with the same nonce.
           const { chainId, from, nonce } = transaction;
-          transactionHash = await sendCancellationTransaction({
+          const transactionHash = await sendCancellationTransaction({
             chainId,
             from,
-            nonce: Number(nonce),
+            nonce,
           });
-          break;
+          cancelledTransaction = {
+            ...transaction,
+            status: "cancelled",
+            cancelledAt: new Date(),
+            sentTransactionHashes: [transactionHash],
+          };
+        }
+      }
 
-        case "mined":
-        case "cancelled":
-        case "errored":
-          // Cannot cancel a transaction that is already completed.
-          throw createCustomError(
-            "Transaction cannot be cancelled.",
-            StatusCodes.BAD_REQUEST,
-            "TRANSACTION_CANNOT_BE_CANCELLED",
-          );
+      if (!cancelledTransaction) {
+        throw createCustomError(
+          "Transaction cannot be cancelled.",
+          StatusCodes.BAD_REQUEST,
+          "TRANSACTION_CANNOT_BE_CANCELLED",
+        );
       }
 
-      const cancelledTransaction: CancelledTransaction = {
-        ...transaction,
-        status: "cancelled",
-        sentAt: "sentAt" in transaction ? transaction.sentAt : new Date(),
-        sentAtBlock:
-          "sentAtBlock" in transaction
-            ? transaction.sentAtBlock
-            : await getBlockNumberish(transaction.chainId),
-        data: transaction.data ?? "0x",
-        nonce: "nonce" in transaction ? transaction.nonce : -1,
-        retryCount: "retryCount" in transaction ? transaction.retryCount : 0,
-        sentTransactionHashes: [transactionHash],
-        cancelledAt: new Date(),
-      };
+      // A queued or sent transaction was successfully cancelled.
       await TransactionDB.set(cancelledTransaction);
       await enqueueTransactionWebhook(cancelledTransaction);
       await _reportUsageSuccess(cancelledTransaction);
@@ -145,7 +146,7 @@ export async function cancelTransaction(fastify: FastifyInstance) {
           queueId,
           status: "success",
           message,
-          transactionHash,
+          transactionHash: cancelledTransaction.sentTransactionHashes.at(-1),
         },
       });
     },
diff --git a/src/server/routes/transaction/syncRetry.ts b/src/server/routes/transaction/syncRetry.ts
@@ -69,7 +69,7 @@ export async function syncRetryTransaction(fastify: FastifyInstance) {
           "TRANSACTION_NOT_FOUND",
         );
       }
-      if (transaction.status !== "sent") {
+      if (transaction.status !== "sent" || transaction.isUserOp) {
         throw createCustomError(
           "Transaction cannot be retried.",
           StatusCodes.BAD_REQUEST,
@@ -90,7 +90,7 @@ export async function syncRetryTransaction(fastify: FastifyInstance) {
           maxPriorityFeePerGas: maxPriorityFeePerGas
             ? BigInt(maxPriorityFeePerGas)
             : undefined,
-          nonce: Number(transaction.nonce),
+          nonce: transaction.nonce,
         },
       });
 
diff --git a/src/server/schemas/transaction/index.ts b/src/server/schemas/transaction/index.ts
@@ -241,7 +241,10 @@ export const toTransactionSchema = (
   const resolveTransactionHash = (): string | null => {
     switch (transaction.status) {
       case "sent":
-        return transaction.sentTransactionHashes.at(-1) ?? null;
+        if (!transaction.isUserOp) {
+          return transaction.sentTransactionHashes.at(-1) ?? null;
+        }
+        break;
       case "mined":
         return transaction.transactionHash;
     }
diff --git a/src/utils/env.ts b/src/utils/env.ts
@@ -118,3 +118,6 @@ export const env = createEnv({
     throw new Error("Invalid environment variables");
   },
 });
+
+console.log("[DEBUG] env", env);
+throw "done";
diff --git a/src/utils/transaction/cancelTransaction.ts b/src/utils/transaction/cancelTransaction.ts
@@ -23,7 +23,7 @@ export const sendCancellationTransaction = async (
       to: from,
       data: "0x",
       value: 0n,
-      nonce: Number(nonce),
+      nonce,
     },
   });
 
diff --git a/src/utils/transaction/types.ts b/src/utils/transaction/types.ts
@@ -34,6 +34,7 @@ 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.
@@ -56,11 +57,18 @@ export type SentTransaction =
       sentAtBlock: bigint;
     }) &
       (
-        | { nonce: number; sentTransactionHashes: Hex[] }
-        | { userOpNonce: string; userOpHash: Hex }
+        | { isUserOp: false; nonce: number; sentTransactionHashes: Hex[] }
+        | { isUserOp: true; nonce: string; userOpHash: Hex }
       );
 
-export type MinedTransaction = Omit<SentTransaction, "status"> & {
+// This type allows extending SentTransaction to support the ORed fields.
+type _SentTransactionEOA = SentTransaction & { isUserOp: false };
+type _SentTransactionUserOp = SentTransaction & { isUserOp: true };
+
+export type MinedTransaction = (
+  | Omit<_SentTransactionEOA, "status">
+  | Omit<_SentTransactionUserOp, "status">
+) & {
   status: "mined";
 
   transactionHash: Hex;
@@ -82,7 +90,10 @@ export type ErroredTransaction = Omit<QueuedTransaction, "status"> & {
 };
 
 // CancelledTransaction has been cancelled either via API or after some deadline.
-export type CancelledTransaction = Omit<SentTransaction, "status"> & {
+export type CancelledTransaction = (
+  | Omit<_SentTransactionEOA, "status">
+  | Omit<_SentTransactionUserOp, "status">
+) & {
   status: "cancelled";
 
   cancelledAt: Date;
diff --git a/src/worker/tasks/cancelTransactionWorker.ts b/src/worker/tasks/cancelTransactionWorker.ts
@@ -25,7 +25,11 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
 
   // Assert valid transaction state.
   const sentTransaction = await TransactionDB.get(queueId);
-  if (sentTransaction?.status !== "sent") {
+  if (
+    !sentTransaction ||
+    sentTransaction.status !== "sent" ||
+    sentTransaction.isUserOp
+  ) {
     job.log(`Invalid transaction state: ${stringify(sentTransaction)}`);
     return;
   }
@@ -36,7 +40,7 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
     chainId,
     from,
     // Crucial: Set the same transaction's nonce.
-    nonce: Number(nonce),
+    nonce,
   });
 
   job.log(`Cancel transaction sent: ${transactionHash}`);
diff --git a/src/worker/tasks/mineTransactionWorker.ts b/src/worker/tasks/mineTransactionWorker.ts
@@ -49,7 +49,7 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
 
   // Handle user operation or EOA transaction.
   let resultTransaction: MinedTransaction | null;
-  if ("userOpHash" in sentTransaction) {
+  if (sentTransaction.isUserOp) {
     resultTransaction = await _handleUserOp(job, sentTransaction);
   } else {
     resultTransaction = await _handleTransaction(job, sentTransaction);
@@ -99,11 +99,8 @@ const _reportUsageError = (erroredTransaction: ErroredTransaction) => {
 
 const _handleTransaction = async (
   job: Job,
-  sentTransaction: SentTransaction,
+  sentTransaction: SentTransaction & { isUserOp: false },
 ): Promise<MinedTransaction | null> => {
-  if (!("sentTransactionHashes" in sentTransaction)) {
-    throw "Missing 'sentTransactionHashes' when mining transaction.";
-  }
   const { queueId, chainId, sentTransactionHashes } = sentTransaction;
 
   const chain = await getChain(chainId);
@@ -169,12 +166,8 @@ const _handleTransaction = async (
 
 const _handleUserOp = async (
   job: Job,
-  sentTransaction: SentTransaction,
+  sentTransaction: SentTransaction & { isUserOp: true },
 ): Promise<MinedTransaction> => {
-  if (!("userOpHash" in sentTransaction)) {
-    throw new Error("Missing 'userOpHash' when mining user operation.");
-  }
-
   const { chainId, userOpHash } = sentTransaction;
   const chain = await getChain(chainId);
   const rpcRequest = getRpcClient({
@@ -232,7 +225,7 @@ _worker.on("failed", async (job: Job<string> | undefined) => {
       return;
     }
 
-    if ("userOpHash" in sentTransaction) {
+    if (sentTransaction.isUserOp) {
       // If userOp, set as errored.
       job.log("Transaction is unmined after timeout. Erroring transaction...");
       const erroredTransaction: ErroredTransaction = {
diff --git a/src/worker/tasks/sendTransactionWorker.ts b/src/worker/tasks/sendTransactionWorker.ts
@@ -100,7 +100,8 @@ const _handleQueuedTransaction = async (
     return {
       ...queuedTransaction,
       status: "sent",
-      userOpNonce: signedUserOp.nonce.toString(),
+      isUserOp: true,
+      nonce: signedUserOp.nonce.toString(),
       userOpHash,
       retryCount: 0,
       sentAt: new Date(),
@@ -133,6 +134,7 @@ const _handleQueuedTransaction = async (
   return {
     ...queuedTransaction,
     status: "sent",
+    isUserOp: false,
     nonce: populatedTransaction.nonce,
     sentTransactionHashes: [transactionHash],
     retryCount: 0,
@@ -151,8 +153,8 @@ const _handleSentTransaction = async (
   retryCount: number,
 ): Promise<SentTransaction | ErroredTransaction> => {
   const { chainId, from } = sentTransaction;
-  if (!("nonce" in sentTransaction)) {
-    throw new Error("Missing 'nonce' when retrying transaction.");
+  if (sentTransaction.isUserOp) {
+    throw new Error("Cannot retry a userOp.");
   }
 
   const populatedTransaction = await toSerializableTransaction({
