@agentlayer.tech/wallet 0.1.77 → 0.1.88

package/wdk-evm-wallet/src/wdk_evm_wallet.js

@@ -23,12 +23,68 @@ const DEFAULT_LIFI_SLIPPAGE = 0.005;
 const ALWAYS_DENIED_LIFI_BRIDGES = ["mayan"];
 const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 const UNISWAP_SUPPORTED_CHAIN_IDS = { ethereum: 1, base: 8453, robinhood: 4663 };
-// Universal Router v2.0 allow-list (defense-in-depth: /swap response `to` must match).
-const UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK = {
-  ethereum: "0x66a9893cc07d91d95644aedd05d03f95e1dba8af",
-  base: "0x6ff5693b99212da76ad316178a184ab56d299b43",
-  robinhood: "0x8876789976decbfcbbbe364623c63652db8c0904",
+// Every executable path is declared here rather than inferred from a Trading
+// API response. A new chain/router version therefore requires an explicit,
+// reviewed allow-list entry before it can receive a signed transaction.
+const UNISWAP_EXECUTION_PROFILES = {
+  ethereum: {
+    chainId: 1,
+    universalRouters: { "2.0": "0x66a9893cc07d91d95644aedd05d03f95e1dba8af" },
+    wrappedNative: "0xc02aaA39b223fe8d0a0e5c4f27ead9083c756cc2".toLowerCase(),
+    ammProtocols: ["V2", "V3", "V4"],
+  },
+  base: {
+    chainId: 8453,
+    universalRouters: { "2.0": "0x6ff5693b99212da76ad316178a184ab56d299b43" },
+    wrappedNative: "0x4200000000000000000000000000000000000006",
+    ammProtocols: ["V2", "V3", "V4"],
+  },
+  robinhood: {
+    chainId: 4663,
+    // Robinhood Chain has no Universal Router 2.0 deployment - Uniswap
+    // defaults it (like Ink) to 2.1.1, and requesting "2.0" makes the Trading
+    // API return a blanket "No quotes available" for every pair on this
+    // chain. See https://blog.uniswap.org/robinhood-chain-is-live. Same
+    // contract address as before; only the version label changes.
+    universalRouters: { "2.1.1": "0x8876789976decbfcbbbe364623c63652db8c0904" },
+    wrappedNative: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
+    // Full protocol stack like ethereum/base - the earlier V3-only filter
+    // wasn't the actual blocker (see router version note above) but there's
+    // no reason to hide V2/V4 routes from the Trading API either.
+    ammProtocols: ["V2", "V3", "V4"],
+    v3DirectFallback: {
+      quoterV2: "0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7",
+      swapRouter02: "0xcaf681a66d020601342297493863e78c959e5cb2",
+      feeTiers: [100, 500, 3000, 10000],
+    },
+  },
 };
+// Compatibility export for callers/tests. New execution code resolves a router
+// from UNISWAP_EXECUTION_PROFILES and its explicitly selected version.
+const UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK = Object.fromEntries(
+  Object.entries(UNISWAP_EXECUTION_PROFILES).map(([network, profile]) => [
+    network,
+    profile.universalRouters["2.0"],
+  ])
+);
+const UNISWAP_WRAPPED_NATIVE_BY_NETWORK = Object.fromEntries(
+  Object.entries(UNISWAP_EXECUTION_PROFILES).map(([network, profile]) => [
+    network,
+    profile.wrappedNative,
+  ])
+);
+const WETH_DEPOSIT_SELECTOR = "0xd0e30db0";
+const WETH_WITHDRAW_SELECTOR = "0x2e1a7d4d";
+const UNISWAP_V3_QUOTER_INTERFACE = new Interface([
+  "function quoteExactInputSingle((address tokenIn,address tokenOut,uint256 amountIn,uint24 fee,uint160 sqrtPriceLimitX96) params) external returns (uint256 amountOut,uint160 sqrtPriceX96After,uint32 initializedTicksCrossed,uint256 gasEstimate)",
+]);
+const UNISWAP_V3_SWAP_ROUTER_INTERFACE = new Interface([
+  "function exactInputSingle((address tokenIn,address tokenOut,uint24 fee,address recipient,uint256 amountIn,uint256 amountOutMinimum,uint160 sqrtPriceLimitX96) params) payable returns (uint256 amountOut)",
+  "function unwrapWETH9(uint256 amountMinimum,address recipient) payable",
+  "function multicall(bytes[] data) payable returns (bytes[] results)",
+]);
+const UNISWAP_CLASSIC_ROUTINGS = new Set(["CLASSIC"]);
+const UNISWAPX_ROUTINGS = new Set(["DUTCH_V2", "DUTCH_V3", "LIMIT_ORDER", "PRIORITY"]);
 const AAVE_RAY = 10n ** 27n;
 const LIDO_STETH_DECIMALS = 18;
 const LIDO_MIN_STETH_WITHDRAWAL_AMOUNT = 100n;
@@ -104,8 +160,20 @@ const MORPHO_MAX_LIST_LIMIT = 500;
 // two minutes is below the indexer's own aggregation noise.
 const MORPHO_DISCOVERY_CACHE_TTL_MS = 120_000;
 const MORPHO_DISCOVERY_CACHE_MAX_ENTRIES = 64;
+// DeFi routes can take a different on-chain branch between estimate time and
+// inclusion. Estimate exact final calldata immediately before signing and use
+// an explicit headroom rather than relying on the provider/WDK default.
+const DEFI_GAS_BUFFER_BPS = 13_000n;
+const MORPHO_GAS_BUFFER_BPS = DEFI_GAS_BUFFER_BPS;
+const BPS_DENOMINATOR = 10_000n;
 const morphoDiscoveryCache = new Map();
 
+function applyGasBuffer(value, bufferBps = MORPHO_GAS_BUFFER_BPS) {
+  const normalizedValue = BigInt(value);
+  const normalizedBufferBps = BigInt(bufferBps);
+  return (normalizedValue * normalizedBufferBps + BPS_DENOMINATOR - 1n) / BPS_DENOMINATOR;
+}
+
 function morphoDiscoveryCacheGet(key) {
   const entry = morphoDiscoveryCache.get(key);
   if (!entry) {
@@ -857,6 +925,115 @@ function assertUniswapSupportedNetwork(network) {
   return chainId;
 }
 
+function getUniswapNetworkExecutionProfile(network) {
+  const profile = UNISWAP_EXECUTION_PROFILES[network];
+  if (!profile) {
+    assertUniswapSupportedNetwork(network);
+  }
+  return profile;
+}
+
+function resolveUniswapRouterExecutionProfile(network, routerVersion) {
+  const networkProfile = getUniswapNetworkExecutionProfile(network);
+  const version = String(routerVersion || "2.0").trim() || "2.0";
+  const router = networkProfile.universalRouters[version];
+  if (!router) {
+    throw createTaggedError(
+      `Uniswap Universal Router version ${version} is not approved for ${network}.`,
+      "uniswap_router_version_unsupported",
+      {
+        network,
+        chainId: networkProfile.chainId,
+        requestedVersion: version,
+        supportedVersions: Object.keys(networkProfile.universalRouters),
+      }
+    );
+  }
+  return { ...networkProfile, routerVersion: version, router };
+}
+
+function encodeUint256(value) {
+  return BigInt(value).toString(16).padStart(64, "0");
+}
+
+function buildDirectWrappedNativeOperation(networkProfile, swapRequest) {
+  const wrappedNative = networkProfile.wrappedNative;
+  if (isZeroAddress(swapRequest.tokenIn) && swapRequest.tokenOut === wrappedNative) {
+    return {
+      executionKind: "wrap",
+      routing: "WRAP",
+      transaction: { to: wrappedNative, data: WETH_DEPOSIT_SELECTOR, value: swapRequest.tokenInAmount },
+    };
+  }
+  if (swapRequest.tokenIn === wrappedNative && isZeroAddress(swapRequest.tokenOut)) {
+    return {
+      executionKind: "unwrap",
+      routing: "UNWRAP",
+      transaction: {
+        to: wrappedNative,
+        data: `${WETH_WITHDRAW_SELECTOR}${encodeUint256(swapRequest.tokenInAmount)}`,
+        value: 0n,
+      },
+    };
+  }
+  return null;
+}
+
+function buildUniswapV3DirectSwapTransaction({
+  networkProfile,
+  recipient,
+  swapRequest,
+  feeTier,
+  minimumTokenOutAmount,
+}) {
+  const fallback = networkProfile.v3DirectFallback;
+  if (!fallback) {
+    throw new Error("Uniswap V3 direct fallback is not configured for this network.");
+  }
+  const nativeTokenIn = isZeroAddress(swapRequest.tokenIn);
+  const nativeTokenOut = isZeroAddress(swapRequest.tokenOut);
+  const effectiveTokenIn = nativeTokenIn ? networkProfile.wrappedNative : swapRequest.tokenIn;
+  const effectiveTokenOut = nativeTokenOut ? networkProfile.wrappedNative : swapRequest.tokenOut;
+  const exactInput = UNISWAP_V3_SWAP_ROUTER_INTERFACE.encodeFunctionData("exactInputSingle", [
+    {
+      tokenIn: effectiveTokenIn,
+      tokenOut: effectiveTokenOut,
+      fee: feeTier,
+      // For an ETH output the router must receive WETH first, then unwrap it in
+      // the same atomic multicall. All other paths transfer directly to the user.
+      recipient: nativeTokenOut ? fallback.swapRouter02 : recipient,
+      amountIn: swapRequest.tokenInAmount,
+      amountOutMinimum: minimumTokenOutAmount,
+      sqrtPriceLimitX96: 0,
+    },
+  ]);
+  const data = nativeTokenOut
+    ? UNISWAP_V3_SWAP_ROUTER_INTERFACE.encodeFunctionData("multicall(bytes[])", [
+        [
+          exactInput,
+          UNISWAP_V3_SWAP_ROUTER_INTERFACE.encodeFunctionData("unwrapWETH9", [
+            minimumTokenOutAmount,
+            recipient,
+          ]),
+        ],
+      ])
+    : exactInput;
+  return {
+    to: fallback.swapRouter02,
+    data,
+    value: nativeTokenIn ? swapRequest.tokenInAmount : 0n,
+  };
+}
+
+function isUniswapNoQuotesAvailableError(error) {
+  return (
+    error &&
+    typeof error === "object" &&
+    error.errorCode === "network_unavailable" &&
+    /no quotes available/i.test(String(error.message || ""))
+  );
+}
+
 function uniswapSlippagePercentFromBps(bps) {
   const parsed = Number(bps);
   if (!Number.isInteger(parsed) || parsed < 0 || parsed > 5000) {
@@ -2352,12 +2529,20 @@ export class WdkEvmWalletService {
         const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
         let result;
         try {
-          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
-            this.#buildMorphoOperationOptions(request)
-          );
+          result = await this.#sendMorphoProtocolOperation({
+            account,
+            runtimeConfig,
+            protocol,
+            request,
+          });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Morpho operation",
+          failureCode: "morpho_operation_reverted",
+          timeoutCode: "morpho_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = requirementExecution.totalFee + resultFee;
         return {
@@ -2383,6 +2568,7 @@ export class WdkEvmWalletService {
             requirementsFee: requirementExecution.totalFee.toString(),
             requirements: requirementExecution.transactions,
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
@@ -2529,12 +2715,20 @@ export class WdkEvmWalletService {
         const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
         let result;
         try {
-          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
-            this.#buildMorphoOperationOptions(request)
-          );
+          result = await this.#sendMorphoProtocolOperation({
+            account,
+            runtimeConfig,
+            protocol,
+            request,
+          });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Morpho operation",
+          failureCode: "morpho_operation_reverted",
+          timeoutCode: "morpho_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = requirementExecution.totalFee + resultFee;
         return {
@@ -2560,6 +2754,7 @@ export class WdkEvmWalletService {
             requirementsFee: requirementExecution.totalFee.toString(),
             requirements: requirementExecution.transactions,
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
@@ -2696,13 +2891,25 @@ export class WdkEvmWalletService {
         const protocol = new AaveProtocolEvm(account);
         let result;
         try {
-          result = await protocol[request.operation]({
-            token: request.token,
-            amount: request.amount,
+          result = await this.#sendBufferedDefiProtocolOperation({
+            account,
+            runtimeConfig,
+            operationLabel: `Aave ${request.operation}`,
+            operation: request.operation,
+            invoke: () =>
+              protocol[request.operation]({
+                token: request.token,
+                amount: request.amount,
+              }),
           });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Aave operation",
+          failureCode: "aave_operation_reverted",
+          timeoutCode: "aave_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -2731,6 +2938,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedAaveOperation({
@@ -3012,7 +3220,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.operationTx,
+          operationLabel: `Lido ${request.operation}`,
+          operation: request.operation,
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Lido operation",
+          failureCode: "lido_operation_reverted",
+          timeoutCode: "lido_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -3041,6 +3261,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedLidoOperation({
@@ -3163,7 +3384,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.operationTx,
+          operationLabel: `Lido ${request.operation}`,
+          operation: request.operation,
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Lido withdrawal",
+          failureCode: "lido_withdrawal_reverted",
+          timeoutCode: "lido_withdrawal_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -3192,6 +3425,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedLidoWithdrawal({
@@ -3424,12 +3658,23 @@ export class WdkEvmWalletService {
             })
           : finalPlan.simulation;
         this.#assertSimulationSucceeded(effectiveSimulation);
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const swapResult = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.swapTx,
+          operationLabel: "Velora swap",
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+          operationLabel: "Velora swap",
+          failureCode: "swap_reverted",
+          timeoutCode: "swap_confirmation_timeout",
+        });
+        const totalFee = approvalExecution.totalFee + BigInt(swapResult.fee);
         const result = {
-          hash,
+          ...swapResult,
           fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
+          swapFee: swapResult.fee,
           approvalFee: approvalExecution.totalFee.toString(),
           tokenInAmount: finalPlan.tokenInAmount.toString(),
           tokenOutAmount: finalPlan.tokenOutAmount.toString(),
@@ -3470,6 +3715,7 @@ export class WdkEvmWalletService {
           simulation: effectiveSimulation,
           swapTransaction: finalPlan.swapTransaction,
           result,
+          confirmed: true,
           source: "wdk-protocol-swap-velora-evm",
         };
       } catch (error) {
@@ -3580,12 +3826,23 @@ export class WdkEvmWalletService {
           : finalPlan.simulation;
         this.#assertSimulationSucceeded(effectiveSimulation);
 
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const swapResult = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: sourceAddress,
+          tx: finalPlan.swapTx,
+          operationLabel: "LI.FI swap",
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+          operationLabel: "LI.FI swap",
+          failureCode: "swap_reverted",
+          timeoutCode: "swap_confirmation_timeout",
+        });
+        const totalFee = approvalExecution.totalFee + BigInt(swapResult.fee);
         const result = {
-          hash,
+          ...swapResult,
           fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
+          swapFee: swapResult.fee,
           approvalFee: approvalExecution.totalFee.toString(),
           tokenInAmount: finalPlan.tokenInAmount.toString(),
           tokenOutAmount: finalPlan.tokenOutAmount.toString(),
@@ -3612,6 +3869,7 @@ export class WdkEvmWalletService {
             },
           }),
           result,
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedSwap({
@@ -3757,36 +4015,84 @@ export class WdkEvmWalletService {
           );
         }
 
-        const signature =
-          finalPlan.isNativeTokenIn || !finalPlan.permitData
-            ? null
-            : await this.#signUniswapPermit(account, finalPlan.permitData, runtimeConfig);
-
-        const swapTx = await this.#fetchUniswapSwapCalldata({
-          runtimeConfig,
-          quoteResponse: finalPlan.quoteResponse,
-          permitData: finalPlan.permitData,
-          signature,
-        });
+        const signature = finalPlan.permitData
+          ? await this.#signUniswapPermit(account, finalPlan.permitData, runtimeConfig)
+          : null;
 
-        const simulation = await this.#simulatePreparedTransaction({
-          runtimeConfig,
-          from: address,
-          tx: swapTx,
-        });
-        this.#assertSimulationSucceeded(simulation);
+        let simulation;
+        let swapTransaction = null;
+        let result;
+        if (finalPlan.isUniswapX) {
+          const order = await this.#submitUniswapOrder({
+            quoteResponse: finalPlan.quoteResponse,
+            signature,
+            nativeTokenIn: finalPlan.isNativeTokenIn,
+            routing: finalPlan.routing,
+            routerProfile: finalPlan.routerProfile,
+          });
+          simulation = {
+            ok: true,
+            skipped: true,
+            reason: "uniswapx-order",
+            message: "UniswapX validates and submits the signed order to its filler network.",
+            details: null,
+          };
+          result = {
+            orderId: order.orderId,
+            orderStatus: order.orderStatus,
+            approvalFee: approvalExecution.totalFee.toString(),
+            tokenInAmount: finalPlan.tokenInAmount.toString(),
+            tokenOutAmount: finalPlan.tokenOutAmount.toString(),
+            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+            ...(approvalExecution.resetAllowanceHash
+              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+              : {}),
+          };
+        } else {
+          const swapTx =
+            finalPlan.preparedTransaction ||
+            (await this.#fetchUniswapSwapCalldata({
+              runtimeConfig,
+              routerProfile: finalPlan.routerProfile,
+              quoteResponse: finalPlan.quoteResponse,
+              permitData: finalPlan.permitData,
+              signature,
+            }));
+          simulation = await this.#simulatePreparedTransaction({
+            runtimeConfig,
+            from: address,
+            tx: swapTx,
+          });
+          this.#assertSimulationSucceeded(simulation);
 
-        const { hash } = await account.sendTransaction(swapTx);
-        const result = {
-          hash,
-          approvalFee: approvalExecution.totalFee.toString(),
-          tokenInAmount: finalPlan.tokenInAmount.toString(),
-          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
-          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-          ...(approvalExecution.resetAllowanceHash
-            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-            : {}),
-        };
+          const swapResult = await this.#sendBufferedDefiTransaction({
+            account,
+            runtimeConfig,
+            from: address,
+            tx: swapTx,
+            operationLabel: "Uniswap swap",
+          });
+          await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+            operationLabel: "Uniswap swap",
+            failureCode: "swap_reverted",
+            timeoutCode: "swap_confirmation_timeout",
+          });
+          swapTransaction = {
+            to: swapTx.to,
+            value: swapTx.value.toString(),
+            dataHash: sha256Hex(swapTx.data),
+          };
+          result = {
+            ...swapResult,
+            approvalFee: approvalExecution.totalFee.toString(),
+            tokenInAmount: finalPlan.tokenInAmount.toString(),
+            tokenOutAmount: finalPlan.tokenOutAmount.toString(),
+            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+            ...(approvalExecution.resetAllowanceHash
+              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+              : {}),
+          };
+        }
         return {
           ...(await this.#formatUniswapSwapResponse({
             runtimeConfig,
@@ -3802,8 +4108,9 @@ export class WdkEvmWalletService {
             },
           })),
           simulation,
-          swapTransaction: { to: swapTx.to, value: swapTx.value.toString(), dataHash: sha256Hex(swapTx.data) },
+          swapTransaction,
           result,
+          confirmed: Boolean(result.hash),
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedSwap({
@@ -3845,7 +4152,8 @@ export class WdkEvmWalletService {
       address,
       protocol: "uniswap",
       executionSupported: true,
-      routing: "CLASSIC",
+      executionKind: plan.executionKind,
+      routing: plan.routing,
       swapRequest: {
         tokenIn: swapRequest.tokenIn,
         tokenOut: swapRequest.tokenOut,
@@ -3854,6 +4162,7 @@ export class WdkEvmWalletService {
       tokenInMetadata,
       tokenOutMetadata,
       inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
+      outputAmount: plan.tokenOutAmount.toString(),
       outputAmountFormatted: formatUnits(plan.tokenOutAmount, tokenOutMetadata.decimals),
       quoteFingerprint: plan.quoteFingerprint,
       slippageBps: plan.slippageBps,
@@ -3871,7 +4180,19 @@ export class WdkEvmWalletService {
         readError: plan.allowanceReadError,
       },
       router: plan.router,
-      source: "uniswap-trading-api",
+      swapTransaction: plan.preparedTransaction
+        ? {
+            to: plan.preparedTransaction.to,
+            value: plan.preparedTransaction.value.toString(),
+            dataHash: sha256Hex(plan.preparedTransaction.data),
+          }
+        : null,
+      source:
+        plan.executionKind === "wrap" || plan.executionKind === "unwrap"
+          ? "canonical-wrapped-native"
+          : plan.executionKind === "v3-direct"
+            ? "uniswap-v3-direct-fallback"
+          : "uniswap-trading-api",
     };
   }
 
@@ -4325,6 +4646,150 @@ export class WdkEvmWalletService {
     return options;
   }
 
+  async #sendMorphoProtocolOperation({ account, runtimeConfig, protocol, request }) {
+    const methods = this.#getMorphoOperationMethods(request);
+    const originalSendTransaction = account.sendTransaction;
+    if (typeof originalSendTransaction !== "function") {
+      throw new Error("Morpho operation requires an EVM account with sendTransaction().");
+    }
+    const hadOwnSendTransaction = Object.prototype.hasOwnProperty.call(account, "sendTransaction");
+
+    // The protocol constructs the final calldata immediately before sending it.
+    // Intercept that one protocol-scoped send so the estimate and padded limit
+    // are based on the exact transaction, rather than a stale preview.
+    account.sendTransaction = async (tx) => {
+      const gas = await this.#prepareMorphoGasLimit({
+        runtimeConfig,
+        from: await account.getAddress(),
+        tx,
+        operation: request.operation,
+      });
+      const result = await originalSendTransaction.call(account, {
+        ...tx,
+        gasLimit: gas.gasLimit,
+      });
+      return {
+        ...result,
+        fee: gas.maximumFee,
+        gasEstimate: gas.gasEstimate.toString(),
+        gasLimit: gas.gasLimit.toString(),
+        gasBufferBps: MORPHO_GAS_BUFFER_BPS.toString(),
+      };
+    };
+
+    try {
+      return await protocol[methods.sendMethod](this.#buildMorphoOperationOptions(request));
+    } finally {
+      if (hadOwnSendTransaction) {
+        account.sendTransaction = originalSendTransaction;
+      } else {
+        delete account.sendTransaction;
+      }
+    }
+  }
+
+  async #prepareMorphoGasLimit({ runtimeConfig, from, tx, operation }) {
+    return this.#prepareBufferedDefiGasLimit({
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel: `morpho ${operation}`,
+      unavailableCode: "morpho_gas_estimate_unavailable",
+      unavailableMessage: "Morpho gas estimate was empty. Generate a new quote before sending.",
+    });
+  }
+
+  async #prepareBufferedDefiGasLimit({
+    runtimeConfig,
+    from,
+    tx,
+    operationLabel,
+    unavailableCode = "defi_gas_estimate_unavailable",
+    unavailableMessage = "DeFi gas estimate was empty. Generate a new quote before sending.",
+  }) {
+    const gasEstimateHex = await rpcRequest(runtimeConfig.providerUrl, "eth_estimateGas", [
+      {
+        from: normalizeAddress(from, "from"),
+        to: normalizeAddress(String(tx.to || ""), "to"),
+        data: assertNonEmptyString(String(tx.data || ""), "data"),
+        value: toRpcHex(tx.value || 0),
+      },
+    ]);
+    const gasEstimate = BigInt(gasEstimateHex || "0x0");
+    if (gasEstimate <= 0n) {
+      throw createTaggedError(unavailableMessage, unavailableCode, { operation: operationLabel });
+    }
+    const gasLimit = applyGasBuffer(gasEstimate, DEFI_GAS_BUFFER_BPS);
+    const effectiveFeePerGas = await this.#getEffectiveGasPrice(runtimeConfig);
+    const maximumFee = gasLimit * effectiveFeePerGas;
+    this.#assertMaxFee(runtimeConfig, maximumFee, operationLabel);
+    return { gasEstimate, gasLimit, maximumFee };
+  }
+
+  async #sendBufferedDefiTransaction({ account, runtimeConfig, from, tx, operationLabel }) {
+    return this.#sendBufferedDefiTransactionWithSender({
+      sendTransaction: (preparedTx) => account.sendTransaction(preparedTx),
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel,
+    });
+  }
+
+  async #sendBufferedDefiTransactionWithSender({
+    sendTransaction,
+    runtimeConfig,
+    from,
+    tx,
+    operationLabel,
+  }) {
+    const gas = await this.#prepareBufferedDefiGasLimit({
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel,
+    });
+    const result = await sendTransaction({ ...tx, gasLimit: gas.gasLimit });
+    return {
+      ...result,
+      fee: gas.maximumFee.toString(),
+      gasEstimate: gas.gasEstimate.toString(),
+      gasLimit: gas.gasLimit.toString(),
+      gasBufferBps: DEFI_GAS_BUFFER_BPS.toString(),
+    };
+  }
+
+  async #sendBufferedDefiProtocolOperation({
+    account,
+    runtimeConfig,
+    operationLabel,
+    operation,
+    invoke,
+  }) {
+    const originalSendTransaction = account.sendTransaction;
+    if (typeof originalSendTransaction !== "function") {
+      throw new Error(`${operationLabel} requires an EVM account with sendTransaction().`);
+    }
+    const hadOwnSendTransaction = Object.prototype.hasOwnProperty.call(account, "sendTransaction");
+    account.sendTransaction = async (tx) =>
+      this.#sendBufferedDefiTransactionWithSender({
+        sendTransaction: (preparedTx) => originalSendTransaction.call(account, preparedTx),
+        runtimeConfig,
+        from: await account.getAddress(),
+        tx,
+        operationLabel: `${operationLabel} ${operation}`,
+      });
+    try {
+      return await invoke();
+    } finally {
+      if (hadOwnSendTransaction) {
+        account.sendTransaction = originalSendTransaction;
+      } else {
+        delete account.sendTransaction;
+      }
+    }
+  }
+
   async #buildMorphoOperationPlan({
     account,
     runtimeConfig,
@@ -4525,7 +4990,7 @@ export class WdkEvmWalletService {
     try {
       const quote = await protocol[methods.quoteMethod](operationOptions);
       return {
-        fee: BigInt(quote?.fee || 0),
+        fee: applyGasBuffer(BigInt(quote?.fee || 0), MORPHO_GAS_BUFFER_BPS),
         error: null,
       };
     } catch (error) {
@@ -4622,11 +5087,23 @@ export class WdkEvmWalletService {
     for (let index = 0; index < plan.requirements.transactions.length; index += 1) {
       const requirementTx = plan.requirements.transactions[index];
       const step = plan.requirements.steps[index];
-      const result = await account.sendTransaction({
+      const tx = {
         to: requirementTx.to,
         value: requirementTx.value ?? 0n,
         data: requirementTx.data,
-      });
+      };
+      // ERC-20 approval writes intentionally retain the narrow WDK path. A
+      // Morpho authorization is a protocol write, so give it the same buffer
+      // as the potentially stateful final operation.
+      const result = step?.type === "authorization"
+        ? await this.#sendBufferedDefiTransaction({
+            account,
+            runtimeConfig,
+            from: await account.getAddress(),
+            tx,
+            operationLabel: "Morpho authorization",
+          })
+        : await account.sendTransaction(tx);
       const fee = BigInt(result?.fee || 0);
       totalFee += fee;
       transactions.push({
@@ -4702,13 +5179,19 @@ export class WdkEvmWalletService {
       }
 
       for (const context of requirementExecution.authorizationContexts || []) {
-        const result = await account.sendTransaction({
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: await account.getAddress(),
+          operationLabel: "Morpho authorization cleanup",
+          tx: {
           to: context.contractAddress,
           value: 0n,
           data: MORPHO_AUTHORIZATION_INTERFACE.encodeFunctionData("setAuthorization", [
             context.authorized,
             false,
           ]),
+          },
         });
         cleanup.authorizations.push({
           contractAddress: context.contractAddress,
@@ -5179,12 +5662,19 @@ export class WdkEvmWalletService {
     };
   }
 
-  async #uniswapTradingApiRequest(pathname, body) {
+  async #uniswapTradingApiRequest(
+    pathname,
+    body,
+    { erc20EthEnabled = false, routerVersion = this.config.uniswapRouterVersion, chainId = null } = {}
+  ) {
     const headers = {
       "Content-Type": "application/json",
       Accept: "application/json",
-      "x-universal-router-version": this.config.uniswapRouterVersion,
+      "x-universal-router-version": routerVersion,
     };
+    if (erc20EthEnabled) {
+      headers["x-erc20eth-enabled"] = "true";
+    }
     if (this.config.uniswapViaGateway) {
       // The provider gateway holds the Uniswap key and injects x-api-key upstream;
       // we authenticate to it with the shared gateway bearer (same token used for
@@ -5193,6 +5683,13 @@ export class WdkEvmWalletService {
       if (token) {
         headers.Authorization = `Bearer ${token}`;
       }
+      // The gateway selects its own configured version and checks this value for
+      // equality. The chain id is an allow-listed routing hint, never an upstream
+      // header passthrough.
+      if (chainId !== null) {
+        headers["x-agentlayer-chain-id"] = String(chainId);
+        headers["x-agentlayer-uniswap-router-version"] = routerVersion;
+      }
     } else {
       if (!this.config.uniswapApiKey) {
         throw createTaggedError(
@@ -5246,9 +5743,9 @@ export class WdkEvmWalletService {
     return payload;
   }
 
-  async #fetchUniswapQuote({ runtimeConfig, address, swapRequest }) {
+  async #fetchUniswapQuote({ runtimeConfig, routerProfile, address, swapRequest }) {
     const chainId = UNISWAP_SUPPORTED_CHAIN_IDS[runtimeConfig.network];
-    const payload = await this.#uniswapTradingApiRequest("/quote", {
+    const quoteRequest = {
       swapper: address,
       tokenIn: swapRequest.tokenIn,
       tokenOut: swapRequest.tokenOut,
@@ -5257,21 +5754,50 @@ export class WdkEvmWalletService {
       amount: swapRequest.tokenInAmount.toString(),
       type: "EXACT_INPUT",
       slippageTolerance: swapRequest.slippagePercent,
-      // The live Trading API rejects routingPreference:"CLASSIC"; restricting
-      // protocols to V2/V3/V4 is what excludes UniswapX and yields routing=CLASSIC.
-      protocols: ["V2", "V3", "V4"],
-    });
+    };
+    const requestOptions = {
+      erc20EthEnabled: isZeroAddress(swapRequest.tokenIn),
+      routerVersion: routerProfile.routerVersion,
+      chainId,
+    };
+    const ammProtocols = routerProfile.ammProtocols;
+    let payload;
+    try {
+      // Prefer the full route set. On a sub-minimum UniswapX request the API can
+      // return No quotes available even when an AMM pool is liquid, so retry the
+      // same exact swap through AMMs only before reporting a quote failure.
+      payload = await this.#uniswapTradingApiRequest(
+        "/quote",
+        {
+          ...quoteRequest,
+          protocols: [
+            ...ammProtocols,
+            runtimeConfig.network === "ethereum" ? "UNISWAPX_V2" : "UNISWAPX_V3",
+          ],
+        },
+        requestOptions
+      );
+    } catch (error) {
+      if (!isUniswapNoQuotesAvailableError(error)) {
+        throw error;
+      }
+      payload = await this.#uniswapTradingApiRequest(
+        "/quote",
+        { ...quoteRequest, protocols: ammProtocols },
+        requestOptions
+      );
+    }
     const routing = String(payload.routing || "").toUpperCase();
-    if (routing !== "CLASSIC") {
+    if (!UNISWAP_CLASSIC_ROUTINGS.has(routing) && !UNISWAPX_ROUTINGS.has(routing)) {
       throw createTaggedError(
-        `Uniswap returned unsupported routing '${routing}'. Only CLASSIC is enabled in this runtime.`,
+        `Uniswap returned unsupported routing '${routing}'.`,
         "uniswap_unsupported_route",
         { provider: "uniswap", routing }
       );
     }
     if (!payload.quote || typeof payload.quote !== "object" || !payload.quote.output) {
       throw createTaggedError(
-        "Uniswap quote response is missing CLASSIC quote/output fields.",
+        "Uniswap quote response is missing quote/output fields.",
         "network_unavailable",
         { provider: "uniswap" }
       );
@@ -5279,8 +5805,195 @@ export class WdkEvmWalletService {
     return payload;
   }
 
+  async #quoteRobinhoodV3Direct({ runtimeConfig, networkProfile, swapRequest }) {
+    const fallback = networkProfile.v3DirectFallback;
+    if (!fallback) {
+      return null;
+    }
+    const tokenIn = isZeroAddress(swapRequest.tokenIn)
+      ? networkProfile.wrappedNative
+      : swapRequest.tokenIn;
+    const tokenOut = isZeroAddress(swapRequest.tokenOut)
+      ? networkProfile.wrappedNative
+      : swapRequest.tokenOut;
+    let best = null;
+    for (const feeTier of fallback.feeTiers) {
+      const data = UNISWAP_V3_QUOTER_INTERFACE.encodeFunctionData("quoteExactInputSingle", [
+        {
+          tokenIn,
+          tokenOut,
+          amountIn: swapRequest.tokenInAmount,
+          fee: feeTier,
+          sqrtPriceLimitX96: 0,
+        },
+      ]);
+      try {
+        const raw = await rpcRequest(runtimeConfig.providerUrl, "eth_call", [
+          { to: fallback.quoterV2, data },
+          "latest",
+        ]);
+        const decoded = UNISWAP_V3_QUOTER_INTERFACE.decodeFunctionResult(
+          "quoteExactInputSingle",
+          raw
+        );
+        const amountOut = BigInt(decoded[0]);
+        if (amountOut > 0n && (!best || amountOut > best.amountOut)) {
+          best = { feeTier, amountOut, gasEstimate: BigInt(decoded[3]) };
+        }
+      } catch {
+        // A missing pool and a failed Quoter call are equivalent for this
+        // constrained direct route. Try every reviewed fee tier before failing.
+      }
+    }
+    return best;
+  }
+
+  async #buildRobinhoodV3DirectFallbackPlan({ account, runtimeConfig, address, swapRequest }) {
+    const networkProfile = getUniswapNetworkExecutionProfile(runtimeConfig.network);
+    const quoted = await this.#quoteRobinhoodV3Direct({
+      runtimeConfig,
+      networkProfile,
+      swapRequest,
+    });
+    if (!quoted) {
+      return null;
+    }
+    const slippageBps = Math.round(swapRequest.slippagePercent * 100);
+    const minimumTokenOutAmount =
+      quoted.amountOut - (quoted.amountOut * BigInt(slippageBps)) / 10000n;
+    const nativeTokenIn = isZeroAddress(swapRequest.tokenIn);
+    const spender = nativeTokenIn ? null : networkProfile.v3DirectFallback.swapRouter02;
+    const allowanceState = nativeTokenIn
+      ? { currentAllowance: swapRequest.tokenInAmount, error: null }
+      : await this.#getSwapAllowanceState({
+          account,
+          tokenAddress: swapRequest.tokenIn,
+          spender,
+        });
+    const approval = nativeTokenIn
+      ? { required: false, estimatedFee: 0n, steps: [] }
+      : await this.#buildSwapApprovalPlan({
+          account,
+          runtimeConfig,
+          tokenAddress: swapRequest.tokenIn,
+          spender,
+          requiredAmount: swapRequest.tokenInAmount,
+          currentAllowance: allowanceState.currentAllowance,
+        });
+    const preparedTransaction = buildUniswapV3DirectSwapTransaction({
+      networkProfile,
+      recipient: address,
+      swapRequest,
+      feeTier: quoted.feeTier,
+      minimumTokenOutAmount,
+    });
+    const quoteFingerprint = sha256Hex(
+      JSON.stringify({
+        chainId: runtimeConfig.chainId,
+        network: runtimeConfig.network,
+        from: address.toLowerCase(),
+        router: networkProfile.v3DirectFallback.swapRouter02,
+        spender: spender ? spender.toLowerCase() : null,
+        tokenIn: swapRequest.tokenIn.toLowerCase(),
+        tokenOut: swapRequest.tokenOut.toLowerCase(),
+        tokenInAmount: swapRequest.tokenInAmount.toString(),
+        feeTier: quoted.feeTier,
+        slippageBps,
+        executionKind: "v3-direct",
+      })
+    );
+    return {
+      quoteResponse: null,
+      permitData: null,
+      isNativeTokenIn: nativeTokenIn,
+      spender,
+      currentAllowance: allowanceState.currentAllowance,
+      allowanceReadError: allowanceState.error,
+      approval,
+      tokenInAmount: swapRequest.tokenInAmount,
+      tokenOutAmount: quoted.amountOut,
+      minimumTokenOutAmount,
+      slippageBps,
+      routing: "CLASSIC",
+      executionKind: "v3-direct",
+      isUniswapX: false,
+      quoteFingerprint,
+      // QuoterV2 returns a gas-unit estimate, not a wei-denominated fee.
+      // Keep the fee field empty rather than mislabeling units in the preview.
+      gasFee: null,
+      gasFeeUSD: null,
+      router: networkProfile.v3DirectFallback.swapRouter02,
+      routerProfile: null,
+      preparedTransaction,
+      v3FeeTier: quoted.feeTier,
+    };
+  }
+
   async #buildUniswapSwapPlan({ account, runtimeConfig, address, swapRequest }) {
-    const quoteResponse = await this.#fetchUniswapQuote({ runtimeConfig, address, swapRequest });
+    const networkProfile = getUniswapNetworkExecutionProfile(runtimeConfig.network);
+    const directOperation = buildDirectWrappedNativeOperation(networkProfile, swapRequest);
+    const slippageBps = Math.round(swapRequest.slippagePercent * 100);
+    if (directOperation) {
+      const quoteFingerprint = sha256Hex(
+        JSON.stringify({
+          chainId: runtimeConfig.chainId,
+          network: runtimeConfig.network,
+          from: address.toLowerCase(),
+          executionKind: directOperation.executionKind,
+          wrappedNative: networkProfile.wrappedNative,
+          tokenIn: swapRequest.tokenIn,
+          tokenOut: swapRequest.tokenOut,
+          tokenInAmount: swapRequest.tokenInAmount.toString(),
+        })
+      );
+      return {
+        quoteResponse: null,
+        permitData: null,
+        isNativeTokenIn: isZeroAddress(swapRequest.tokenIn),
+        spender: null,
+        currentAllowance: 0n,
+        allowanceReadError: null,
+        approval: { required: false, estimatedFee: 0n, steps: [] },
+        tokenInAmount: swapRequest.tokenInAmount,
+        tokenOutAmount: swapRequest.tokenInAmount,
+        minimumTokenOutAmount: swapRequest.tokenInAmount,
+        slippageBps,
+        routing: directOperation.routing,
+        executionKind: directOperation.executionKind,
+        isUniswapX: false,
+        quoteFingerprint,
+        gasFee: null,
+        gasFeeUSD: null,
+        router: networkProfile.wrappedNative,
+        routerProfile: null,
+        preparedTransaction: directOperation.transaction,
+      };
+    }
+
+    const routerProfile = this.#resolveUniswapRouterProfile(runtimeConfig);
+    let quoteResponse;
+    try {
+      quoteResponse = await this.#fetchUniswapQuote({
+        runtimeConfig,
+        routerProfile,
+        address,
+        swapRequest,
+      });
+    } catch (error) {
+      if (runtimeConfig.network !== "robinhood" || !isUniswapNoQuotesAvailableError(error)) {
+        throw error;
+      }
+      const fallbackPlan = await this.#buildRobinhoodV3DirectFallbackPlan({
+        account,
+        runtimeConfig,
+        address,
+        swapRequest,
+      });
+      if (fallbackPlan) {
+        return fallbackPlan;
+      }
+      throw error;
+    }
     const permitData = quoteResponse.permitData ?? null;
     const isNativeTokenIn = isZeroAddress(swapRequest.tokenIn);
     const spender = isNativeTokenIn ? null : PERMIT2_ADDRESS;
@@ -5302,16 +6015,17 @@ export class WdkEvmWalletService {
           requiredAmount: swapRequest.tokenInAmount,
           currentAllowance,
         });
-    const tokenOutAmount = BigInt(String(quoteResponse.quote.output.amount || "0"));
-    const slippageBps = Math.round(swapRequest.slippagePercent * 100);
+    const quoteOutput = quoteResponse.quote.output;
+    const tokenOutAmount = BigInt(String(quoteOutput.amount || "0"));
     // The Trading API returns the post-slippage floor directly; fall back to a
     // local computation only if the field is absent.
     const minimumTokenOutAmount =
-      quoteResponse.quote.output.minimumAmount !== undefined &&
-      quoteResponse.quote.output.minimumAmount !== null
-        ? BigInt(String(quoteResponse.quote.output.minimumAmount))
+      quoteOutput.minimumAmount !== undefined && quoteOutput.minimumAmount !== null
+        ? BigInt(String(quoteOutput.minimumAmount))
         : tokenOutAmount - (tokenOutAmount * BigInt(slippageBps)) / 10000n;
-    const router = UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK[runtimeConfig.network];
+    const routing = String(quoteResponse.routing || "").toUpperCase();
+    const isUniswapX = UNISWAPX_ROUTINGS.has(routing);
+    const router = isUniswapX ? null : routerProfile.router;
     // Bind only the stable swap *intent* (who/what/how-much/slippage/route), never
     // the live quoted output: the Trading API re-prices every block, so including
     // tokenOutAmount here made execute's re-quote fingerprint differ from preview's
@@ -5323,13 +6037,15 @@ export class WdkEvmWalletService {
         chainId: runtimeConfig.chainId,
         network: runtimeConfig.network,
         from: address.toLowerCase(),
-        router: router.toLowerCase(),
+        router: router ? router.toLowerCase() : null,
         spender: spender ? spender.toLowerCase() : null,
         tokenIn: swapRequest.tokenIn.toLowerCase(),
         tokenOut: swapRequest.tokenOut.toLowerCase(),
         tokenInAmount: swapRequest.tokenInAmount.toString(),
         slippageBps,
-        routing: "CLASSIC",
+        routing,
+        executionKind: isUniswapX ? "uniswapx" : "classic",
+        routerVersion: routerProfile.routerVersion,
       })
     );
     return {
@@ -5344,13 +6060,25 @@ export class WdkEvmWalletService {
       tokenOutAmount,
       minimumTokenOutAmount,
       slippageBps,
+      routing,
+      executionKind: isUniswapX ? "uniswapx" : "classic",
+      isUniswapX,
       quoteFingerprint,
       gasFee: quoteResponse.quote.gasFee ?? null,
       gasFeeUSD: quoteResponse.quote.gasFeeUSD ?? null,
       router,
+      routerProfile,
+      preparedTransaction: null,
     };
   }
 
+  #resolveUniswapRouterProfile(runtimeConfig) {
+    const configuredVersion =
+      this.config.uniswapRouterVersionsByNetwork?.[runtimeConfig.network] ||
+      this.config.uniswapRouterVersion;
+    return resolveUniswapRouterExecutionProfile(runtimeConfig.network, configuredVersion);
+  }
+
   async #signUniswapPermit(account, permitData, runtimeConfig) {
     const typed = normalizeUniswapPermitData(permitData, runtimeConfig);
     return account.signTypedData({
@@ -5360,7 +6088,13 @@ export class WdkEvmWalletService {
     });
   }
 
-  async #fetchUniswapSwapCalldata({ runtimeConfig, quoteResponse, permitData, signature }) {
+  async #fetchUniswapSwapCalldata({
+    runtimeConfig,
+    routerProfile,
+    quoteResponse,
+    permitData,
+    signature,
+  }) {
     const { permitData: _permitData, permitTransaction: _permitTransaction, ...cleanQuote } =
       quoteResponse;
     const body = { ...cleanQuote };
@@ -5370,10 +6104,13 @@ export class WdkEvmWalletService {
       body.signature = signature;
       body.permitData = permitData;
     }
-    const payload = await this.#uniswapTradingApiRequest("/swap", body);
+    const payload = await this.#uniswapTradingApiRequest("/swap", body, {
+      routerVersion: routerProfile.routerVersion,
+      chainId: runtimeConfig.chainId,
+    });
     const swap = payload.swap || {};
     const to = normalizeAddress(String(swap.to || ""), "swap.to");
-    const expectedRouter = UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK[runtimeConfig.network];
+    const expectedRouter = routerProfile.router;
     if (to.toLowerCase() !== expectedRouter) {
       throw createTaggedError(
         "Uniswap /swap returned an unexpected target contract.",
@@ -5382,6 +6119,7 @@ export class WdkEvmWalletService {
       );
     }
     const data = assertNonEmptyString(String(swap.data || ""), "swap.data");
+    const value = parseHexOrDecimalBigInt(swap.value || "0", "swap.value");
     if (data === "0x") {
       throw createTaggedError(
         "Uniswap /swap returned empty calldata. The quote likely expired; generate a new preview.",
@@ -5392,7 +6130,38 @@ export class WdkEvmWalletService {
     return {
       to,
       data,
-      value: parseHexOrDecimalBigInt(swap.value || "0", "swap.value"),
+      value,
+    };
+  }
+
+  async #submitUniswapOrder({ quoteResponse, signature, nativeTokenIn, routing, routerProfile }) {
+    if (!signature) {
+      throw createTaggedError(
+        "UniswapX order quote is missing required signature data.",
+        "uniswap_order_signature_missing",
+        { provider: "uniswap" }
+      );
+    }
+    const payload = await this.#uniswapTradingApiRequest(
+      "/order",
+      { quote: quoteResponse.quote, routing, signature },
+      {
+        erc20EthEnabled: nativeTokenIn,
+        routerVersion: routerProfile.routerVersion,
+        chainId: routerProfile.chainId,
+      }
+    );
+    const orderId = String(payload.orderId || payload.order?.orderId || "").trim();
+    if (!orderId) {
+      throw createTaggedError(
+        "Uniswap /order response is missing orderId.",
+        "network_unavailable",
+        { provider: "uniswap" }
+      );
+    }
+    return {
+      orderId,
+      orderStatus: String(payload.orderStatus || payload.order?.orderStatus || "open"),
     };
   }
 
@@ -7533,13 +8302,21 @@ export class WdkEvmWalletService {
     }
   }
 
-  async #waitForTransactionReceipt(runtimeConfig, txHash) {
+  async #waitForTransactionReceipt(
+    runtimeConfig,
+    txHash,
+    {
+      operationLabel = "Approval transaction",
+      failureCode = "swap_approval_failed",
+      timeoutCode = "swap_approval_timeout",
+    } = {}
+  ) {
     for (let attempt = 0; attempt < 30; attempt += 1) {
       const receipt = await rpcRequest(runtimeConfig.providerUrl, "eth_getTransactionReceipt", [txHash]);
       if (receipt) {
         const status = String(receipt.status || "").toLowerCase();
         if (status === "0x0") {
-          throw createTaggedError("Approval transaction reverted onchain.", "swap_approval_failed", {
+          throw createTaggedError(`${operationLabel} reverted onchain.`, failureCode, {
             txHash,
             network: runtimeConfig.network,
           });
@@ -7549,8 +8326,8 @@ export class WdkEvmWalletService {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
     throw createTaggedError(
-      "Timed out waiting for approval transaction confirmation.",
-      "swap_approval_timeout",
+      `Timed out waiting for ${operationLabel.toLowerCase()} confirmation.`,
+      timeoutCode,
       {
         txHash,
         network: runtimeConfig.network,
@@ -7560,11 +8337,17 @@ export class WdkEvmWalletService {
 }
 
 export const __testables = {
+  applyGasBuffer,
+  MORPHO_GAS_BUFFER_BPS,
   PERMIT2_ADDRESS,
   UNISWAP_SUPPORTED_CHAIN_IDS,
+  UNISWAP_EXECUTION_PROFILES,
   UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK,
+  UNISWAP_WRAPPED_NATIVE_BY_NETWORK,
   normalizeUniswapTokenAddress,
   assertUniswapSupportedNetwork,
+  resolveUniswapRouterExecutionProfile,
+  buildDirectWrappedNativeOperation,
   assertValidNetwork,
   uniswapSlippagePercentFromBps,
   normalizeUniswapPermitData,