@owney/sdk 0.7.23-beta.1 → 0.7.24-beta.0

package/dist/index.js

@@ -664,6 +664,75 @@ function computeAllocationApy(positions) {
   const totalApy = totalValue > 0 ? String(weightedSum / totalValue) : "0";
   return { totalApy, apyByChainAndAsset };
 }
+function earningsForToken(bucket, chainId, asset) {
+  const tokens = bucket?.[String(chainId)];
+  if (!tokens) return null;
+  const wanted = asset.toUpperCase();
+  for (const [symbol, value] of Object.entries(tokens)) {
+    if (symbol.toUpperCase() !== wanted) continue;
+    const amount = Number(value);
+    return Number.isFinite(amount) ? amount : null;
+  }
+  return null;
+}
+function assetsInSnapshot(entry, chainId) {
+  const key2 = String(chainId);
+  const seen = /* @__PURE__ */ new Set();
+  for (const bucket of [
+    entry.daily_total_delta_by_token_withoutFee,
+    entry.daily_total_delta_by_token,
+    entry.lifetime_earnings_by_token,
+    entry.unrealized_earnings_by_token,
+    entry.current_earnings_by_token,
+    entry.total_earnings_by_token
+  ]) {
+    for (const symbol of Object.keys(bucket?.[key2] ?? {})) {
+      seen.add(symbol.toUpperCase());
+    }
+  }
+  return [...seen];
+}
+function netDeltaForSnapshot(entry, chainId, asset) {
+  const net = earningsForToken(
+    entry.daily_total_delta_by_token_withoutFee,
+    chainId,
+    asset
+  );
+  if (net !== null) return net;
+  const gross = earningsForToken(
+    entry.daily_total_delta_by_token,
+    chainId,
+    asset
+  );
+  if (gross === null) return 0;
+  if (!warnedGrossApyFallbacks.has("daily_earnings_delta_without_fee")) {
+    warnedGrossApyFallbacks.add("daily_earnings_delta_without_fee");
+    console.warn(
+      `[owney] @zyfai/sdk did not supply daily_total_delta_by_token_withoutFee; falling back to the gross daily delta, which does not deduct Zyfai's performance fee and so reads high.`
+    );
+  }
+  debugLog("zyfai:earnings", "gross fallback for daily earnings", { gross });
+  return gross;
+}
+function mapDailyEarnings(raw, chainId, tokenSymbol) {
+  const wanted = tokenSymbol?.toUpperCase();
+  const snapshots = [...raw.data ?? []].sort(
+    (a, b) => a.snapshot_date.localeCompare(b.snapshot_date)
+  );
+  const byAsset = /* @__PURE__ */ new Map();
+  for (const entry of snapshots) {
+    for (const asset of assetsInSnapshot(entry, chainId)) {
+      if (wanted && asset !== wanted) continue;
+      const delta = netDeltaForSnapshot(entry, chainId, asset);
+      const series = byAsset.get(asset) ?? { points: [], total: 0 };
+      series.total += delta;
+      series.points.push({ date: entry.snapshot_date, amount: series.total });
+      byAsset.set(asset, series);
+    }
+  }
+  const assets = [...byAsset.entries()].map(([asset, series]) => ({ asset, points: series.points })).sort((a, b) => a.asset.localeCompare(b.asset));
+  return { walletAddress: raw.walletAddress, chainId, assets };
+}
 
 // src/agents/zyfai/zyfai.withdraw-amount.ts
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
@@ -1910,6 +1979,15 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
     return mapApyHistory(raw, chainId, tokenSymbol);
   }
+  async getDailyEarnings(state, chainId, days, tokenSymbol) {
+    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
+    const start = new Date(Date.now() - (DayFilterMapping[days] + 1) * 864e5);
+    const raw = await this.sdk.getDailyEarnings(
+      smartWallet,
+      start.toISOString().slice(0, 10)
+    );
+    return mapDailyEarnings(raw, chainId, tokenSymbol);
+  }
   /**
    * Owney speaks asset symbols ("USDC" / "WETH"); Zyfai's history endpoint
    * takes lowercase `assetType` and denominates WETH as "eth" (the same
@@ -2087,597 +2165,6 @@ 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
-      }
-    }),
-    /** 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
-      }
-    }),
-    /**
-     * 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.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
-import { fallback, http as http2 } from "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 http2(override);
-  const urls = DEFAULT_RPC_URLS[chainId];
-  if (!urls || urls.length === 0) return http2();
-  return fallback(urls.map((url) => http2(url)));
-}
-function receiptTimeoutMs(chainId) {
-  return chainId === 1 ? 6e5 : 18e4;
-}
-
-// src/lib/permit2.ts
-import { bytesToHex } from "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(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
-import { keccak256, toHex } from "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 = toHex(randomBytes(SECRET_BYTES));
-    secrets.push(secret);
-    secretHashes.push(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,
-    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
-  });
-  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, 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
-  });
-  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/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) {
@@ -2871,13 +2358,12 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 import {
   createPublicClient as createPublicClient2,
   createWalletClient,
-  custom,
-  erc20Abi as erc20Abi2
+  custom
 } from "viem";
 import { base as base2, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
 
 // src/lib/transfer-auth.ts
-import { bytesToHex as bytesToHex2 } from "viem";
+import { bytesToHex } from "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" }] }
@@ -2909,7 +2395,7 @@ async function readTokenMeta(publicClient, token) {
 function randomAuthNonce() {
   const bytes = new Uint8Array(32);
   globalThis.crypto.getRandomValues(bytes);
-  return bytesToHex2(bytes);
+  return bytesToHex(bytes);
 }
 
 // src/lib/sponsor-client.ts
@@ -3029,6 +2515,119 @@ async function getSponsorRelayerAddress(input) {
   return parsed.data.relayer;
 }
 
+// src/lib/permit2.ts
+import { bytesToHex as bytesToHex2 } from "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(bytesToHex2(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) {
@@ -3191,7 +2790,7 @@ function makeSponsoredWethCallback(deps) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData, erc20Abi, toHex as toHex2 } from "viem";
+import { encodeFunctionData, erc20Abi, toHex } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -3199,7 +2798,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[toHex2(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[toHex(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -3244,7 +2843,7 @@ function makeSponsoredCallsCallback(deps) {
         {
           version: "2.0.0",
           from: deps.ownerAddress,
-          chainId: toHex2(chainId),
+          chainId: toHex(chainId),
           atomicRequired: false,
           calls: [{ to: token, value: "0x0", data }],
           capabilities: {
@@ -4081,211 +3680,6 @@ 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(
-      createPublicClient2({ chain, transport: custom(provider) }),
-      createWalletClient({
-        account: state.walletAddress,
-        chain,
-        transport: 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 = createWalletClient({
-      account: state.walletAddress,
-      chain: srcChain,
-      transport: custom(provider)
-    });
-    const srcPublic = createPublicClient2({
-      chain: srcChain,
-      transport: swapReadTransport(quote.src.chainId, this.zyfaiRpcUrls)
-    });
-    const dstPublic = createPublicClient2({
-      chain: dstChain,
-      transport: swapReadTransport(quote.dst.chainId, this.zyfaiRpcUrls)
-    });
-    return {
-      api: this.swapApi(),
-      readTargetBalance: () => dstPublic.readContract({
-        address: quote.dst.address,
-        abi: erc20Abi2,
-        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 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.
@@ -4566,6 +3960,72 @@ var OwneySDK = class {
    * @param options.days - Lookback period: "7D", "14D", or "30D"
    * @returns {AccountAgentApy} for a single agent, or {OwneyAccountApy} with totalApy and per-agent breakdown
    */
+  /**
+   * Daily cumulative NET earnings for the selected chain/asset, backing the
+   * "recent earnings" subline. Net is computed as Zyfai's own
+   * `lifetime + unrealized + current x 0.9`, so the figure reconciles with the
+   * balance headline rather than reading ~11% high. (ROUT-452)
+   *
+   * Unlike getAccountApy this does NOT blend across agents: earnings are
+   * summed, not weighted, and an agent that fails to report must not silently
+   * subtract from the total. Without an agentId the series is the sum of the
+   * agents that answered.
+   */
+  async getDailyEarnings({
+    agentId,
+    days,
+    tokenSymbol
+  }) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      const agent = this.getAgent(agentId);
+      if (!agent.getDailyEarnings) {
+        return {
+          walletAddress: state.walletAddress ?? "",
+          chainId,
+          assets: []
+        };
+      }
+      return this.readAgent(
+        agent,
+        "dailyEarnings",
+        () => agent.getDailyEarnings(state, chainId, days, tokenSymbol),
+        { days, tokenSymbol }
+      );
+    }
+    const entries = [...this.getActiveAgents().entries()].filter(
+      ([, agent]) => agent.getDailyEarnings
+    );
+    const series = await Promise.all(
+      entries.map(
+        ([, agent]) => this.readAgent(
+          agent,
+          "dailyEarnings",
+          () => agent.getDailyEarnings(state, chainId, days, tokenSymbol),
+          { days, tokenSymbol }
+        )
+      )
+    );
+    const byAsset = /* @__PURE__ */ new Map();
+    for (const s of series) {
+      for (const { asset, points } of s.assets) {
+        const byDate = byAsset.get(asset) ?? /* @__PURE__ */ new Map();
+        for (const point of points) {
+          byDate.set(point.date, (byDate.get(point.date) ?? 0) + point.amount);
+        }
+        byAsset.set(asset, byDate);
+      }
+    }
+    return {
+      walletAddress: series[0]?.walletAddress ?? state.walletAddress ?? "",
+      chainId,
+      assets: [...byAsset.entries()].map(([asset, byDate]) => ({
+        asset,
+        points: [...byDate.entries()].map(([date, amount]) => ({ date, amount })).sort((a, b) => a.date.localeCompare(b.date))
+      })).sort((a, b) => a.asset.localeCompare(b.asset))
+    };
+  }
   async getAccountApy({
     agentId,
     days,
@@ -4912,8 +4372,8 @@ import { SiweMessage } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX3 = "owney.siwx.session";
-var storage3 = () => {
+var KEY_PREFIX2 = "owney.siwx.session";
+var storage2 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -4921,8 +4381,8 @@ var storage3 = () => {
     return null;
   }
 };
-var buildKey2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}:`;
+var buildKey2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -4954,7 +4414,7 @@ var readLegacySiwxSession = (store, address) => {
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey2(address);
-  const store = storage3();
+  const store = storage2();
   let raw = null;
   try {
     raw = store?.getItem(key2) ?? null;
@@ -4984,7 +4444,7 @@ var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
   const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage3();
+  const store = storage2();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
@@ -4993,7 +4453,7 @@ var writeSiwxSession = (address, _chainId, session) => {
 var clearSiwxSession = (address, _chainId) => {
   const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage3();
+  const store = storage2();
   try {
     store?.removeItem(key2);
   } catch {
@@ -5112,9 +4572,9 @@ function buildSIWXConfig(deps) {
 }
 function createOwneySIWX(config) {
   const zyfai = new ZyfaiSDK2({ apiKey: config.apiKey });
-  const http4 = zyfai.httpClient;
+  const http2 = zyfai.httpClient;
   return buildSIWXConfig({
-    post: (url, data) => http4.post(url, data),
+    post: (url, data) => http2.post(url, data),
     referralSource: config.referralSource
   });
 }
@@ -5126,6 +4586,5 @@ export {
   OwneyError,
   OwneySDK,
   createOwneySIWX,
-  listOrders as listPendingSwaps,
   setOwneyDebug
 };