@owney/sdk 0.7.22-beta.1 → 0.7.23

package/dist/index.cjs

@@ -3,1317 +3,19 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/errors.ts
-var OwneyError, AgentNotFoundError, NotConnectedError, AgentChainIncompatibleError;
-var init_errors = __esm({
-  "src/errors.ts"() {
-    "use strict";
-    OwneyError = class extends Error {
-      code;
-      details;
-      agentId;
-      constructor(code, message, details, agentId) {
-        const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
-        super(`${prefix} ${message}`);
-        this.name = "OwneyError";
-        this.code = code;
-        this.details = details;
-        this.agentId = agentId;
-      }
-    };
-    AgentNotFoundError = class extends OwneyError {
-      constructor(agentId, available) {
-        super(
-          "AGENT_NOT_FOUND",
-          `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
-          { agentId, available },
-          agentId
-        );
-        this.name = "AgentNotFoundError";
-      }
-    };
-    NotConnectedError = class extends OwneyError {
-      constructor() {
-        super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
-        this.name = "NotConnectedError";
-      }
-    };
-    AgentChainIncompatibleError = class extends OwneyError {
-      incompatibleAgents;
-      connectedChainId;
-      constructor(incompatibleAgents, connectedChainId) {
-        const details = incompatibleAgents.map(
-          ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
-        ).join("; ");
-        super(
-          "AGENT_CHAIN_INCOMPATIBLE",
-          `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
-          { incompatibleAgents, connectedChainId }
-        );
-        this.name = "AgentChainIncompatibleError";
-        this.incompatibleAgents = incompatibleAgents;
-        this.connectedChainId = connectedChainId;
-      }
-    };
-  }
-});
-
-// src/lib/debug.ts
-function setOwneyDebug(enabled) {
-  configuredDebug = enabled;
-}
-function isOwneyDebug() {
-  return globalThis.__OWNEY_DEBUG__ === true || configuredDebug;
-}
-function debugLog(scope, message, data) {
-  if (!isOwneyDebug()) return;
-  if (data === void 0) {
-    console.log(`[${scope}] ${message}`);
-  } else {
-    console.log(`[${scope}] ${message}`, data);
-  }
-}
-var configuredDebug;
-var init_debug = __esm({
-  "src/lib/debug.ts"() {
-    "use strict";
-    configuredDebug = false;
-  }
-});
-
-// src/lib/routing-api.ts
-async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL) {
-  const url = `${baseUrl}/api/v1/agent/org-config`;
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "x-owney-api-key": `${apiKey}`
-      }
-    });
-    if (!res.ok) {
-      if (res.status !== 404) {
-        console.warn(
-          `[owney-sdk] Could not read org agent config (${res.status}); leaving user profiles unchanged.`
-        );
-      }
-      return null;
-    }
-    const json = await res.json();
-    const policy = json.success ? json.data ?? null : null;
-    debugLog(
-      "owney-sdk",
-      policy ? "org agent config: loaded" : "org agent config: none set by this partner \u2014 user profiles will be left as they are",
-      policy ?? void 0
-    );
-    return policy;
-  } catch (error) {
-    console.warn(
-      "[owney-sdk] Could not read org agent config (non-fatal):",
-      error instanceof Error ? error.message : String(error)
-    );
-    return null;
-  }
-}
-async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL) {
-  const url = `${baseUrl}/api/v1/agent/keys`;
-  const res = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      "x-owney-api-key": `${apiKey}`
-    }
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new OwneyError(
-      "API_ROUTING_ERROR",
-      `Routing API error ${res.status}: ${text}`,
-      { statusCode: res.status, responseBody: text }
-    );
-  }
-  const json = await res.json();
-  if (!json.success) {
-    throw new OwneyError(
-      "API_ROUTING_FAILED",
-      `Routing API request failed: ${json.message}`,
-      { message: json.message }
-    );
-  }
-  return json.data;
-}
-var ROUTING_API_BASE_URL;
-var init_routing_api = __esm({
-  "src/lib/routing-api.ts"() {
-    "use strict";
-    init_errors();
-    init_debug();
-    ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
-  }
-});
-
-// src/lib/transfer-auth.ts
-function buildTransferWithAuthorizationTypedData(input) {
-  return {
-    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
-    types: {
-      TransferWithAuthorization: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "validAfter", type: "uint256" },
-        { name: "validBefore", type: "uint256" },
-        { name: "nonce", type: "bytes32" }
-      ]
-    },
-    primaryType: "TransferWithAuthorization",
-    message: input.message
-  };
-}
-async function readTokenMeta(publicClient, token) {
-  const [tokenName, tokenVersion] = await Promise.all([
-    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "name" }),
-    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
-  ]);
-  return { tokenName, tokenVersion };
-}
-function randomAuthNonce() {
-  const bytes = new Uint8Array(32);
-  globalThis.crypto.getRandomValues(bytes);
-  return (0, import_viem3.bytesToHex)(bytes);
-}
-function buildPermitTypedData(input) {
-  return {
-    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
-    types: {
-      Permit: [
-        { name: "owner", type: "address" },
-        { name: "spender", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ]
-    },
-    primaryType: "Permit",
-    message: input.message
-  };
-}
-var import_viem3, ERC20_META_ABI;
-var init_transfer_auth = __esm({
-  "src/lib/transfer-auth.ts"() {
-    "use strict";
-    import_viem3 = require("viem");
-    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" }] }
-    ];
-  }
-});
-
-// src/agents/surfliquid/surfliquid.constants.ts
-var SURFLIQUID_CHAIN_ID, SURFLIQUID_CHAIN_NAME, SURFLIQUID_USDC_ADDRESS, SURFLIQUID_PERMIT_CAP, SURFLIQUID_PERMIT_TTL_SECONDS, SURFLIQUID_MIN_DEPOSIT, SURFLIQUID_SUPPORTED_ASSETS, SURFLIQUID_ACTION_MAP;
-var init_surfliquid_constants = __esm({
-  "src/agents/surfliquid/surfliquid.constants.ts"() {
-    "use strict";
-    SURFLIQUID_CHAIN_ID = 8453;
-    SURFLIQUID_CHAIN_NAME = "BASE";
-    SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-    SURFLIQUID_PERMIT_CAP = 10000000000n;
-    SURFLIQUID_PERMIT_TTL_SECONDS = 3600n;
-    SURFLIQUID_MIN_DEPOSIT = "0";
-    SURFLIQUID_SUPPORTED_ASSETS = [
-      {
-        chainId: SURFLIQUID_CHAIN_ID,
-        chain: SURFLIQUID_CHAIN_NAME,
-        assets: [{ symbol: "USDC", minDepositAmount: SURFLIQUID_MIN_DEPOSIT }]
-      }
-    ];
-    SURFLIQUID_ACTION_MAP = {
-      // INITIAL_DEPOSIT is the user's real first deposit, so surface it like any
-      // other funding ("Top up"). The mini-app intentionally hides the "Deposit"
-      // action (it marks Zyfai's smart-account-creation event), which would
-      // otherwise drop a SurfLiquid user's only history row.
-      INITIAL_DEPOSIT: "Top up",
-      DEPOSIT: "Top up",
-      USER_DEPOSIT: "Top up",
-      WITHDRAWAL: "Withdraw",
-      USER_WITHDRAWAL: "Withdraw",
-      REBALANCE: "Rebalance",
-      REBALANCE_COMPLETED: "Rebalance",
-      CROSS_CHAIN_REBALANCE: "Rebalance",
-      MERKL_CLAIM: "Earned"
-    };
-  }
-});
-
-// src/agents/surfliquid/surfliquid.session-store.ts
-var KEY_PREFIX2, EXPIRY_SKEW_MS, memorySessions2, storage2, buildKey2, isFresh, readSurfSession, writeSurfSession, clearSurfSession;
-var init_surfliquid_session_store = __esm({
-  "src/agents/surfliquid/surfliquid.session-store.ts"() {
-    "use strict";
-    KEY_PREFIX2 = "owney.surfliquid.session";
-    EXPIRY_SKEW_MS = 3e4;
-    memorySessions2 = /* @__PURE__ */ new Map();
-    storage2 = () => {
-      if (typeof window === "undefined") return null;
-      try {
-        return window.localStorage;
-      } catch {
-        return null;
-      }
-    };
-    buildKey2 = (apiKey, wallet) => `${KEY_PREFIX2}:${apiKey}:${wallet.toLowerCase()}`;
-    isFresh = (session) => {
-      if (!session?.token) return false;
-      if (!session.expiresAt) return true;
-      const expiresAt = Date.parse(session.expiresAt);
-      if (Number.isNaN(expiresAt)) return true;
-      return Date.now() < expiresAt - EXPIRY_SKEW_MS;
-    };
-    readSurfSession = (apiKey, wallet) => {
-      const key2 = buildKey2(apiKey, wallet);
-      let raw = null;
-      try {
-        raw = storage2()?.getItem(key2) ?? null;
-      } catch {
-        raw = null;
-      }
-      if (raw) {
-        try {
-          const parsed = JSON.parse(raw);
-          if (isFresh(parsed)) return parsed;
-        } catch {
-        }
-        clearSurfSession(apiKey, wallet);
-        return null;
-      }
-      const cached = memorySessions2.get(key2);
-      if (isFresh(cached)) return cached;
-      if (cached) memorySessions2.delete(key2);
-      return null;
-    };
-    writeSurfSession = (apiKey, wallet, session) => {
-      const key2 = buildKey2(apiKey, wallet);
-      memorySessions2.set(key2, session);
-      try {
-        storage2()?.setItem(key2, JSON.stringify(session));
-      } catch {
-      }
-    };
-    clearSurfSession = (apiKey, wallet) => {
-      const key2 = buildKey2(apiKey, wallet);
-      memorySessions2.delete(key2);
-      try {
-        storage2()?.removeItem(key2);
-      } catch {
-      }
-    };
-  }
-});
-
-// src/agents/surfliquid/surfliquid.broker.ts
-function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-function normalizeVault(json) {
-  const root = asRecord(json);
-  const data = asRecord(root.data);
-  const vault = asRecord(root.vault ?? data.vault ?? root.data ?? root);
-  const userVaultAddress = vault.userVaultAddress ?? null;
-  return {
-    userVaultAddress,
-    deploymentSalt: vault.deploymentSalt ?? null,
-    exists: Boolean(userVaultAddress),
-    walletAddress: vault.walletAddress ?? null,
-    homeChainId: vault.homeChainId ?? null,
-    vaultVersion: vault.vaultVersion ?? null,
-    isActive: vault.isActive,
-    totalValueUSD: vault.totalValueUSD ?? null,
-    totalDepositedUSD: vault.totalDepositedUSD ?? null,
-    earned: vault.earned ?? null,
-    apyBreakdown: vault.apyBreakdown ?? null,
-    league: vault.league ?? null,
-    assets: vault.assets ?? [],
-    chainAddresses: vault.chainAddresses ?? []
-  };
-}
-function normalizeSupportedAssets(json, chainId) {
-  const root = asRecord(json);
-  const data = asRecord(root.data);
-  const vault = asRecord(root.vault ?? data.vault ?? root.data ?? root);
-  const source = vault.assets ?? vault.defaultAssets ?? root.defaultAssets ?? data.defaultAssets ?? [];
-  const assets = source.map((asset) => ({
-    assetAddress: asset.assetAddress,
-    assetSymbol: asset.assetSymbol,
-    assetDecimals: asset.assetDecimals,
-    chainId: asset.chainId,
-    chainStatus: asset.chainStatus,
-    currentAPY: asset.currentAPY,
-    nativeAPY: asset.nativeAPY,
-    merklAPY: asset.merklAPY,
-    leagueAPY: asset.leagueAPY,
-    apy7d: asset.apy7d ?? null,
-    apy14d: asset.apy14d ?? null,
-    apy30d: asset.apy30d ?? null
-  }));
-  return chainId === void 0 ? assets : assets.filter((asset) => asset.chainId === chainId);
-}
-function createSurfBroker(options) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const now = options.now ?? Date.now;
-  const base5 = `${options.routingApiBaseUrl.replace(/\/$/, "")}/api/v1/surf`;
-  const wallet = options.walletAddress;
-  let session = readSurfSession(options.apiKey, wallet);
-  const vaultMemo = /* @__PURE__ */ new Map();
-  const storeSession = (next) => {
-    session = next;
-    writeSurfSession(options.apiKey, wallet, next);
-  };
-  const dropSession = () => {
-    session = null;
-    clearSurfSession(options.apiKey, wallet);
-  };
-  async function call2(method, path, body, isAuthCall = false) {
-    const headers = { "x-owney-api-key": options.apiKey };
-    if (session?.token) headers[SURF_SESSION_HEADER] = session.token;
-    if (body !== void 0) headers["content-type"] = "application/json";
-    if (options.origin) headers["origin"] = options.origin;
-    let response;
-    try {
-      response = await fetchImpl(`${base5}${path}`, {
-        method,
-        headers,
-        body: body === void 0 ? void 0 : JSON.stringify(body),
-        signal: AbortSignal.timeout(SURF_BROKER_TIMEOUT_MS)
-      });
-    } catch (error) {
-      throw unavailable(
-        `SurfLiquid broker unreachable: ${error instanceof Error ? error.message : String(error)}`,
-        { path }
-      );
-    }
-    const rotated = response.headers.get(SURF_SESSION_HEADER);
-    if (rotated && rotated !== session?.token) {
-      storeSession({ token: rotated, expiresAt: session?.expiresAt ?? null });
-    }
-    if (response.status === 401 && !isAuthCall) {
-      dropSession();
-      throw new SurfSessionExpiredError();
-    }
-    const text = await response.text();
-    const json = parseJson(text);
-    if (!response.ok) {
-      throw unavailable(`SurfLiquid broker responded ${response.status} on ${path}`, {
-        status: response.status,
-        body: json ?? text
-      });
-    }
-    return json;
-  }
-  const sessionFrom = (json) => {
-    const body = asRecord(json);
-    if (typeof body.token !== "string") throw unavailable("SurfLiquid login returned no session token");
-    const next = { token: body.token, expiresAt: typeof body.expiresAt === "string" ? body.expiresAt : null };
-    storeSession(next);
-    return next;
-  };
-  return {
-    hasSession: () => session !== null,
-    clearSession: dropSession,
-    nonce: async () => {
-      const json = await call2("POST", "/auth/nonce", { walletAddress: wallet }, true);
-      const message = json?.data?.message;
-      if (typeof message !== "string") throw unavailable("SurfLiquid nonce response had no message");
-      return message;
-    },
-    login: async (message, signature) => sessionFrom(await call2("POST", "/auth/login", { walletAddress: wallet, message, signature }, true)),
-    getVault: (walletAddress) => {
-      const key2 = walletAddress.toLowerCase();
-      const hit = vaultMemo.get(key2);
-      if (hit && now() - hit.at < VAULT_MEMO_TTL_MS) return hit.value;
-      const query = new URLSearchParams({ walletAddress });
-      const value = (async () => normalizeVault(await call2("GET", `/vault?${query.toString()}`)))();
-      vaultMemo.set(key2, { at: now(), value });
-      value.catch(() => vaultMemo.delete(key2));
-      return value;
-    },
-    invalidateVault: () => vaultMemo.clear(),
-    prepare: async (homeChainId) => {
-      const json = asRecord(await call2("POST", "/vault/prepare", { homeChainId }));
-      const prepared = asRecord(json.data ?? json);
-      if (typeof prepared.salt !== "string") throw unavailable("SurfLiquid prepare returned no salt");
-      return { salt: prepared.salt };
-    },
-    confirm: async (input) => {
-      await call2("POST", "/vault/confirm", input);
-      vaultMemo.clear();
-    },
-    getBestVault: async (assetSymbol) => {
-      const json = await call2("GET", `/vaults/best?assetSymbol=${encodeURIComponent(assetSymbol)}`);
-      const root = asRecord(json);
-      const list = root.vaults ?? root.data ?? json;
-      return Array.isArray(list) ? list : [];
-    },
-    getAgentMessages: async (walletAddress, page, limit, fromDate, toDate) => {
-      const query = new URLSearchParams({ walletAddress, page: String(page), limit: String(limit) });
-      if (fromDate) query.set("from", fromDate);
-      if (toDate) query.set("to", toDate);
-      const json = asRecord(await call2("GET", `/agent-messages?${query.toString()}`));
-      const data = asRecord(json.data ?? json);
-      return {
-        page: data.page ?? page,
-        limit: data.limit ?? limit,
-        total: data.total ?? 0,
-        pages: data.pages ?? 1,
-        messages: data.messages ?? []
-      };
-    },
-    getSupportedAssets: async (chainId) => normalizeSupportedAssets(
-      await call2("GET", `/vault?${new URLSearchParams({ walletAddress: DISCOVERY_WALLET }).toString()}`),
-      chainId
-    )
-  };
-}
-var SURF_SESSION_HEADER, SURF_BROKER_TIMEOUT_MS, VAULT_MEMO_TTL_MS, AGENT_ID, DISCOVERY_WALLET, SurfSessionExpiredError, asRecord, unavailable;
-var init_surfliquid_broker = __esm({
-  "src/agents/surfliquid/surfliquid.broker.ts"() {
-    "use strict";
-    init_errors();
-    init_surfliquid_session_store();
-    SURF_SESSION_HEADER = "x-surf-session";
-    SURF_BROKER_TIMEOUT_MS = 7e4;
-    VAULT_MEMO_TTL_MS = 1e4;
-    AGENT_ID = "surfliquid";
-    DISCOVERY_WALLET = "0x";
-    SurfSessionExpiredError = class extends Error {
-      constructor() {
-        super("SurfLiquid session expired");
-        this.name = "SurfSessionExpiredError";
-      }
-    };
-    asRecord = (value) => value && typeof value === "object" ? value : {};
-    unavailable = (message, details) => new OwneyError("SURF_UNAVAILABLE", message, details, AGENT_ID);
-  }
-});
-
-// src/agents/surfliquid/surfliquid.mapper.ts
-function mapMessage(message) {
-  const action = SURFLIQUID_ACTION_MAP[message.transactionType];
-  if (!action) return null;
-  return {
-    agent: "surfliquid",
-    action,
-    date: message.timestamp,
-    oldApy: message.apyBefore != null ? String(message.apyBefore) : null,
-    newApy: message.apyAfter != null ? String(message.apyAfter) : null,
-    transactions: [
-      {
-        txHashes: [message.txHash],
-        chainId: message.chainId,
-        tokenSymbol: message.token ?? void 0,
-        amount: message.amount != null ? String(message.amount) : void 0
-      }
-    ],
-    rebalanceLog: []
-  };
-}
-function mapHistory(result, _chainId) {
-  const data = result.messages.map(mapMessage).filter((entry) => entry !== null);
-  const hasMore = result.page < result.pages;
-  return {
-    data,
-    hasMore,
-    nextCursor: hasMore ? String(result.page + 1) : void 0
-  };
-}
-function mapBalances2(vault, chainId, morphoStats) {
-  const assets = (vault.assets ?? []).filter(
-    (asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId
-  );
-  const tokens = assets.map((asset) => ({
-    chain: SURFLIQUID_CHAIN_NAME,
-    chainId: SURFLIQUID_CHAIN_ID,
-    asset: "USDC",
-    amount: String(asset.currentValueUSD)
-  }));
-  const positions = assets.map((asset) => {
-    const stats = morphoStats?.get(asset.morphoVaultAddress?.toLowerCase() ?? "");
-    return {
-      chain: SURFLIQUID_CHAIN_NAME,
-      protocol: "Morpho",
-      // The specific MetaMorpho vault (e.g. "Gauntlet USDC Frontier"), read from
-      // Morpho — renders as "Morpho <vault>" alongside zyfai's vault detail.
-      pool: stats?.name ?? void 0,
-      asset: "USDC",
-      amount: String(asset.currentValueUSD),
-      apy: asset.currentAPY,
-      // TVL + liquidity come straight from Morpho (SurfLiquid's API omits them).
-      tvl: stats?.tvlUsd,
-      liquidity: stats?.liquidityUsd
-    };
-  });
-  const total = assets.reduce(
-    (sum, asset) => sum + asset.currentValueUSD,
-    0
-  );
-  return {
-    smartWallet: vault.userVaultAddress ?? void 0,
-    totalBalance: String(total),
-    totalBalanceAsset: "usdc",
-    tokens,
-    positions
-  };
-}
-function mapAccountApy(vault, days) {
-  const breakdown = vault.apyBreakdown;
-  const windowed = breakdown ? breakdown[APY_WINDOW_KEY[days]] : void 0;
-  const apy = windowed != null ? windowed : breakdown?.currentAPY ?? 0;
-  return {
-    walletAddress: vault.walletAddress ?? "",
-    weightedApyAfterFee: apy,
-    apyByChainAndAsset: { [SURFLIQUID_CHAIN_ID]: { USDC: apy } },
-    // Parity with Sail: SurfLiquid's core-sdk exposes no daily net-APY series.
-    history: []
-  };
-}
-function mapEarnings2(vault, vaultAddress) {
-  return {
-    smartWallet: vaultAddress,
-    lifetimeEarnings: vault.earned?.totalEarningsUSD ?? 0,
-    tokens: []
-  };
-}
-function mapUserProfile2(vault, address) {
-  return {
-    address,
-    smartWallet: vault.userVaultAddress ?? "",
-    chains: [SURFLIQUID_CHAIN_ID],
-    // SurfLiquid uses cookie-based session auth — no session-key concept.
-    hasActiveSessionKey: false,
-    protocols: ["SurfLiquid"]
-  };
-}
-var APY_WINDOW_KEY;
-var init_surfliquid_mapper = __esm({
-  "src/agents/surfliquid/surfliquid.mapper.ts"() {
-    "use strict";
-    init_surfliquid_constants();
-    APY_WINDOW_KEY = {
-      "7D": "apy7d",
-      "14D": "apy14d",
-      "30D": "apy30d"
-    };
-  }
-});
-
-// src/agents/surfliquid/surfliquid.contracts.ts
-var import_viem6, SURFLIQUID_FACTORY_ADDRESS, SURFLIQUID_FACTORY_ABI, SURFLIQUID_VAULT_ABI, USDC_ABI;
-var init_surfliquid_contracts = __esm({
-  "src/agents/surfliquid/surfliquid.contracts.ts"() {
-    "use strict";
-    import_viem6 = require("viem");
-    SURFLIQUID_FACTORY_ADDRESS = "0x8fa50DeA8DB10987D7d22ac092001c3613C18779";
-    SURFLIQUID_FACTORY_ABI = (0, import_viem6.parseAbi)([
-      "function deployVault(address vaultOwner, bytes32 salt) returns (address)",
-      "function computeVaultAddress(address vaultOwner, bytes32 salt) view returns (address)"
-    ]);
-    SURFLIQUID_VAULT_ABI = (0, import_viem6.parseAbi)([
-      "function initialDeposit(address asset, address vault, uint256 amount)",
-      "function userDeposit(address asset, uint256 amount)",
-      // amount 0 withdraws everything; proceeds go to the vault's owner.
-      "function withdraw(address asset, uint256 amount)",
-      "function assetHasInitialDeposit(address asset) view returns (bool)",
-      "function owner() view returns (address)"
-    ]);
-    USDC_ABI = (0, import_viem6.parseAbi)([
-      "function approve(address spender, uint256 amount)",
-      "function transfer(address to, uint256 amount)",
-      "function transferFrom(address from, address to, uint256 value)",
-      "function balanceOf(address account) view returns (uint256)",
-      "function allowance(address owner, address spender) view returns (uint256)",
-      "function nonces(address owner) view returns (uint256)",
-      "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)"
-    ]);
-  }
-});
-
-// src/agents/surfliquid/surfliquid.calls.ts
-function buildDepositCalls(input) {
-  const { smartAccount, owner, vault, amount, permit, deploySalt } = input;
-  if (permit && permit.owner.toLowerCase() !== owner.toLowerCase()) {
-    throw new Error("Permit must be signed by the smart account's owner");
-  }
-  if (permit && permit.value < amount) {
-    throw new Error("Permit allowance is worth less than the deposit");
-  }
-  if (!input.hasInitialDeposit && !input.morphoVault) {
-    throw new Error("A first deposit needs a target morpho vault");
-  }
-  const calls = [];
-  if (deploySalt) {
-    calls.push(
-      call(SURFLIQUID_FACTORY_ADDRESS, SURFLIQUID_FACTORY_ABI, "deployVault", [
-        smartAccount,
-        deploySalt
-      ])
-    );
-  }
-  if (permit) {
-    calls.push(
-      call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "permit", [
-        permit.owner,
-        smartAccount,
-        permit.value,
-        permit.deadline,
-        permit.v,
-        permit.r,
-        permit.s
-      ])
-    );
-  }
-  calls.push(
-    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "transferFrom", [owner, smartAccount, amount]),
-    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "approve", [vault, amount]),
-    input.hasInitialDeposit ? call(vault, SURFLIQUID_VAULT_ABI, "userDeposit", [SURFLIQUID_USDC_ADDRESS, amount]) : call(vault, SURFLIQUID_VAULT_ABI, "initialDeposit", [
-      SURFLIQUID_USDC_ADDRESS,
-      input.morphoVault,
-      amount
-    ])
-  );
-  return calls;
-}
-function buildWithdrawCalls(input) {
-  return [
-    call(input.vault, SURFLIQUID_VAULT_ABI, "withdraw", [
-      SURFLIQUID_USDC_ADDRESS,
-      input.amount ?? 0n
-    ])
-  ];
-}
-function buildSweepCalls(input) {
-  return [call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "transfer", [input.owner, input.amount])];
-}
-var import_viem7, call;
-var init_surfliquid_calls = __esm({
-  "src/agents/surfliquid/surfliquid.calls.ts"() {
-    "use strict";
-    import_viem7 = require("viem");
-    init_surfliquid_constants();
-    init_surfliquid_contracts();
-    call = (to, abi, functionName, args) => ({
-      to,
-      data: (0, import_viem7.encodeFunctionData)({ abi, functionName, args })
-    });
-  }
-});
-
-// src/agents/surfliquid/surfliquid.sponsorship.ts
-async function resolveVault(ctx) {
-  const registered = await ctx.api.getVault(ctx.wallet.ownerAddress);
-  const smartAccount = ctx.wallet.smartAccountAddress;
-  if (!registered.userVaultAddress) {
-    const salt2 = registered.deploymentSalt ?? (await ctx.api.prepare(SURFLIQUID_CHAIN_ID)).salt;
-    return {
-      vault: await ctx.chain.computeVaultAddress(smartAccount, salt2),
-      deploySalt: salt2,
-      registerAfterDeposit: true
-    };
-  }
-  const vault = registered.userVaultAddress;
-  if (await ctx.chain.isDeployed(vault)) {
-    const owner = await ctx.chain.readVaultOwner(vault);
-    if (owner.toLowerCase() !== smartAccount.toLowerCase()) {
-      throw new VaultNotSponsorableError(`SurfLiquid vault ${vault} is not owned by the smart account`);
-    }
-    return { vault, registerAfterDeposit: false };
-  }
-  const salt = registered.deploymentSalt;
-  const deployable = salt ? await ctx.chain.computeVaultAddress(smartAccount, salt) : void 0;
-  if (!salt || deployable?.toLowerCase() !== vault.toLowerCase()) {
-    throw new VaultNotSponsorableError(`Registered SurfLiquid vault ${vault} does not match this smart account`);
-  }
-  return { vault, deploySalt: salt, registerAfterDeposit: false };
-}
-async function pickMorphoVault(api) {
-  const candidates = await api.getBestVault("USDC");
-  const candidate = candidates.find((option) => option.chainId === SURFLIQUID_CHAIN_ID);
-  if (!candidate) {
-    throw new Error(`SurfLiquid has no morpho vault for USDC on chain ${SURFLIQUID_CHAIN_ID}`);
-  }
-  return candidate.vaultAddress;
-}
-async function permitIfShort(input) {
-  const { chain, wallet, amount } = input;
-  const allowance = await chain.readAllowance(wallet.ownerAddress, wallet.smartAccountAddress);
-  if (allowance >= amount) return void 0;
-  const [{ tokenName, tokenVersion }, nonce] = await Promise.all([
-    chain.readTokenMeta(),
-    chain.readPermitNonce(wallet.ownerAddress)
-  ]);
-  const message = {
-    owner: wallet.ownerAddress,
-    spender: wallet.smartAccountAddress,
-    value: amount > SURFLIQUID_PERMIT_CAP ? amount : SURFLIQUID_PERMIT_CAP,
-    nonce,
-    deadline: BigInt(Math.floor(Date.now() / 1e3)) + SURFLIQUID_PERMIT_TTL_SECONDS
-  };
-  const signature = await wallet.signPermit(
-    buildPermitTypedData({
-      token: SURFLIQUID_USDC_ADDRESS,
-      chainId: SURFLIQUID_CHAIN_ID,
-      tokenName,
-      tokenVersion,
-      message
-    })
-  );
-  const { r, s, v, yParity } = (0, import_viem8.parseSignature)(signature);
-  return {
-    owner: message.owner,
-    value: message.value,
-    deadline: message.deadline,
-    v: Number(v ?? BigInt(yParity + 27)),
-    r,
-    s
-  };
-}
-async function depositSponsored(input) {
-  const { api, chain, wallet, amount } = input;
-  const { vault, deploySalt, registerAfterDeposit } = await resolveVault(input);
-  const hasInitialDeposit = deploySalt ? false : await chain.hasInitialDeposit(vault, SURFLIQUID_USDC_ADDRESS);
-  const morphoVault = hasInitialDeposit ? void 0 : await pickMorphoVault(api);
-  const permit = await permitIfShort({ chain, wallet, amount });
-  const txHash = await wallet.sendCalls(
-    buildDepositCalls({
-      smartAccount: wallet.smartAccountAddress,
-      owner: wallet.ownerAddress,
-      vault,
-      amount,
-      permit,
-      hasInitialDeposit,
-      morphoVault,
-      deploySalt
-    })
-  );
-  if (registerAfterDeposit && deploySalt) {
-    try {
-      await api.confirm({
-        userVaultAddress: vault,
-        homeChainId: SURFLIQUID_CHAIN_ID,
-        deploymentSalt: deploySalt,
-        initialAssets: []
-      });
-    } catch (error) {
-      console.warn(
-        "[owney-sdk] SurfLiquid vault registration failed after a successful deposit:",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  return { txHash, vault };
-}
-async function withdrawSponsored(input) {
-  const { api, chain, wallet, amount } = input;
-  const registered = await api.getVault(wallet.ownerAddress);
-  if (!registered.userVaultAddress) {
-    throw new Error("SurfLiquid has no vault registered for this wallet");
-  }
-  const vault = registered.userVaultAddress;
-  const owner = await chain.readVaultOwner(vault);
-  if (owner.toLowerCase() !== wallet.smartAccountAddress.toLowerCase()) {
-    throw new VaultNotSponsorableError(`SurfLiquid vault ${vault} is not owned by the smart account`);
-  }
-  const withdrawHash = await wallet.sendCalls(buildWithdrawCalls({ vault, amount }));
-  try {
-    const proceeds = await chain.usdcBalanceOf(wallet.smartAccountAddress);
-    if (proceeds === 0n) return { txHash: withdrawHash, amount: "0" };
-    const sweepHash = await wallet.sendCalls(
-      buildSweepCalls({ owner: wallet.ownerAddress, amount: proceeds })
-    );
-    return { txHash: sweepHash, amount: proceeds.toString() };
-  } catch (error) {
-    throw new SubmittedError(
-      `SurfLiquid withdrawal ${withdrawHash} landed but the sweep did not: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-var import_viem8, SubmittedError, VaultNotSponsorableError;
-var init_surfliquid_sponsorship = __esm({
-  "src/agents/surfliquid/surfliquid.sponsorship.ts"() {
-    "use strict";
-    import_viem8 = require("viem");
-    init_transfer_auth();
-    init_surfliquid_constants();
-    init_surfliquid_calls();
-    SubmittedError = class extends Error {
-      constructor(message, userOpHash) {
-        super(message);
-        this.userOpHash = userOpHash;
-        this.name = "SubmittedError";
-      }
-      userOpHash;
-    };
-    VaultNotSponsorableError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "VaultNotSponsorableError";
-      }
-    };
-  }
-});
-
-// src/agents/surfliquid/surfliquid.morpho.ts
-async function queryMorpho(query, vaultAddress, chainId) {
-  try {
-    const res = await fetch(MORPHO_API_URL, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        query,
-        variables: { address: vaultAddress, chainId }
-      })
-    });
-    if (!res.ok) return null;
-    const json = await res.json();
-    if (json.errors) return null;
-    return json.data ?? null;
-  } catch (error) {
-    console.warn("surfliquid: Morpho vault stats fetch failed", {
-      vaultAddress,
-      chainId,
-      error
-    });
-    return null;
-  }
-}
-function toStats(name, tvlUsd, liquidityUsd) {
-  if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
-    return null;
-  }
-  return {
-    name: typeof name === "string" ? name : null,
-    tvlUsd,
-    liquidityUsd
-  };
-}
-async function fetchMorphoVaultStats(vaultAddress, chainId) {
-  const v1 = await queryMorpho(VAULT_STATS_QUERY, vaultAddress, chainId);
-  const vault = v1?.vaultByAddress;
-  const v1Stats = toStats(
-    vault?.name,
-    vault?.state?.totalAssetsUsd,
-    vault?.liquidity?.usd
-  );
-  if (v1Stats) return v1Stats;
-  const v2 = await queryMorpho(VAULT_V2_STATS_QUERY, vaultAddress, chainId);
-  const vaultV2 = v2?.vaultV2ByAddress;
-  return toStats(vaultV2?.name, vaultV2?.totalAssetsUsd, vaultV2?.liquidityUsd);
-}
-async function fetchMorphoStatsByVault(vaultAddresses, chainId) {
-  const unique = [...new Set(vaultAddresses.map((a) => a.toLowerCase()))];
-  const entries = await Promise.all(
-    unique.map(
-      async (address) => [address, await fetchMorphoVaultStats(address, chainId)]
-    )
-  );
-  const byVault = /* @__PURE__ */ new Map();
-  for (const [address, stats] of entries) {
-    if (stats) byVault.set(address, stats);
-  }
-  return byVault;
-}
-var MORPHO_API_URL, VAULT_STATS_QUERY, VAULT_V2_STATS_QUERY;
-var init_surfliquid_morpho = __esm({
-  "src/agents/surfliquid/surfliquid.morpho.ts"() {
-    "use strict";
-    MORPHO_API_URL = "https://api.morpho.org/graphql";
-    VAULT_STATS_QUERY = `
-  query VaultStats($address: String!, $chainId: Int!) {
-    vaultByAddress(address: $address, chainId: $chainId) {
-      name
-      state { totalAssetsUsd }
-      liquidity { usd }
-    }
-  }
-`;
-    VAULT_V2_STATS_QUERY = `
-  query VaultV2Stats($address: String!, $chainId: Int!) {
-    vaultV2ByAddress(address: $address, chainId: $chainId) {
-      name
-      totalAssetsUsd
-      liquidityUsd
-    }
-  }
-`;
-  }
-});
-
-// src/agents/surfliquid/surfliquid.smart-account.ts
-var surfliquid_smart_account_exports = {};
-__export(surfliquid_smart_account_exports, {
-  createSponsoredChain: () => createSponsoredChain,
-  createSponsoredWallet: () => createSponsoredWallet,
-  pinAccount: () => pinAccount
-});
-function publicClientFor(rpcUrl) {
-  return (0, import_viem9.createPublicClient)({ chain: import_chains2.base, transport: (0, import_viem9.http)(rpcUrl) });
-}
-function createSponsoredChain(rpcUrl) {
-  const client = publicClientFor(rpcUrl);
-  return {
-    computeVaultAddress: (owner, salt) => client.readContract({
-      address: SURFLIQUID_FACTORY_ADDRESS,
-      abi: SURFLIQUID_FACTORY_ABI,
-      functionName: "computeVaultAddress",
-      args: [owner, salt]
-    }),
-    isDeployed: async (address) => {
-      const code = await client.getCode({ address });
-      return Boolean(code && code !== "0x");
-    },
-    readVaultOwner: (vault) => client.readContract({ address: vault, abi: SURFLIQUID_VAULT_ABI, functionName: "owner" }),
-    hasInitialDeposit: (vault, asset) => client.readContract({
-      address: vault,
-      abi: SURFLIQUID_VAULT_ABI,
-      functionName: "assetHasInitialDeposit",
-      args: [asset]
-    }),
-    usdcBalanceOf: (address) => client.readContract({
-      address: SURFLIQUID_USDC_ADDRESS,
-      abi: USDC_ABI,
-      functionName: "balanceOf",
-      args: [address]
-    }),
-    // Cast: viem's OP-stack tx union does not match the generic PublicClient
-    // the helper is typed against, though every method it uses is present.
-    readTokenMeta: () => readTokenMeta(client, SURFLIQUID_USDC_ADDRESS),
-    readAllowance: (owner, spender) => client.readContract({
-      address: SURFLIQUID_USDC_ADDRESS,
-      abi: USDC_ABI,
-      functionName: "allowance",
-      args: [owner, spender]
-    }),
-    readPermitNonce: (owner) => client.readContract({
-      address: SURFLIQUID_USDC_ADDRESS,
-      abi: USDC_ABI,
-      functionName: "nonces",
-      args: [owner]
-    })
-  };
-}
-function pinAccount(provider, address) {
-  return {
-    ...provider,
-    request: (args) => args.method === "eth_accounts" || args.method === "eth_requestAccounts" ? Promise.resolve([address]) : provider.request(args)
-  };
-}
-async function createSponsoredWallet(input) {
-  const entryPoint = { address: import_account_abstraction.entryPoint08Address, version: "0.8" };
-  const account = await (0, import_accounts.toSimpleSmartAccount)({
-    client: publicClientFor(input.rpcUrl),
-    owner: pinAccount(input.provider, input.ownerAddress),
-    entryPoint
-  });
-  const bundlerTransport = (0, import_viem9.http)(sponsorProxyUrl(input.routingApiBaseUrl), {
-    fetchOptions: { headers: { "x-owney-api-key": input.apiKey } }
-  });
-  const pimlico = (0, import_pimlico.createPimlicoClient)({ transport: bundlerTransport, entryPoint });
-  const smartAccountClient = (0, import_permissionless.createSmartAccountClient)({
-    account,
-    chain: import_chains2.base,
-    bundlerTransport,
-    paymaster: pimlico,
-    userOperation: {
-      estimateFeesPerGas: async () => (await pimlico.getUserOperationGasPrice()).fast
-    }
-  });
-  const walletClient = (0, import_viem9.createWalletClient)({
-    account: input.ownerAddress,
-    chain: import_chains2.base,
-    transport: (0, import_viem9.custom)(input.provider)
-  });
-  return {
-    smartAccountAddress: account.address,
-    ownerAddress: input.ownerAddress,
-    // The EOA signs, not the smart account: USDC verifies ECDSA from the token holder.
-    signPermit: (typedData) => walletClient.signTypedData({
-      account: input.ownerAddress,
-      domain: typedData.domain,
-      types: typedData.types,
-      primaryType: typedData.primaryType,
-      message: typedData.message
-    }),
-    sendCalls: async (calls) => {
-      const userOpHash = await smartAccountClient.sendUserOperation({
-        calls: calls.map((c) => ({ to: c.to, data: c.data, value: 0n }))
-      });
-      try {
-        const receipt = await smartAccountClient.waitForUserOperationReceipt({ hash: userOpHash });
-        return receipt.receipt.transactionHash;
-      } catch (error) {
-        throw new SubmittedError(
-          `user operation ${userOpHash} was submitted but its receipt never arrived`,
-          userOpHash
-        );
-      }
-    }
-  };
-}
-var import_permissionless, import_accounts, import_pimlico, import_viem9, import_account_abstraction, import_chains2, sponsorProxyUrl;
-var init_surfliquid_smart_account = __esm({
-  "src/agents/surfliquid/surfliquid.smart-account.ts"() {
-    "use strict";
-    import_permissionless = require("permissionless");
-    import_accounts = require("permissionless/accounts");
-    import_pimlico = require("permissionless/clients/pimlico");
-    import_viem9 = require("viem");
-    import_account_abstraction = require("viem/account-abstraction");
-    import_chains2 = require("viem/chains");
-    init_transfer_auth();
-    init_surfliquid_constants();
-    init_surfliquid_contracts();
-    init_surfliquid_sponsorship();
-    sponsorProxyUrl = (routingApiBaseUrl) => `${routingApiBaseUrl.replace(/\/$/, "")}/api/v1/sponsor/pimlico-rpc/${SURFLIQUID_CHAIN_ID}`;
-  }
-});
-
-// src/agents/surfliquid/surfliquid.agent.ts
-var surfliquid_agent_exports = {};
-__export(surfliquid_agent_exports, {
-  SurfLiquidAgent: () => SurfLiquidAgent
-});
-function toOwneyError(error) {
-  if (error instanceof OwneyError) return error;
-  if (error instanceof SubmittedError) {
-    return new OwneyError("OPERATION_PENDING", error.message, { userOpHash: error.userOpHash }, AGENT_ID2);
-  }
-  if (error instanceof VaultNotSponsorableError) {
-    return new OwneyError("VAULT_NOT_SPONSORABLE", error.message, void 0, AGENT_ID2);
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  const code = error?.code;
-  if (code === WALLET_REJECTED_CODE || /user rejected|user denied/i.test(message)) {
-    return new OwneyError("USER_REJECTED", message, void 0, AGENT_ID2);
-  }
-  return new OwneyError("SPONSORSHIP_UNAVAILABLE", message, void 0, AGENT_ID2);
-}
-var import_viem10, import_chains3, AGENT_ID2, WALLET_REJECTED_CODE, DISCOVERY_WALLET2, HISTORY_DEFAULT_LIMIT, APY_WINDOW_KEY2, SurfLiquidAgent;
-var init_surfliquid_agent = __esm({
-  "src/agents/surfliquid/surfliquid.agent.ts"() {
-    "use strict";
-    import_viem10 = require("viem");
-    import_chains3 = require("viem/chains");
-    init_errors();
-    init_surfliquid_constants();
-    init_surfliquid_broker();
-    init_surfliquid_mapper();
-    init_surfliquid_sponsorship();
-    init_surfliquid_morpho();
-    init_routing_api();
-    AGENT_ID2 = "surfliquid";
-    WALLET_REJECTED_CODE = 4001;
-    DISCOVERY_WALLET2 = "0x";
-    HISTORY_DEFAULT_LIMIT = 10;
-    APY_WINDOW_KEY2 = {
-      "7D": "apy7d",
-      "14D": "apy14d",
-      "30D": "apy30d"
-    };
-    SurfLiquidAgent = class {
-      constructor(config) {
-        this.config = config;
-      }
-      config;
-      id = AGENT_ID2;
-      supportedChainIds = [SURFLIQUID_CHAIN_ID];
-      supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
-      broker = null;
-      brokerWallet = null;
-      // Dedicated instance for the anonymous "0x" asset probe — never shares a slot
-      // with the user's broker, so discovery can never evict or overwrite a session.
-      discoveryBroker = null;
-      // In-flight SIWE, shared by concurrent callers: SurfLiquid's nonce is single-use.
-      connectPromise = null;
-      get routingApiBaseUrl() {
-        return this.config.routingApiBaseUrl ?? ROUTING_API_BASE_URL;
-      }
-      // Synchronous so the check-and-assign below cannot interleave with a concurrent call.
-      brokerFor(walletAddress) {
-        if (this.broker && this.brokerWallet === walletAddress.toLowerCase()) return this.broker;
-        this.broker = createSurfBroker({
-          routingApiBaseUrl: this.routingApiBaseUrl,
-          apiKey: this.config.apiKey,
-          walletAddress,
-          fetchImpl: this.config.fetchImpl
-        });
-        this.brokerWallet = walletAddress.toLowerCase();
-        return this.broker;
-      }
-      async connect(state, shouldForce = false) {
-        const broker = this.brokerFor(state.walletAddress);
-        if (!shouldForce && broker.hasSession()) return broker;
-        if (this.connectPromise) return this.connectPromise;
-        this.connectPromise = (async () => {
-          const message = await broker.nonce();
-          const walletClient = (0, import_viem10.createWalletClient)({
-            account: state.walletAddress,
-            chain: import_chains3.base,
-            transport: (0, import_viem10.custom)(state.provider)
-          });
-          const signature = await walletClient.signMessage({ account: state.walletAddress, message });
-          await broker.login(message, signature);
-          return broker;
-        })();
-        try {
-          return await this.connectPromise;
-        } finally {
-          this.connectPromise = null;
-        }
-      }
-      /** A 401 can only surface before any signature (SurfLiquid is never called between sign and submit). */
-      async withSession(state, run) {
-        try {
-          return await run();
-        } catch (error) {
-          if (!(error instanceof SurfSessionExpiredError)) throw error;
-          await this.connect(state, true);
-          try {
-            return await run();
-          } catch (retryError) {
-            if (!(retryError instanceof SurfSessionExpiredError)) throw retryError;
-            throw new OwneyError("SURF_UNAVAILABLE", "SurfLiquid session could not be re-established", void 0, AGENT_ID2);
-          }
-        }
-      }
-      async sponsoredWallet(state) {
-        const { createSponsoredWallet: createSponsoredWallet2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        return createSponsoredWallet2({
-          provider: state.provider,
-          ownerAddress: state.walletAddress,
-          routingApiBaseUrl: this.routingApiBaseUrl,
-          apiKey: this.config.apiKey,
-          rpcUrl: this.config.rpcUrl
-        });
-      }
-      // --- IAgent: lifecycle ---
-      async disconnect() {
-        this.broker?.clearSession();
-        this.broker = null;
-        this.brokerWallet = null;
-      }
-      async activateAgent(state, _chainId) {
-        await this.connect(state);
-      }
-      // --- IAgent: funds (gasless only) ---
-      async deposit(state, _chainId, amount, _asset, _depositCallback) {
-        const broker = await this.connect(state);
-        const wallet = await this.sponsoredWallet(state);
-        const { createSponsoredChain: createSponsoredChain2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        try {
-          const { txHash, vault } = await this.withSession(
-            state,
-            () => depositSponsored({ amount: BigInt(amount), api: broker, chain: createSponsoredChain2(this.config.rpcUrl), wallet })
-          );
-          broker.invalidateVault();
-          return { txHash, smartWallet: vault, amount };
-        } catch (error) {
-          throw toOwneyError(error);
-        }
-      }
-      async withdraw(state, _chainId, _token, amount) {
-        const broker = await this.connect(state);
-        const wallet = await this.sponsoredWallet(state);
-        const { createSponsoredChain: createSponsoredChain2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        try {
-          const result = await this.withSession(
-            state,
-            () => withdrawSponsored({
-              amount: amount != null ? BigInt(amount) : void 0,
-              api: broker,
-              chain: createSponsoredChain2(this.config.rpcUrl),
-              wallet
-            })
-          );
-          broker.invalidateVault();
-          return { txHash: result.txHash, type: amount != null ? "partial" : "full", amount: result.amount };
-        } catch (error) {
-          throw toOwneyError(error);
-        }
-      }
-      // --- IAgent: portfolio reads ---
-      async vault(state) {
-        const broker = await this.connect(state);
-        return this.withSession(state, () => broker.getVault(state.walletAddress));
-      }
-      async getBalances(state, chainId) {
-        const vault = await this.vault(state);
-        const morphoVaultAddresses = (vault.assets ?? []).filter((asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId).map((asset) => asset.morphoVaultAddress).filter((address) => Boolean(address));
-        const morphoStats = await fetchMorphoStatsByVault(morphoVaultAddresses, chainId);
-        return mapBalances2(vault, chainId, morphoStats);
-      }
-      async getEarnings(state) {
-        const vault = await this.vault(state);
-        return mapEarnings2(vault, vault.userVaultAddress ?? state.walletAddress);
-      }
-      async getAccountApy(state, _chainId, days) {
-        return mapAccountApy(await this.vault(state), days);
-      }
-      async getHistory(state, chainId, options) {
-        const broker = await this.connect(state);
-        const page = options?.cursor ? Number(options.cursor) : 1;
-        const limit = options?.limit ?? HISTORY_DEFAULT_LIMIT;
-        const result = await this.withSession(
-          state,
-          () => broker.getAgentMessages(state.walletAddress, page, limit, options?.fromDate, options?.toDate)
-        );
-        return mapHistory(result, chainId);
-      }
-      async getUserProfile(state) {
-        return mapUserProfile2(await this.vault(state), state.walletAddress);
-      }
-      // --- IAgent: discovery (no wallet, no session) ---
-      async getAgentApy(days, _options) {
-        this.discoveryBroker ??= createSurfBroker({
-          routingApiBaseUrl: this.routingApiBaseUrl,
-          apiKey: this.config.apiKey,
-          walletAddress: DISCOVERY_WALLET2,
-          fetchImpl: this.config.fetchImpl
-        });
-        const assets = await this.discoveryBroker.getSupportedAssets(SURFLIQUID_CHAIN_ID);
-        const usdc = assets.find((asset) => asset.assetSymbol === "USDC");
-        if (!usdc) return { averageApy: 0 };
-        const windowed = usdc[APY_WINDOW_KEY2[days]];
-        return { averageApy: windowed != null ? windowed : usdc.currentAPY };
-      }
-    };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
-});
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
@@ -1325,12 +27,59 @@ __export(index_exports, {
   OwneyError: () => OwneyError,
   OwneySDK: () => OwneySDK,
   createOwneySIWX: () => createOwneySIWX,
+  recentEarningsFromPoints: () => recentEarningsFromPoints,
   setOwneyDebug: () => setOwneyDebug
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/lib/agent-reads.ts
-init_errors();
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  agentId;
+  constructor(code, message, details, agentId) {
+    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+    super(`${prefix} ${message}`);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+    this.agentId = agentId;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available },
+      agentId
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
 
 // src/lib/rate-limit.ts
 function rateLimitDelay(error, now = Date.now()) {
@@ -1497,11 +246,24 @@ var SupportedAssets = [
   }
 ];
 
-// src/agents/zyfai/zyfai.mapper.ts
-init_debug();
+// src/lib/debug.ts
+var configuredDebug = false;
+function setOwneyDebug(enabled) {
+  configuredDebug = enabled;
+}
+function isOwneyDebug() {
+  return globalThis.__OWNEY_DEBUG__ === true || configuredDebug;
+}
+function debugLog(scope, message, data) {
+  if (!isOwneyDebug()) return;
+  if (data === void 0) {
+    console.log(`[${scope}] ${message}`);
+  } else {
+    console.log(`[${scope}] ${message}`, data);
+  }
+}
 
 // src/lib/utils.ts
-init_errors();
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
     throw new OwneyError(
@@ -1512,12 +274,6 @@ var isValidChainId = (chainId) => {
   }
   return chainId;
 };
-function isSameAsset(tokenSymbol, asset) {
-  const token = tokenSymbol.toLowerCase();
-  const target = asset.toLowerCase();
-  if (token === target) return true;
-  return target === "weth" && token === "eth" || target === "eth" && token === "weth";
-}
 function hexToDecimal(hex, decimals = 6) {
   const normalized = hex.startsWith("0x") || hex.startsWith("0X") ? hex : `0x${hex}`;
   const parsed = BigInt(normalized);
@@ -1942,6 +698,63 @@ function computeAllocationApy(positions) {
   const totalApy = totalValue > 0 ? String(weightedSum / totalValue) : "0";
   return { totalApy, apyByChainAndAsset };
 }
+var ZYFAI_NET_OF_FEE_MULTIPLIER = 0.9;
+function sumEarningsBucket(bucket, chainId, tokenSymbol) {
+  const tokens = bucket?.[String(chainId)];
+  if (!tokens) return null;
+  const wanted = tokenSymbol?.toUpperCase();
+  let total = 0;
+  let matched = false;
+  for (const [symbol, value] of Object.entries(tokens)) {
+    if (wanted && symbol.toUpperCase() !== wanted) continue;
+    matched = true;
+    const amount = Number(value);
+    if (!Number.isFinite(amount)) continue;
+    total += amount;
+  }
+  return matched ? total : null;
+}
+function netEarningsForSnapshot(entry, chainId, tokenSymbol) {
+  const lifetime = sumEarningsBucket(entry.lifetime_earnings_by_token, chainId, tokenSymbol);
+  const unrealized = sumEarningsBucket(entry.unrealized_earnings_by_token, chainId, tokenSymbol);
+  const current = sumEarningsBucket(entry.current_earnings_by_token, chainId, tokenSymbol);
+  if (lifetime === null && unrealized === null && current === null) {
+    const gross = sumEarningsBucket(entry.total_earnings_by_token, chainId, tokenSymbol);
+    if (gross === null) return null;
+    if (!warnedGrossApyFallbacks.has("daily_earnings_net_components")) {
+      warnedGrossApyFallbacks.add("daily_earnings_net_components");
+      console.warn(
+        `[owney] @zyfai/sdk omitted the daily net-earnings components; falling back to gross totals, which do not deduct Zyfai's performance fee and so read high.`
+      );
+    }
+    debugLog("zyfai:earnings", "gross fallback for daily earnings", { gross });
+    return gross;
+  }
+  return (lifetime ?? 0) + (unrealized ?? 0) + (current ?? 0) * ZYFAI_NET_OF_FEE_MULTIPLIER;
+}
+function mapDailyEarnings(raw, chainId, tokenSymbol) {
+  const points = (raw.data ?? []).map((entry) => ({
+    date: entry.snapshot_date,
+    net: netEarningsForSnapshot(entry, chainId, tokenSymbol)
+  })).filter((p) => p.net !== null).sort((a, b) => a.date.localeCompare(b.date));
+  return { walletAddress: raw.walletAddress, points };
+}
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function recentEarningsFromPoints(points, requestedDays) {
+  if (points.length === 0) return null;
+  const first = points[0];
+  const last = points[points.length - 1];
+  const spanDays = Math.round(
+    (Date.parse(last.date) - Date.parse(first.date)) / MS_PER_DAY
+  );
+  const amount = Math.max(0, last.net - first.net);
+  return {
+    amount,
+    spanDays: Number.isFinite(spanDays) ? spanDays : 0,
+    // A single snapshot spans no window at all, so it is always truncated.
+    isTruncated: requestedDays === void 0 ? points.length < 2 : spanDays < requestedDays
+  };
+}
 
 // src/agents/zyfai/zyfai.withdraw-amount.ts
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
@@ -1991,9 +804,6 @@ function decodeHistoryCursor(token) {
   return parsed;
 }
 
-// src/agents/zyfai/zyfai.agent.ts
-init_errors();
-
 // src/agents/zyfai/zyfai.auth-cache.ts
 var KEY_PREFIX = "owney.zyfai.session";
 var storage = () => {
@@ -2256,7 +1066,6 @@ function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect
 }
 
 // src/agents/zyfai/zyfai.agent.ts
-init_debug();
 var ERC7579_IS_MODULE_INSTALLED_ABI = (0, import_viem.parseAbi)([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
@@ -2775,37 +1584,6 @@ var ZyfaiAgent = class _ZyfaiAgent {
       );
     }
   }
-  /**
-   * Records the deposit with Zyfai, retrying transient failures.
-   *
-   * This runs AFTER the transfer has already landed on-chain, so it must never
-   * fail the deposit — the funds moved. But it is also the ONLY source of the
-   * "Top up wallet" entry the history is built from: Zyfai auto-deploys the
-   * balance it detects either way, so when this call is lost the user's deposit
-   * never appears in Activity (an earlier withdrawal stays the newest row) and
-   * nothing ever backfills it. Retry, then log loudly enough to be recoverable.
-   */
-  async logDepositWithRetry(chainId, txHash, amount, tokenAddress) {
-    const ATTEMPTS = 3;
-    const RETRY_DELAY_MS = 1e3;
-    for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
-      try {
-        await (tokenAddress ? this.sdk.logDeposit(chainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(chainId, txHash, amount));
-        return;
-      } catch (logError) {
-        if (attempt === ATTEMPTS) {
-          console.error(
-            "[owney-sdk] Deposit landed on-chain but logDeposit failed \u2014 it will be missing from Zyfai history:",
-            { txHash, chainId, amount, tokenAddress, error: logError }
-          );
-          return;
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, RETRY_DELAY_MS * attempt)
-        );
-      }
-    }
-  }
   /**
    * True when `smartWallet` is the backend-managed pool wallet Zyfai assigned
    * to this EOA — the "new wallet" kind that is predeployed on the chains it
@@ -3115,12 +1893,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
         );
         const txHash = await depositCallback(smartWallet, validChainId, amount);
         const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
-        await this.logDepositWithRetry(
-          validChainId,
-          txHash,
-          amount,
-          tokenAddress
-        );
+        try {
+          await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
+        } catch (logError) {
+          console.warn(
+            "[owney-sdk] Deposit landed on-chain but logDeposit failed (non-fatal):",
+            logError
+          );
+        }
         return { txHash, smartWallet, amount };
       }
       await this.ensureWalletDeployed(this.getAddress(), validChainId);
@@ -3203,9 +1983,9 @@ var ZyfaiAgent = class _ZyfaiAgent {
       const recent = this.earningsSnapshot;
       const current = recent?.key === key2 && Date.now() - recent.at < 5e3 ? recent.raw : await this.readEarnings(key2, smartWallet);
       const lastCheck = current.data.lastCheckTimestamp ? Date.parse(current.data.lastCheckTimestamp) : Number.NaN;
-      const isFresh2 = Number.isFinite(lastCheck) && Date.now() - lastCheck < EARNINGS_REFRESH_COOLDOWN_MS;
-      const earnings = isFresh2 ? current : await this.sdk.calculateOnchainEarnings(smartWallet);
-      if (!isFresh2 && generation === this.earningsGeneration) {
+      const isFresh = Number.isFinite(lastCheck) && Date.now() - lastCheck < EARNINGS_REFRESH_COOLDOWN_MS;
+      const earnings = isFresh ? current : await this.sdk.calculateOnchainEarnings(smartWallet);
+      if (!isFresh && generation === this.earningsGeneration) {
         this.earningsSnapshot = { key: key2, raw: earnings, at: Date.now() };
       }
       return mapEarnings(earnings, smartWallet);
@@ -3221,6 +2001,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
@@ -3334,13 +2123,71 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
 };
 
-// src/client.ts
-init_errors();
-init_debug();
-init_routing_api();
+// src/lib/routing-api.ts
+var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/org-config`;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-owney-api-key": `${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      if (res.status !== 404) {
+        console.warn(
+          `[owney-sdk] Could not read org agent config (${res.status}); leaving user profiles unchanged.`
+        );
+      }
+      return null;
+    }
+    const json = await res.json();
+    const policy = json.success ? json.data ?? null : null;
+    debugLog(
+      "owney-sdk",
+      policy ? "org agent config: loaded" : "org agent config: none set by this partner \u2014 user profiles will be left as they are",
+      policy ?? void 0
+    );
+    return policy;
+  } catch (error) {
+    console.warn(
+      "[owney-sdk] Could not read org agent config (non-fatal):",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/keys`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "x-owney-api-key": `${apiKey}`
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new OwneyError(
+      "API_ROUTING_ERROR",
+      `Routing API error ${res.status}: ${text}`,
+      { statusCode: res.status, responseBody: text }
+    );
+  }
+  const json = await res.json();
+  if (!json.success) {
+    throw new OwneyError(
+      "API_ROUTING_FAILED",
+      `Routing API request failed: ${json.message}`,
+      { message: json.message }
+    );
+  }
+  return json.data;
+}
 
 // src/lib/health-report.ts
-init_errors();
 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) {
   try {
@@ -3376,10 +2223,11 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 // src/lib/helpers/withdraw-helper.ts
 var import_viem2 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
+  const target = asset.toUpperCase();
   return agents.map((agent) => {
     const agentBalance = aggregated[agent.id];
     const tokenBalance = agentBalance?.tokens.find(
-      (t) => t.chainId === chainId && isSameAsset(t.asset, asset)
+      (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
     if (!tokenBalance) return { agent, balance: 0n };
     return { agent, balance: (0, import_viem2.parseUnits)(tokenBalance.amount, decimals) };
@@ -3529,21 +2377,52 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem11 = require("viem");
-var import_chains4 = require("viem/chains");
+var import_viem6 = require("viem");
+var import_chains2 = require("viem/chains");
 
-// src/lib/sponsored-deposit.ts
-init_errors();
-init_transfer_auth();
+// src/lib/transfer-auth.ts
+var import_viem3 = 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" }] }
+];
+function buildTransferWithAuthorizationTypedData(input) {
+  return {
+    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "TransferWithAuthorization",
+    message: input.message
+  };
+}
+async function readTokenMeta(publicClient, token) {
+  const [tokenName, tokenVersion] = await Promise.all([
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "name" }),
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
+  ]);
+  return { tokenName, tokenVersion };
+}
+function randomAuthNonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return (0, import_viem3.bytesToHex)(bytes);
+}
 
 // src/lib/sponsor-client.ts
-init_errors();
 var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function postSponsorTransferAuth(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base5}/api/v1/sponsor/erc20-transfer-auth`, {
+    res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3580,10 +2459,10 @@ async function postSponsorTransferAuth(input) {
   return parsed.data;
 }
 async function postSponsorPermit2Transfer(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base5}/api/v1/sponsor/permit2-transfer`, {
+    res = await fetch(`${base3}/api/v1/sponsor/permit2-transfer`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -3618,11 +2497,11 @@ async function postSponsorPermit2Transfer(input) {
   return parsed.data;
 }
 async function getSponsorRelayerAddress(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
     res = await fetch(
-      `${base5}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
+      `${base3}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
       {
         headers: { "x-owney-api-key": input.apiKey }
       }
@@ -3733,7 +2612,6 @@ async function readErc20Balance(publicClient, token, owner) {
 }
 
 // src/lib/chain-guard.ts
-init_errors();
 var CHAIN_NAMES = {
   1: "Ethereum",
   8453: "Base",
@@ -3847,7 +2725,6 @@ function makeSponsoredDepositCallback(deps) {
 }
 
 // src/lib/sponsored-weth-deposit.ts
-init_errors();
 var PERMIT_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredWethCallback(deps) {
   const get = deps.httpGet ?? getSponsorRelayerAddress;
@@ -3932,7 +2809,6 @@ function makeSponsoredWethCallback(deps) {
 
 // src/lib/sponsored-calls-deposit.ts
 var import_viem5 = require("viem");
-init_errors();
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -4049,9 +2925,9 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: import_chains4.base,
-  42161: import_chains4.arbitrum,
-  1: import_chains4.mainnet
+  8453: import_chains2.base,
+  42161: import_chains2.arbitrum,
+  1: import_chains2.mainnet
 };
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
@@ -4061,7 +2937,6 @@ var SPONSORED_WETH_BY_CHAIN = {
 function shouldFallbackToUserPaid(error, asset, appCallback) {
   return (asset === "WETH" || asset === "USDC") && appCallback === void 0 && error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && error.details?.safeToFallback === true;
 }
-var AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai"];
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -4208,14 +3083,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_viem11.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem11.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem11.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem11.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -4261,14 +3136,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_viem11.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem11.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem11.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem11.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -4345,7 +3220,7 @@ var OwneySDK = class {
         );
         this.disabledAgents.clear();
         for (const { key: key2, agent_type, is_enabled } of agentKeys) {
-          const agent = await this.createAgent(agent_type, key2);
+          const agent = this.createAgent(agent_type, key2);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -4366,18 +3241,10 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  async createAgent(agentId, key2) {
+  createAgent(agentId, key2) {
     if (agentId === "zyfai") {
       return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
     }
-    if (agentId === "surfliquid") {
-      if (!key2) return null;
-      const { SurfLiquidAgent: SurfLiquidAgent2 } = await Promise.resolve().then(() => (init_surfliquid_agent(), surfliquid_agent_exports));
-      return new SurfLiquidAgent2({
-        apiKey: this.apiKey,
-        routingApiBaseUrl: this.routingApiBaseUrl
-      });
-    }
     return null;
   }
   /**
@@ -4775,14 +3642,15 @@ var OwneySDK = class {
   async hasExistingBalance(agent, state, chainId, asset, requireReliableRead = false) {
     try {
       const balance = await agent.getBalances(state, chainId);
+      const target = asset.toLowerCase();
       const token = balance.tokens.find(
-        (t) => t.chainId === chainId && isSameAsset(t.asset, asset)
+        (t) => t.chainId === chainId && t.asset.toLowerCase() === target
       );
       const targetChainName = agent.supportedAssets.find((entry) => entry.chainId === chainId)?.chain?.trim().toUpperCase();
       const position = (balance.positions ?? []).find((p) => {
         const positionChain = p.chain.trim().toUpperCase();
         const matchesChain = positionChain === String(chainId) || targetChainName !== void 0 && positionChain === targetChainName;
-        return matchesChain && isSameAsset(p.asset, asset) && Number(p.amount) > 0;
+        return matchesChain && p.asset.toLowerCase() === target && Number(p.amount) > 0;
       });
       return !!token && Number(token.amount) > 0 || !!position;
     } catch (error) {
@@ -4829,34 +3697,6 @@ var OwneySDK = class {
     }
     return eligible;
   }
-  /**
-   * Agent ids the routing API provisioned for this org that support the given
-   * chain + asset, ordered by preference ({@link AGENT_ELIGIBILITY_ORDER},
-   * surfliquid first). Returns `[]` when the org has no compatible agent — never
-   * throws on an empty org. Loads agent keys on first call (apiKey only, no
-   * wallet), so the UI can resolve which agent to use before the user connects.
-   *
-   * This is the source of truth for agent availability: an agent appears here
-   * iff the routing API returned its key. No per-app feature flags.
-   */
-  async getEligibleAgentIds(chainId, asset) {
-    try {
-      await this.ensureAgentsInitialized();
-    } catch (error) {
-      if (error instanceof OwneyError && error.code === "API_NO_AGENTS") {
-        return [];
-      }
-      throw error;
-    }
-    return [...this.agents.values()].filter((agent) => {
-      const chainAssets = agent.supportedAssets.find(
-        (sa) => sa.chainId === chainId
-      );
-      return chainAssets?.assets.some((a) => a.symbol === asset) ?? false;
-    }).map((agent) => agent.id).sort(
-      (a, b) => AGENT_ELIGIBILITY_ORDER.indexOf(a) - AGENT_ELIGIBILITY_ORDER.indexOf(b)
-    );
-  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -4893,19 +3733,9 @@ var OwneySDK = class {
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
     if (!amount) {
-      const aggregated2 = await this.getBalances();
-      const funded = projectAgentBalancesForAsset(
-        eligibleAgents,
-        aggregated2.agentBalances,
-        chainId,
-        asset,
-        assetInfo.decimals
-      ).filter(
-        ({ agent, balance }) => balance > 0n || aggregated2.agentErrors?.[agent.id] !== void 0
-      ).map(({ agent }) => agent);
       const results2 = {};
       const agentErrors2 = {};
-      for (const agent of funded) {
+      for (const agent of eligibleAgents) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
@@ -5148,6 +3978,60 @@ 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 ?? "", points: [] };
+      }
+      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 byDate = /* @__PURE__ */ new Map();
+    for (const s of series) {
+      for (const point of s.points) {
+        byDate.set(point.date, (byDate.get(point.date) ?? 0) + point.net);
+      }
+    }
+    return {
+      walletAddress: series[0]?.walletAddress ?? state.walletAddress ?? "",
+      points: [...byDate.entries()].map(([date, net]) => ({ date, net })).sort((a, b) => a.date.localeCompare(b.date))
+    };
+  }
   async getAccountApy({
     agentId,
     days,
@@ -5362,10 +4246,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem11.createWalletClient)({
+    const wallet = (0, import_viem6.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem11.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -5375,9 +4259,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem11.createPublicClient)({
+    const publicClient = (0, import_viem6.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem11.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -5488,18 +4372,14 @@ var OwneySDK = class {
   }
 };
 
-// src/index.ts
-init_errors();
-init_debug();
-
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem12 = require("viem");
+var import_viem7 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX3 = "owney.siwx.session";
-var storage3 = () => {
+var KEY_PREFIX2 = "owney.siwx.session";
+var storage2 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -5507,8 +4387,8 @@ var storage3 = () => {
     return null;
   }
 };
-var buildKey3 = (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;
@@ -5539,8 +4419,8 @@ var readLegacySiwxSession = (store, address) => {
 };
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
-  const key2 = buildKey3(address);
-  const store = storage3();
+  const key2 = buildKey2(address);
+  const store = storage2();
   let raw = null;
   try {
     raw = store?.getItem(key2) ?? null;
@@ -5568,18 +4448,18 @@ var readSiwxSession = (address, chainId) => {
 };
 var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key2 = buildKey3(address);
+  const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage3();
+  const store = storage2();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
   }
 };
 var clearSiwxSession = (address, _chainId) => {
-  const key2 = buildKey3(address);
+  const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage3();
+  const store = storage2();
   try {
     store?.removeItem(key2);
   } catch {
@@ -5620,7 +4500,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem12.getAddress)(accountAddress),
+          address: (0, import_viem7.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,
@@ -5698,9 +4578,9 @@ function buildSIWXConfig(deps) {
 }
 function createOwneySIWX(config) {
   const zyfai = new import_sdk2.ZyfaiSDK({ apiKey: config.apiKey });
-  const http3 = zyfai.httpClient;
+  const http2 = zyfai.httpClient;
   return buildSIWXConfig({
-    post: (url, data) => http3.post(url, data),
+    post: (url, data) => http2.post(url, data),
     referralSource: config.referralSource
   });
 }
@@ -5713,5 +4593,6 @@ function createOwneySIWX(config) {
   OwneyError,
   OwneySDK,
   createOwneySIWX,
+  recentEarningsFromPoints,
   setOwneyDebug
 });