send-transaction userOp update

Author: farhanW3

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

@@ -79,7 +79,27 @@ export async function sendTransaction(fastify: FastifyInstance) {
 
       let queueId: string;
       if (accountAddress) {
-        throw new Error("@TODO: Unimplemented");
+        queueId = await insertTransaction({
+          insertedTransaction: {
+            isUserOp: true,
+            chainId,
+            from: fromAddress as Address,
+            to: toAddress as Address | undefined,
+            data: data as Hex,
+            value: BigInt(value),
+            accountAddress: accountAddress as Address,
+            signerAddress: fromAddress as Address,
+            target: toAddress as Address | undefined,
+
+            gas: maybeBigInt(txOverrides?.gas),
+            maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
+            maxPriorityFeePerGas: maybeBigInt(
+              txOverrides?.maxPriorityFeePerGas,
+            ),
+          },
+          shouldSimulate: simulateTx,
+          idempotencyKey,
+        });
       } else {
         queueId = await insertTransaction({
           insertedTransaction: {

src/utils/transaction/simulateQueuedTransaction.ts

@@ -43,7 +43,26 @@ export const simulateQueuedTransaction = async (
   const chain = await getChain(chainId);
 
   let transaction: PreparedTransaction;
-  if (from && accountAddress && signerAddress && target && functionName) {
+  if (data) {
+    // Resolve data.
+    transaction = prepareTransaction({
+      client: thirdwebClient,
+      chain,
+      to,
+      data,
+      value,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+    });
+  } else if (
+    from &&
+    accountAddress &&
+    signerAddress &&
+    target &&
+    functionName
+  ) {
     try {
       // Resolve Target Contract
       const targetContract = getContract({
@@ -63,19 +82,6 @@ export const simulateQueuedTransaction = async (
     } catch (error: any) {
       return error.toString();
     }
-  } else if (data) {
-    // Resolve data.
-    transaction = prepareTransaction({
-      client: thirdwebClient,
-      chain,
-      to,
-      data,
-      value,
-      gas,
-      gasPrice,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-    });
   } else if (to && functionName && functionArgs) {
     const contract = getContract({
       client: thirdwebClient,

src/utils/transaction/userOperation.ts

@@ -32,16 +32,10 @@ export const generateSignedUserOperation = async (
     accountAddress,
     target,
     from,
+    data,
   } = queuedTransaction;
 
-  if (
-    !from ||
-    !accountAddress ||
-    !signerAddress ||
-    !target ||
-    !functionName ||
-    !functionArgs
-  ) {
+  if (!from || !accountAddress || !signerAddress || !target) {
     throw new Error("Invalid UserOperation parameters");
   }
 
@@ -76,16 +70,33 @@ export const generateSignedUserOperation = async (
   });
 
   // Prepare Transaction
-  const preparedTransaction = prepareContractCall({
-    contract: targetContract,
-    method: resolveMethod(functionName),
-    params: functionArgs,
-    value,
-  });
-
-  const toAddress = await resolvePromisedValue(preparedTransaction.to);
-  const txValue = await resolvePromisedValue(preparedTransaction.value);
-  const txData = await resolvePromisedValue(preparedTransaction.data);
+  let preparedTransaction:
+    | Awaited<ReturnType<typeof prepareContractCall>>
+    | undefined;
+
+  let toAddress: string | undefined;
+  let txValue: bigint | undefined;
+  let txData: Hex | undefined;
+
+  // Handle UserOp Requests with FunctionName & Args
+  if (functionName && functionArgs) {
+    preparedTransaction = prepareContractCall({
+      contract: targetContract,
+      method: resolveMethod(functionName),
+      params: functionArgs,
+      value,
+    });
+    toAddress = await resolvePromisedValue(preparedTransaction.to);
+    txValue = await resolvePromisedValue(preparedTransaction.value);
+    txData = await resolvePromisedValue(preparedTransaction.data);
+  } // Handle UserOp Requests with Data & Target
+  else if (data && target) {
+    toAddress = target;
+    txValue = value || 0n;
+    txData = data;
+  } else {
+    throw new Error("Invalid UserOperation parameters");
+  }
 
   // Prepare UserOperation Call
   const userOpCall = prepareContractCall({
@@ -146,14 +157,3 @@ export const generateSignedUserOperation = async (
   // Return Signed UserOperation
   return signedUserOp;
 };
-
-export const isUserOperation = (
-  queuedTransaction: QueuedTransaction,
-): boolean => {
-  const { from, accountAddress, signerAddress, target, functionName } =
-    queuedTransaction;
-
-  return Boolean(
-    from && accountAddress && signerAddress && target && functionName,
-  );
-};