@agentlayer.tech/wallet 0.1.76 → 0.1.84

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

@@ -22,12 +22,64 @@ const DEFAULT_SWAP_SLIPPAGE_BPS = 100;
 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 };
-// Universal Router v2.0 allow-list (defense-in-depth: /swap response `to` must match).
-const UNISWAP_UNIVERSAL_ROUTER_BY_NETWORK = {
-  ethereum: "0x66a9893cc07d91d95644aedd05d03f95e1dba8af",
-  base: "0x6ff5693b99212da76ad316178a184ab56d299b43",
+const UNISWAP_SUPPORTED_CHAIN_IDS = { ethereum: 1, base: 8453, robinhood: 4663 };
+// 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,
+    universalRouters: { "2.0": "0x8876789976decbfcbbbe364623c63652db8c0904" },
+    wrappedNative: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
+    // Robinhood's official deployment exposes the V3 stack. Asking the Trading
+    // API for undeployed V2/V4 routes can make an otherwise valid V3-only pair
+    // appear unavailable, so keep the protocol set chain-specific.
+    ammProtocols: ["V3"],
+    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;
@@ -502,10 +554,13 @@ function assertValidNetwork(network, fieldName = "network") {
     eth: "ethereum",
     "base-mainnet": "base",
     base_sepolia: "base-sepolia",
+    "robinhood-mainnet": "robinhood",
   };
   const effective = aliases[normalized] || normalized;
-  if (!["ethereum", "sepolia", "base", "base-sepolia"].includes(effective)) {
-    throw new Error(`${fieldName} must be one of: ethereum, sepolia, base, base-sepolia.`);
+  if (!["ethereum", "sepolia", "base", "base-sepolia", "robinhood"].includes(effective)) {
+    throw new Error(
+      `${fieldName} must be one of: ethereum, sepolia, base, base-sepolia, robinhood.`
+    );
   }
   return effective;
 }
@@ -847,12 +902,121 @@ function assertUniswapSupportedNetwork(network) {
   const chainId = UNISWAP_SUPPORTED_CHAIN_IDS[network];
   if (!chainId) {
     throw new Error(
-      "Uniswap Trading API swaps are currently supported only on ethereum and base mainnet."
+      "Uniswap Trading API swaps are currently supported only on ethereum, base, and robinhood mainnet."
     );
   }
   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) {
@@ -3753,36 +3917,73 @@ 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 { hash } = await account.sendTransaction(swapTx);
+          swapTransaction = {
+            to: swapTx.to,
+            value: swapTx.value.toString(),
+            dataHash: sha256Hex(swapTx.data),
+          };
+          result = {
+            hash,
+            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,
@@ -3798,7 +3999,7 @@ export class WdkEvmWalletService {
             },
           })),
           simulation,
-          swapTransaction: { to: swapTx.to, value: swapTx.value.toString(), dataHash: sha256Hex(swapTx.data) },
+          swapTransaction,
           result,
         };
       } catch (error) {
@@ -3841,7 +4042,8 @@ export class WdkEvmWalletService {
       address,
       protocol: "uniswap",
       executionSupported: true,
-      routing: "CLASSIC",
+      executionKind: plan.executionKind,
+      routing: plan.routing,
       swapRequest: {
         tokenIn: swapRequest.tokenIn,
         tokenOut: swapRequest.tokenOut,
@@ -3850,6 +4052,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,
@@ -3867,7 +4070,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",
     };
   }
 
@@ -5175,12 +5390,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
@@ -5189,6 +5411,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(
@@ -5242,9 +5471,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,
@@ -5253,21 +5482,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" }
       );
@@ -5275,8 +5533,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;
@@ -5298,16 +5743,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
@@ -5319,13 +5765,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 {
@@ -5340,13 +5788,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({
@@ -5356,7 +5816,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 };
@@ -5366,10 +5832,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.",
@@ -5378,6 +5847,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.",
@@ -5388,7 +5858,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"),
     };
   }
 
@@ -7558,8 +8059,14 @@ export class WdkEvmWalletService {
 export const __testables = {
   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,
 };