sendCalls in executeQuote if the wallet supports it (#229)

azf20 · web-flow · commit 284e24d5e5cd · 2025-06-25T06:25:20.000+02:00
* sendCalls if the wallet supports it

* optional param, rename, approve input, simulate
diff --git a/.changeset/thirty-snails-camp.md b/.changeset/thirty-snails-camp.md
@@ -0,0 +1,5 @@
+---
+"@across-protocol/app-sdk": patch
+---
+
+Added atomic sendCalls with fallback to `executeQuote`
diff --git a/apps/example/package.json b/apps/example/package.json
@@ -36,7 +36,7 @@
     "tailwind-merge": "^2.6.0",
     "tailwindcss-animate": "^1.0.7",
     "usehooks-ts": "^3.1.0",
-    "viem": "^2.20.1",
+    "viem": "^2.31.2",
     "wagmi": "^2.12.25"
   },
   "devDependencies": {
@@ -53,4 +53,4 @@
     "tsx": "^4.19.0",
     "typescript": "^5"
   }
-}
+}
diff --git a/packages/sdk/package.json b/packages/sdk/package.json
@@ -53,14 +53,14 @@
     "typedoc": "^0.26.7",
     "typedoc-plugin-markdown": "^4.4.1",
     "typescript": "^5.3.3",
-    "viem": "^2.20.1",
+    "viem": "2.31.2",
     "vitest": "^2.0.5",
     "zod": "^3.24.2"
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "viem": "^2.20.1"
+    "viem": "^2.31.2"
   }
-}
+}
diff --git a/packages/sdk/src/actions/executeQuote.ts b/packages/sdk/src/actions/executeQuote.ts
@@ -18,6 +18,8 @@ import {
 } from "../types/index.js";
 import { parseFillLogs, waitForFillTx } from "./waitForFillTx.js";
 import { parseDepositLogs } from "./getDepositFromLogs.js";
+import { prepareAtomicApproveDepositTx } from "./prepareAtomicApproveDepositTx.js";
+import { waitForAtomicTx } from "./waitForAtomicTx.js";
 
 export type ExecutionProgress = TransactionProgress;
 
@@ -161,6 +163,10 @@ export type ExecuteQuoteParams = {
    * The logger to use.
    */
   logger?: LoggerT;
+  /**
+   * Whether to use atomic transactions if supported by the wallet.
+   */
+  atomicIfSupported?: boolean;
 };
 
 /**
@@ -194,7 +200,9 @@ export type ExecuteQuoteResponseParams = {
  * @returns The deposit ID and receipts for the deposit and fill transactions. See {@link ExecuteQuoteResponseParams}.
  * @public
  */
-export async function executeQuote(params: ExecuteQuoteParams): Promise<ExecuteQuoteResponseParams> {
+export async function executeQuote(
+  params: ExecuteQuoteParams,
+): Promise<ExecuteQuoteResponseParams> {
   const {
     integratorId,
     deposit,
@@ -207,6 +215,7 @@ export async function executeQuote(params: ExecuteQuoteParams): Promise<ExecuteQ
     forceOriginChain,
     onProgress,
     logger,
+    atomicIfSupported = false,
   } = params;
 
   const onProgressHandler =
@@ -281,6 +290,111 @@ export async function executeQuote(params: ExecuteQuoteParams): Promise<ExecuteQ
 
         onProgressHandler(currentTransactionProgress);
 
+        if (atomicIfSupported) {
+          logger?.debug("Checking if wallet supports atomic transactions");
+          try {
+            const capabilities = await walletClient.getCapabilities({
+              account,
+              chainId: deposit.originChainId,
+            });
+
+            if (
+              capabilities?.atomic?.status === "supported" ||
+              capabilities?.atomic?.status === "ready"
+            ) {
+              logger?.debug(
+                "Wallet supports atomic sendCalls, triggering atomic flow",
+              );
+              // Simulate both approval and deposit calls
+              const { calls } = await prepareAtomicApproveDepositTx({
+                walletClient,
+                publicClient: originClient,
+                deposit,
+                approvalAmount: BigInt(inputAmount),
+                integratorId,
+                logger,
+              });
+
+              const { id: callId } = await walletClient.sendCalls({
+                account,
+                calls,
+                forceAtomic: true,
+              });
+
+              logger?.debug(`Atomic call ID: ${callId}`);
+
+              const destinationBlock = await destinationClient.getBlockNumber();
+
+              const { depositId, depositTxReceipt } = await waitForAtomicTx({
+                callId,
+                originChainId: deposit.originChainId,
+                walletClient,
+              });
+
+              const depositLog = parseDepositLogs(depositTxReceipt.logs);
+
+              const depositSuccessProgress: TransactionProgress = {
+                step: "deposit",
+                status: "txSuccess",
+                txReceipt: depositTxReceipt,
+                depositId,
+                depositLog,
+                meta: { deposit },
+              };
+              onProgressHandler(depositSuccessProgress);
+
+              // After successful deposit, wait for fill
+              const fillMeta: FillMeta = {
+                depositId,
+                deposit,
+              };
+              const fillPendingProgress: TransactionProgress = {
+                step: "fill",
+                status: "txPending",
+                meta: fillMeta,
+              };
+              onProgressHandler(fillPendingProgress);
+
+              const { fillTxReceipt, fillTxTimestamp, actionSuccess } =
+                await waitForFillTx({
+                  deposit,
+                  depositId,
+                  depositTxHash: depositTxReceipt.transactionHash,
+                  destinationChainClient: destinationClient,
+                  fromBlock: destinationBlock - 100n, // TODO: use dynamic block buffer based chain
+                });
+
+              const fillLog = parseFillLogs(fillTxReceipt.logs);
+
+              const fillSuccessProgress: TransactionProgress = {
+                step: "fill",
+                status: "txSuccess",
+                txReceipt: fillTxReceipt,
+                fillTxTimestamp,
+                actionSuccess,
+                fillLog,
+                meta: fillMeta,
+              };
+              onProgressHandler(fillSuccessProgress);
+              return { depositId, depositTxReceipt, fillTxReceipt };
+            }
+          } catch (error) {
+            if (
+              error instanceof Error &&
+              error.message
+                .toLowerCase()
+                .includes("user rejected account upgrade")
+            ) {
+              logger?.debug(
+                "User rejected smart account upgrade, falling back to regular flow",
+              );
+            } else {
+              throw error;
+            }
+          }
+        }
+
+        // Fall back to regular approval flow
         const { request } = await simulateApproveTx({
           walletClient,
           publicClient: originClient,
diff --git a/packages/sdk/src/actions/prepareAtomicApproveDepositTx.ts b/packages/sdk/src/actions/prepareAtomicApproveDepositTx.ts
@@ -0,0 +1,112 @@
+import {
+  Hex,
+  PublicClient,
+  WalletClient,
+  parseAbi,
+  SimulateCallsReturnType,
+  Call,
+  encodeFunctionData,
+  concatHex,
+} from "viem";
+import { Quote } from "./getQuote.js";
+import { LoggerT } from "../utils/index.js";
+import { spokePoolAbiV3_5 } from "../abis/SpokePool/index.js";
+import { addressToBytes32, getIntegratorDataSuffix } from "../utils/index.js";
+
+export type PrepareAtomicApproveDepositTxParams = {
+  walletClient: WalletClient;
+  publicClient: PublicClient;
+  deposit: Quote["deposit"];
+  approvalAmount: bigint;
+  integratorId: Hex;
+  logger?: LoggerT;
+};
+
+export type PrepareAtomicApproveDepositTxResult = {
+  simulationResult?: SimulateCallsReturnType<readonly Call[]>;
+  calls: readonly Call[];
+  simulationError?: Error;
+};
+
+export async function prepareAtomicApproveDepositTx(
+  params: PrepareAtomicApproveDepositTxParams,
+): Promise<PrepareAtomicApproveDepositTxResult> {
+  const {
+    walletClient,
+    publicClient,
+    deposit,
+    approvalAmount,
+    integratorId,
+    logger,
+  } = params;
+
+  const account = walletClient.account;
+
+  if (!account) {
+    throw new Error("Wallet account has to be set");
+  }
+
+  const connectedChainId = await walletClient.getChainId();
+
+  if (connectedChainId !== deposit.originChainId) {
+    throw new Error(
+      `Connected chainId ${connectedChainId} does not match originChainId ${deposit.originChainId}`,
+    );
+  }
+
+  const calls: readonly Call[] = [
+    {
+      to: deposit.inputToken,
+      abi: parseAbi([
+        "function approve(address spender, uint256 amount) public returns (bool)",
+      ]),
+      functionName: "approve",
+      args: [deposit.spokePoolAddress, approvalAmount],
+    },
+    {
+      to: deposit.spokePoolAddress,
+      data: concatHex([
+        encodeFunctionData({
+          abi: spokePoolAbiV3_5,
+          functionName: "deposit",
+          args: [
+            addressToBytes32(account.address),
+            addressToBytes32(deposit.recipient ?? account.address),
+            addressToBytes32(deposit.inputToken),
+            addressToBytes32(deposit.outputToken),
+            BigInt(deposit.inputAmount),
+            deposit.outputAmount,
+            BigInt(deposit.destinationChainId),
+            addressToBytes32(deposit.exclusiveRelayer),
+            deposit.quoteTimestamp,
+            deposit.fillDeadline,
+            deposit.exclusivityDeadline,
+            deposit.message,
+          ],
+        }),
+        getIntegratorDataSuffix(integratorId),
+      ]),
+      value: deposit.isNative ? BigInt(deposit.inputAmount) : 0n,
+    },
+  ] as const;
+
+  try {
+    const simulationResult = await publicClient.simulateCalls({
+      account,
+      calls,
+    });
+
+    logger?.debug("Atomic transaction simulation result", simulationResult);
+
+    return {
+      simulationResult: simulationResult,
+      calls,
+    };
+  } catch (error) {
+    logger?.debug("Atomic transaction simulation failed", error);
+    return {
+      simulationError: error as Error,
+      calls,
+    };
+  }
+}
diff --git a/packages/sdk/src/actions/waitForAtomicTx.ts b/packages/sdk/src/actions/waitForAtomicTx.ts
@@ -0,0 +1,51 @@
+import { Hash, TransactionReceipt } from "viem";
+import { ConfiguredWalletClient } from "../types/index.js";
+import { getDepositFromLogs } from "./getDepositFromLogs.js";
+import { NoDepositLogError } from "../errors/index.js";
+
+export type WaitForAtomicTxParams = {
+  callId: string;
+  originChainId: number;
+  walletClient: ConfiguredWalletClient;
+};
+
+export type AtomicTxStatus = {
+  depositTxReceipt: TransactionReceipt;
+  depositId: bigint;
+};
+
+export async function waitForAtomicTx(
+  params: WaitForAtomicTxParams,
+): Promise<AtomicTxStatus> {
+  const { callId, originChainId, walletClient } = params;
+
+  const callResult = await walletClient.waitForCallsStatus({
+    id: callId,
+  });
+
+  if (!callResult?.receipts?.[0]) {
+    throw new Error("No receipt returned from atomic transaction");
+  }
+
+  if (callResult.receipts[0].status === "reverted") {
+    throw new Error("Atomic transaction reverted");
+  }
+
+  const receipt = callResult.receipts[0] as TransactionReceipt;
+
+  const depositLog = getDepositFromLogs({
+    originChainId,
+    receipt,
+  });
+
+  if (!depositLog || !depositLog.depositId) {
+    throw new NoDepositLogError(callId as Hash, originChainId);
+  }
+
+  const depositId = depositLog.depositId;
+
+  return {
+    depositTxReceipt: receipt,
+    depositId,
+  };
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@across-protocol/app-sdk": patch
 +---
++
 +Added atomic sendCalls with fallback to `executeQuote`