Add queueTxRaw (#341)

Author: adam-maj

src/db/transactions/queueNativeTokenTransferTx.ts

@@ -7,8 +7,7 @@ import { ERC4337EthersSigner } from "@thirdweb-dev/wallets/dist/declarations/src
 import { BigNumber } from "ethers";
 import type { ContractExtension } from "../../schema/extension";
 import { PrismaTransaction } from "../../schema/prisma";
-import { getPrismaWithPostgresTx } from "../client";
-import { getWalletDetails } from "../wallets/getWalletDetails";
+import { queueTxRaw } from "./queueTxRaw";
 
 interface QueueTxParams {
   pgtx?: PrismaTransaction;
@@ -29,31 +28,21 @@ export const queueTx = async ({
   deployedContractAddress,
   deployedContractType,
 }: QueueTxParams) => {
-  // Simulate transaction
   try {
     if (!deployedContractAddress) {
       await tx.simulate();
     }
-  } catch (e) {
-    const message = (e as TransactionError)?.reason || (e as any).message || e;
-    throw new Error(`Transaction simulation failed with reason: ${message}`);
-  }
-
-  const prisma = getPrismaWithPostgresTx(pgtx);
-
-  const fromAddress = (await tx.getSignerAddress()).toLowerCase();
-  const walletDetails = await getWalletDetails({
-    pgtx,
-    address: fromAddress,
-  });
-
-  if (!walletDetails) {
-    throw new Error(`No configured wallet found with address ${fromAddress}`);
+  } catch (err: any) {
+    const errorMessage =
+      (err as TransactionError)?.reason || (err as any).message || err;
+    throw new Error(
+      `Transaction simulation failed with reason: ${errorMessage}`,
+    );
   }
 
   // TODO: We need a much safer way of detecting if the transaction should be a user operation
   const isUserOp = !!(tx.getSigner as ERC4337EthersSigner).erc4337provider;
-  const txTableData = {
+  const txData = {
     chainId: chainId.toString(),
     functionName: tx.getMethod(),
     functionArgs: JSON.stringify(tx.getArgs()),
@@ -65,28 +54,30 @@ export const queueTx = async ({
   };
 
   if (isUserOp) {
-    const { id: queueId } = await prisma.transactions.create({
-      data: {
-        ...txTableData,
-        // Fields needed to get smart wallet signer in worker
-        signerAddress: await (
-          tx.getSigner as ERC4337EthersSigner
-        ).originalSigner.getAddress(),
-        accountAddress: fromAddress,
-        // Fields needed to send user operation
-        target: tx.getTarget().toLowerCase(),
-      },
+    const signerAddress = await (
+      tx.getSigner as ERC4337EthersSigner
+    ).originalSigner.getAddress();
+    const accountAddress = await tx.getSignerAddress();
+    const target = tx.getTarget();
+
+    const { id: queueId } = await queueTxRaw({
+      pgtx,
+      ...txData,
+      signerAddress,
+      accountAddress,
+      target,
     });
 
     return queueId;
   } else {
-    const { id: queueId } = await prisma.transactions.create({
-      data: {
-        ...txTableData,
-        // Fields needed to send transaction
-        fromAddress,
-        toAddress: tx.getTarget().toLowerCase(),
-      },
+    const fromAddress = await tx.getSignerAddress();
+    const toAddress = tx.getTarget();
+
+    const { id: queueId } = await queueTxRaw({
+      pgtx,
+      ...txData,
+      fromAddress,
+      toAddress,
     });
 
     return queueId;

src/db/transactions/queueTx.ts

@@ -0,0 +1,49 @@
+import type { Prisma } from "@prisma/client";
+import { PrismaTransaction } from "../../schema/prisma";
+import { getPrismaWithPostgresTx } from "../client";
+import { getWalletDetails } from "../wallets/getWalletDetails";
+
+type QueueTxRawParams = Omit<
+  Prisma.TransactionsCreateInput,
+  "fromAddress" | "signerAddress"
+> & {
+  pgtx?: PrismaTransaction;
+} & (
+    | {
+        fromAddress: string;
+        signerAddress?: never;
+      }
+    | {
+        fromAddress?: never;
+        signerAddress: string;
+      }
+  );
+
+// TODO: Simulation should be moved to this function
+export const queueTxRaw = async ({ pgtx, ...tx }: QueueTxRawParams) => {
+  const prisma = getPrismaWithPostgresTx(pgtx);
+
+  const walletDetails = await getWalletDetails({
+    pgtx,
+    address: (tx.fromAddress || tx.signerAddress) as string,
+  });
+
+  if (!walletDetails) {
+    throw new Error(
+      `No backend wallet found with address ${
+        tx.fromAddress || tx.signerAddress
+      }`,
+    );
+  }
+
+  return prisma.transactions.create({
+    data: {
+      ...tx,
+      fromAddress: tx.fromAddress?.toLowerCase(),
+      toAddress: tx.toAddress?.toLowerCase(),
+      target: tx.target?.toLowerCase(),
+      signerAddress: tx.signerAddress?.toLowerCase(),
+      accountAddress: tx.accountAddress?.toLowerCase(),
+    },
+  });
+};

src/db/transactions/queueTxRaw.ts

@@ -1,7 +1,7 @@
 import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { prisma } from "../../../db/client";
+import { queueTxRaw } from "../../../db/transactions/queueTxRaw";
 import {
   standardResponseSchema,
   transactionWritesResponseSchema,
@@ -62,16 +62,12 @@ export async function sendTransaction(fastify: FastifyInstance) {
       const fromAddress = request.headers["x-backend-wallet-address"] as string;
       const chainId = await getChainIdFromChain(chain);
 
-      // TODO: At some point we should simulate this first
-      // For now, it's okay not to since its a raw transaction
-      const { id: queueId } = await prisma.transactions.create({
-        data: {
-          chainId: chainId.toString(),
-          fromAddress,
-          toAddress,
-          data,
-          value,
-        },
+      const { id: queueId } = await queueTxRaw({
+        chainId: chainId.toString(),
+        fromAddress,
+        toAddress,
+        data,
+        value,
       });
 
       reply.status(StatusCodes.OK).send({

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

@@ -67,11 +67,12 @@ export async function sendTransactionBatch(fastify: FastifyInstance) {
         groupId,
         id: uuidv4(),
         chainId: chainId.toString(),
-        fromAddress,
-        toAddress: tx.toAddress,
+        fromAddress: fromAddress.toLowerCase(),
+        toAddress: tx.toAddress?.toLowerCase(),
         data: tx.data,
         value: tx.value,
       }));
+
       await prisma.transactions.createMany({
         data,
       });

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

@@ -7,8 +7,8 @@ import {
 import { constants } from "ethers";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { queueNativeTokenTransferTx } from "../../../db/transactions/queueNativeTokenTransferTx";
 import { queueTx } from "../../../db/transactions/queueTx";
+import { queueTxRaw } from "../../../db/transactions/queueTxRaw";
 import { getContract } from "../../../utils/cache/getContract";
 import { getSdk } from "../../../utils/cache/getSdk";
 import {
@@ -85,16 +85,27 @@ export async function transfer(fastify: FastifyInstance) {
           throw new Error("Insufficient balance");
         }
 
-        queueId = await queueNativeTokenTransferTx({
-          chainId,
+        const params = {
+          toAddress: to,
+          fromAddress: walletAddress,
+          currencyAddress,
+          value: normalizedValue.toHexString(),
+        };
+
+        ({ id: queueId } = await queueTxRaw({
+          chainId: chainId.toString(),
+          functionName: "transfer",
+          functionArgs: JSON.stringify([
+            params.toAddress,
+            params.value,
+            params.currencyAddress,
+          ]),
           extension: "none",
-          transferParams: {
-            toAddress: to,
-            fromAddress: walletAddress,
-            value: normalizedValue.toHexString(),
-            currencyAddress: currencyAddress,
-          },
-        });
+          fromAddress: params.fromAddress,
+          toAddress: params.toAddress,
+          value: params.value,
+          data: "0x",
+        }));
       } else {
         const contract = await getContract({
           chainId,

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

@@ -1,7 +1,7 @@
 import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { prisma } from "../../../db/client";
+import { queueTxRaw } from "../../../db/transactions/queueTxRaw";
 import {
   standardResponseSchema,
   transactionWritesResponseSchema,
@@ -45,15 +45,13 @@ export async function withdraw(fastify: FastifyInstance) {
 
       const chainId = await getChainIdFromChain(chain);
 
-      const { id: queueId } = await prisma.transactions.create({
-        data: {
-          chainId: chainId.toString(),
-          extension: "withdraw",
-          functionName: "transfer",
-          fromAddress: walletAddress,
-          toAddress,
-          data: "0x",
-        },
+      const { id: queueId } = await queueTxRaw({
+        chainId: chainId.toString(),
+        extension: "withdraw",
+        functionName: "transfer",
+        fromAddress: walletAddress,
+        toAddress,
+        data: "0x",
       });
 
       res.status(StatusCodes.OK).send({