chore: moved simulation to queueRawTx (#402)

* added raw call data simulation

* updated

* added simulate tx to write endpoint

* updated simulation

* updated simulation result

* added simulation endpoint

* finish simulation

* updated params

* removed pgtx

* renamed simulation -> simulate

* renamed simulation -> simulate

* renamed endpoint

* build

* updates to fix simulatTx string -> bool

* added cause

* updated sim error response, few others upds

---------

Co-authored-by: farhanW3 <farhan@thirdweb.com>

Author: gerrysaporito

src/db/transactions/queueTx.ts

@@ -1,7 +1,6 @@
 import type {
   DeployTransaction,
   Transaction,
-  TransactionError,
 } from "@thirdweb-dev/sdk";
 import { ERC4337EthersSigner } from "@thirdweb-dev/wallets/dist/declarations/src/evm/connectors/smart-wallet/lib/erc4337-signer";
 import { BigNumber } from "ethers";
@@ -20,15 +19,14 @@ interface QueueTxParams {
   simulateTx?: boolean;
 }
 
-// TODO: Simulation should be done before this function
 export const queueTx = async ({
   pgtx,
   tx,
   chainId,
   extension,
   deployedContractAddress,
   deployedContractType,
-  simulateTx = false,
+  simulateTx,
 }: QueueTxParams) => {
   // TODO: We need a much safer way of detecting if the transaction should be a user operation
   const isUserOp = !!(tx.getSigner as ERC4337EthersSigner).erc4337provider;
@@ -56,21 +54,11 @@ export const queueTx = async ({
       signerAddress,
       accountAddress,
       target,
+      simulateTx
     });
 
     return queueId;
   } else {
-    try {
-      if (!deployedContractAddress && simulateTx) {
-        await tx.simulate();
-      }
-    } catch (err: any) {
-      const errorMessage =
-        (err as TransactionError)?.reason || (err as any).message || err;
-      throw new Error(
-        `Transaction simulation failed with reason: ${errorMessage}`,
-      );
-    }
     const fromAddress = await tx.getSignerAddress();
     const toAddress = tx.getTarget();
 
@@ -79,6 +67,7 @@ export const queueTx = async ({
       ...txData,
       fromAddress,
       toAddress,
+      simulateTx
     });
 
     return queueId;

src/db/transactions/queueTxRaw.ts

@@ -1,5 +1,6 @@
 import type { Prisma } from "@prisma/client";
 import { PrismaTransaction } from "../../schema/prisma";
+import { simulateTx } from "../../server/utils/simulateTx";
 import { getPrismaWithPostgresTx } from "../client";
 import { getWalletDetails } from "../wallets/getWalletDetails";
 
@@ -8,6 +9,7 @@ type QueueTxRawParams = Omit<
   "fromAddress" | "signerAddress"
 > & {
   pgtx?: PrismaTransaction;
+  simulateTx?: boolean;
 } & (
     | {
         fromAddress: string;
@@ -19,8 +21,11 @@ type QueueTxRawParams = Omit<
       }
   );
 
-// TODO: Simulation should be moved to this function
-export const queueTxRaw = async ({ pgtx, ...tx }: QueueTxRawParams) => {
+export const queueTxRaw = async ({
+  simulateTx: shouldSimulate,
+  pgtx,
+  ...tx
+}: QueueTxRawParams) => {
   const prisma = getPrismaWithPostgresTx(pgtx);
 
   const walletDetails = await getWalletDetails({
@@ -36,6 +41,10 @@ export const queueTxRaw = async ({ pgtx, ...tx }: QueueTxRawParams) => {
     );
   }
 
+  if (shouldSimulate) {
+    await simulateTx({ txRaw: tx });
+  }
+
   return prisma.transactions.create({
     data: {
       ...tx,

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

@@ -3,6 +3,7 @@ import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { queueTxRaw } from "../../../db/transactions/queueTxRaw";
 import {
+  requestQuerystringSchema,
   standardResponseSchema,
   transactionWritesResponseSchema,
 } from "../../schemas/sharedApiSchemas";
@@ -40,6 +41,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
     Params: Static<typeof ParamsSchema>;
     Body: Static<typeof requestBodySchema>;
     Reply: Static<typeof transactionWritesResponseSchema>;
+    Querystring: Static<typeof requestQuerystringSchema>;
   }>({
     method: "POST",
     url: "/backend-wallet/:chain/send-transaction",
@@ -51,6 +53,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
       params: ParamsSchema,
       body: requestBodySchema,
       headers: Type.Omit(walletAuthSchema, ["x-account-address"]),
+      querystring: requestQuerystringSchema,
       response: {
         ...standardResponseSchema,
         [StatusCodes.OK]: transactionWritesResponseSchema,
@@ -59,6 +62,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
     handler: async (request, reply) => {
       const { chain } = request.params;
       const { toAddress, data, value } = request.body;
+      const { simulateTx } = request.query;
       const fromAddress = request.headers["x-backend-wallet-address"] as string;
       const chainId = await getChainIdFromChain(chain);
 
@@ -68,6 +72,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
         toAddress,
         data,
         value,
+        simulateTx: simulateTx,
       });
 
       reply.status(StatusCodes.OK).send({

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

@@ -0,0 +1,125 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { getContract } from "../../../utils/cache/getContract";
+import {
+  simulateResponseSchema,
+  standardResponseSchema,
+} from "../../schemas/sharedApiSchemas";
+import { walletAuthSchema } from "../../schemas/wallet";
+import { getChainIdFromChain } from "../../utils/chain";
+import { SimulateTxParams, simulateTx } from "../../utils/simulateTx";
+
+// INPUT
+const ParamsSchema = Type.Object({
+  chain: Type.String(),
+});
+
+const simulateRequestBodySchema = Type.Object({
+  toAddress: Type.String({
+    description: "Address of the contract",
+  }),
+  value: Type.Optional(
+    Type.String({
+      examples: ["0"],
+      description: "Native Currency Value",
+    }),
+  ),
+  // Decoded transaction args
+  functionName: Type.Optional(
+    Type.String({
+      description: "Name of the function to call on Contract",
+    }),
+  ),
+  args: Type.Optional(
+    Type.Array(
+      Type.Union([
+        Type.String({
+          description: "Arguments for the function. Comma Separated",
+        }),
+        Type.Tuple([Type.String(), Type.String()]),
+        Type.Object({}),
+        Type.Array(Type.Any()),
+        Type.Any(),
+      ]),
+    ),
+  ),
+  // Raw transaction args
+  data: Type.Optional(
+    Type.String({
+      description: "Transaction Data",
+    }),
+  ),
+});
+
+// LOGIC
+export async function simulateTransaction(fastify: FastifyInstance) {
+  fastify.route<{
+    Params: Static<typeof ParamsSchema>;
+    Body: Static<typeof simulateRequestBodySchema>;
+    Reply: Static<typeof simulateResponseSchema>;
+  }>({
+    method: "POST",
+    url: "/backend-wallet/:chain/simulate-transaction",
+    schema: {
+      summary: "Simulate a transaction",
+      description: "Simulate a transaction with transaction parameters",
+      tags: ["Backend Wallet"],
+      operationId: "simulateTransaction",
+      params: ParamsSchema,
+      body: simulateRequestBodySchema,
+      headers: Type.Omit(walletAuthSchema, ["x-account-address"]),
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: simulateResponseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      // Destruct core params
+      const { chain } = request.params;
+      const { toAddress, value, functionName, args, data } = request.body;
+      const walletAddress = request.headers[
+        "x-backend-wallet-address"
+      ] as string;
+      const accountAddress = request.headers["x-account-address"] as string;
+      const chainId = await getChainIdFromChain(chain);
+
+      // Get decoded tx simulate args
+      let simulateArgs: SimulateTxParams;
+      if (functionName && args) {
+        const contract = await getContract({
+          chainId,
+          contractAddress: toAddress,
+          walletAddress,
+          accountAddress,
+        });
+        const tx = contract.prepare(functionName, args, {
+          value: value ?? "0",
+        });
+        simulateArgs = { tx };
+      }
+      // Get raw tx simulate args
+      else {
+        simulateArgs = {
+          txRaw: {
+            chainId: chainId.toString(),
+            fromAddress: walletAddress,
+            toAddress,
+            data,
+            value,
+          },
+        };
+      }
+
+      // Simulate raw tx
+      await simulateTx(simulateArgs);
+
+      // Return success
+      reply.status(StatusCodes.OK).send({
+        result: {
+          success: true,
+        },
+      });
+    },
+  });
+}

src/server/routes/index.ts

@@ -110,6 +110,7 @@ import { queueStatus } from "./system/queue";
 import { checkGroupStatus } from "./transaction/group";
 import { sendSignedTransaction } from "./transaction/sendSignedTx";
 import { sendSignedUserOp } from "./transaction/sendSignedUserOp";
+import { simulateTransaction } from "./backend-wallet/simulateTransaction";
 
 export const withRoutes = async (fastify: FastifyInstance) => {
   // Backend Wallets
@@ -127,6 +128,7 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(getAllTransactions);
   await fastify.register(resetBackendWalletNonces);
   await fastify.register(getBackendWalletNonce);
+  await fastify.register(simulateTransaction);
 
   // Configuration
   await fastify.register(getWalletsConfiguration);

src/server/schemas/sharedApiSchemas.ts

@@ -155,6 +155,14 @@ export const transactionWritesResponseSchema = Type.Object({
   }),
 });
 
+export const simulateResponseSchema = Type.Object({
+  result: Type.Object({
+    success: Type.Boolean({
+      description: "Simulation Success",
+    }),
+  }),
+});
+
 transactionWritesResponseSchema.example = {
   result: {
     queueId: "9eb88b00-f04f-409b-9df7-7dcc9003bc35",

src/server/utils/simulateTx.ts

@@ -0,0 +1,59 @@
+import {
+  DeployTransaction,
+  Transaction,
+  TransactionError,
+} from "@thirdweb-dev/sdk";
+import { ethers } from "ethers";
+import { getSdk } from "../../utils/cache/getSdk";
+import { createCustomError } from "../middleware/error";
+
+type SimulateTxRawParams = {
+  chainId: string;
+  toAddress?: string | null;
+  fromAddress?: string | null;
+  data?: string | null;
+  value?: any;
+};
+
+const simulateTxRaw = async (args: SimulateTxRawParams) => {
+  const sdk = await getSdk({ chainId: parseInt(args.chainId) });
+  const simulateResult = await sdk.getProvider().call({
+    to: `${args.toAddress}`,
+    from: `${args.fromAddress}`,
+    data: `${args.data}`,
+    value: `${args.value}`,
+  });
+  if (simulateResult.length > 2) {
+    // '0x' is the success result value
+    const decoded = ethers.utils.defaultAbiCoder.decode(
+      ["string"],
+      ethers.utils.hexDataSlice(simulateResult, 4),
+    );
+    throw new Error(decoded[0]);
+  }
+};
+
+export type SimulateTxParams = {
+  tx?: Transaction<any> | DeployTransaction;
+  txRaw?: SimulateTxRawParams;
+};
+
+export const simulateTx = async ({ tx, txRaw }: SimulateTxParams) => {
+  try {
+    if (tx) {
+      await tx.simulate();
+    } else if (txRaw) {
+      await simulateTxRaw(txRaw);
+    } else {
+      throw new Error("No transaction to simulate");
+    }
+  } catch (err) {
+    const errorMessage =
+      (err as TransactionError)?.reason || (err as any).message || err;
+    throw createCustomError(
+      `Transaction simulation failed with reason: ${errorMessage}`,
+      400,
+      "BAD_REQUEST",
+    );
+  }
+};