@owney/sdk 0.7.24-beta.0 → 0.7.25-beta.0

package/dist/index.cjs

@@ -27,6 +27,7 @@ __export(index_exports, {
   OwneyError: () => OwneyError,
   OwneySDK: () => OwneySDK,
   createOwneySIWX: () => createOwneySIWX,
+  listPendingSwaps: () => listOrders,
   setOwneyDebug: () => setOwneyDebug
 });
 module.exports = __toCommonJS(index_exports);
@@ -2198,6 +2199,653 @@ async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL) {
   return json.data;
 }
 
+// src/lib/chain-guard.ts
+var CHAIN_NAMES = {
+  1: "Ethereum",
+  8453: "Base",
+  42161: "Arbitrum"
+};
+function chainName(chainId) {
+  return CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
+}
+async function ensureWalletOnChain(pub, wallet, expected) {
+  const actual = await pub.getChainId();
+  if (actual === expected) return;
+  try {
+    await wallet.switchChain({ id: expected });
+  } catch (error) {
+    throw new OwneyError(
+      "CHAIN_MISMATCH",
+      `Your wallet is on ${chainName(actual)}. Switch it to ${chainName(expected)} and try again.`,
+      {
+        expectedChainId: expected,
+        actualChainId: actual,
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+  const after = await pub.getChainId();
+  if (after !== expected) {
+    throw new OwneyError(
+      "CHAIN_MISMATCH",
+      `Your wallet is still on ${chainName(after)}. Switch it to ${chainName(expected)} and try again.`,
+      { expectedChainId: expected, actualChainId: after }
+    );
+  }
+}
+
+// src/lib/swap/swap-api.ts
+async function request(baseUrl, apiKey, path, init) {
+  const url = `${baseUrl}/api/v1/swap${path}`;
+  const res = await fetch(url, {
+    method: init?.method ?? "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "x-owney-api-key": apiKey
+    },
+    ...init ? { body: JSON.stringify(init.body) } : {}
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    if (res.status === 429) {
+      throw new OwneyError(
+        "SWAP_RATE_LIMITED",
+        "Swap provider is rate limiting, retry shortly",
+        { statusCode: res.status }
+      );
+    }
+    if (res.status === 403) {
+      throw new OwneyError(
+        "SWAP_DISABLED",
+        "Swap is not enabled for this organization",
+        { statusCode: res.status }
+      );
+    }
+    throw new OwneyError(
+      "SWAP_REQUEST_FAILED",
+      `Swap API error ${res.status}: ${text}`,
+      { statusCode: res.status, responseBody: text }
+    );
+  }
+  const json = await res.json();
+  if (!json.success) {
+    throw new OwneyError(
+      "SWAP_REQUEST_FAILED",
+      `Swap API request failed: ${json.message ?? "unknown error"}`,
+      { message: json.message }
+    );
+  }
+  return json.data;
+}
+function createSwapApi(baseUrl, apiKey) {
+  return {
+    /** Source assets the user may pay with, and each chain's deposit targets. */
+    listTokens: () => request(baseUrl, apiKey, "/tokens"),
+    /**
+     * `walletAddress` is required even though the routing API could not infer
+     * it: the Fusion+ quoter binds a quote to whoever will sign the order and
+     * rejects the request without it.
+     */
+    quote: (params) => request(baseUrl, apiKey, "/quote", {
+      method: "POST",
+      body: {
+        srcChainId: params.from.chainId,
+        srcSymbol: params.from.symbol,
+        dstChainId: params.to.chainId,
+        dstSymbol: params.to.symbol,
+        amount: params.from.amount,
+        walletAddress: params.walletAddress,
+        ...params.direction ? { direction: params.direction } : {}
+      }
+    }),
+    /** Ready-to-send calldata for a same-chain swap. */
+    swapTx: (params) => request(baseUrl, apiKey, "/tx", {
+      method: "POST",
+      body: {
+        srcChainId: params.from.chainId,
+        srcSymbol: params.from.symbol,
+        dstChainId: params.to.chainId,
+        dstSymbol: params.to.symbol,
+        amount: params.from.amount,
+        walletAddress: params.walletAddress,
+        slippage: params.slippage,
+        ...params.direction ? { direction: params.direction } : {}
+      }
+    }),
+    /**
+     * Builds a Fusion+ order server-side and returns EIP-712 typed data.
+     *
+     * Only HASHES go over the wire. The preimages never leave the browser —
+     * see swap.secrets.
+     */
+    buildOrder: (params) => request(baseUrl, apiKey, "/order/build", {
+      method: "POST",
+      body: {
+        srcChainId: params.from.chainId,
+        srcSymbol: params.from.symbol,
+        dstChainId: params.to.chainId,
+        dstSymbol: params.to.symbol,
+        amount: params.from.amount,
+        walletAddress: params.walletAddress,
+        secretHashes: params.secretHashes,
+        ...params.direction ? { direction: params.direction } : {},
+        ...params.receiver ? { receiver: params.receiver } : {}
+      }
+    }),
+    submitOrder: (body) => request(baseUrl, apiKey, "/order", { method: "POST", body }),
+    /**
+     * Only call once `readyForSecrets` reports the escrow deployed. Publishing
+     * earlier hands a resolver the preimage while the user's funds are locked
+     * and nothing has been posted on the destination chain.
+     */
+    submitSecret: (orderHash, secret) => request(baseUrl, apiKey, "/order/secret", {
+      method: "POST",
+      body: { orderHash, secret }
+    }),
+    orderStatus: (orderHash) => request(baseUrl, apiKey, `/order/${orderHash}`),
+    readyForSecrets: (orderHash) => request(
+      baseUrl,
+      apiKey,
+      `/order/${orderHash}/ready-for-secrets`
+    )
+  };
+}
+
+// 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"],
+  8453: ["https://mainnet.base.org", "https://base-rpc.publicnode.com"],
+  42161: [
+    "https://arb1.arbitrum.io/rpc",
+    "https://arbitrum-one-rpc.publicnode.com"
+  ]
+};
+function swapReadTransport(chainId, overrides) {
+  const override = overrides?.[chainId];
+  if (override) return (0, import_viem2.http)(override);
+  const urls = DEFAULT_RPC_URLS[chainId];
+  if (!urls || urls.length === 0) return (0, import_viem2.http)();
+  return (0, import_viem2.fallback)(urls.map((url) => (0, import_viem2.http)(url)));
+}
+function receiptTimeoutMs(chainId) {
+  return chainId === 1 ? 6e5 : 18e4;
+}
+
+// src/lib/permit2.ts
+var import_viem3 = require("viem");
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: input.chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    types: {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    },
+    primaryType: "PermitTransferFrom",
+    message: input.message
+  };
+}
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt((0, import_viem3.bytesToHex)(bytes));
+}
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
+
+// src/lib/swap/swap.secrets.ts
+var import_viem4 = require("viem");
+var SECRET_BYTES = 32;
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (!cryptoObj?.getRandomValues) {
+    throw new Error(
+      "[owney-sdk] Secure randomness is unavailable, so a swap secret cannot be generated safely."
+    );
+  }
+  cryptoObj.getRandomValues(bytes);
+  return bytes;
+}
+function mintSecrets(count) {
+  if (!Number.isInteger(count) || count < 1) {
+    throw new Error(
+      `[owney-sdk] A swap needs at least one secret, got ${String(count)}.`
+    );
+  }
+  const secrets = [];
+  const secretHashes = [];
+  for (let i = 0; i < count; i++) {
+    const secret = (0, import_viem4.toHex)(randomBytes(SECRET_BYTES));
+    secrets.push(secret);
+    secretHashes.push((0, import_viem4.keccak256)(secret));
+  }
+  return { secrets, secretHashes };
+}
+
+// src/lib/swap/swap.types.ts
+var SWAP_TERMINAL_STATUSES = [
+  "executed",
+  "expired",
+  "cancelled",
+  "refunded"
+];
+var isSwapTerminal = (status) => SWAP_TERMINAL_STATUSES.includes(status);
+
+// src/lib/swap/swap.order-runner.ts
+var DEFAULT_POLL_MS = 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;
+async function runFusionOrder(deps, options) {
+  const {
+    orderHash,
+    secrets,
+    onStage,
+    pollIntervalMs = DEFAULT_POLL_MS,
+    timeoutMs = DEFAULT_TIMEOUT_MS
+  } = options;
+  const deadline = deps.now() + timeoutMs;
+  let failures = 0;
+  const published = /* @__PURE__ */ new Set();
+  onStage?.("swapping");
+  for (; ; ) {
+    if (deps.now() >= deadline) {
+      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 }
+      );
+    }
+    let ready;
+    try {
+      ready = await deps.readyForSecrets(orderHash);
+    } catch {
+      ready = {};
+    }
+    for (const fill of ready.fills ?? []) {
+      if (published.has(fill.idx)) continue;
+      const secret = secrets[fill.idx];
+      if (secret === void 0) {
+        throw new OwneyError(
+          "SWAP_REQUEST_FAILED",
+          `Swap needs a secret for fill ${fill.idx} that this session does not have. The order will refund once its timelock expires.`,
+          { orderHash, fillIndex: fill.idx }
+        );
+      }
+      try {
+        await deps.submitSecret(orderHash, secret);
+        published.add(fill.idx);
+      } catch {
+        failures += 1;
+      }
+    }
+    let status;
+    try {
+      ({ status } = await deps.orderStatus(orderHash));
+      failures = 0;
+    } catch {
+      failures += 1;
+      await deps.sleep(backoffFor(failures, pollIntervalMs));
+      continue;
+    }
+    if (status === "refunding") onStage?.("refunding");
+    if (isSwapTerminal(status)) {
+      if (status === "executed") {
+        onStage?.("swapped");
+        return { status, filled: true };
+      }
+      if (status === "refunded") onStage?.("refunded");
+      throw new OwneyError(
+        status === "refunded" ? "SWAP_ORDER_REFUNDED" : status === "cancelled" ? "SWAP_ORDER_CANCELLED" : "SWAP_ORDER_EXPIRED",
+        status === "refunded" ? "The swap did not complete and your funds have been returned." : "The swap did not complete in time. Your funds will be returned once the timelock expires.",
+        { 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;
+var storage2 = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+var keyFor = (orderHash) => `${KEY_PREFIX2}.${orderHash}`;
+function saveOrder(order) {
+  const store = storage2();
+  if (!store) return;
+  try {
+    store.setItem(keyFor(order.orderHash), JSON.stringify(order));
+  } catch {
+  }
+}
+function clearOrder(orderHash) {
+  const store = storage2();
+  if (!store) return;
+  try {
+    store.removeItem(keyFor(orderHash));
+  } catch {
+  }
+}
+function listOrders(now = Date.now()) {
+  const store = storage2();
+  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_PREFIX2}.`)) 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_MS) {
+          store.removeItem(key2);
+          continue;
+        }
+        if (Array.isArray(parsed.secrets) && parsed.secrets.length > 0) {
+          out.push(parsed);
+        }
+      } catch {
+        store.removeItem(key2);
+      }
+    }
+  } catch {
+    return out;
+  }
+  return out.sort((a, b) => b.createdAt - a.createdAt);
+}
+
+// src/lib/swap/swap.executor.ts
+var DEFAULT_SLIPPAGE = 1;
+async function affordableAmount(deps, quoted) {
+  const balance = await deps.readSourceBalance();
+  if (balance >= quoted) return quoted;
+  debugLog("owney-sdk", "swap: trimming to the current source balance", {
+    quoted: quoted.toString(),
+    balance: balance.toString(),
+    short: (quoted - balance).toString()
+  });
+  return balance;
+}
+async function executeSwap(deps, options) {
+  const { quote, walletAddress, onStage } = options;
+  debugLog("owney-sdk", "swap: start", {
+    rail: quote.rail,
+    from: `${quote.src.amount} ${quote.src.symbol} on ${quote.src.chainId}`,
+    to: `${quote.dst.symbol} on ${quote.dst.chainId}`,
+    expected: quote.dst.amount,
+    floor: quote.dstAmountMin
+  });
+  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 after = await deps.readTargetBalance();
+  const received = after - before;
+  debugLog("owney-sdk", "swap: target balance after", {
+    after: after.toString(),
+    received: received.toString()
+  });
+  if (received <= 0n) {
+    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 }
+    );
+  }
+  return { received: received.toString(), ...result };
+}
+async function runClassic(deps, options) {
+  const {
+    quote,
+    walletAddress,
+    slippage = DEFAULT_SLIPPAGE,
+    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));
+  onStage?.("quoting");
+  debugLog("owney-sdk", "swap: fetching classic calldata");
+  const { tx } = await deps.api.swapTx({
+    from: {
+      chainId: quote.src.chainId,
+      symbol: quote.src.symbol,
+      amount: amount.toString()
+    },
+    to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
+    walletAddress,
+    slippage,
+    ...direction ? { direction } : {}
+  });
+  const isNative = BigInt(tx.value ?? "0") > 0n;
+  if (!isNative) {
+    const needed = amount;
+    const current = await deps.readAllowance(tx.to);
+    debugLog("owney-sdk", "swap: allowance", {
+      spender: tx.to,
+      current: current.toString(),
+      needed: needed.toString()
+    });
+    if (current < needed) {
+      onStage?.("approving");
+      await deps.ensureChain(quote.src.chainId);
+      await deps.approve(tx.to, MAX_UINT256);
+    }
+  }
+  onStage?.("signing");
+  await deps.ensureChain(quote.src.chainId);
+  debugLog("owney-sdk", "swap: sending classic swap tx", { to: tx.to });
+  const txHash = await deps.sendTransaction({
+    to: tx.to,
+    data: tx.data,
+    value: tx.value ?? "0"
+  });
+  onStage?.("swapped");
+  return { txHash };
+}
+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));
+  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()
+    });
+    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");
+    }
+  }
+  const { secrets, secretHashes } = mintSecrets(quote.secretsCount ?? 1);
+  onStage?.("quoting");
+  debugLog("owney-sdk", "swap: building fusion order", {
+    secrets: secretHashes.length
+  });
+  const built = await deps.api.buildOrder({
+    from: {
+      chainId: quote.src.chainId,
+      symbol: quote.src.symbol,
+      // The trimmed amount — the order is re-quoted at this size server-side.
+      amount: amount.toString()
+    },
+    to: { chainId: quote.dst.chainId, symbol: quote.dst.symbol },
+    walletAddress,
+    secretHashes,
+    ...direction ? { direction } : {}
+  });
+  saveOrder({
+    orderHash: built.orderHash,
+    secrets,
+    srcChainId: quote.src.chainId,
+    srcSymbol: quote.src.symbol,
+    dstChainId: quote.dst.chainId,
+    dstSymbol: quote.dst.symbol,
+    amount: amount.toString(),
+    createdAt: Date.now()
+  });
+  debugLog("owney-sdk", "swap: order built", { orderHash: built.orderHash });
+  onStage?.("signing");
+  await deps.ensureChain(quote.src.chainId);
+  debugLog("owney-sdk", "swap: awaiting signature in wallet", {
+    signingOnChain: quote.src.chainId
+  });
+  const signature = await deps.signTypedData(built.typedData);
+  debugLog("owney-sdk", "swap: signed, submitting to relayer");
+  await deps.api.submitOrder({
+    srcChainId: quote.src.chainId,
+    // The ORDER STRUCT, not the typed-data envelope we just signed. Sending
+    // the envelope here gets a bare 500 from the relayer.
+    order: built.order,
+    signature,
+    quoteId: built.quoteId,
+    // Single-fill orders must NOT carry secretHashes — the relayer rejects
+    // them with SECRET_HASHES_NOT_REQUIRED. The one hash is already inside the
+    // order's hashlock, so repeating it here is redundant, and only a
+    // multi-fill order (a Merkle tree of hashes) needs them listed.
+    ...secretHashes.length > 1 ? { secretHashes } : {},
+    ...built.extension ? { extension: built.extension } : {}
+  });
+  debugLog("owney-sdk", "swap: order submitted, polling escrows");
+  try {
+    await runFusionOrder(deps.runner, {
+      orderHash: built.orderHash,
+      secrets,
+      ...onStage ? { onStage } : {}
+    });
+  } catch (error) {
+    if (error instanceof OwneyError && (error.code === "SWAP_ORDER_REFUNDED" || error.code === "SWAP_ORDER_CANCELLED")) {
+      clearOrder(built.orderHash);
+    }
+    throw error;
+  }
+  clearOrder(built.orderHash);
+  return { orderHash: built.orderHash };
+}
+
+// src/lib/swap/swap.arrival.ts
+var DEFAULT_TIMEOUT_MS2 = 18e4;
+var DEFAULT_POLL_MS2 = 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
+  } = 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)
+      });
+    }
+    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)
+          } : {}
+        }
+      );
+    }
+    await sleep(pollMs);
+  }
+}
+
 // src/lib/health-report.ts
 var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function reportAgentFailure(apiKey, agentType, errorCode, baseUrl = ROUTING_API_BASE_URL2) {
@@ -2232,7 +2880,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-var import_viem2 = require("viem");
+var import_viem5 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   const target = asset.toUpperCase();
   return agents.map((agent) => {
@@ -2241,7 +2889,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_viem2.parseUnits)(tokenBalance.amount, decimals) };
+    return { agent, balance: (0, import_viem5.parseUnits)(tokenBalance.amount, decimals) };
   });
 }
 function planProportionalShares(balances, requested, totalAvailable) {
@@ -2388,11 +3036,11 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem6 = require("viem");
+var import_viem8 = require("viem");
 var import_chains2 = require("viem/chains");
 
 // src/lib/transfer-auth.ts
-var import_viem3 = require("viem");
+var import_viem6 = 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" }] }
@@ -2424,7 +3072,7 @@ async function readTokenMeta(publicClient, token) {
 function randomAuthNonce() {
   const bytes = new Uint8Array(32);
   globalThis.crypto.getRandomValues(bytes);
-  return (0, import_viem3.bytesToHex)(bytes);
+  return (0, import_viem6.bytesToHex)(bytes);
 }
 
 // src/lib/sponsor-client.ts
@@ -2544,119 +3192,6 @@ async function getSponsorRelayerAddress(input) {
   return parsed.data.relayer;
 }
 
-// src/lib/permit2.ts
-var import_viem4 = require("viem");
-var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var MAX_UINT256 = 2n ** 256n - 1n;
-var ERC20_ALLOWANCE_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    stateMutability: "view",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "approve",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  }
-];
-function buildPermitTransferFromTypedData(input) {
-  return {
-    domain: {
-      name: "Permit2",
-      chainId: input.chainId,
-      verifyingContract: PERMIT2_ADDRESS
-    },
-    types: {
-      PermitTransferFrom: [
-        { name: "permitted", type: "TokenPermissions" },
-        { name: "spender", type: "address" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ],
-      TokenPermissions: [
-        { name: "token", type: "address" },
-        { name: "amount", type: "uint256" }
-      ]
-    },
-    primaryType: "PermitTransferFrom",
-    message: input.message
-  };
-}
-function randomPermit2Nonce() {
-  const bytes = new Uint8Array(32);
-  globalThis.crypto.getRandomValues(bytes);
-  return BigInt((0, import_viem4.bytesToHex)(bytes));
-}
-async function readPermit2Allowance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "allowance",
-    args: [owner, PERMIT2_ADDRESS]
-  });
-}
-async function readErc20Balance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "balanceOf",
-    args: [owner]
-  });
-}
-
-// src/lib/chain-guard.ts
-var CHAIN_NAMES = {
-  1: "Ethereum",
-  8453: "Base",
-  42161: "Arbitrum"
-};
-function chainName(chainId) {
-  return CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
-}
-async function ensureWalletOnChain(pub, wallet, expected) {
-  const actual = await pub.getChainId();
-  if (actual === expected) return;
-  try {
-    await wallet.switchChain({ id: expected });
-  } catch (error) {
-    throw new OwneyError(
-      "CHAIN_MISMATCH",
-      `Your wallet is on ${chainName(actual)}. Switch it to ${chainName(expected)} and try again.`,
-      {
-        expectedChainId: expected,
-        actualChainId: actual,
-        cause: error instanceof Error ? error.message : String(error)
-      }
-    );
-  }
-  const after = await pub.getChainId();
-  if (after !== expected) {
-    throw new OwneyError(
-      "CHAIN_MISMATCH",
-      `Your wallet is still on ${chainName(after)}. Switch it to ${chainName(expected)} and try again.`,
-      { expectedChainId: expected, actualChainId: after }
-    );
-  }
-}
-
 // src/lib/sponsored-deposit.ts
 var AUTH_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredDepositCallback(deps) {
@@ -2819,7 +3354,7 @@ function makeSponsoredWethCallback(deps) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-var import_viem5 = require("viem");
+var import_viem7 = require("viem");
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -2827,7 +3362,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[(0, import_viem5.toHex)(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[(0, import_viem7.toHex)(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -2861,8 +3396,8 @@ function makeSponsoredCallsCallback(deps) {
         { chainId }
       );
     }
-    const data = (0, import_viem5.encodeFunctionData)({
-      abi: import_viem5.erc20Abi,
+    const data = (0, import_viem7.encodeFunctionData)({
+      abi: import_viem7.erc20Abi,
       functionName: "transfer",
       args: [smartWallet, BigInt(amount)]
     });
@@ -2872,7 +3407,7 @@ function makeSponsoredCallsCallback(deps) {
         {
           version: "2.0.0",
           from: deps.ownerAddress,
-          chainId: (0, import_viem5.toHex)(chainId),
+          chainId: (0, import_viem7.toHex)(chainId),
           atomicRequired: false,
           calls: [{ to: token, value: "0x0", data }],
           capabilities: {
@@ -3094,14 +3629,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_viem6.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem8.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem6.custom)(provider)
+        transport: (0, import_viem8.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem8.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem6.custom)(provider)
+        transport: (0, import_viem8.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -3147,14 +3682,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_viem6.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem8.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem6.custom)(provider)
+        transport: (0, import_viem8.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem8.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem6.custom)(provider)
+        transport: (0, import_viem8.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -3185,12 +3720,10 @@ var OwneySDK = class {
       this.orgAgentConfigPromise = fetchOrgAgentConfig(
         this.apiKey,
         this.routingApiBaseUrl
-      ).then(
-        (config) => {
-          this.orgAgentConfig = config;
-          return config;
-        }
-      );
+      ).then((config) => {
+        this.orgAgentConfig = config;
+        return config;
+      });
     }
     return this.orgAgentConfigPromise;
   }
@@ -3709,6 +4242,330 @@ var OwneySDK = class {
     return eligible;
   }
   // --- Fund operations ---
+  // --- Swap to yield (ROUT-242) ---
+  /** Lazily built so an app that never swaps pays nothing for it. */
+  swapApiClient;
+  swapApi() {
+    this.swapApiClient ??= createSwapApi(
+      this.routingApiBaseUrl ?? ROUTING_API_BASE_URL,
+      this.apiKey
+    );
+    return this.swapApiClient;
+  }
+  /**
+   * Put the wallet on `chainId`, or fail with something actionable.
+   *
+   * Reuses the same guard the deposit rail uses, which re-reads the chain after
+   * switching — some wallets resolve wallet_switchEthereumChain before the
+   * network has actually changed.
+   */
+  async ensureSwapChain(chainId) {
+    const provider = this.requireConnectedProvider();
+    const state = this.requireState();
+    const chain = VIEM_CHAIN2[chainId];
+    if (!chain) {
+      throw new OwneyError(
+        "CHAIN_UNSUPPORTED",
+        `Chain ${chainId} is not supported`,
+        { chainId }
+      );
+    }
+    await ensureWalletOnChain(
+      (0, import_viem8.createPublicClient)({ chain, transport: (0, import_viem8.custom)(provider) }),
+      (0, import_viem8.createWalletClient)({
+        account: state.walletAddress,
+        chain,
+        transport: (0, import_viem8.custom)(provider)
+      }),
+      chainId
+    );
+  }
+  /**
+   * Binds the executor's abstract deps to this client's wallet.
+   *
+   * Kept as a builder rather than baked into the executor so the whole swap
+   * flow stays testable without a provider — the executor never imports viem.
+   */
+  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 wallet = (0, import_viem8.createWalletClient)({
+      account: state.walletAddress,
+      chain: srcChain,
+      transport: (0, import_viem8.custom)(provider)
+    });
+    const srcPublic = (0, import_viem8.createPublicClient)({
+      chain: srcChain,
+      transport: swapReadTransport(quote.src.chainId, this.zyfaiRpcUrls)
+    });
+    const dstPublic = (0, import_viem8.createPublicClient)({
+      chain: dstChain,
+      transport: swapReadTransport(quote.dst.chainId, this.zyfaiRpcUrls)
+    });
+    return {
+      api: this.swapApi(),
+      // Native-aware, like readSourceBalance below. Native ETH is never a
+      // DEPOSIT target, so this only ever mattered once withdrawal shipped —
+      // and there it is the headline case. balanceOf() on the 0xEeee sentinel
+      // reverts, which would have read as "the swap landed nothing".
+      readTargetBalance: async () => {
+        const dst = quote.dst.address;
+        if (dst.toLowerCase().startsWith("0xeeee")) {
+          return dstPublic.getBalance({ address: state.walletAddress });
+        }
+        return dstPublic.readContract({
+          address: dst,
+          abi: import_viem8.erc20Abi,
+          functionName: "balanceOf",
+          args: [state.walletAddress]
+        });
+      },
+      sendTransaction: async (tx) => {
+        const hash = await wallet.sendTransaction({
+          to: tx.to,
+          data: tx.data,
+          value: BigInt(tx.value || "0"),
+          account: state.walletAddress,
+          chain: srcChain
+        });
+        const receipt = await srcPublic.waitForTransactionReceipt({
+          timeout: receiptTimeoutMs(quote.src.chainId),
+          hash,
+          confirmations: 1
+        });
+        if (receipt.status !== "success") {
+          throw new OwneyError(
+            "SWAP_REQUEST_FAILED",
+            `Swap transaction reverted (tx ${hash})`,
+            { hash }
+          );
+        }
+        return hash;
+      },
+      signTypedData: (typedData) => wallet.signTypedData({
+        account: state.walletAddress,
+        ...typedData
+      }),
+      // Chain-bound like every other read here: the wallet provider's chain is
+      // not ours to rely on mid-swap.
+      readSourceBalance: async () => {
+        const src = quote.src.address;
+        if (src.toLowerCase().startsWith("0xeeee")) {
+          return srcPublic.getBalance({ address: state.walletAddress });
+        }
+        return srcPublic.readContract({
+          address: src,
+          abi: ERC20_ALLOWANCE_ABI,
+          functionName: "balanceOf",
+          args: [state.walletAddress]
+        });
+      },
+      readAllowance: (spender) => srcPublic.readContract({
+        address: quote.src.address,
+        abi: ERC20_ALLOWANCE_ABI,
+        functionName: "allowance",
+        args: [state.walletAddress, spender]
+      }),
+      approve: async (spender, amount) => {
+        const hash = await wallet.writeContract({
+          address: quote.src.address,
+          abi: ERC20_ALLOWANCE_ABI,
+          functionName: "approve",
+          args: [spender, amount],
+          account: state.walletAddress,
+          chain: srcChain
+        });
+        await srcPublic.waitForTransactionReceipt({
+          hash,
+          confirmations: 1,
+          timeout: receiptTimeoutMs(quote.src.chainId)
+        });
+        return hash;
+      },
+      ensureChain: (chainId) => this.ensureSwapChain(chainId),
+      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()
+      }
+    };
+  }
+  /**
+   * Assets the user may pay with, and what each chain deposits into.
+   *
+   * The source list is deliberately wider than the deposit list: it includes
+   * native ETH and USDT, which Owney never holds but users often do.
+   */
+  async getSwapTokens() {
+    return this.swapApi().listTokens();
+  }
+  /**
+   * Price a swap without committing to it.
+   *
+   * `dstAmountMin` is the number to validate against a deposit minimum —
+   * `dst.amount` is an estimate that a decaying auction or slippage can undercut,
+   * and a swap landing below the floor leaves the user swapped but not
+   * deposited.
+   */
+  async getSwapQuote(params) {
+    const state = this.requireState();
+    return this.swapApi().quote({
+      ...params,
+      walletAddress: state.walletAddress
+    });
+  }
+  /**
+   * Swap an asset the user holds into a deposit asset, then deposit it.
+   *
+   * Kept separate from `deposit()` rather than bolted on as an option: the
+   * return shape differs, the staging callback is meaningless on the plain
+   * path, and integrators who never swap should not have to reason about any
+   * of it.
+   *
+   * The deposit runs on the MEASURED arrival, not the quote. A quote is an
+   * estimate, so depositing the quoted figure would either strand dust or try
+   * to move funds that never came.
+   *
+   * Failure modes differ in a way callers must respect. A same-chain swap is
+   * atomic — if it fails, nothing moved. A cross-chain swap escrows the user's
+   * funds first, so SWAP_ORDER_EXPIRED / REFUNDED / CANCELLED all mean the
+   * money left the wallet. Only the former can honestly say "nothing has left
+   * your wallet".
+   */
+  async swapAndDeposit(options) {
+    const state = this.requireState();
+    const api = this.swapApi();
+    const quote = await api.quote({
+      from: options.from,
+      to: options.to,
+      walletAddress: state.walletAddress
+    });
+    await this.ensureSwapChain(quote.src.chainId);
+    const swap = await executeSwap(this.buildSwapDeps(quote), {
+      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 };
+  }
+  /**
+   * Withdraw from an agent and swap the proceeds into whatever the user wants
+   * to hold, delivered to their own wallet.
+   *
+   * The mirror of `swapAndDeposit()`, with one structural difference that
+   * drives the whole implementation: a deposit swap starts from funds already
+   * sitting in the wallet, but a withdrawal has to wait for them. The agent's
+   * provider acknowledges a withdrawal and *then* queues the on-chain transfer
+   * to the EOA, so `withdraw()` resolving means "accepted", not "arrived".
+   * Quoting before the tokens land would size the swap against a balance that
+   * is not there yet.
+   *
+   * The swap is therefore sized from the MEASURED arrival, exactly as the
+   * deposit path sizes its deposit from the measured swap output. On a full
+   * withdrawal there is no other number available — "MAX" has no figure until
+   * the agent picks one.
+   *
+   * **Failure here is not symmetrical with the deposit path.** A failed
+   * deposit-swap leaves the user holding what they started with. A failed
+   * withdrawal-swap leaves them holding the AGENT'S asset in their own wallet:
+   * the money is out, safe, and in the wrong denomination. Both
+   * `WITHDRAW_ARRIVAL_TIMEOUT` and `WITHDRAW_SWAP_FAILED` carry `withdrawn` for
+   * that reason — the UI has to tell the user where their money actually is,
+   * and must never present either as a lost withdrawal.
+   */
+  async withdrawAndSwap(options) {
+    const state = this.requireState();
+    const activeChainId = this.requireChainId();
+    if (options.from.chainId !== activeChainId) {
+      throw new OwneyError(
+        "CHAIN_MISMATCH",
+        `Cannot withdraw from chain ${options.from.chainId} while the active chain is ${activeChainId}. Activate on that chain first.`,
+        { requested: options.from.chainId, active: activeChainId }
+      );
+    }
+    const asset = SupportedAssets.find(
+      (a) => a.chainId === options.from.chainId && a.symbol === options.from.symbol.toUpperCase()
+    );
+    if (!asset) {
+      throw new OwneyError(
+        "WITHDRAW_NO_PERMITTED_TOKENS",
+        `${options.from.symbol} on chain ${options.from.chainId} is not an asset Owney holds`,
+        { ...options.from }
+      );
+    }
+    const srcChain = VIEM_CHAIN2[options.from.chainId];
+    const srcPublic = (0, import_viem8.createPublicClient)({
+      chain: srcChain,
+      transport: swapReadTransport(options.from.chainId, this.zyfaiRpcUrls)
+    });
+    const readWalletBalance = () => srcPublic.readContract({
+      address: asset.address,
+      abi: import_viem8.erc20Abi,
+      functionName: "balanceOf",
+      args: [state.walletAddress]
+    });
+    const baseline = await readWalletBalance();
+    debugLog("owney-sdk", "withdrawAndSwap: baseline", {
+      asset: `${asset.symbol}@${asset.chainId}`,
+      baseline: baseline.toString()
+    });
+    options.onSwapProgress?.("withdrawing");
+    const withdraw = await this.withdraw({
+      asset: options.from.symbol,
+      ...options.amount === void 0 ? {} : { amount: options.amount },
+      ...options.agentId ? { agentId: options.agentId } : {}
+    });
+    const arrived = await awaitWithdrawalArrival({
+      readBalance: readWalletBalance,
+      baseline,
+      ...options.arrivalTimeoutMs === void 0 ? {} : { timeoutMs: options.arrivalTimeoutMs }
+    });
+    const withdrawn = arrived.toString();
+    options.onSwapProgress?.("withdrawn");
+    try {
+      const quote = await this.swapApi().quote({
+        from: { ...options.from, amount: withdrawn },
+        to: options.to,
+        direction: "withdraw",
+        walletAddress: state.walletAddress
+      });
+      await this.ensureSwapChain(quote.src.chainId);
+      const swap = await executeSwap(this.buildSwapDeps(quote), {
+        quote,
+        walletAddress: state.walletAddress,
+        direction: "withdraw",
+        ...options.slippage === void 0 ? {} : { slippage: options.slippage },
+        ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {}
+      });
+      return { withdraw, withdrawn, swap };
+    } catch (error) {
+      throw new OwneyError(
+        "WITHDRAW_SWAP_FAILED",
+        `Withdrew ${withdrawn} ${asset.symbol} to your wallet, but the swap to ${options.to.symbol} did not complete. The funds are in your wallet as ${asset.symbol}.`,
+        {
+          withdrawn,
+          asset: asset.symbol,
+          chainId: asset.chainId,
+          intendedSymbol: options.to.symbol,
+          intendedChainId: options.to.chainId,
+          cause: error instanceof Error ? error.message : String(error),
+          ...error instanceof OwneyError ? { causeCode: error.code } : {}
+        }
+      );
+    }
+  }
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
    * Validates that the asset is supported by the target agent(s) on the active chain.
@@ -3879,7 +4736,11 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     if (agentId) {
       const agent = this.getAgent(agentId);
-      const result = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+      const result = await this.readAgent(
+        agent,
+        "balances",
+        () => agent.getBalances(state, chainId)
+      );
       return result;
     }
     let totalBalance = 0;
@@ -3887,7 +4748,11 @@ var OwneySDK = class {
     const entries = [...this.getActiveAgents().entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
-        const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+        const b = await this.readAgent(
+          agent,
+          "balances",
+          () => agent.getBalances(state, chainId)
+        );
         return [id, b];
       })
     );
@@ -3908,7 +4773,8 @@ var OwneySDK = class {
       const reason = settledResult.reason;
       agentFailures.push(reason);
       const retryDelay = rateLimitDelay(reason);
-      if (retryDelay !== void 0) agentRetryAt[agentId2] = Date.now() + retryDelay;
+      if (retryDelay !== void 0)
+        agentRetryAt[agentId2] = Date.now() + retryDelay;
       agentErrors[agentId2] = reason instanceof Error ? reason.message : String(reason);
     }
     if (successCount === 0) {
@@ -3935,14 +4801,22 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     if (agentId) {
       const agent = this.getAgent(agentId);
-      return this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
+      return this.readAgent(
+        agent,
+        "earnings",
+        () => agent.getEarnings(state, chainId)
+      );
     }
     let totalEarnings = 0;
     const results = {};
     const entries = [...this.getActiveAgents().entries()];
     const earningsResults = await Promise.all(
       entries.map(async ([id, agent]) => {
-        const e = await this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
+        const e = await this.readAgent(
+          agent,
+          "earnings",
+          () => agent.getEarnings(state, chainId)
+        );
         return [id, e];
       })
     );
@@ -4087,7 +4961,11 @@ var OwneySDK = class {
       ),
       Promise.all(
         entries.map(async ([id, agent]) => {
-          const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+          const b = await this.readAgent(
+            agent,
+            "balances",
+            () => agent.getBalances(state, chainId)
+          );
           return [id, balanceForApyScope(b, chainId, tokenSymbol)];
         })
       )
@@ -4147,7 +5025,12 @@ var OwneySDK = class {
     const { agentId, filters } = options ?? {};
     if (agentId) {
       const agent = this.getAgent(agentId);
-      return this.readAgent(agent, "history", () => agent.getHistory(state, chainId, filters), filters);
+      return this.readAgent(
+        agent,
+        "history",
+        () => agent.getHistory(state, chainId, filters),
+        filters
+      );
     }
     const activeAgents = [...this.getActiveAgents().values()];
     const cursorMap = filters?.cursor ? decodeMultiAgentCursor(filters.cursor) : {};
@@ -4204,13 +5087,21 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     if (agentId) {
       const agent = this.getAgent(agentId);
-      return this.readAgent(agent, "profile", () => agent.getUserProfile(state, chainId));
+      return this.readAgent(
+        agent,
+        "profile",
+        () => agent.getUserProfile(state, chainId)
+      );
     }
     const results = {};
     const entries = [...this.getActiveAgents().entries()];
     const profileResults = await Promise.all(
       entries.map(async ([id, agent]) => {
-        const p = await this.readAgent(agent, "profile", () => agent.getUserProfile(state, chainId));
+        const p = await this.readAgent(
+          agent,
+          "profile",
+          () => agent.getUserProfile(state, chainId)
+        );
         return [id, p];
       })
     );
@@ -4269,10 +5160,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem6.createWalletClient)({
+    const wallet = (0, import_viem8.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem6.custom)(provider)
+      transport: (0, import_viem8.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -4282,9 +5173,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem6.createPublicClient)({
+    const publicClient = (0, import_viem8.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem6.custom)(provider)
+      transport: (0, import_viem8.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -4318,13 +5209,23 @@ var OwneySDK = class {
     const agentOptions = { tokenSymbol, chainId };
     if (agentId) {
       const agent = this.getAgent(agentId);
-      return this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
+      return this.readAgent(
+        agent,
+        "agentApy",
+        () => agent.getAgentApy(days, agentOptions),
+        { days, ...agentOptions }
+      );
     }
     const results = {};
     const agentEntries = [...this.agents.entries()];
     const apyResults = await Promise.all(
       agentEntries.map(async ([id, agent]) => {
-        const apy = await this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
+        const apy = await this.readAgent(
+          agent,
+          "agentApy",
+          () => agent.getAgentApy(days, agentOptions),
+          { days, ...agentOptions }
+        );
         return [id, apy];
       })
     );
@@ -4351,7 +5252,11 @@ var OwneySDK = class {
     const entries = [...activeAgents.entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
-        const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+        const b = await this.readAgent(
+          agent,
+          "balances",
+          () => agent.getBalances(state, chainId)
+        );
         return [id, b.positions ?? []];
       })
     );
@@ -4396,13 +5301,13 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem7 = require("viem");
+var import_viem9 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX2 = "owney.siwx.session";
-var storage2 = () => {
+var KEY_PREFIX3 = "owney.siwx.session";
+var storage3 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -4410,8 +5315,8 @@ var storage2 = () => {
     return null;
   }
 };
-var buildKey2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}:`;
+var buildKey2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -4443,7 +5348,7 @@ var readLegacySiwxSession = (store, address) => {
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey2(address);
-  const store = storage2();
+  const store = storage3();
   let raw = null;
   try {
     raw = store?.getItem(key2) ?? null;
@@ -4473,7 +5378,7 @@ var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
   const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage2();
+  const store = storage3();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
@@ -4482,7 +5387,7 @@ var writeSiwxSession = (address, _chainId, session) => {
 var clearSiwxSession = (address, _chainId) => {
   const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage2();
+  const store = storage3();
   try {
     store?.removeItem(key2);
   } catch {
@@ -4523,7 +5428,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem7.getAddress)(accountAddress),
+          address: (0, import_viem9.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,
@@ -4601,9 +5506,9 @@ function buildSIWXConfig(deps) {
 }
 function createOwneySIWX(config) {
   const zyfai = new import_sdk2.ZyfaiSDK({ apiKey: config.apiKey });
-  const http2 = zyfai.httpClient;
+  const http4 = zyfai.httpClient;
   return buildSIWXConfig({
-    post: (url, data) => http2.post(url, data),
+    post: (url, data) => http4.post(url, data),
     referralSource: config.referralSource
   });
 }
@@ -4616,5 +5521,6 @@ function createOwneySIWX(config) {
   OwneyError,
   OwneySDK,
   createOwneySIWX,
+  listPendingSwaps,
   setOwneyDebug
 });