add x-account-factory-address header to contract-write and send-transaction (#645)

* add `x-account-factory-address` header to contract-write and send-transaction

* fix: custom error when invalid accountFactoryAddress

* chore: Update x-account-factory-address description in wallet schema

Author: d4mr

src/db/transactions/queueTx.ts

@@ -6,6 +6,7 @@ import { maybeBigInt, normalizeAddress } from "../../utils/primitiveTypes";
 import { insertTransaction } from "../../utils/transaction/insertTransaction";
 
 interface QueueTxParams {
+  // we should move away from Transaction type (v4 SDK)
   tx: Transaction<any> | DeployTransaction;
   chainId: number;
   extension: ContractExtension;
@@ -14,6 +15,7 @@ interface QueueTxParams {
   deployedContractType?: string;
   simulateTx?: boolean;
   idempotencyKey?: string;
+  accountFactoryAddress?: Address;
   txOverrides?: {
     gas?: string;
     maxFeePerGas?: string;
@@ -31,6 +33,7 @@ export const queueTx = async ({
   simulateTx,
   idempotencyKey,
   txOverrides,
+  accountFactoryAddress,
 }: QueueTxParams) => {
   // Transaction Details
   const functionName = tx.getMethod();
@@ -68,6 +71,7 @@ export const queueTx = async ({
         signerAddress,
         accountAddress: normalizeAddress(await tx.getSignerAddress()),
         target: normalizeAddress(tx.getTarget()),
+        accountFactoryAddress,
       },
       idempotencyKey,
       shouldSimulate: simulateTx,

src/server/middleware/error.ts

@@ -30,6 +30,14 @@ export const createCustomDateTimestampError = (key: string): CustomError => {
   );
 };
 
+export const createBadAddressError = (key: string): CustomError => {
+  return createCustomError(
+    `Invalid ${key} Value. Needs to be a valid EVM address`,
+    422,
+    "INVALID_ADDRESS",
+  );
+};
+
 const flipObject = (data: any) =>
   Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
 

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

@@ -11,6 +11,7 @@ import {
 } from "../../schemas/sharedApiSchemas";
 import { txOverridesSchema } from "../../schemas/txOverrides";
 import {
+  maybeAddress,
   walletChainParamSchema,
   walletWithAAHeaderSchema,
 } from "../../schemas/wallet";
@@ -73,6 +74,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
         "x-backend-wallet-address": fromAddress,
         "x-idempotency-key": idempotencyKey,
         "x-account-address": accountAddress,
+        "x-account-factory-address": accountFactoryAddress,
       } = request.headers as Static<typeof walletWithAAHeaderSchema>;
 
       const chainId = await getChainIdFromChain(chain);
@@ -90,7 +92,10 @@ export async function sendTransaction(fastify: FastifyInstance) {
             accountAddress: accountAddress as Address,
             signerAddress: fromAddress as Address,
             target: toAddress as Address | undefined,
-
+            accountFactoryAddress: maybeAddress(
+              accountFactoryAddress,
+              "x-account-factory-address",
+            ),
             gas: maybeBigInt(txOverrides?.gas),
             maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
             maxPriorityFeePerGas: maybeBigInt(

src/server/routes/contract/write/write.ts

@@ -11,7 +11,10 @@ import {
   transactionWritesResponseSchema,
 } from "../../../schemas/sharedApiSchemas";
 import { txOverridesWithValueSchema } from "../../../schemas/txOverrides";
-import { walletWithAAHeaderSchema } from "../../../schemas/wallet";
+import {
+  maybeAddress,
+  walletWithAAHeaderSchema,
+} from "../../../schemas/wallet";
 import { getChainIdFromChain } from "../../../utils/chain";
 
 // INPUT
@@ -66,6 +69,7 @@ export async function writeToContract(fastify: FastifyInstance) {
         "x-backend-wallet-address": walletAddress,
         "x-account-address": accountAddress,
         "x-idempotency-key": idempotencyKey,
+        "x-account-factory-address": accountFactoryAddress,
       } = request.headers as Static<typeof walletWithAAHeaderSchema>;
 
       const chainId = await getChainIdFromChain(chain);
@@ -76,6 +80,7 @@ export async function writeToContract(fastify: FastifyInstance) {
         accountAddress,
         abi,
       });
+
       const tx = contract.prepare(functionName, args, {
         value: txOverrides?.value,
         gasLimit: txOverrides?.gas,
@@ -90,6 +95,10 @@ export async function writeToContract(fastify: FastifyInstance) {
         extension: "none",
         idempotencyKey,
         txOverrides,
+        accountFactoryAddress: maybeAddress(
+          accountFactoryAddress,
+          "x-account-factory-address",
+        ),
       });
 
       reply.status(StatusCodes.OK).send({

src/server/schemas/wallet/index.ts

@@ -1,5 +1,7 @@
 import { Type } from "@sinclair/typebox";
+import { Address, getAddress } from "thirdweb";
 import { env } from "../../../utils/env";
+import { createBadAddressError } from "../../middleware/error";
 import { AddressSchema } from "../address";
 
 export const walletHeaderSchema = Type.Object({
@@ -20,8 +22,31 @@ export const walletWithAAHeaderSchema = Type.Object({
     ...AddressSchema,
     description: "Smart account address",
   }),
+  "x-account-factory-address": Type.Optional({
+    ...AddressSchema,
+    description:
+      "Smart account factory address. If omitted, engine will try to resolve it from the chain.",
+  }),
 });
 
+/**
+ * Helper function to parse an address string.
+ * Returns undefined if the address is undefined.
+ *
+ * Throws a custom 422 INVALID_ADDRESS error with variableName if the address is invalid (other than undefined).
+ */
+export function maybeAddress(
+  address: string | undefined,
+  variableName: string,
+): Address | undefined {
+  if (!address) return undefined;
+  try {
+    return getAddress(address);
+  } catch {
+    throw createBadAddressError(variableName);
+  }
+}
+
 export const walletChainParamSchema = Type.Object({
   chain: Type.String({
     examples: ["80002"],

src/utils/transaction/types.ts

@@ -33,6 +33,7 @@ export type InsertedTransaction = {
   // User Operation
   signerAddress?: Address;
   accountAddress?: Address;
+  accountFactoryAddress?: Address;
   target?: Address;
   sender?: Address;
 };

src/utils/transaction/userOperation.ts

@@ -1,6 +1,7 @@
 import {
   Address,
   Hex,
+  getAddress,
   getContract,
   prepareContractCall,
   readContract,
@@ -25,6 +26,7 @@ export const generateSignedUserOperation = async (
     gas,
     signerAddress,
     accountAddress,
+    accountFactoryAddress: userProvidedAccountFactoryAddress,
     target,
     from,
     data,
@@ -43,12 +45,26 @@ export const generateSignedUserOperation = async (
     address: accountAddress as Address,
   });
 
-  // Resolve Factory Contract Address from Smart-Account Contract
-  const accountFactoryAddress = await readContract({
-    contract: smartAccountContract,
-    method: "function factory() view returns (address)",
-    params: [],
-  });
+  // use the user provided factory address if available
+  let accountFactoryAddress = userProvidedAccountFactoryAddress;
+
+  if (!accountFactoryAddress) {
+    // Resolve Factory Contract Address from Smart-Account Contract
+    try {
+      const onchainAccountFactoryAddress = await readContract({
+        contract: smartAccountContract,
+        method: "function factory() view returns (address)",
+        params: [],
+      });
+
+      accountFactoryAddress = getAddress(onchainAccountFactoryAddress);
+    } catch (e) {
+      // if no factory address is found, throw an error
+      throw new Error(
+        `Failed to find factory address for account '${accountAddress}' on chain '${chainId}'`,
+      );
+    }
+  }
 
   // Resolve Factory Contract
   const accountFactoryContract = getContract({