@owney/sdk 0.7.26-beta.3 → 0.7.26-beta.5

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,
@@ -2283,7 +2298,8 @@ function createSwapApi(baseUrl, apiKey) {
         // Omitted, the routing API searches every supported chain — which is
         // what a picker wants, since its rows already span all three.
         ...params.chainId === void 0 ? {} : { chainId: String(params.chainId) },
-        ...params.limit === void 0 ? {} : { limit: String(params.limit) }
+        ...params.limit === void 0 ? {} : { limit: String(params.limit) },
+        ...params.direction === void 0 ? {} : { direction: params.direction }
       }).toString()}`
     ),
     /**
@@ -2369,12 +2385,41 @@ function createSwapApi(baseUrl, apiKey) {
 // src/lib/swap/swap.rpc.ts
 import { fallback, http as http2 } from "viem";
 var DEFAULT_RPC_URLS = {
-  1: ["https://cloudflare-eth.com", "https://ethereum-rpc.publicnode.com"],
+  // NOT cloudflare-eth.com, which used to lead this list. It answers
+  // eth_chainId happily, errors on eth_blockNumber, and — the part that
+  // actually broke things — returns `result: null` for the receipt of a
+  // transaction that is demonstrably mined. Null is a VALID answer meaning
+  // "not found", so viem's fallback has no reason to try the next endpoint:
+  // waitForTransactionReceipt simply polls until it times out, which on this
+  // chain is ten minutes of a spinner (ROUT-242). An endpoint that ERRORS is
+  // safe; an endpoint that lies quietly is not.
+  1: ["https://ethereum-rpc.publicnode.com", "https://eth.drpc.org"],
   8453: ["https://mainnet.base.org", "https://base-rpc.publicnode.com"],
   42161: [
     "https://arb1.arbitrum.io/rpc",
     "https://arbitrum-one-rpc.publicnode.com"
-  ]
+  ],
+  // Added with the wider swap chain set (ROUT-242, comment 15982). Every one
+  // of these answered with `access-control-allow-origin: *` on 2026-09-29;
+  // a chain without two verified endpoints does not belong in the list.
+  10: ["https://mainnet.optimism.io", "https://optimism-rpc.publicnode.com"],
+  // polygon-rpc.com led this list until it started answering every call with
+  // "API key disabled, reason: tenant disabled". It errors rather than lying,
+  // so the fallback did cover it — at the cost of a failed request in front of
+  // every Polygon read.
+  137: ["https://polygon-bor-rpc.publicnode.com", "https://polygon.drpc.org"],
+  56: ["https://bsc-dataseed.bnbchain.org", "https://bsc-rpc.publicnode.com"],
+  43114: [
+    "https://api.avax.network/ext/bc/C/rpc",
+    "https://avalanche-c-chain-rpc.publicnode.com"
+  ],
+  143: ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"],
+  // ONE endpoint, not two: of the six the public chain registry lists for Arc,
+  // this is the only one that answers a browser at all. viem ships none. It
+  // was checked with a real eth_chainId call (0x13b2), not just a CORS header,
+  // but a single provider is a single point of failure - add a second when one
+  // exists.
+  5042: ["https://rpc.beamrpc.com"]
 };
 function swapReadTransport(chainId, overrides) {
   const override = overrides?.[chainId];
@@ -2387,6 +2432,167 @@ function receiptTimeoutMs(chainId) {
   return chainId === 1 ? 6e5 : 18e4;
 }
 
+// src/lib/swap/swap.wrap.ts
+var WRAP_SELECTOR = "0xd0e30db0";
+var FALLBACK_WRAP_GAS = 50000n;
+var APPROVE_GAS = 60000n;
+var GAS_SAFETY = 2n;
+var MIN_WALLET_GAS_PRICE = 3000000000n;
+async function wrapNative(deps, options) {
+  const { chainId, wrapper, nativeSymbol, requested } = options;
+  const balance = await deps.readNativeBalance();
+  let wrapGas;
+  try {
+    wrapGas = await deps.estimateWrapGas(wrapper, requested);
+  } catch (error) {
+    wrapGas = FALLBACK_WRAP_GAS;
+    debugLog("owney-sdk", "wrap: gas estimate failed, using the fallback", {
+      fallback: FALLBACK_WRAP_GAS.toString(),
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const measured = await deps.getMaxFeePerGas();
+  const gasPrice = measured > MIN_WALLET_GAS_PRICE ? measured : MIN_WALLET_GAS_PRICE;
+  const reserve = (wrapGas + APPROVE_GAS) * gasPrice * GAS_SAFETY;
+  const spendable = balance > reserve ? balance - reserve : 0n;
+  const wrapped = requested < spendable ? requested : spendable;
+  debugLog("owney-sdk", "wrap: sizing", {
+    balance: balance.toString(),
+    requested: requested.toString(),
+    measuredGasPrice: measured.toString(),
+    reservedAtGasPrice: gasPrice.toString(),
+    reserve: reserve.toString(),
+    wrapped: wrapped.toString()
+  });
+  if (wrapped <= 0n) {
+    throw new OwneyError(
+      "SWAP_INSUFFICIENT_GAS",
+      `Not enough ${nativeSymbol} to cover both the swap and its network fees. Leave a little ${nativeSymbol} for gas, or swap a smaller amount.`,
+      {
+        chainId,
+        // Named in the details as well as the message so the app's own copy
+        // can say "leave a little POL" rather than re-deriving it.
+        symbol: nativeSymbol,
+        balance: balance.toString(),
+        requested: requested.toString(),
+        reserve: reserve.toString()
+      }
+    );
+  }
+  await deps.ensureChain(chainId);
+  debugLog("owney-sdk", "wrap: sending deposit()", {
+    wrapper,
+    value: wrapped.toString()
+  });
+  const txHash = await deps.sendTransaction(
+    { to: wrapper, data: WRAP_SELECTOR, value: wrapped.toString() },
+    options.onSubmitted
+  );
+  return { wrapped, txHash };
+}
+function requireWrapper(quote) {
+  const wrapper = quote.wrappedNative;
+  if (!wrapper?.address) {
+    throw new OwneyError(
+      "SWAP_NATIVE_UNSUPPORTED",
+      `Swapping ${quote.src.symbol} from this chain to another isn't supported yet. Swap a token instead, or move to the destination chain first.`,
+      { chainId: quote.src.chainId, symbol: quote.src.symbol }
+    );
+  }
+  return { symbol: wrapper.symbol, address: wrapper.address };
+}
+
+// src/lib/swap/swap.chains.ts
+import {
+  arbitrum as arbitrum2,
+  arc,
+  avalanche,
+  base as base2,
+  bsc,
+  mainnet as mainnet2,
+  monad,
+  optimism,
+  polygon
+} from "viem/chains";
+var CHAINS = {
+  8453: base2,
+  42161: arbitrum2,
+  1: mainnet2,
+  10: optimism,
+  137: polygon,
+  56: bsc,
+  43114: avalanche,
+  143: monad,
+  5042: arc
+};
+var SWAP_CHAIN_IDS = Object.keys(CHAINS).map(Number);
+function swapChain(chainId) {
+  return CHAINS[chainId];
+}
+
+// src/lib/swap/swap.arrival.ts
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_POLL_MS = 4e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function awaitWithdrawalArrival(options) {
+  const { arrived, lastReadError } = await awaitBalanceIncrease(options);
+  if (arrived !== null) return arrived;
+  throw new OwneyError(
+    "WITHDRAW_ARRIVAL_TIMEOUT",
+    "The withdrawal was accepted but the funds had not arrived in time to swap them. They are on their way to your wallet in the original asset.",
+    {
+      baseline: options.baseline.toString(),
+      waitedMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      ...lastReadError ? { lastReadError } : {}
+    }
+  );
+}
+async function awaitBalanceIncrease(options) {
+  const {
+    readBalance,
+    baseline,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    pollMs = DEFAULT_POLL_MS
+  } = options;
+  const deadline = Date.now() + timeoutMs;
+  debugLog("owney-sdk", "arrival: waiting for funds to land", {
+    baseline: baseline.toString(),
+    timeoutMs
+  });
+  let lastError;
+  for (; ; ) {
+    try {
+      const balance = await readBalance();
+      if (balance > baseline) {
+        const arrived = balance - baseline;
+        debugLog("owney-sdk", "arrival: funds landed", {
+          arrived: arrived.toString()
+        });
+        return { arrived };
+      }
+    } catch (error) {
+      lastError = error;
+      debugLog("owney-sdk", "arrival: balance read failed, retrying", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (Date.now() >= deadline) {
+      debugLog("owney-sdk", "arrival: nothing landed before the deadline", {
+        baseline: baseline.toString(),
+        waitedMs: timeoutMs,
+        ...lastError ? {
+          lastReadError: lastError instanceof Error ? lastError.message : String(lastError)
+        } : {}
+      });
+      return lastError ? {
+        arrived: null,
+        lastReadError: lastError instanceof Error ? lastError.message : String(lastError)
+      } : { arrived: null };
+    }
+    await sleep(pollMs);
+  }
+}
+
 // src/lib/permit2.ts
 import { bytesToHex } from "viem";
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
@@ -2510,17 +2716,17 @@ var SWAP_TERMINAL_STATUSES = [
 var isSwapTerminal = (status) => SWAP_TERMINAL_STATUSES.includes(status);
 
 // src/lib/swap/swap.order-runner.ts
-var DEFAULT_POLL_MS = 5e3;
+var DEFAULT_POLL_MS2 = 5e3;
 var MAX_BACKOFF_MS = 3e4;
-var backoffFor = (failures, base3) => Math.min(base3 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS);
-var DEFAULT_TIMEOUT_MS = 15 * 60 * 1e3;
+var backoffFor = (failures, base4) => Math.min(base4 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS);
+var DEFAULT_TIMEOUT_MS2 = 15 * 60 * 1e3;
 async function runFusionOrder(deps, options) {
   const {
     orderHash,
     secrets,
     onStage,
-    pollIntervalMs = DEFAULT_POLL_MS,
-    timeoutMs = DEFAULT_TIMEOUT_MS
+    pollIntervalMs = DEFAULT_POLL_MS2,
+    timeoutMs = DEFAULT_TIMEOUT_MS2
   } = options;
   const deadline = deps.now() + timeoutMs;
   let failures = 0;
@@ -2531,7 +2737,11 @@ async function runFusionOrder(deps, options) {
       throw new OwneyError(
         "SWAP_REQUEST_FAILED",
         "Timed out waiting for the swap to settle. It may still complete \u2014 check the order status before retrying.",
-        { orderHash }
+        // Marks the one failure that means "we stopped watching a live order",
+        // as opposed to a verdict or a prompt nobody answered. The executor
+        // checks the wallet before believing it: resolvers do not stop filling
+        // because we stopped looking (ROUT-242, comment 15980).
+        { orderHash, settlementUnconfirmed: true }
       );
     }
     let ready;
@@ -2584,10 +2794,10 @@ async function runFusionOrder(deps, options) {
 }
 
 // src/lib/swap/swap.same-chain-runner.ts
-var DEFAULT_POLL_MS2 = 5e3;
+var DEFAULT_POLL_MS3 = 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;
+var backoffFor2 = (failures, base4) => Math.min(base4 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS2);
+var DEFAULT_TIMEOUT_MS3 = 3 * 60 * 1e3;
 function explain(status) {
   switch (status) {
     case "expired":
@@ -2610,8 +2820,8 @@ async function runSameChainOrder(deps, options) {
   const {
     orderHash,
     onStage,
-    pollIntervalMs = DEFAULT_POLL_MS2,
-    timeoutMs = DEFAULT_TIMEOUT_MS2
+    pollIntervalMs = DEFAULT_POLL_MS3,
+    timeoutMs = DEFAULT_TIMEOUT_MS3
   } = options;
   const deadline = deps.now() + timeoutMs;
   let failures = 0;
@@ -2709,6 +2919,35 @@ function listOrders(now = Date.now()) {
 }
 
 // src/lib/swap/swap.executor.ts
+var WALLET_PROMPT_TIMEOUT_MS = 3 * 60 * 1e3;
+async function awaitWalletPrompt(prompt, what) {
+  let timer;
+  try {
+    return await Promise.race([
+      prompt(),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new OwneyError(
+              "SWAP_WALLET_PROMPT_TIMEOUT",
+              // Naming the stale request matters: the wallet is still holding
+              // it, which is why the next connection attempt is refused too
+              // ("Connection can be declined if a previous request is still
+              // active"). Dismissing it is what actually unblocks them.
+              `Your wallet didn't answer the request to ${what}. Open your wallet, dismiss any request still waiting there, and try again.`,
+              { prompt: what, timeoutMs: WALLET_PROMPT_TIMEOUT_MS }
+            )
+          );
+        }, WALLET_PROMPT_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function stoppedWatching(error) {
+  return error instanceof OwneyError && error.details?.settlementUnconfirmed === true;
+}
 var DEFAULT_SLIPPAGE = 1;
 async function affordableAmount(deps, quoted) {
   const balance = await deps.readSourceBalance();
@@ -2731,21 +2970,39 @@ 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) : 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", {
-    after: after.toString(),
-    received: received.toString()
+  let result;
+  let railError;
+  try {
+    result = quote.rail === "classic" ? await runClassic(deps, options) : quote.rail === "fusion" ? await runSameChainFusion(deps, options, walletAddress) : await runFusion(deps, options, walletAddress);
+  } catch (error) {
+    if (!stoppedWatching(error)) throw error;
+    railError = error;
+    debugLog("owney-sdk", "swap: rail failed, checking whether funds landed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const { arrived } = await awaitBalanceIncrease({
+    readBalance: () => deps.readTargetBalance(),
+    baseline: before,
+    ...options.arrivalTimeoutMs === void 0 ? {} : { timeoutMs: options.arrivalTimeoutMs },
+    ...options.arrivalPollMs === void 0 ? {} : { pollMs: options.arrivalPollMs }
   });
-  if (received <= 0n) {
+  if (arrived === null) {
+    if (railError) throw railError;
     throw new OwneyError(
       "SWAP_REQUEST_FAILED",
       "The swap completed but no funds arrived in the wallet. Check the transaction before retrying.",
-      { rail: quote.rail, ...result }
+      { rail: quote.rail, ...result ?? {} }
     );
   }
-  return { received: received.toString(), ...result };
+  if (railError) {
+    debugLog("owney-sdk", "swap: rail gave up but the funds are here", {
+      received: arrived.toString()
+    });
+    const orderHash = railError.details?.orderHash;
+    if (orderHash) clearOrder(orderHash);
+  }
+  return { received: arrived.toString(), ...result ?? {} };
 }
 async function runClassic(deps, options) {
   const {
@@ -2825,7 +3082,10 @@ async function runSameChainFusion(deps, options, walletAddress) {
   });
   onStage?.("signing");
   await deps.ensureChain(quote.src.chainId);
-  const signature = await deps.signTypedData(built.typedData);
+  const signature = await awaitWalletPrompt(
+    () => deps.signTypedData(built.typedData),
+    "sign the swap"
+  );
   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,
@@ -2855,7 +3115,10 @@ async function authoriseSpend(deps, options, amount, isNativeSource) {
   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;
+  const permit = quote.permitSupported ? await awaitWalletPrompt(
+    async () => deps.buildPermit?.(quote.spender, MAX_UINT256),
+    `approve ${quote.src.symbol}`
+  ) ?? void 0 : void 0;
   if (permit) {
     debugLog("owney-sdk", "swap: permitting limit order protocol", {
       bytes: (permit.length - 2) / 2
@@ -2869,8 +3132,15 @@ async function authoriseSpend(deps, options, amount, isNativeSource) {
 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);
+  if (isNativeSource) {
+    throw new OwneyError(
+      "SWAP_NATIVE_UNSUPPORTED",
+      `${quote.src.symbol} has to be wrapped before it can be swapped to another chain. Nothing has left your wallet.`,
+      { chainId: quote.src.chainId, symbol: quote.src.symbol }
+    );
+  }
+  const amount = await affordableAmount(deps, BigInt(quote.src.amount));
+  const permit = await authoriseSpend(deps, options, amount, false);
   const { secrets, secretHashes } = mintSecrets(quote.secretsCount ?? 1);
   onStage?.("quoting");
   debugLog("owney-sdk", "swap: building fusion order", {
@@ -2905,7 +3175,10 @@ async function runFusion(deps, options, walletAddress) {
   debugLog("owney-sdk", "swap: awaiting signature in wallet", {
     signingOnChain: quote.src.chainId
   });
-  const signature = await deps.signTypedData(built.typedData);
+  const signature = await awaitWalletPrompt(
+    () => deps.signTypedData(built.typedData),
+    "sign the swap"
+  );
   debugLog("owney-sdk", "swap: signed, submitting to relayer");
   await deps.api.submitOrder({
     srcChainId: quote.src.chainId,
@@ -3041,54 +3314,64 @@ async function buildErc2612Permit(reads, input) {
   );
 }
 
-// src/lib/swap/swap.arrival.ts
-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_MS3,
-    pollMs = DEFAULT_POLL_MS3
-  } = options;
-  const deadline = Date.now() + timeoutMs;
-  debugLog("owney-sdk", "withdraw: waiting for funds to land", {
-    baseline: baseline.toString(),
-    timeoutMs
-  });
-  let lastError;
-  for (; ; ) {
-    try {
-      const balance = await readBalance();
-      if (balance > baseline) {
-        const arrived = balance - baseline;
-        debugLog("owney-sdk", "withdraw: funds landed", {
-          arrived: arrived.toString()
-        });
-        return arrived;
-      }
-    } catch (error) {
-      lastError = error;
-      debugLog("owney-sdk", "withdraw: balance read failed, retrying", {
-        message: error instanceof Error ? error.message : String(error)
-      });
+// src/lib/swap/swap.pending-deposit.ts
+var KEY_PREFIX3 = "owney.swap.pending-deposit";
+var MAX_AGE_MS2 = 24 * 60 * 60 * 1e3;
+var storage3 = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+var keyFor2 = (id) => `${KEY_PREFIX3}.${id}`;
+function savePendingDeposit(entry) {
+  const store = storage3();
+  if (!store) return;
+  try {
+    store.setItem(keyFor2(entry.id), JSON.stringify(entry));
+  } catch {
+    return;
+  }
+}
+function clearPendingDeposit(id) {
+  const store = storage3();
+  if (!store) return;
+  try {
+    store.removeItem(keyFor2(id));
+  } catch {
+    return;
+  }
+}
+function listPendingDeposits(now = Date.now()) {
+  const store = storage3();
+  if (!store) return [];
+  const out = [];
+  try {
+    const keys = [];
+    for (let i = 0; i < store.length; i++) {
+      const key2 = store.key(i);
+      if (key2?.startsWith(`${KEY_PREFIX3}.`)) keys.push(key2);
     }
-    if (Date.now() >= deadline) {
-      throw new OwneyError(
-        "WITHDRAW_ARRIVAL_TIMEOUT",
-        "The withdrawal was accepted but the funds had not arrived in time to swap them. They are on their way to your wallet in the original asset.",
-        {
-          baseline: baseline.toString(),
-          waitedMs: timeoutMs,
-          ...lastError ? {
-            lastReadError: lastError instanceof Error ? lastError.message : String(lastError)
-          } : {}
+    for (const key2 of keys) {
+      const raw = store.getItem(key2);
+      if (!raw) continue;
+      try {
+        const parsed = JSON.parse(raw);
+        if (now - parsed.createdAt > MAX_AGE_MS2) {
+          store.removeItem(key2);
+          continue;
         }
-      );
+        out.push(parsed);
+      } catch {
+        store.removeItem(key2);
+      }
     }
-    await sleep(pollMs);
+  } catch {
+    return out;
   }
+  return out.sort((a, b) => b.createdAt - a.createdAt);
 }
 
 // src/lib/health-report.ts
@@ -3288,7 +3571,7 @@ import {
   custom,
   erc20Abi as erc20Abi2
 } from "viem";
-import { base as base2, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
+import { base as base3, arbitrum as arbitrum3, mainnet as mainnet3 } from "viem/chains";
 
 // src/lib/transfer-auth.ts
 import { bytesToHex as bytesToHex2 } from "viem";
@@ -3329,10 +3612,10 @@ function randomAuthNonce() {
 // src/lib/sponsor-client.ts
 var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function postSponsorTransferAuth(input) {
-  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
+    res = await fetch(`${base4}/api/v1/sponsor/erc20-transfer-auth`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3369,10 +3652,10 @@ async function postSponsorTransferAuth(input) {
   return parsed.data;
 }
 async function postSponsorPermit2Transfer(input) {
-  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base3}/api/v1/sponsor/permit2-transfer`, {
+    res = await fetch(`${base4}/api/v1/sponsor/permit2-transfer`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3407,11 +3690,11 @@ async function postSponsorPermit2Transfer(input) {
   return parsed.data;
 }
 async function getSponsorRelayerAddress(input) {
-  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
     res = await fetch(
-      `${base3}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
+      `${base4}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
       {
         headers: { "x-owney-api-key": input.apiKey }
       }
@@ -3696,6 +3979,7 @@ function makeSponsoredCallsCallback(deps) {
 }
 
 // src/client.ts
+var WALLET_CATCHUP_TIMEOUT_MS = 3e4;
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -3722,9 +4006,9 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: base2,
-  42161: arbitrum2,
-  1: mainnet2
+  8453: base3,
+  42161: arbitrum3,
+  1: mainnet3
 };
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
@@ -4513,7 +4797,7 @@ var OwneySDK = class {
   async ensureSwapChain(chainId) {
     const provider = this.requireConnectedProvider();
     const state = this.requireState();
-    const chain = VIEM_CHAIN2[chainId];
+    const chain = swapChain(chainId);
     if (!chain) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
@@ -4531,6 +4815,111 @@ var OwneySDK = class {
       chainId
     );
   }
+  /**
+   * Turn a native-source cross-chain quote into an ERC-20 one.
+   *
+   * Fusion+ cannot escrow native value, so the quote arrives with
+   * `requiresOnchainOrder` set and the relayer would refuse the order after
+   * the user signed it (ROUT-242). Wrapping first costs one transaction and
+   * puts the swap back on the ERC-20 rail that already works, rather than
+   * adding a second order type that would need its own escrow handling.
+   *
+   * Re-quoted afterwards rather than patched: the amount wrapped may be less
+   * than the amount quoted (gas has to come out of the same balance), and
+   * every executor dep — allowance, permit, balances — is derived from the
+   * quote's source token. A quote naming ETH would have all of them reading
+   * the wrong asset.
+   */
+  async wrapNativeSource(quote, walletAddress, onStage, direction) {
+    const wrapper = requireWrapper(quote);
+    const chainId = quote.src.chainId;
+    const chain = swapChain(chainId);
+    const provider = this.requireConnectedProvider();
+    const publicClient = createPublicClient2({
+      chain,
+      transport: swapReadTransport(chainId, this.zyfaiRpcUrls)
+    });
+    const wallet = createWalletClient({
+      account: walletAddress,
+      chain,
+      transport: custom(provider)
+    });
+    onStage?.("wrapping");
+    const { wrapped } = await wrapNative(
+      {
+        readNativeBalance: () => publicClient.getBalance({
+          address: walletAddress
+        }),
+        estimateWrapGas: (to, value) => publicClient.estimateGas({
+          account: walletAddress,
+          to,
+          data: WRAP_SELECTOR,
+          value
+        }),
+        // The 1559 ceiling, not the spot price: a wallet bills against the
+        // former and the two differ wildly on a quiet chain.
+        getMaxFeePerGas: async () => {
+          const fees = await publicClient.estimateFeesPerGas();
+          return fees.maxFeePerGas ?? publicClient.getGasPrice();
+        },
+        sendTransaction: async (tx, onSubmitted) => {
+          const hash = await wallet.sendTransaction({
+            to: tx.to,
+            data: tx.data,
+            value: BigInt(tx.value),
+            account: walletAddress,
+            chain
+          });
+          onSubmitted?.(hash);
+          const receipt = await publicClient.waitForTransactionReceipt({
+            hash,
+            confirmations: 1,
+            timeout: receiptTimeoutMs(chainId)
+          });
+          if (receipt.status !== "success") {
+            throw new OwneyError(
+              "SWAP_REQUEST_FAILED",
+              `Wrapping your ${quote.src.symbol} failed (tx ${hash}). Nothing was swapped.`,
+              { hash }
+            );
+          }
+          return hash;
+        },
+        ensureChain: (id) => this.ensureSwapChain(id)
+      },
+      {
+        chainId,
+        wrapper: wrapper.address,
+        nativeSymbol: quote.src.symbol,
+        requested: BigInt(quote.src.amount),
+        onSubmitted: () => onStage?.("wrapped")
+      }
+    );
+    debugLog("owney-sdk", "swap: wrapped native source", {
+      symbol: wrapper.symbol,
+      amount: wrapped.toString()
+    });
+    try {
+      return await this.swapApi().quote({
+        from: { chainId, symbol: wrapper.symbol, amount: wrapped.toString() },
+        to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
+        walletAddress,
+        ...direction ? { direction } : {}
+      });
+    } catch (error) {
+      throw new OwneyError(
+        "SWAP_REQUEST_FAILED",
+        `Your ${quote.src.symbol} was wrapped to ${wrapper.symbol}, but the swap couldn't be priced. The funds are in your wallet as ${wrapper.symbol} \u2014 swap that instead, no need to wrap again.`,
+        {
+          wrappedSymbol: wrapper.symbol,
+          wrappedAmount: wrapped.toString(),
+          chainId,
+          cause: error instanceof Error ? error.message : String(error),
+          ...error instanceof OwneyError ? { causeCode: error.code } : {}
+        }
+      );
+    }
+  }
   /**
    * Binds the executor's abstract deps to this client's wallet.
    *
@@ -4540,8 +4929,8 @@ var OwneySDK = class {
   buildSwapDeps(quote) {
     const state = this.requireState();
     const provider = this.requireConnectedProvider();
-    const srcChain = VIEM_CHAIN2[quote.src.chainId];
-    const dstChain = VIEM_CHAIN2[quote.dst.chainId];
+    const srcChain = swapChain(quote.src.chainId);
+    const dstChain = swapChain(quote.dst.chainId);
     const wallet = createWalletClient({
       account: state.walletAddress,
       chain: srcChain,
@@ -4671,13 +5060,59 @@ var OwneySDK = class {
         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),
-        orderStatus: (h) => this.swapApi().orderStatus(h),
-        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-        now: () => Date.now()
-      }
+      runner: this.swapRunnerDeps()
+    };
+  }
+  /**
+   * Waits until the WALLET'S OWN node reports at least `amount` of `token`.
+   *
+   * Separate from the swap's arrival measurement on purpose: that one runs on
+   * a pinned HTTP RPC, and what matters here is the view the deposit will
+   * actually use. Returns whether it got there — a courtesy, not a gate, since
+   * the deposit's own check is the authority and refusing to even attempt
+   * would strand funds we might have been able to move.
+   */
+  async walletSeesBalance(chainId, token, amount) {
+    const provider = this.requireConnectedProvider();
+    const state = this.requireState();
+    const pub = createPublicClient2({
+      chain: swapChain(chainId),
+      transport: custom(provider)
+    });
+    const { arrived } = await awaitBalanceIncrease({
+      readBalance: () => pub.readContract({
+        address: token,
+        abi: ERC20_ALLOWANCE_ABI,
+        functionName: "balanceOf",
+        args: [state.walletAddress]
+      }),
+      // `awaitBalanceIncrease` resolves on the first read STRICTLY above the
+      // baseline, so one below the target means "at least the target".
+      baseline: amount - 1n,
+      timeoutMs: WALLET_CATCHUP_TIMEOUT_MS
+    });
+    return arrived !== null;
+  }
+  /**
+   * Runs a quoted swap. A named seam rather than an inline `executeSwap` call
+   * so the deposit half of `swapAndDeposit` can be exercised on its own.
+   */
+  runSwap(quote, options) {
+    return executeSwap(this.buildSwapDeps(quote), { quote, ...options });
+  }
+  /**
+   * The half of the swap deps that only ever talks to the routing API.
+   *
+   * Split out because resuming an order needs exactly this and nothing else —
+   * no provider, no wallet client, no chain. See `resumePendingSwaps`.
+   */
+  swapRunnerDeps() {
+    return {
+      readyForSecrets: (h) => this.swapApi().readyForSecrets(h),
+      submitSecret: (h, secret) => this.swapApi().submitSecret(h, secret),
+      orderStatus: (h) => this.swapApi().orderStatus(h),
+      sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+      now: () => Date.now()
     };
   }
   /**
@@ -4689,6 +5124,126 @@ var OwneySDK = class {
   async getSwapTokens() {
     return this.swapApi().listTokens();
   }
+  /**
+   * Swaps that landed but were never deposited, newest first.
+   *
+   * The money is already in the wallet in the right asset — what is missing is
+   * an ordinary deposit, which is why this needs no order and no signature to
+   * describe. See `completePendingDeposit`.
+   */
+  listPendingDeposits() {
+    return listPendingDeposits();
+  }
+  /**
+   * Deposit a swap that already landed.
+   *
+   * Nothing is swapped again: the funds are in the wallet, so this is the
+   * second half of `swapAndDeposit` on its own. Cleared only once the deposit
+   * has actually gone through — a failure here leaves the record in place so it
+   * can be offered again rather than silently dropped.
+   */
+  async completePendingDeposit(id) {
+    const entry = listPendingDeposits().find((p) => p.id === id);
+    if (!entry) {
+      throw new OwneyError(
+        "SWAP_REQUEST_FAILED",
+        "That swap is no longer waiting to be added.",
+        { id }
+      );
+    }
+    await this.ensureSwapChain(entry.chainId);
+    const deposit = await this.deposit({
+      amount: entry.received,
+      asset: entry.symbol,
+      ...entry.agentId ? { agentId: entry.agentId } : {}
+    });
+    clearPendingDeposit(entry.id);
+    return deposit;
+  }
+  /**
+   * Pick up cross-chain swaps a previous session left in flight.
+   *
+   * A Fusion+ order is only finished when the client publishes a secret for
+   * each fill, once the escrows exist — so a user who closed the tab mid-swap
+   * leaves an order nobody will ever complete, and it expires and refunds
+   * instead of arriving. The preimages are stored for exactly this (24h sweep,
+   * see the secret store); this is the other half.
+   *
+   * Needs NO wallet, deliberately. The signature already happened and the funds
+   * are already escrowed, so finishing is pure API work — demanding a reconnect
+   * first would strand the people it exists for.
+   *
+   * Every order is attempted even if an earlier one throws: they are unrelated
+   * escrows, and one ending badly must not abandon the next one's secrets.
+   * `unfinished` is not a verdict — the order may still settle, so unless the
+   * chain has said refunded or cancelled its preimages are kept.
+   */
+  async resumePendingSwaps(options = {}) {
+    const pending = listOrders();
+    if (pending.length === 0) return [];
+    const runner = this.swapRunnerDeps();
+    const results = [];
+    for (const order of pending) {
+      try {
+        await runFusionOrder(runner, {
+          orderHash: order.orderHash,
+          secrets: order.secrets,
+          ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+          ...options.onStage ? {
+            onStage: (stage) => options.onStage(order.orderHash, stage)
+          } : {}
+        });
+        clearOrder(order.orderHash);
+        results.push({
+          orderHash: order.orderHash,
+          status: "completed"
+        });
+      } catch (error) {
+        if (error instanceof OwneyError && (error.code === "SWAP_ORDER_REFUNDED" || error.code === "SWAP_ORDER_CANCELLED")) {
+          clearOrder(order.orderHash);
+        }
+        results.push({
+          orderHash: order.orderHash,
+          status: "unfinished",
+          ...error instanceof OwneyError ? { error } : {}
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * 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.
    *
@@ -4710,7 +5265,8 @@ var OwneySDK = class {
     return this.swapApi().searchTokens({
       query,
       ...params.chainId === void 0 ? {} : { chainId: params.chainId },
-      ...params.limit === void 0 ? {} : { limit: params.limit }
+      ...params.limit === void 0 ? {} : { limit: params.limit },
+      ...params.direction === void 0 ? {} : { direction: params.direction }
     });
   }
   /**
@@ -4749,26 +5305,56 @@ var OwneySDK = class {
   async swapAndDeposit(options) {
     const state = this.requireState();
     const api = this.swapApi();
-    const quote = await api.quote({
+    const quoted = await api.quote({
       from: options.from,
       to: options.to,
       walletAddress: state.walletAddress
     });
+    const quote = quoted.requiresOnchainOrder ? await this.wrapNativeSource(
+      quoted,
+      state.walletAddress,
+      options.onSwapProgress
+    ) : quoted;
     await this.ensureSwapChain(quote.src.chainId);
-    const swap = await executeSwap(this.buildSwapDeps(quote), {
-      quote,
+    const swap = await this.runSwap(quote, {
       walletAddress: state.walletAddress,
       ...options.slippage === void 0 ? {} : { slippage: options.slippage },
       ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {}
     });
     options.onSwapProgress?.("depositing");
-    await this.ensureSwapChain(quote.dst.chainId);
-    const deposit = await this.deposit({
-      amount: swap.received,
-      asset: options.to.symbol,
-      ...options.agentId ? { agentId: options.agentId } : {}
-    });
-    return { swap, deposit };
+    try {
+      await this.ensureSwapChain(quote.dst.chainId);
+      await this.walletSeesBalance(
+        quote.dst.chainId,
+        quote.dst.address,
+        BigInt(swap.received)
+      );
+      const deposit = await this.deposit({
+        amount: swap.received,
+        asset: options.to.symbol,
+        ...options.agentId ? { agentId: options.agentId } : {}
+      });
+      return { swap, deposit };
+    } catch (error) {
+      const pending = {
+        id: `${quote.dst.chainId}-${options.to.symbol}-${Date.now()}`,
+        received: swap.received,
+        symbol: options.to.symbol,
+        chainId: quote.dst.chainId,
+        ...options.agentId ? { agentId: options.agentId } : {},
+        createdAt: Date.now()
+      };
+      savePendingDeposit(pending);
+      throw new OwneyError(
+        "SWAP_DEPOSIT_PENDING",
+        `The swap went through and your ${options.to.symbol} is in your wallet, but adding it to the agent didn't complete. Nothing needs swapping again.`,
+        {
+          ...pending,
+          cause: error instanceof Error ? error.message : String(error),
+          ...error instanceof OwneyError ? { causeCode: error.code } : {}
+        }
+      );
+    }
   }
   /**
    * Withdraw from an agent and swap the proceeds into whatever the user wants
@@ -5616,8 +6202,8 @@ import { SiweMessage } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX3 = "owney.siwx.session";
-var storage3 = () => {
+var KEY_PREFIX4 = "owney.siwx.session";
+var storage4 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -5625,8 +6211,8 @@ var storage3 = () => {
     return null;
   }
 };
-var buildKey2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}:`;
+var buildKey2 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -5658,7 +6244,7 @@ var readLegacySiwxSession = (store, address) => {
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey2(address);
-  const store = storage3();
+  const store = storage4();
   let raw = null;
   try {
     raw = store?.getItem(key2) ?? null;
@@ -5688,7 +6274,7 @@ var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
   const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage3();
+  const store = storage4();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
@@ -5697,7 +6283,7 @@ var writeSiwxSession = (address, _chainId, session) => {
 var clearSiwxSession = (address, _chainId) => {
   const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage3();
+  const store = storage4();
   try {
     store?.removeItem(key2);
   } catch {
@@ -5830,6 +6416,7 @@ export {
   OwneyError,
   OwneySDK,
   createOwneySIWX,
+  listPendingDeposits,
   listOrders as listPendingSwaps,
   setOwneyDebug
 };