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

package/dist/index.cjs

@@ -26,9 +26,15 @@ __export(index_exports, {
   NotConnectedError: () => NotConnectedError,
   OwneyError: () => OwneyError,
   OwneySDK: () => OwneySDK,
+  clearWithdrawSwap: () => clearWithdrawSwap,
   createOwneySIWX: () => createOwneySIWX,
+  listPendingDeposits: () => listPendingDeposits,
   listPendingSwaps: () => listOrders,
-  setOwneyDebug: () => setOwneyDebug
+  listWithdrawSwaps: () => listWithdrawSwaps,
+  saveWithdrawSwap: () => saveWithdrawSwap,
+  setOwneyDebug: () => setOwneyDebug,
+  subscribeWithdrawSwaps: () => subscribeWithdrawSwaps,
+  updateWithdrawSwap: () => updateWithdrawSwap
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2328,11 +2334,12 @@ function createSwapApi(baseUrl, apiKey) {
       baseUrl,
       apiKey,
       `/tokens/search?${new URLSearchParams({
-        query: params.query,
+        ...params.query === void 0 ? {} : { query: params.query },
         // 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()}`
     ),
     /**
@@ -2418,12 +2425,41 @@ function createSwapApi(baseUrl, apiKey) {
 // src/lib/swap/swap.rpc.ts
 var import_viem2 = require("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];
@@ -2436,6 +2472,157 @@ 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
+var import_chains2 = require("viem/chains");
+var CHAINS = {
+  8453: import_chains2.base,
+  42161: import_chains2.arbitrum,
+  1: import_chains2.mainnet,
+  10: import_chains2.optimism,
+  137: import_chains2.polygon,
+  56: import_chains2.bsc,
+  43114: import_chains2.avalanche,
+  143: import_chains2.monad,
+  5042: import_chains2.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
 var import_viem3 = require("viem");
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
@@ -2559,17 +2746,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;
@@ -2580,7 +2767,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;
@@ -2633,10 +2824,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":
@@ -2659,8 +2850,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;
@@ -2758,6 +2949,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();
@@ -2780,21 +3000,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 {
@@ -2874,7 +3112,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,
@@ -2886,6 +3127,10 @@ async function runSameChainFusion(deps, options, walletAddress) {
     quoteId: built.quoteId,
     ...built.extension ? { extension: built.extension } : {}
   });
+  try {
+    options.onOrderSubmitted?.(built.orderHash);
+  } catch {
+  }
   await runSameChainOrder(deps.sameChainRunner ?? deps.runner, {
     orderHash: built.orderHash,
     ...onStage ? { onStage } : {}
@@ -2904,7 +3149,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
@@ -2918,8 +3166,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", {
@@ -2954,7 +3209,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,
@@ -2971,6 +3229,10 @@ async function runFusion(deps, options, walletAddress) {
     ...built.extension ? { extension: built.extension } : {}
   });
   debugLog("owney-sdk", "swap: order submitted, polling escrows");
+  try {
+    options.onOrderSubmitted?.(built.orderHash);
+  } catch {
+  }
   try {
     await runFusionOrder(deps.runner, {
       orderHash: built.orderHash,
@@ -3085,54 +3347,158 @@ 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 (; ; ) {
+// src/lib/swap/swap.withdraw-swap.ts
+var KEY_PREFIX3 = "owney.swap.withdraw";
+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 = (orderHash) => `${KEY_PREFIX3}.${orderHash}`;
+var listeners = /* @__PURE__ */ new Set();
+function subscribeWithdrawSwaps(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var notify = () => {
+  for (const listener of listeners) {
     try {
-      const balance = await readBalance();
-      if (balance > baseline) {
-        const arrived = balance - baseline;
-        debugLog("owney-sdk", "withdraw: funds landed", {
-          arrived: arrived.toString()
-        });
-        return arrived;
+      listener();
+    } catch {
+    }
+  }
+};
+function saveWithdrawSwap(record) {
+  const store = storage3();
+  if (!store) return;
+  try {
+    store.setItem(keyFor2(record.orderHash), JSON.stringify(record));
+  } catch {
+    return;
+  }
+  notify();
+}
+function updateWithdrawSwap(orderHash, patch) {
+  const store = storage3();
+  if (!store) return;
+  try {
+    const raw = store.getItem(keyFor2(orderHash));
+    if (!raw) return;
+    const current = JSON.parse(raw);
+    const next = { ...current, ...patch };
+    if (next.status !== "swapping" && current.status === "swapping" && next.settledAt === void 0) {
+      next.settledAt = Date.now();
+    }
+    store.setItem(keyFor2(orderHash), JSON.stringify(next));
+  } catch {
+    return;
+  }
+  notify();
+}
+function clearWithdrawSwap(orderHash) {
+  const store = storage3();
+  if (!store) return;
+  try {
+    store.removeItem(keyFor2(orderHash));
+  } catch {
+    return;
+  }
+  notify();
+}
+function listWithdrawSwaps(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);
+    }
+    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);
       }
-    } catch (error) {
-      lastError = error;
-      debugLog("owney-sdk", "withdraw: balance read failed, retrying", {
-        message: error instanceof Error ? error.message : String(error)
-      });
     }
-    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)
-          } : {}
+  } catch {
+    return out;
+  }
+  return out.sort((a, b) => b.createdAt - a.createdAt);
+}
+
+// src/lib/swap/swap.pending-deposit.ts
+var KEY_PREFIX4 = "owney.swap.pending-deposit";
+var MAX_AGE_MS3 = 24 * 60 * 60 * 1e3;
+var storage4 = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+var keyFor3 = (id) => `${KEY_PREFIX4}.${id}`;
+function savePendingDeposit(entry) {
+  const store = storage4();
+  if (!store) return;
+  try {
+    store.setItem(keyFor3(entry.id), JSON.stringify(entry));
+  } catch {
+    return;
+  }
+}
+function clearPendingDeposit(id) {
+  const store = storage4();
+  if (!store) return;
+  try {
+    store.removeItem(keyFor3(id));
+  } catch {
+    return;
+  }
+}
+function listPendingDeposits(now = Date.now()) {
+  const store = storage4();
+  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_PREFIX4}.`)) keys.push(key2);
+    }
+    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_MS3) {
+          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
@@ -3326,7 +3692,7 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 
 // src/client.ts
 var import_viem9 = require("viem");
-var import_chains2 = require("viem/chains");
+var import_chains3 = require("viem/chains");
 
 // src/lib/transfer-auth.ts
 var import_viem7 = require("viem");
@@ -3367,10 +3733,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",
@@ -3407,10 +3773,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",
@@ -3445,11 +3811,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 }
       }
@@ -3734,6 +4100,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");
 }
@@ -3760,9 +4127,9 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: import_chains2.base,
-  42161: import_chains2.arbitrum,
-  1: import_chains2.mainnet
+  8453: import_chains3.base,
+  42161: import_chains3.arbitrum,
+  1: import_chains3.mainnet
 };
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
@@ -4551,7 +4918,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",
@@ -4569,6 +4936,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 = (0, import_viem9.createPublicClient)({
+      chain,
+      transport: swapReadTransport(chainId, this.zyfaiRpcUrls)
+    });
+    const wallet = (0, import_viem9.createWalletClient)({
+      account: walletAddress,
+      chain,
+      transport: (0, import_viem9.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.
    *
@@ -4578,8 +5050,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 = (0, import_viem9.createWalletClient)({
       account: state.walletAddress,
       chain: srcChain,
@@ -4709,13 +5181,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 = (0, import_viem9.createPublicClient)({
+      chain: swapChain(chainId),
+      transport: (0, import_viem9.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()
     };
   }
   /**
@@ -4727,6 +5245,167 @@ 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();
+  }
+  /**
+   * Backgrounded withdrawal swaps and how they ended, newest first.
+   *
+   * Nothing to act on — unlike `listPendingDeposits`, which describes a job the
+   * user can finish. This is a watch: the funds are in escrow and the only
+   * open question is where they land. See `swap.withdraw-swap.ts`.
+   */
+  listWithdrawSwaps() {
+    return listWithdrawSwaps();
+  }
+  /**
+   * Retire a settled record. The user has read the outcome.
+   *
+   * Only they do this — a record that disappears on its own takes with it the
+   * only thing telling someone where their money went.
+   */
+  dismissWithdrawSwap(orderHash) {
+    clearWithdrawSwap(orderHash);
+  }
+  /**
+   * 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) {
+      await this.resumeSameChainSwaps(options);
+      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);
+        updateWithdrawSwap(order.orderHash, { status: "landed" });
+        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);
+          updateWithdrawSwap(order.orderHash, { status: "refunded" });
+        } else {
+          updateWithdrawSwap(order.orderHash, { status: "unknown" });
+        }
+        results.push({
+          orderHash: order.orderHash,
+          status: "unfinished",
+          ...error instanceof OwneyError ? { error } : {}
+        });
+      }
+    }
+    await this.resumeSameChainSwaps(options);
+    return results;
+  }
+  /**
+   * Pick up SAME-CHAIN orders a previous session left in the auction.
+   *
+   * They are not in the secret store and never will be: that store exists to
+   * keep preimages, and a same-chain fill needs none — the resolver takes the
+   * maker's tokens and delivers the taker's in one transaction. So the only
+   * record of one is the withdrawal record itself, which carries the order
+   * hash, and that is all a resume needs here.
+   *
+   * Gentler than the Fusion+ case in the way that matters. Nothing is
+   * escrowed, so an order nobody ever picks up leaves the wallet exactly as it
+   * was — this is catching up on news, not rescuing funds.
+   *
+   * Same-chain is read off the record rather than stored as a rail: a
+   * withdrawal whose source and destination share a chain could not have been
+   * anything else.
+   */
+  async resumeSameChainSwaps(options = {}) {
+    const running = listWithdrawSwaps().filter(
+      (record) => record.status === "swapping" && record.srcChainId === record.dstChainId
+    );
+    for (const record of running) {
+      const runner = {
+        // The chain bound in. That product keys its orders per chain, and the
+        // Fusion+ endpoint answers 404 for one — which would read as an order
+        // that vanished rather than one still in the auction.
+        orderStatus: (h) => this.swapApi().orderStatus(h, record.srcChainId),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now()
+      };
+      try {
+        await runSameChainOrder(runner, {
+          orderHash: record.orderHash,
+          ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+          ...options.onStage ? {
+            onStage: (stage) => options.onStage(record.orderHash, stage)
+          } : {}
+        });
+        updateWithdrawSwap(record.orderHash, { status: "landed" });
+      } catch (error) {
+        const code = error instanceof OwneyError ? error.code : void 0;
+        updateWithdrawSwap(record.orderHash, {
+          status: code === "SWAP_ORDER_EXPIRED" || code === "SWAP_ORDER_CANCELLED" ? "refunded" : "unknown"
+        });
+      }
+    }
+  }
   /**
    * What the wallet actually holds, across every supported chain, restricted
    * to tokens a swap could use.
@@ -4773,15 +5452,19 @@ var OwneySDK = class {
    * tokens can share a ticker, and `providers` (how many token lists carry the
    * address) is the only usable signal for telling them apart. Surface it.
    *
-   * Returns nothing for a blank query rather than asking for the whole list.
+   * A blank query WITH a chainId lists that chain's catalogue instead of
+   * searching it — what a picker wants when someone selects a chain before
+   * typing anything. Blank with no chain returns nothing: that would be asking
+   * for the top of every catalogue at once, which is a download, not a list.
    */
   async searchSwapTokens(params) {
-    const query = params.query.trim();
-    if (!query) return { tokens: [] };
+    const query = params.query?.trim() ?? "";
+    if (!query && params.chainId === void 0) return { tokens: [] };
     return this.swapApi().searchTokens({
-      query,
+      ...query ? { 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 }
     });
   }
   /**
@@ -4820,26 +5503,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
@@ -4928,7 +5641,14 @@ var OwneySDK = class {
         walletAddress: state.walletAddress,
         direction: "withdraw",
         ...options.slippage === void 0 ? {} : { slippage: options.slippage },
-        ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {}
+        ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {},
+        ...options.onOrderSubmitted ? {
+          onOrderSubmitted: (orderHash) => options.onOrderSubmitted({
+            orderHash,
+            withdrawn,
+            expected: quote.dst.amount
+          })
+        } : {}
       });
       return { withdraw, withdrawn, swap };
     } catch (error) {
@@ -5687,8 +6407,8 @@ var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX3 = "owney.siwx.session";
-var storage3 = () => {
+var KEY_PREFIX5 = "owney.siwx.session";
+var storage5 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -5696,8 +6416,8 @@ var storage3 = () => {
     return null;
   }
 };
-var buildKey2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}:`;
+var buildKey2 = (address) => `${KEY_PREFIX5}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX5}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -5729,7 +6449,7 @@ var readLegacySiwxSession = (store, address) => {
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey2(address);
-  const store = storage3();
+  const store = storage5();
   let raw = null;
   try {
     raw = store?.getItem(key2) ?? null;
@@ -5759,7 +6479,7 @@ var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
   const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage3();
+  const store = storage5();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
@@ -5768,7 +6488,7 @@ var writeSiwxSession = (address, _chainId, session) => {
 var clearSiwxSession = (address, _chainId) => {
   const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage3();
+  const store = storage5();
   try {
     store?.removeItem(key2);
   } catch {
@@ -5901,7 +6621,13 @@ function createOwneySIWX(config) {
   NotConnectedError,
   OwneyError,
   OwneySDK,
+  clearWithdrawSwap,
   createOwneySIWX,
+  listPendingDeposits,
   listPendingSwaps,
-  setOwneyDebug
+  listWithdrawSwaps,
+  saveWithdrawSwap,
+  setOwneyDebug,
+  subscribeWithdrawSwaps,
+  updateWithdrawSwap
 });