@owney/sdk 0.7.26-beta.2 → 0.7.26-beta.4

package/dist/index.cjs

@@ -2309,6 +2309,21 @@ function createSwapApi(baseUrl, apiKey) {
      * Already filtered server-side to what a quote will accept, so anything
      * returned here can be paid with.
      */
+    /**
+     * Tokens the wallet holds on one chain.
+     *
+     * Already filtered upstream to non-zero balances of tokens the routing API
+     * would quote — 1inch answers with every token it knows about, zeros
+     * included, and the curation that decides what is offerable lives there.
+     */
+    walletBalances: (params) => request(
+      baseUrl,
+      apiKey,
+      `/balances?${new URLSearchParams({
+        chainId: String(params.chainId),
+        walletAddress: params.walletAddress
+      })}`
+    ),
     searchTokens: (params) => request(
       baseUrl,
       apiKey,
@@ -2366,9 +2381,10 @@ function createSwapApi(baseUrl, apiKey) {
         dstSymbol: params.to.symbol,
         amount: params.from.amount,
         walletAddress: params.walletAddress,
-        secretHashes: params.secretHashes,
+        ...params.secretHashes ? { secretHashes: params.secretHashes } : {},
         ...params.direction ? { direction: params.direction } : {},
-        ...params.receiver ? { receiver: params.receiver } : {}
+        ...params.receiver ? { receiver: params.receiver } : {},
+        ...params.permit ? { permit: params.permit } : {}
       }
     }),
     submitOrder: (body) => request(baseUrl, apiKey, "/order", { method: "POST", body }),
@@ -2381,7 +2397,16 @@ function createSwapApi(baseUrl, apiKey) {
       method: "POST",
       body: { orderHash, secret }
     }),
-    orderStatus: (orderHash) => request(baseUrl, apiKey, `/order/${orderHash}`),
+    /**
+     * @param chainId present only for a SAME-CHAIN order. That product keys its
+     * orders per chain and the Fusion+ endpoint does not know them, so asking
+     * without it answers 404 — which reads as an order that vanished.
+     */
+    orderStatus: (orderHash, chainId) => request(
+      baseUrl,
+      apiKey,
+      chainId === void 0 ? `/order/${orderHash}` : `/order/${orderHash}?chainId=${chainId}`
+    ),
     readyForSecrets: (orderHash) => request(
       baseUrl,
       apiKey,
@@ -2524,7 +2549,12 @@ var SWAP_TERMINAL_STATUSES = [
   "executed",
   "expired",
   "cancelled",
-  "refunded"
+  "refunded",
+  "filled",
+  "false-predicate",
+  "not-enough-balance-or-allowance",
+  "wrong-permit",
+  "invalid-signature"
 ];
 var isSwapTerminal = (status) => SWAP_TERMINAL_STATUSES.includes(status);
 
@@ -2602,6 +2632,71 @@ async function runFusionOrder(deps, options) {
   }
 }
 
+// src/lib/swap/swap.same-chain-runner.ts
+var DEFAULT_POLL_MS2 = 5e3;
+var MAX_BACKOFF_MS2 = 3e4;
+var backoffFor2 = (failures, base3) => Math.min(base3 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS2);
+var DEFAULT_TIMEOUT_MS2 = 3 * 60 * 1e3;
+function explain(status) {
+  switch (status) {
+    case "expired":
+      return "No one filled the swap in time, so nothing was exchanged. Your funds never left your wallet.";
+    case "cancelled":
+      return "The swap was cancelled before anyone filled it. Your funds never left your wallet.";
+    case "not-enough-balance-or-allowance":
+      return "The swap could not be filled because the balance or approval had changed since it was signed. Nothing was exchanged.";
+    case "wrong-permit":
+      return "The approval signed with this swap was not accepted. Nothing was exchanged \u2014 try again, approving in your wallet if you are asked to.";
+    case "invalid-signature":
+      return "The swap signature was rejected. Nothing was exchanged.";
+    case "false-predicate":
+      return "The swap's conditions no longer held when it was filled. Nothing was exchanged.";
+    default:
+      return "The swap did not complete. Nothing was exchanged.";
+  }
+}
+async function runSameChainOrder(deps, options) {
+  const {
+    orderHash,
+    onStage,
+    pollIntervalMs = DEFAULT_POLL_MS2,
+    timeoutMs = DEFAULT_TIMEOUT_MS2
+  } = options;
+  const deadline = deps.now() + timeoutMs;
+  let failures = 0;
+  onStage?.("swapping");
+  for (; ; ) {
+    if (deps.now() >= deadline) {
+      throw new OwneyError(
+        "SWAP_ORDER_EXPIRED",
+        "No one filled the swap in time. Nothing was exchanged and your funds are still in your wallet.",
+        { orderHash }
+      );
+    }
+    let status;
+    try {
+      ({ status } = await deps.orderStatus(orderHash));
+      failures = 0;
+    } catch {
+      failures += 1;
+      await deps.sleep(backoffFor2(failures, pollIntervalMs));
+      continue;
+    }
+    if (isSwapTerminal(status)) {
+      if (status === "filled" || status === "executed") {
+        onStage?.("swapped");
+        return { status, filled: true };
+      }
+      throw new OwneyError(
+        status === "cancelled" ? "SWAP_ORDER_CANCELLED" : "SWAP_ORDER_EXPIRED",
+        explain(status),
+        { orderHash, status }
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+}
+
 // src/lib/swap/swap.secret-store.ts
 var KEY_PREFIX2 = "owney.swap.order";
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -2685,7 +2780,7 @@ async function executeSwap(deps, options) {
   });
   const before = await deps.readTargetBalance();
   debugLog("owney-sdk", "swap: target balance before", before.toString());
-  const result = quote.rail === "classic" ? await runClassic(deps, options) : await runFusion(deps, options, walletAddress);
+  const result = quote.rail === "classic" ? await runClassic(deps, options) : quote.rail === "fusion" ? await runSameChainFusion(deps, options, walletAddress) : await runFusion(deps, options, walletAddress);
   const after = await deps.readTargetBalance();
   const received = after - before;
   debugLog("owney-sdk", "swap: target balance after", {
@@ -2756,25 +2851,75 @@ async function runClassic(deps, options) {
   onStage?.("swapped");
   return { txHash };
 }
-async function runFusion(deps, options, walletAddress) {
+async function runSameChainFusion(deps, options, walletAddress) {
   const { quote, direction, onStage } = options;
   const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
   const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
-  if (quote.spender && !isNativeSource) {
-    const needed = amount;
-    const current = await deps.readAllowance(quote.spender);
-    debugLog("owney-sdk", "swap: fusion allowance", {
-      spender: quote.spender,
-      current: current.toString(),
-      needed: needed.toString()
+  const permit = await authoriseSpend(deps, options, amount, isNativeSource);
+  onStage?.("quoting");
+  debugLog("owney-sdk", "swap: building same-chain fusion order");
+  const built = await deps.api.buildOrder({
+    from: {
+      chainId: quote.src.chainId,
+      symbol: quote.src.symbol,
+      amount: amount.toString()
+    },
+    to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
+    walletAddress,
+    ...direction ? { direction } : {},
+    ...permit ? { permit } : {}
+  });
+  debugLog("owney-sdk", "swap: same-chain order built", {
+    orderHash: built.orderHash
+  });
+  onStage?.("signing");
+  await deps.ensureChain(quote.src.chainId);
+  const signature = await deps.signTypedData(built.typedData);
+  debugLog("owney-sdk", "swap: signed, submitting same-chain order");
+  await deps.api.submitOrder({
+    // Without this the routing API hands the order to the Fusion+ relayer,
+    // which does not know it and answers with an error that names nothing.
+    rail: "fusion",
+    srcChainId: quote.src.chainId,
+    order: built.order,
+    signature,
+    quoteId: built.quoteId,
+    ...built.extension ? { extension: built.extension } : {}
+  });
+  await runSameChainOrder(deps.sameChainRunner ?? deps.runner, {
+    orderHash: built.orderHash,
+    ...onStage ? { onStage } : {}
+  });
+  return { orderHash: built.orderHash };
+}
+async function authoriseSpend(deps, options, amount, isNativeSource) {
+  const { quote, onStage } = options;
+  if (!quote.spender || isNativeSource) return void 0;
+  const current = await deps.readAllowance(quote.spender);
+  debugLog("owney-sdk", "swap: fusion allowance", {
+    spender: quote.spender,
+    current: current.toString(),
+    needed: amount.toString()
+  });
+  if (current >= amount) return void 0;
+  onStage?.("approving");
+  await deps.ensureChain(quote.src.chainId);
+  const permit = quote.permitSupported ? await deps.buildPermit?.(quote.spender, MAX_UINT256) ?? void 0 : void 0;
+  if (permit) {
+    debugLog("owney-sdk", "swap: permitting limit order protocol", {
+      bytes: (permit.length - 2) / 2
     });
-    if (current < needed) {
-      onStage?.("approving");
-      await deps.ensureChain(quote.src.chainId);
-      await deps.approve(quote.spender, MAX_UINT256);
-      debugLog("owney-sdk", "swap: approved limit order protocol");
-    }
+    return permit;
   }
+  await deps.approve(quote.spender, MAX_UINT256);
+  debugLog("owney-sdk", "swap: approved limit order protocol");
+  return void 0;
+}
+async function runFusion(deps, options, walletAddress) {
+  const { quote, direction, onStage } = options;
+  const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
+  const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
+  const permit = await authoriseSpend(deps, options, amount, isNativeSource);
   const { secrets, secretHashes } = mintSecrets(quote.secretsCount ?? 1);
   onStage?.("quoting");
   debugLog("owney-sdk", "swap: building fusion order", {
@@ -2790,7 +2935,8 @@ async function runFusion(deps, options, walletAddress) {
     to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
     walletAddress,
     secretHashes,
-    ...direction ? { direction } : {}
+    ...direction ? { direction } : {},
+    ...permit ? { permit } : {}
   });
   saveOrder({
     orderHash: built.orderHash,
@@ -2841,16 +2987,114 @@ async function runFusion(deps, options, walletAddress) {
   return { orderHash: built.orderHash };
 }
 
+// src/lib/swap/swap.permit.ts
+var import_viem5 = require("viem");
+var PERMIT_ABI = (0, import_viem5.parseAbi)([
+  "function nonces(address owner) view returns (uint256)",
+  "function name() view returns (string)",
+  "function version() view returns (string)",
+  "function DOMAIN_SEPARATOR() view returns (bytes32)"
+]);
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var VERSION_CANDIDATES = ["1", "2"];
+var PERMIT_TTL_SECONDS = 3600;
+async function tryRead(read) {
+  try {
+    return await read();
+  } catch {
+    return null;
+  }
+}
+function matchDomain(name, versions, chainId, token, onChainSeparator) {
+  for (const version of versions) {
+    const domain = { name, version, chainId, verifyingContract: token };
+    if ((0, import_viem5.domainSeparator)({ domain }) === onChainSeparator) return domain;
+  }
+  return null;
+}
+async function buildErc2612Permit(reads, input) {
+  const { token, owner, spender, value, chainId } = input;
+  const call = (functionName, args) => reads.readContract({
+    address: token,
+    abi: PERMIT_ABI,
+    functionName,
+    ...args ? { args } : {}
+  });
+  const nonce = await tryRead(() => call("nonces", [owner]));
+  if (nonce === null) {
+    debugLog("owney-sdk", "permit: token has no nonces(), using approval", {
+      token
+    });
+    return null;
+  }
+  const separator = await tryRead(
+    () => call("DOMAIN_SEPARATOR")
+  );
+  const name = await tryRead(() => call("name"));
+  if (!separator || !name) {
+    debugLog("owney-sdk", "permit: domain unverifiable, using approval", {
+      token,
+      hasSeparator: Boolean(separator),
+      hasName: Boolean(name)
+    });
+    return null;
+  }
+  const declared = await tryRead(() => call("version"));
+  const domain = matchDomain(
+    name,
+    declared ? [declared, ...VERSION_CANDIDATES] : VERSION_CANDIDATES,
+    chainId,
+    token,
+    separator
+  );
+  if (!domain) {
+    debugLog("owney-sdk", "permit: no domain matched, using approval", {
+      token,
+      declared
+    });
+    return null;
+  }
+  const deadline = BigInt(Math.floor((input.now?.() ?? Date.now()) / 1e3)) + BigInt(PERMIT_TTL_SECONDS);
+  const signature = await input.signTypedData({
+    domain,
+    types: PERMIT_TYPES,
+    primaryType: "Permit",
+    message: { owner, spender, value, nonce, deadline }
+  });
+  const { r, s, v, yParity } = (0, import_viem5.parseSignature)(signature);
+  const recoveryV = v ?? BigInt(yParity + 27);
+  return (0, import_viem5.encodeAbiParameters)(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint8" },
+      { type: "bytes32" },
+      { type: "bytes32" }
+    ],
+    [owner, spender, value, deadline, Number(recoveryV), r, s]
+  );
+}
+
 // src/lib/swap/swap.arrival.ts
-var DEFAULT_TIMEOUT_MS2 = 18e4;
-var DEFAULT_POLL_MS2 = 4e3;
+var DEFAULT_TIMEOUT_MS3 = 18e4;
+var DEFAULT_POLL_MS3 = 4e3;
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function awaitWithdrawalArrival(options) {
   const {
     readBalance,
     baseline,
-    timeoutMs = DEFAULT_TIMEOUT_MS2,
-    pollMs = DEFAULT_POLL_MS2
+    timeoutMs = DEFAULT_TIMEOUT_MS3,
+    pollMs = DEFAULT_POLL_MS3
   } = options;
   const deadline = Date.now() + timeoutMs;
   debugLog("owney-sdk", "withdraw: waiting for funds to land", {
@@ -2925,7 +3169,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   const target = asset.toUpperCase();
   return agents.map((agent) => {
@@ -2934,7 +3178,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
     if (!tokenBalance) return { agent, balance: 0n };
-    return { agent, balance: (0, import_viem5.parseUnits)(tokenBalance.amount, decimals) };
+    return { agent, balance: (0, import_viem6.parseUnits)(tokenBalance.amount, decimals) };
   });
 }
 function planProportionalShares(balances, requested, totalAvailable) {
@@ -3081,11 +3325,11 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 var import_chains2 = require("viem/chains");
 
 // src/lib/transfer-auth.ts
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 var ERC20_META_ABI = [
   { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] },
   { type: "function", name: "version", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] }
@@ -3117,7 +3361,7 @@ async function readTokenMeta(publicClient, token) {
 function randomAuthNonce() {
   const bytes = new Uint8Array(32);
   globalThis.crypto.getRandomValues(bytes);
-  return (0, import_viem6.bytesToHex)(bytes);
+  return (0, import_viem7.bytesToHex)(bytes);
 }
 
 // src/lib/sponsor-client.ts
@@ -3399,7 +3643,7 @@ function makeSponsoredWethCallback(deps) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -3407,7 +3651,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[(0, import_viem7.toHex)(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[(0, import_viem8.toHex)(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -3441,8 +3685,8 @@ function makeSponsoredCallsCallback(deps) {
         { chainId }
       );
     }
-    const data = (0, import_viem7.encodeFunctionData)({
-      abi: import_viem7.erc20Abi,
+    const data = (0, import_viem8.encodeFunctionData)({
+      abi: import_viem8.erc20Abi,
       functionName: "transfer",
       args: [smartWallet, BigInt(amount)]
     });
@@ -3452,7 +3696,7 @@ function makeSponsoredCallsCallback(deps) {
         {
           version: "2.0.0",
           from: deps.ownerAddress,
-          chainId: (0, import_viem7.toHex)(chainId),
+          chainId: (0, import_viem8.toHex)(chainId),
           atomicRequired: false,
           calls: [{ to: token, value: "0x0", data }],
           capabilities: {
@@ -3674,14 +3918,14 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => (0, import_viem8.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem9.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem8.custom)(provider)
+        transport: (0, import_viem9.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem8.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem9.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem8.custom)(provider)
+        transport: (0, import_viem9.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -3727,14 +3971,14 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => (0, import_viem8.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem9.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem8.custom)(provider)
+        transport: (0, import_viem9.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem8.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem9.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem8.custom)(provider)
+        transport: (0, import_viem9.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -4316,11 +4560,11 @@ var OwneySDK = class {
       );
     }
     await ensureWalletOnChain(
-      (0, import_viem8.createPublicClient)({ chain, transport: (0, import_viem8.custom)(provider) }),
-      (0, import_viem8.createWalletClient)({
+      (0, import_viem9.createPublicClient)({ chain, transport: (0, import_viem9.custom)(provider) }),
+      (0, import_viem9.createWalletClient)({
         account: state.walletAddress,
         chain,
-        transport: (0, import_viem8.custom)(provider)
+        transport: (0, import_viem9.custom)(provider)
       }),
       chainId
     );
@@ -4336,16 +4580,16 @@ var OwneySDK = class {
     const provider = this.requireConnectedProvider();
     const srcChain = VIEM_CHAIN2[quote.src.chainId];
     const dstChain = VIEM_CHAIN2[quote.dst.chainId];
-    const wallet = (0, import_viem8.createWalletClient)({
+    const wallet = (0, import_viem9.createWalletClient)({
       account: state.walletAddress,
       chain: srcChain,
-      transport: (0, import_viem8.custom)(provider)
+      transport: (0, import_viem9.custom)(provider)
     });
-    const srcPublic = (0, import_viem8.createPublicClient)({
+    const srcPublic = (0, import_viem9.createPublicClient)({
       chain: srcChain,
       transport: swapReadTransport(quote.src.chainId, this.zyfaiRpcUrls)
     });
-    const dstPublic = (0, import_viem8.createPublicClient)({
+    const dstPublic = (0, import_viem9.createPublicClient)({
       chain: dstChain,
       transport: swapReadTransport(quote.dst.chainId, this.zyfaiRpcUrls)
     });
@@ -4362,7 +4606,7 @@ var OwneySDK = class {
         }
         return dstPublic.readContract({
           address: dst,
-          abi: import_viem8.erc20Abi,
+          abi: import_viem9.erc20Abi,
           functionName: "balanceOf",
           args: [state.walletAddress]
         });
@@ -4430,6 +4674,41 @@ var OwneySDK = class {
         return hash;
       },
       ensureChain: (chainId) => this.ensureSwapChain(chainId),
+      /**
+       * Sign the approval instead of paying for it. Null means the token
+       * cannot be permitted (WETH has no `permit`) or its domain could not be
+       * verified, and the executor sends an ordinary approval instead.
+       *
+       * Reads go through srcPublic like every other read here — the domain is
+       * chain-scoped, and reading a nonce off whatever chain the wallet
+       * happens to sit on would sign a permit the token rejects.
+       */
+      buildPermit: (spender, amount) => buildErc2612Permit(
+        {
+          readContract: (args) => srcPublic.readContract(args)
+        },
+        {
+          token: quote.src.address,
+          owner: state.walletAddress,
+          spender,
+          value: amount,
+          chainId: quote.src.chainId,
+          signTypedData: (payload) => wallet.signTypedData({
+            account: state.walletAddress,
+            ...payload
+          })
+        }
+      ),
+      /**
+       * Same-chain polling, with the chain bound in. That product keys its
+       * orders per chain; asking the Fusion+ endpoint for one answers 404,
+       * which would read as an order that vanished mid-swap.
+       */
+      sameChainRunner: {
+        orderStatus: (h) => this.swapApi().orderStatus(h, quote.src.chainId),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now()
+      },
       runner: {
         readyForSecrets: (h) => this.swapApi().readyForSecrets(h),
         submitSecret: (h, secret) => this.swapApi().submitSecret(h, secret),
@@ -4448,6 +4727,39 @@ var OwneySDK = class {
   async getSwapTokens() {
     return this.swapApi().listTokens();
   }
+  /**
+   * What the wallet actually holds, across every supported chain, restricted
+   * to tokens a swap could use.
+   *
+   * `getSwapTokens` answers "what may someone pay with in principle" from a
+   * fixed list. This answers "what has this wallet got", which is a different
+   * question and the one a picker needs: a user can hold something routable —
+   * tBTC, say — that no fixed list of ours would ever mention.
+   *
+   * Each chain is asked separately because that is how the balance product is
+   * shaped, and a chain that fails contributes nothing rather than failing the
+   * lot. A picker with two chains in it beats an error. (ROUT-242)
+   */
+  async getWalletBalances(chainIds) {
+    const state = this.requireState();
+    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const failedChainIds = [];
+    const results = await Promise.all(
+      chains.map(async (chainId) => {
+        try {
+          const { tokens } = await this.swapApi().walletBalances({
+            chainId,
+            walletAddress: state.walletAddress
+          });
+          return tokens.map((token) => ({ ...token, chainId }));
+        } catch {
+          failedChainIds.push(chainId);
+          return [];
+        }
+      })
+    );
+    return { tokens: results.flat(), failedChainIds };
+  }
   /**
    * Search the assets a user may pay with, across every supported chain.
    *
@@ -4575,13 +4887,13 @@ var OwneySDK = class {
       );
     }
     const srcChain = VIEM_CHAIN2[options.from.chainId];
-    const srcPublic = (0, import_viem8.createPublicClient)({
+    const srcPublic = (0, import_viem9.createPublicClient)({
       chain: srcChain,
       transport: swapReadTransport(options.from.chainId, this.zyfaiRpcUrls)
     });
     const readWalletBalance = () => srcPublic.readContract({
       address: asset.address,
-      abi: import_viem8.erc20Abi,
+      abi: import_viem9.erc20Abi,
       functionName: "balanceOf",
       args: [state.walletAddress]
     });
@@ -4593,7 +4905,7 @@ var OwneySDK = class {
     options.onSwapProgress?.("withdrawing");
     const withdraw = await this.withdraw({
       asset: options.from.symbol,
-      ...options.amount === void 0 ? {} : { amount: (0, import_viem8.parseUnits)(options.amount, asset.decimals).toString() },
+      ...options.amount === void 0 ? {} : { amount: (0, import_viem9.parseUnits)(options.amount, asset.decimals).toString() },
       ...options.agentId ? { agentId: options.agentId } : {}
     });
     const arrived = await awaitWithdrawalArrival({
@@ -5229,10 +5541,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem8.createWalletClient)({
+    const wallet = (0, import_viem9.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem8.custom)(provider)
+      transport: (0, import_viem9.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -5242,9 +5554,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem8.createPublicClient)({
+    const publicClient = (0, import_viem9.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem8.custom)(provider)
+      transport: (0, import_viem9.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -5370,7 +5682,7 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -5497,7 +5809,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem9.getAddress)(accountAddress),
+          address: (0, import_viem10.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,

package/dist/index.d.cts

@@ -13,11 +13,16 @@ import { SIWXConfig } from '@reown/appkit-controllers';
  * `classic` — same chain. One atomic transaction: it either completes or
  * nothing moved.
  *
+ * `fusion` — same chain, filled by a resolver against a signed intent. No
+ * transaction from the user, so no native gas: that is the entire reason it
+ * exists. The trade is certainty — the order sits in an auction and can expire
+ * unfilled, where a classic swap resolves immediately either way.
+ *
  * `fusion-plus` — crossing chains. The user's funds sit in an escrow while a
  * resolver fills the other side, so the order has a lifecycle and can end in
  * `expired` → `refunding` → `refunded` without ever depositing.
  */
-type SwapRail = "classic" | "fusion-plus";
+type SwapRail = "classic" | "fusion" | "fusion-plus";
 type SwapTokenInfo = {
     readonly symbol: string;
     readonly address: string;
@@ -49,6 +54,26 @@ type SwapChainTokens = {
  * the bulk list does, and the extra fields are the ones a picker needs to let
  * someone choose safely between three tokens all called PEPE.
  */
+/**
+ * A token the wallet actually holds, as the Pay with picker needs it.
+ *
+ * The picker used to read a fixed list of (token, chain) pairs, so it could
+ * only ever offer those. This is the other direction — what is really there —
+ * already intersected server-side with what the routing API would quote, so
+ * every row can be acted on. (ROUT-242)
+ */
+type SwapWalletBalance = {
+    readonly symbol: string;
+    readonly address: `0x${string}`;
+    readonly decimals: number;
+    readonly chainId: number;
+    readonly name?: string;
+    readonly logoURI?: string;
+    readonly tags?: readonly string[];
+    readonly isNative?: true;
+    /** Smallest unit, as a decimal string. */
+    readonly balance: string;
+};
 type SwapTokenSearchResult = SwapTokenInfo & {
     readonly chainId: number;
     readonly name?: string;
@@ -110,6 +135,17 @@ type SwapQuote = {
      * calldata instead.
      */
     spender?: string;
+    /**
+     * Cross-chain only. True when the routing API will accept an EIP-2612 permit
+     * on the order, so the approval is performed by the resolver inside the fill
+     * and the user needs no native ETH. False or absent means send an approval
+     * transaction, which is what every swap did before ROUT-242.
+     *
+     * It has to arrive on the QUOTE rather than being tried and recovered from:
+     * the client decides whether to spend the user's gas before the order it
+     * would be attached to exists.
+     */
+    permitSupported?: boolean;
     /**
      * True only for a cross-chain swap FROM native ETH, which needs an on-chain
      * order creation carrying the full amount as msg.value. The user's funds
@@ -155,7 +191,7 @@ type SwapQuote = {
  * `refunding` is the window the returning-funds screen renders: the order has
  * failed and the money is on its way back, but is not back yet.
  */
-type SwapOrderStatus = "pending" | "executed" | "expired" | "cancelled" | "refunding" | "refunded" | "unpublished";
+type SwapOrderStatus = "pending" | "executed" | "expired" | "cancelled" | "refunding" | "refunded" | "unpublished" | "filled" | "partially-filled" | "false-predicate" | "not-enough-balance-or-allowance" | "wrong-permit" | "invalid-signature";
 /**
  * Stage reported to the UI while a swap runs, in either direction.
  *
@@ -909,6 +945,24 @@ declare class OwneySDK {
     getSwapTokens(): Promise<{
         chains: SwapChainTokens[];
     }>;
+    /**
+     * What the wallet actually holds, across every supported chain, restricted
+     * to tokens a swap could use.
+     *
+     * `getSwapTokens` answers "what may someone pay with in principle" from a
+     * fixed list. This answers "what has this wallet got", which is a different
+     * question and the one a picker needs: a user can hold something routable —
+     * tBTC, say — that no fixed list of ours would ever mention.
+     *
+     * Each chain is asked separately because that is how the balance product is
+     * shaped, and a chain that fails contributes nothing rather than failing the
+     * lot. A picker with two chains in it beats an error. (ROUT-242)
+     */
+    getWalletBalances(chainIds?: readonly number[]): Promise<{
+        tokens: SwapWalletBalance[];
+        /** Chains that could not be read, so the caller can say so or retry. */
+        failedChainIds: number[];
+    }>;
     /**
      * Search the assets a user may pay with, across every supported chain.
      *

package/dist/index.d.ts

@@ -13,11 +13,16 @@ import { SIWXConfig } from '@reown/appkit-controllers';
  * `classic` — same chain. One atomic transaction: it either completes or
  * nothing moved.
  *
+ * `fusion` — same chain, filled by a resolver against a signed intent. No
+ * transaction from the user, so no native gas: that is the entire reason it
+ * exists. The trade is certainty — the order sits in an auction and can expire
+ * unfilled, where a classic swap resolves immediately either way.
+ *
  * `fusion-plus` — crossing chains. The user's funds sit in an escrow while a
  * resolver fills the other side, so the order has a lifecycle and can end in
  * `expired` → `refunding` → `refunded` without ever depositing.
  */
-type SwapRail = "classic" | "fusion-plus";
+type SwapRail = "classic" | "fusion" | "fusion-plus";
 type SwapTokenInfo = {
     readonly symbol: string;
     readonly address: string;
@@ -49,6 +54,26 @@ type SwapChainTokens = {
  * the bulk list does, and the extra fields are the ones a picker needs to let
  * someone choose safely between three tokens all called PEPE.
  */
+/**
+ * A token the wallet actually holds, as the Pay with picker needs it.
+ *
+ * The picker used to read a fixed list of (token, chain) pairs, so it could
+ * only ever offer those. This is the other direction — what is really there —
+ * already intersected server-side with what the routing API would quote, so
+ * every row can be acted on. (ROUT-242)
+ */
+type SwapWalletBalance = {
+    readonly symbol: string;
+    readonly address: `0x${string}`;
+    readonly decimals: number;
+    readonly chainId: number;
+    readonly name?: string;
+    readonly logoURI?: string;
+    readonly tags?: readonly string[];
+    readonly isNative?: true;
+    /** Smallest unit, as a decimal string. */
+    readonly balance: string;
+};
 type SwapTokenSearchResult = SwapTokenInfo & {
     readonly chainId: number;
     readonly name?: string;
@@ -110,6 +135,17 @@ type SwapQuote = {
      * calldata instead.
      */
     spender?: string;
+    /**
+     * Cross-chain only. True when the routing API will accept an EIP-2612 permit
+     * on the order, so the approval is performed by the resolver inside the fill
+     * and the user needs no native ETH. False or absent means send an approval
+     * transaction, which is what every swap did before ROUT-242.
+     *
+     * It has to arrive on the QUOTE rather than being tried and recovered from:
+     * the client decides whether to spend the user's gas before the order it
+     * would be attached to exists.
+     */
+    permitSupported?: boolean;
     /**
      * True only for a cross-chain swap FROM native ETH, which needs an on-chain
      * order creation carrying the full amount as msg.value. The user's funds
@@ -155,7 +191,7 @@ type SwapQuote = {
  * `refunding` is the window the returning-funds screen renders: the order has
  * failed and the money is on its way back, but is not back yet.
  */
-type SwapOrderStatus = "pending" | "executed" | "expired" | "cancelled" | "refunding" | "refunded" | "unpublished";
+type SwapOrderStatus = "pending" | "executed" | "expired" | "cancelled" | "refunding" | "refunded" | "unpublished" | "filled" | "partially-filled" | "false-predicate" | "not-enough-balance-or-allowance" | "wrong-permit" | "invalid-signature";
 /**
  * Stage reported to the UI while a swap runs, in either direction.
  *
@@ -909,6 +945,24 @@ declare class OwneySDK {
     getSwapTokens(): Promise<{
         chains: SwapChainTokens[];
     }>;
+    /**
+     * What the wallet actually holds, across every supported chain, restricted
+     * to tokens a swap could use.
+     *
+     * `getSwapTokens` answers "what may someone pay with in principle" from a
+     * fixed list. This answers "what has this wallet got", which is a different
+     * question and the one a picker needs: a user can hold something routable —
+     * tBTC, say — that no fixed list of ours would ever mention.
+     *
+     * Each chain is asked separately because that is how the balance product is
+     * shaped, and a chain that fails contributes nothing rather than failing the
+     * lot. A picker with two chains in it beats an error. (ROUT-242)
+     */
+    getWalletBalances(chainIds?: readonly number[]): Promise<{
+        tokens: SwapWalletBalance[];
+        /** Chains that could not be read, so the caller can say so or retry. */
+        failedChainIds: number[];
+    }>;
     /**
      * Search the assets a user may pay with, across every supported chain.
      *

package/dist/index.js

@@ -2275,6 +2275,21 @@ function createSwapApi(baseUrl, apiKey) {
      * Already filtered server-side to what a quote will accept, so anything
      * returned here can be paid with.
      */
+    /**
+     * Tokens the wallet holds on one chain.
+     *
+     * Already filtered upstream to non-zero balances of tokens the routing API
+     * would quote — 1inch answers with every token it knows about, zeros
+     * included, and the curation that decides what is offerable lives there.
+     */
+    walletBalances: (params) => request(
+      baseUrl,
+      apiKey,
+      `/balances?${new URLSearchParams({
+        chainId: String(params.chainId),
+        walletAddress: params.walletAddress
+      })}`
+    ),
     searchTokens: (params) => request(
       baseUrl,
       apiKey,
@@ -2332,9 +2347,10 @@ function createSwapApi(baseUrl, apiKey) {
         dstSymbol: params.to.symbol,
         amount: params.from.amount,
         walletAddress: params.walletAddress,
-        secretHashes: params.secretHashes,
+        ...params.secretHashes ? { secretHashes: params.secretHashes } : {},
         ...params.direction ? { direction: params.direction } : {},
-        ...params.receiver ? { receiver: params.receiver } : {}
+        ...params.receiver ? { receiver: params.receiver } : {},
+        ...params.permit ? { permit: params.permit } : {}
       }
     }),
     submitOrder: (body) => request(baseUrl, apiKey, "/order", { method: "POST", body }),
@@ -2347,7 +2363,16 @@ function createSwapApi(baseUrl, apiKey) {
       method: "POST",
       body: { orderHash, secret }
     }),
-    orderStatus: (orderHash) => request(baseUrl, apiKey, `/order/${orderHash}`),
+    /**
+     * @param chainId present only for a SAME-CHAIN order. That product keys its
+     * orders per chain and the Fusion+ endpoint does not know them, so asking
+     * without it answers 404 — which reads as an order that vanished.
+     */
+    orderStatus: (orderHash, chainId) => request(
+      baseUrl,
+      apiKey,
+      chainId === void 0 ? `/order/${orderHash}` : `/order/${orderHash}?chainId=${chainId}`
+    ),
     readyForSecrets: (orderHash) => request(
       baseUrl,
       apiKey,
@@ -2490,7 +2515,12 @@ var SWAP_TERMINAL_STATUSES = [
   "executed",
   "expired",
   "cancelled",
-  "refunded"
+  "refunded",
+  "filled",
+  "false-predicate",
+  "not-enough-balance-or-allowance",
+  "wrong-permit",
+  "invalid-signature"
 ];
 var isSwapTerminal = (status) => SWAP_TERMINAL_STATUSES.includes(status);
 
@@ -2568,6 +2598,71 @@ async function runFusionOrder(deps, options) {
   }
 }
 
+// src/lib/swap/swap.same-chain-runner.ts
+var DEFAULT_POLL_MS2 = 5e3;
+var MAX_BACKOFF_MS2 = 3e4;
+var backoffFor2 = (failures, base3) => Math.min(base3 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS2);
+var DEFAULT_TIMEOUT_MS2 = 3 * 60 * 1e3;
+function explain(status) {
+  switch (status) {
+    case "expired":
+      return "No one filled the swap in time, so nothing was exchanged. Your funds never left your wallet.";
+    case "cancelled":
+      return "The swap was cancelled before anyone filled it. Your funds never left your wallet.";
+    case "not-enough-balance-or-allowance":
+      return "The swap could not be filled because the balance or approval had changed since it was signed. Nothing was exchanged.";
+    case "wrong-permit":
+      return "The approval signed with this swap was not accepted. Nothing was exchanged \u2014 try again, approving in your wallet if you are asked to.";
+    case "invalid-signature":
+      return "The swap signature was rejected. Nothing was exchanged.";
+    case "false-predicate":
+      return "The swap's conditions no longer held when it was filled. Nothing was exchanged.";
+    default:
+      return "The swap did not complete. Nothing was exchanged.";
+  }
+}
+async function runSameChainOrder(deps, options) {
+  const {
+    orderHash,
+    onStage,
+    pollIntervalMs = DEFAULT_POLL_MS2,
+    timeoutMs = DEFAULT_TIMEOUT_MS2
+  } = options;
+  const deadline = deps.now() + timeoutMs;
+  let failures = 0;
+  onStage?.("swapping");
+  for (; ; ) {
+    if (deps.now() >= deadline) {
+      throw new OwneyError(
+        "SWAP_ORDER_EXPIRED",
+        "No one filled the swap in time. Nothing was exchanged and your funds are still in your wallet.",
+        { orderHash }
+      );
+    }
+    let status;
+    try {
+      ({ status } = await deps.orderStatus(orderHash));
+      failures = 0;
+    } catch {
+      failures += 1;
+      await deps.sleep(backoffFor2(failures, pollIntervalMs));
+      continue;
+    }
+    if (isSwapTerminal(status)) {
+      if (status === "filled" || status === "executed") {
+        onStage?.("swapped");
+        return { status, filled: true };
+      }
+      throw new OwneyError(
+        status === "cancelled" ? "SWAP_ORDER_CANCELLED" : "SWAP_ORDER_EXPIRED",
+        explain(status),
+        { orderHash, status }
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+}
+
 // src/lib/swap/swap.secret-store.ts
 var KEY_PREFIX2 = "owney.swap.order";
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -2651,7 +2746,7 @@ async function executeSwap(deps, options) {
   });
   const before = await deps.readTargetBalance();
   debugLog("owney-sdk", "swap: target balance before", before.toString());
-  const result = quote.rail === "classic" ? await runClassic(deps, options) : await runFusion(deps, options, walletAddress);
+  const result = quote.rail === "classic" ? await runClassic(deps, options) : quote.rail === "fusion" ? await runSameChainFusion(deps, options, walletAddress) : await runFusion(deps, options, walletAddress);
   const after = await deps.readTargetBalance();
   const received = after - before;
   debugLog("owney-sdk", "swap: target balance after", {
@@ -2722,25 +2817,75 @@ async function runClassic(deps, options) {
   onStage?.("swapped");
   return { txHash };
 }
-async function runFusion(deps, options, walletAddress) {
+async function runSameChainFusion(deps, options, walletAddress) {
   const { quote, direction, onStage } = options;
   const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
   const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
-  if (quote.spender && !isNativeSource) {
-    const needed = amount;
-    const current = await deps.readAllowance(quote.spender);
-    debugLog("owney-sdk", "swap: fusion allowance", {
-      spender: quote.spender,
-      current: current.toString(),
-      needed: needed.toString()
+  const permit = await authoriseSpend(deps, options, amount, isNativeSource);
+  onStage?.("quoting");
+  debugLog("owney-sdk", "swap: building same-chain fusion order");
+  const built = await deps.api.buildOrder({
+    from: {
+      chainId: quote.src.chainId,
+      symbol: quote.src.symbol,
+      amount: amount.toString()
+    },
+    to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
+    walletAddress,
+    ...direction ? { direction } : {},
+    ...permit ? { permit } : {}
+  });
+  debugLog("owney-sdk", "swap: same-chain order built", {
+    orderHash: built.orderHash
+  });
+  onStage?.("signing");
+  await deps.ensureChain(quote.src.chainId);
+  const signature = await deps.signTypedData(built.typedData);
+  debugLog("owney-sdk", "swap: signed, submitting same-chain order");
+  await deps.api.submitOrder({
+    // Without this the routing API hands the order to the Fusion+ relayer,
+    // which does not know it and answers with an error that names nothing.
+    rail: "fusion",
+    srcChainId: quote.src.chainId,
+    order: built.order,
+    signature,
+    quoteId: built.quoteId,
+    ...built.extension ? { extension: built.extension } : {}
+  });
+  await runSameChainOrder(deps.sameChainRunner ?? deps.runner, {
+    orderHash: built.orderHash,
+    ...onStage ? { onStage } : {}
+  });
+  return { orderHash: built.orderHash };
+}
+async function authoriseSpend(deps, options, amount, isNativeSource) {
+  const { quote, onStage } = options;
+  if (!quote.spender || isNativeSource) return void 0;
+  const current = await deps.readAllowance(quote.spender);
+  debugLog("owney-sdk", "swap: fusion allowance", {
+    spender: quote.spender,
+    current: current.toString(),
+    needed: amount.toString()
+  });
+  if (current >= amount) return void 0;
+  onStage?.("approving");
+  await deps.ensureChain(quote.src.chainId);
+  const permit = quote.permitSupported ? await deps.buildPermit?.(quote.spender, MAX_UINT256) ?? void 0 : void 0;
+  if (permit) {
+    debugLog("owney-sdk", "swap: permitting limit order protocol", {
+      bytes: (permit.length - 2) / 2
     });
-    if (current < needed) {
-      onStage?.("approving");
-      await deps.ensureChain(quote.src.chainId);
-      await deps.approve(quote.spender, MAX_UINT256);
-      debugLog("owney-sdk", "swap: approved limit order protocol");
-    }
+    return permit;
   }
+  await deps.approve(quote.spender, MAX_UINT256);
+  debugLog("owney-sdk", "swap: approved limit order protocol");
+  return void 0;
+}
+async function runFusion(deps, options, walletAddress) {
+  const { quote, direction, onStage } = options;
+  const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
+  const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
+  const permit = await authoriseSpend(deps, options, amount, isNativeSource);
   const { secrets, secretHashes } = mintSecrets(quote.secretsCount ?? 1);
   onStage?.("quoting");
   debugLog("owney-sdk", "swap: building fusion order", {
@@ -2756,7 +2901,8 @@ async function runFusion(deps, options, walletAddress) {
     to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
     walletAddress,
     secretHashes,
-    ...direction ? { direction } : {}
+    ...direction ? { direction } : {},
+    ...permit ? { permit } : {}
   });
   saveOrder({
     orderHash: built.orderHash,
@@ -2807,16 +2953,119 @@ async function runFusion(deps, options, walletAddress) {
   return { orderHash: built.orderHash };
 }
 
+// src/lib/swap/swap.permit.ts
+import {
+  domainSeparator,
+  encodeAbiParameters,
+  parseAbi as parseAbi2,
+  parseSignature
+} from "viem";
+var PERMIT_ABI = parseAbi2([
+  "function nonces(address owner) view returns (uint256)",
+  "function name() view returns (string)",
+  "function version() view returns (string)",
+  "function DOMAIN_SEPARATOR() view returns (bytes32)"
+]);
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var VERSION_CANDIDATES = ["1", "2"];
+var PERMIT_TTL_SECONDS = 3600;
+async function tryRead(read) {
+  try {
+    return await read();
+  } catch {
+    return null;
+  }
+}
+function matchDomain(name, versions, chainId, token, onChainSeparator) {
+  for (const version of versions) {
+    const domain = { name, version, chainId, verifyingContract: token };
+    if (domainSeparator({ domain }) === onChainSeparator) return domain;
+  }
+  return null;
+}
+async function buildErc2612Permit(reads, input) {
+  const { token, owner, spender, value, chainId } = input;
+  const call = (functionName, args) => reads.readContract({
+    address: token,
+    abi: PERMIT_ABI,
+    functionName,
+    ...args ? { args } : {}
+  });
+  const nonce = await tryRead(() => call("nonces", [owner]));
+  if (nonce === null) {
+    debugLog("owney-sdk", "permit: token has no nonces(), using approval", {
+      token
+    });
+    return null;
+  }
+  const separator = await tryRead(
+    () => call("DOMAIN_SEPARATOR")
+  );
+  const name = await tryRead(() => call("name"));
+  if (!separator || !name) {
+    debugLog("owney-sdk", "permit: domain unverifiable, using approval", {
+      token,
+      hasSeparator: Boolean(separator),
+      hasName: Boolean(name)
+    });
+    return null;
+  }
+  const declared = await tryRead(() => call("version"));
+  const domain = matchDomain(
+    name,
+    declared ? [declared, ...VERSION_CANDIDATES] : VERSION_CANDIDATES,
+    chainId,
+    token,
+    separator
+  );
+  if (!domain) {
+    debugLog("owney-sdk", "permit: no domain matched, using approval", {
+      token,
+      declared
+    });
+    return null;
+  }
+  const deadline = BigInt(Math.floor((input.now?.() ?? Date.now()) / 1e3)) + BigInt(PERMIT_TTL_SECONDS);
+  const signature = await input.signTypedData({
+    domain,
+    types: PERMIT_TYPES,
+    primaryType: "Permit",
+    message: { owner, spender, value, nonce, deadline }
+  });
+  const { r, s, v, yParity } = parseSignature(signature);
+  const recoveryV = v ?? BigInt(yParity + 27);
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint8" },
+      { type: "bytes32" },
+      { type: "bytes32" }
+    ],
+    [owner, spender, value, deadline, Number(recoveryV), r, s]
+  );
+}
+
 // src/lib/swap/swap.arrival.ts
-var DEFAULT_TIMEOUT_MS2 = 18e4;
-var DEFAULT_POLL_MS2 = 4e3;
+var DEFAULT_TIMEOUT_MS3 = 18e4;
+var DEFAULT_POLL_MS3 = 4e3;
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function awaitWithdrawalArrival(options) {
   const {
     readBalance,
     baseline,
-    timeoutMs = DEFAULT_TIMEOUT_MS2,
-    pollMs = DEFAULT_POLL_MS2
+    timeoutMs = DEFAULT_TIMEOUT_MS3,
+    pollMs = DEFAULT_POLL_MS3
   } = options;
   const deadline = Date.now() + timeoutMs;
   debugLog("owney-sdk", "withdraw: waiting for funds to land", {
@@ -4402,6 +4651,41 @@ var OwneySDK = class {
         return hash;
       },
       ensureChain: (chainId) => this.ensureSwapChain(chainId),
+      /**
+       * Sign the approval instead of paying for it. Null means the token
+       * cannot be permitted (WETH has no `permit`) or its domain could not be
+       * verified, and the executor sends an ordinary approval instead.
+       *
+       * Reads go through srcPublic like every other read here — the domain is
+       * chain-scoped, and reading a nonce off whatever chain the wallet
+       * happens to sit on would sign a permit the token rejects.
+       */
+      buildPermit: (spender, amount) => buildErc2612Permit(
+        {
+          readContract: (args) => srcPublic.readContract(args)
+        },
+        {
+          token: quote.src.address,
+          owner: state.walletAddress,
+          spender,
+          value: amount,
+          chainId: quote.src.chainId,
+          signTypedData: (payload) => wallet.signTypedData({
+            account: state.walletAddress,
+            ...payload
+          })
+        }
+      ),
+      /**
+       * Same-chain polling, with the chain bound in. That product keys its
+       * orders per chain; asking the Fusion+ endpoint for one answers 404,
+       * which would read as an order that vanished mid-swap.
+       */
+      sameChainRunner: {
+        orderStatus: (h) => this.swapApi().orderStatus(h, quote.src.chainId),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now()
+      },
       runner: {
         readyForSecrets: (h) => this.swapApi().readyForSecrets(h),
         submitSecret: (h, secret) => this.swapApi().submitSecret(h, secret),
@@ -4420,6 +4704,39 @@ var OwneySDK = class {
   async getSwapTokens() {
     return this.swapApi().listTokens();
   }
+  /**
+   * What the wallet actually holds, across every supported chain, restricted
+   * to tokens a swap could use.
+   *
+   * `getSwapTokens` answers "what may someone pay with in principle" from a
+   * fixed list. This answers "what has this wallet got", which is a different
+   * question and the one a picker needs: a user can hold something routable —
+   * tBTC, say — that no fixed list of ours would ever mention.
+   *
+   * Each chain is asked separately because that is how the balance product is
+   * shaped, and a chain that fails contributes nothing rather than failing the
+   * lot. A picker with two chains in it beats an error. (ROUT-242)
+   */
+  async getWalletBalances(chainIds) {
+    const state = this.requireState();
+    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const failedChainIds = [];
+    const results = await Promise.all(
+      chains.map(async (chainId) => {
+        try {
+          const { tokens } = await this.swapApi().walletBalances({
+            chainId,
+            walletAddress: state.walletAddress
+          });
+          return tokens.map((token) => ({ ...token, chainId }));
+        } catch {
+          failedChainIds.push(chainId);
+          return [];
+        }
+      })
+    );
+    return { tokens: results.flat(), failedChainIds };
+  }
   /**
    * Search the assets a user may pay with, across every supported chain.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.26-beta.2",
+  "version": "0.7.26-beta.4",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",