@owney/sdk 0.7.16-beta.7 → 0.7.17-beta.0

package/dist/index.cjs

@@ -1,18 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 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 });
@@ -25,1245 +15,183 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// 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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentChainIncompatibleError: () => AgentChainIncompatibleError,
+  AgentNotFoundError: () => AgentNotFoundError,
+  InvalidHistoryCursorError: () => InvalidHistoryCursorError,
+  NotConnectedError: () => NotConnectedError,
+  OwneyError: () => OwneyError,
+  OwneySDK: () => OwneySDK,
+  createOwneySIWX: () => createOwneySIWX,
+  setOwneyDebug: () => setOwneyDebug
 });
+module.exports = __toCommonJS(index_exports);
 
 // 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/routing-api.ts
-var routing_api_exports = {};
-__export(routing_api_exports, {
-  ROUTING_API_BASE_URL: () => ROUTING_API_BASE_URL,
-  fetchAgentKeys: () => fetchAgentKeys,
-  fetchOrgAgentConfig: () => fetchOrgAgentConfig
-});
-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;
+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;
   }
-}
-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 }
+};
+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";
   }
-  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
-  };
-}
-function buildReceiveWithAuthorizationTypedData(input) {
-  const transfer = buildTransferWithAuthorizationTypedData(input);
-  return {
-    ...transfer,
-    types: { ReceiveWithAuthorization: transfer.types.TransferWithAuthorization },
-    primaryType: "ReceiveWithAuthorization"
-  };
-}
-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);
-}
-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/lib/permit2.ts
-function buildPermitTransferFromTypedData(input) {
-  return {
-    domain: {
-      name: "Permit2",
-      chainId: input.chainId,
-      verifyingContract: PERMIT2_ADDRESS
-    },
-    types: {
-      PermitTransferFrom: [
-        { name: "permitted", type: "TokenPermissions" },
-        { name: "spender", type: "address" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ],
-      TokenPermissions: [
-        { name: "token", type: "address" },
-        { name: "amount", type: "uint256" }
-      ]
-    },
-    primaryType: "PermitTransferFrom",
-    message: input.message
-  };
-}
-function randomPermit2Nonce() {
-  const bytes = new Uint8Array(32);
-  globalThis.crypto.getRandomValues(bytes);
-  return BigInt((0, import_viem4.bytesToHex)(bytes));
-}
-async function readPermit2Allowance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "allowance",
-    args: [owner, PERMIT2_ADDRESS]
-  });
-}
-async function readErc20Balance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "balanceOf",
-    args: [owner]
-  });
-}
-var import_viem4, PERMIT2_ADDRESS, MAX_UINT256, ERC20_ALLOWANCE_ABI;
-var init_permit2 = __esm({
-  "src/lib/permit2.ts"() {
-    "use strict";
-    import_viem4 = require("viem");
-    PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-    MAX_UINT256 = 2n ** 256n - 1n;
-    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" }]
-      }
-    ];
-  }
-});
-
-// src/agents/surfliquid/surfliquid.constants.ts
-var SURFLIQUID_CHAIN_ID, SURFLIQUID_CHAIN_NAME, SURFLIQUID_USDC_ADDRESS, SURFLIQUID_USDC_DECIMALS, SURFLIQUID_MIN_DEPOSIT, SURFLIQUID_APPROVAL_TARGET, 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_USDC_DECIMALS = 6;
-    SURFLIQUID_MIN_DEPOSIT = "0";
-    SURFLIQUID_APPROVAL_TARGET = 100000000000n;
-    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.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.wallet-adapter.ts
-var import_core_sdk, OwneyWalletAdapter;
-var init_surfliquid_wallet_adapter = __esm({
-  "src/agents/surfliquid/surfliquid.wallet-adapter.ts"() {
-    "use strict";
-    import_core_sdk = require("@surf_liquid/core-sdk");
-    OwneyWalletAdapter = class extends import_core_sdk.BaseWalletAdapter {
-      constructor(eip1193Provider) {
-        super();
-        this.eip1193Provider = eip1193Provider;
-      }
-      eip1193Provider;
-      name = "owney";
-      get installed() {
-        return true;
-      }
-      resolveProvider() {
-        return this.eip1193Provider;
-      }
-    };
-  }
-});
-
-// 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.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 balanceOf(address account) view returns (uint256)",
-      "function receiveWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, bytes signature)"
-    ]);
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
   }
-});
-
-// src/agents/surfliquid/surfliquid.calls.ts
-function buildDepositCalls(input) {
-  const { smartAccount, vault, amount, authorization, deploySalt } = input;
-  if (authorization.to.toLowerCase() !== smartAccount.toLowerCase()) {
-    throw new Error("Transfer authorization must pay the smart account");
-  }
-  if (authorization.value < amount) {
-    throw new Error("Transfer authorization 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
-      ])
+};
+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;
   }
-  calls.push(
-    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "receiveWithAuthorization", [
-      authorization.from,
-      authorization.to,
-      authorization.value,
-      authorization.validAfter,
-      authorization.validBefore,
-      authorization.nonce,
-      authorization.signature
-    ]),
-    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
-var surfliquid_sponsorship_exports = {};
-__export(surfliquid_sponsorship_exports, {
-  SubmittedError: () => SubmittedError,
-  depositSponsored: () => depositSponsored,
-  isSafeToRetry: () => isSafeToRetry,
-  withdrawSponsored: () => withdrawSponsored
-});
-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 Error(`SurfLiquid vault ${vault} is not owned by the smart account`);
+// src/lib/rate-limit.ts
+function rateLimitDelay(error, now = Date.now()) {
+  const seen = /* @__PURE__ */ new Set();
+  let limited = false;
+  let delay = 0;
+  function visit(value, depth = 0) {
+    if (depth > 6 || value == null) return;
+    if (typeof value === "string") {
+      if (/rate[ _-]?limit|too many requests|HTTP_429|\b429\b/i.test(value))
+        limited = true;
+      return;
     }
-    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 Error(`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 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 { tokenName, tokenVersion } = await chain.readTokenMeta();
-  const message = {
-    from: wallet.ownerAddress,
-    to: wallet.smartAccountAddress,
-    value: amount,
-    validAfter: 0n,
-    validBefore: BigInt(Math.floor(Date.now() / 1e3)) + AUTHORIZATION_TTL_SECONDS,
-    nonce: randomAuthNonce()
-  };
-  const signature = await wallet.signTransferAuthorization(
-    buildReceiveWithAuthorizationTypedData({
-      token: SURFLIQUID_USDC_ADDRESS,
-      chainId: SURFLIQUID_CHAIN_ID,
-      tokenName,
-      tokenVersion,
-      message
-    })
-  );
-  const txHash = await wallet.sendCalls(
-    buildDepositCalls({
-      smartAccount: wallet.smartAccountAddress,
-      vault,
-      amount,
-      authorization: { ...message, signature },
-      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)
-      );
+    if (typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    const record = value;
+    if ([record.status, record.statusCode, record.code].some(
+      (code) => String(code) === "429"
+    )) {
+      limited = true;
+    }
+    for (const key2 of ["retryAfterSeconds", "retryAfter"]) {
+      const seconds = Number(record[key2]);
+      if (Number.isFinite(seconds) && seconds > 0)
+        delay = Math.max(delay, seconds * 1e3);
+    }
+    const retryAt = Number(record.retryAt);
+    if (Number.isFinite(retryAt) && retryAt > now)
+      delay = Math.max(delay, retryAt - now);
+    const headers = record.headers;
+    const header = typeof headers?.get === "function" ? headers.get("Retry-After") : headers?.["retry-after"] ?? headers?.["Retry-After"];
+    if (typeof header === "string" || typeof header === "number") {
+      const seconds = Number(header);
+      const ms = Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(String(header)) - now;
+      if (Number.isFinite(ms) && ms > 0) delay = Math.max(delay, ms);
+    }
+    for (const key2 of [
+      "message",
+      "code",
+      "cause",
+      "details",
+      "response",
+      "data",
+      "fields"
+    ]) {
+      visit(record[key2], depth + 1);
+    }
+    for (const key2 of ["agentErrors", "failures"]) {
+      const entries = record[key2];
+      if (entries && typeof entries === "object") {
+        for (const entry of Object.values(entries)) visit(entry, depth + 1);
+      }
     }
   }
-  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 Error(`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)}`
-    );
-  }
+  visit(error);
+  return limited ? delay : void 0;
 }
-var AUTHORIZATION_TTL_SECONDS, SubmittedError, isSafeToRetry;
-var init_surfliquid_sponsorship = __esm({
-  "src/agents/surfliquid/surfliquid.sponsorship.ts"() {
-    "use strict";
-    init_transfer_auth();
-    init_surfliquid_constants();
-    init_surfliquid_calls();
-    AUTHORIZATION_TTL_SECONDS = 3600n;
-    SubmittedError = class extends Error {
-      constructor(message, userOpHash) {
-        super(message);
-        this.userOpHash = userOpHash;
-        this.name = "SubmittedError";
-      }
-      userOpHash;
-    };
-    isSafeToRetry = (error) => !(error instanceof SubmittedError);
-  }
-});
 
-// 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_viem8.createPublicClient)({ chain: import_chains2.base, transport: (0, import_viem8.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)
-  };
-}
-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_viem8.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_viem8.createWalletClient)({
-    account: input.ownerAddress,
-    chain: import_chains2.base,
-    transport: (0, import_viem8.custom)(input.provider)
-  });
-  return {
-    smartAccountAddress: account.address,
-    ownerAddress: input.ownerAddress,
-    // The EOA signs, not the smart account: USDC verifies ECDSA from the token holder.
-    signTransferAuthorization: (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_viem8, 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_viem8 = 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/lib/agent-reads.ts
+var AgentReads = class {
+  inFlight = /* @__PURE__ */ new Map();
+  cooldowns = /* @__PURE__ */ new Map();
+  // A reconnect must not reuse work started by the previous connection.
+  clearInFlight() {
+    this.inFlight.clear();
+  }
+  limited(agentId, until) {
+    return new OwneyError(
+      "AGENT_RATE_LIMITED",
+      "Too many requests. Please wait before trying again.",
+      {
+        statusCode: 429,
+        retryAt: until,
+        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3))
+      },
+      agentId
+    );
   }
-});
-
-// src/agents/surfliquid/surfliquid.agent.ts
-var surfliquid_agent_exports = {};
-__export(surfliquid_agent_exports, {
-  SurfLiquidAgent: () => SurfLiquidAgent
-});
-var import_core_sdk2, import_viem9, import_chains3, APY_WINDOW_KEY2, SurfLiquidAgent;
-var init_surfliquid_agent = __esm({
-  "src/agents/surfliquid/surfliquid.agent.ts"() {
-    "use strict";
-    import_core_sdk2 = require("@surf_liquid/core-sdk");
-    import_viem9 = require("viem");
-    import_chains3 = require("viem/chains");
-    init_errors();
-    init_surfliquid_constants();
-    init_permit2();
-    init_surfliquid_mapper();
-    init_surfliquid_wallet_adapter();
-    init_surfliquid_morpho();
-    APY_WINDOW_KEY2 = {
-      "7D": "apy7d",
-      "14D": "apy14d",
-      "30D": "apy30d"
-    };
-    SurfLiquidAgent = class {
-      constructor(config) {
-        this.config = config;
-      }
-      config;
-      id = "surfliquid";
-      supportedChainIds = [SURFLIQUID_CHAIN_ID];
-      supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
-      surf = null;
-      connectedAddress = null;
-      // In-flight connect+auth, shared by concurrent callers to dedupe SIWE.
-      connectPromise = null;
-      ensureSurf() {
-        if (this.surf) return this.surf;
-        this.surf = import_core_sdk2.SurfClient.create({
-          projectName: this.config.projectName,
-          appId: this.config.appId,
-          environment: "mainnet",
-          chainId: SURFLIQUID_CHAIN_ID,
-          apiBaseUrl: this.config.apiBaseUrl,
-          rpcUrl: this.config.rpcUrl,
-          // Let the SDK auto-approve USDC to the vault before depositing.
-          autoApprove: true
-        });
-        return this.surf;
-      }
-      /**
-       * Connects + authenticates the SurfClient against owney's provider. Skips the
-       * SIWE prompt when already authenticated for this wallet (cookie session).
-       */
-      async connect(state) {
-        const surf = this.ensureSurf();
-        const sameWallet = this.connectedAddress?.toLowerCase() === state.walletAddress.toLowerCase();
-        if (sameWallet && surf.getAuthState().authenticated) {
-          return surf;
-        }
-        if (this.connectPromise) return this.connectPromise;
-        this.connectPromise = (async () => {
-          surf.registerWalletAdapter(
-            "owney",
-            new OwneyWalletAdapter(state.provider)
-          );
-          await surf.connectWallet("owney");
-          await surf.authenticate();
-          this.connectedAddress = state.walletAddress;
-          return surf;
-        })();
-        try {
-          return await this.connectPromise;
-        } finally {
-          this.connectPromise = null;
-        }
-      }
-      /**
-       * Returns the user's vault address, deploying one on first use. SurfLiquid's
-       * deposit requires the vault to exist, so this must run before depositing.
-       * Existing vault → returned as-is; otherwise `deployVault()` is sent
-       * (user-pays) and the freshly deployed address is returned.
-       */
-      async resolveVaultAddress(surf, owner) {
-        const vault = await surf.getVault(owner).catch(() => null);
-        if (vault?.exists && vault.userVaultAddress) {
-          return vault.userVaultAddress;
-        }
-        const { vaultAddress } = await surf.deployVault();
-        return vaultAddress;
-      }
-      /**
-       * Grants the user's vault a standing USDC allowance so SurfLiquid's
-       * `autoApprove` has nothing to do — see {@link SURFLIQUID_APPROVAL_TARGET}
-       * for why one prompt per deposit is worth removing.
-       *
-       * Fails OPEN on a read error: if the allowance can't be checked we simply
-       * return and let SurfLiquid's own per-deposit approve run, because a flaky
-       * RPC must never block a deposit. A failed or rejected APPROVE does
-       * propagate — the user declined a transaction, and letting SurfLiquid
-       * immediately ask again for a smaller one is exactly the double prompt this
-       * removes.
-       */
-      async ensureVaultAllowance(state, vaultAddress, amount) {
-        const spender = vaultAddress;
-        const transport = (0, import_viem9.custom)(state.provider);
-        const publicClient = (0, import_viem9.createPublicClient)({ chain: import_chains3.base, transport });
-        let allowance;
-        try {
-          allowance = await publicClient.readContract({
-            address: SURFLIQUID_USDC_ADDRESS,
-            abi: ERC20_ALLOWANCE_ABI,
-            functionName: "allowance",
-            args: [state.walletAddress, spender]
-          });
-        } catch (error) {
-          console.warn(
-            "[owney-sdk] SurfLiquid allowance pre-check failed; deferring to its per-deposit approve:",
-            error instanceof Error ? error.message : String(error)
-          );
-          return;
-        }
-        if (allowance >= amount) return;
-        const target = amount > SURFLIQUID_APPROVAL_TARGET ? amount : SURFLIQUID_APPROVAL_TARGET;
-        const wallet = (0, import_viem9.createWalletClient)({
-          account: state.walletAddress,
-          chain: import_chains3.base,
-          transport
-        });
-        const hash = await wallet.writeContract({
-          address: SURFLIQUID_USDC_ADDRESS,
-          abi: ERC20_ALLOWANCE_ABI,
-          functionName: "approve",
-          args: [spender, target],
-          account: state.walletAddress,
-          chain: import_chains3.base
-        });
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash,
-          confirmations: 1
-        });
-        if (receipt.status !== "success") {
-          throw new Error(`SurfLiquid USDC approval reverted (tx ${hash})`);
-        }
-      }
-      // --- IAgent: lifecycle ---
-      async disconnect() {
-        if (this.surf) {
-          await this.surf.disconnectWallet();
-        }
-        this.connectedAddress = null;
-      }
-      async activateAgent(state) {
-        await this.connect(state);
-      }
-      /** Their exported client, so `prepare`/`confirm` ride the SIWE cookie this session already holds. */
-      async vaultApi() {
-        const { HttpClient, VaultApiService } = await import("@surf_liquid/core-sdk");
-        return new VaultApiService(
-          new HttpClient({
-            baseUrl: this.config.apiBaseUrl ?? "https://api.surfliquid.com",
-            projectName: this.config.projectName,
-            projectId: this.config.projectName,
-            appId: this.config.appId ?? ""
-          })
-        );
-      }
-      async sponsoredWallet(state) {
-        if (!this.config.apiKey) return null;
-        const { createSponsoredWallet: createSponsoredWallet2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        const { ROUTING_API_BASE_URL: ROUTING_API_BASE_URL4 } = await Promise.resolve().then(() => (init_routing_api(), routing_api_exports));
-        return createSponsoredWallet2({
-          provider: state.provider,
-          ownerAddress: state.walletAddress,
-          // Apps rarely set this; without the default, sponsorship silently never runs in production.
-          routingApiBaseUrl: this.config.routingApiBaseUrl ?? ROUTING_API_BASE_URL4,
-          apiKey: this.config.apiKey,
-          rpcUrl: this.config.rpcUrl
-        });
-      }
-      /** Null means nothing happened on-chain, so the caller is free to retry as user-pays. */
-      async trySponsoredDeposit(state, amount) {
-        const wallet = await this.sponsoredWallet(state).catch(() => null);
-        if (!wallet) return null;
-        const { depositSponsored: depositSponsored2, isSafeToRetry: isSafeToRetry2 } = await Promise.resolve().then(() => (init_surfliquid_sponsorship(), surfliquid_sponsorship_exports));
-        const { createSponsoredChain: createSponsoredChain2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        try {
-          const { txHash, vault } = await depositSponsored2({
-            amount,
-            api: await this.vaultApi(),
-            chain: createSponsoredChain2(this.config.rpcUrl),
-            wallet
-          });
-          return { txHash, smartWallet: vault };
-        } catch (error) {
-          if (!isSafeToRetry2(error)) throw error;
-          console.warn(
-            "[owney-sdk] SurfLiquid sponsored deposit unavailable; falling back to user-pays:",
-            error instanceof Error ? error.message : String(error)
-          );
-          return null;
-        }
-      }
-      async trySponsoredWithdraw(state, amount) {
-        const wallet = await this.sponsoredWallet(state).catch(() => null);
-        if (!wallet) return null;
-        const { withdrawSponsored: withdrawSponsored2, isSafeToRetry: isSafeToRetry2 } = await Promise.resolve().then(() => (init_surfliquid_sponsorship(), surfliquid_sponsorship_exports));
-        const { createSponsoredChain: createSponsoredChain2 } = await Promise.resolve().then(() => (init_surfliquid_smart_account(), surfliquid_smart_account_exports));
-        try {
-          const result = await withdrawSponsored2({
-            amount: amount != null ? BigInt(amount) : void 0,
-            api: await this.vaultApi(),
-            chain: createSponsoredChain2(this.config.rpcUrl),
-            wallet
-          });
-          return {
-            txHash: result.txHash,
-            type: amount != null ? "partial" : "full",
-            amount: result.amount
-          };
-        } catch (error) {
-          if (!isSafeToRetry2(error)) throw error;
-          console.warn(
-            "[owney-sdk] SurfLiquid sponsored withdraw unavailable; falling back to user-pays:",
-            error instanceof Error ? error.message : String(error)
-          );
-          return null;
-        }
-      }
-      // --- IAgent: funds (gasless when sponsorship is reachable, else user-pays) ---
-      async deposit(state, _chainId, amount, _asset, _depositCallback) {
-        const surf = await this.connect(state);
-        const sponsored = await this.trySponsoredDeposit(state, BigInt(amount));
-        if (sponsored) return { ...sponsored, amount };
-        const human = (0, import_viem9.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
-        const smartWallet = await this.resolveVaultAddress(
-          surf,
-          state.walletAddress
-        );
-        await this.ensureVaultAllowance(state, smartWallet, BigInt(amount));
-        const tx = await surf.deposit({
-          asset: SURFLIQUID_USDC_ADDRESS,
-          amount: human
-        });
-        await tx.wait();
-        return { txHash: tx.hash, smartWallet, amount };
-      }
-      async withdraw(state, _chainId, _token, amount) {
-        const surf = await this.connect(state);
-        const sponsored = await this.trySponsoredWithdraw(state, amount);
-        if (sponsored) return sponsored;
-        const human = amount != null ? (0, import_viem9.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS) : void 0;
-        try {
-          const tx = await surf.withdraw({
-            asset: SURFLIQUID_USDC_ADDRESS,
-            amount: human
-          });
-          await tx.wait();
-          return {
-            txHash: tx.hash,
-            type: amount != null ? "partial" : "full",
-            amount: amount ?? "0"
-          };
-        } catch (error) {
-          throw new OwneyError(
-            "WITHDRAW_FAILED",
-            error instanceof Error ? error.message : "SurfLiquid withdraw failed.",
-            { chainId: SURFLIQUID_CHAIN_ID, amount },
-            this.id
-          );
-        }
-      }
-      // --- IAgent: portfolio reads ---
-      async getBalances(state, chainId) {
-        const surf = await this.connect(state);
-        const vault = await surf.getVault(state.walletAddress);
-        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 surf = await this.connect(state);
-        const vault = await surf.getVault(state.walletAddress);
-        return mapEarnings2(vault, vault.userVaultAddress ?? state.walletAddress);
-      }
-      async getAccountApy(state, _chainId, days, _tokenSymbol) {
-        const surf = await this.connect(state);
-        const vault = await surf.getVault(state.walletAddress);
-        return mapAccountApy(vault, days);
-      }
-      async getHistory(state, chainId, options) {
-        const surf = await this.connect(state);
-        const page = options?.cursor ? Number(options.cursor) : 1;
-        const limit = options?.limit ?? 10;
-        const result = await surf.getAgentMessages(
-          state.walletAddress,
-          page,
-          limit,
-          options?.fromDate,
-          options?.toDate
+  run(agentId, key2, fetch2) {
+    const cooldown = this.cooldowns.get(agentId);
+    if (cooldown && cooldown.until > Date.now()) {
+      return Promise.reject(this.limited(agentId, cooldown.until));
+    }
+    const requestKey = JSON.stringify([agentId, key2]);
+    const existing = this.inFlight.get(requestKey);
+    if (existing) return existing;
+    const promise = Promise.resolve().then(fetch2).then(
+      (value) => {
+        if (this.cooldowns.get(agentId) === cooldown)
+          this.cooldowns.delete(agentId);
+        return value;
+      },
+      (error) => {
+        const requestedDelay = rateLimitDelay(error);
+        if (requestedDelay === void 0) throw error;
+        const previous = this.cooldowns.get(agentId);
+        const failures = previous && previous.until > Date.now() ? previous.failures : Math.min((previous?.failures ?? 0) + 1, 5);
+        const delay = Math.max(
+          requestedDelay,
+          Math.min(3e4 * 2 ** (failures - 1), 3e5)
         );
-        return mapHistory(result, chainId);
+        const until = Math.max(previous?.until ?? 0, Date.now() + delay);
+        this.cooldowns.set(agentId, { until, failures });
+        throw this.limited(agentId, until);
       }
-      async getUserProfile(state) {
-        const surf = await this.connect(state);
-        const vault = await surf.getVault(state.walletAddress);
-        return mapUserProfile2(vault, state.walletAddress);
-      }
-      // --- IAgent: discovery (no wallet) ---
-      async getAgentApy(days, _options) {
-        const surf = this.ensureSurf();
-        const assets = await surf.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 };
-      }
-    };
+    ).finally(() => {
+      if (this.inFlight.get(requestKey) === promise)
+        this.inFlight.delete(requestKey);
+    });
+    this.inFlight.set(requestKey, promise);
+    return promise;
   }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AgentChainIncompatibleError: () => AgentChainIncompatibleError,
-  AgentNotFoundError: () => AgentNotFoundError,
-  InvalidHistoryCursorError: () => InvalidHistoryCursorError,
-  NotConnectedError: () => NotConnectedError,
-  OwneyError: () => OwneyError,
-  OwneySDK: () => OwneySDK,
-  createOwneySIWX: () => createOwneySIWX,
-  setOwneyDebug: () => setOwneyDebug
-});
-module.exports = __toCommonJS(index_exports);
+};
 
 // src/agents/zyfai/zyfai.agent.ts
 var import_sdk = require("@zyfai/sdk");
@@ -1317,11 +245,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(
@@ -1332,12 +273,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);
@@ -1800,9 +735,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 = () => {
@@ -2065,7 +997,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)"
 ]);
@@ -2134,7 +1065,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
   // successful decode is cached forever; failures are NOT cached so a transient
   // RPC error retries on the next fetch.
   withdrawAmountCache = /* @__PURE__ */ new Map();
-  earningsRefreshInFlight = null;
+  earningsReads = /* @__PURE__ */ new Map();
+  earningsRefreshes = /* @__PURE__ */ new Map();
+  earningsSnapshot = null;
+  earningsGeneration = 0;
   constructor(apiKey, rpcUrls, referralSource) {
     this.rpcUrls = rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS;
     this.sdk = new import_sdk.ZyfaiSDK({
@@ -2379,6 +1313,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   // --- IAgent: Connection lifecycle ---
   async disconnect() {
+    this.earningsGeneration++;
+    this.earningsReads.clear();
+    this.earningsRefreshes.clear();
+    this.earningsSnapshot = null;
     if (this.connectedAddress && this.connectedChainId !== null) {
       clearSession(this.connectedAddress, this.connectedChainId);
     }
@@ -2571,39 +1509,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
     } catch (error) {
       console.warn(
         "[zyfai] applyPoolPolicy failed (non-fatal):",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * 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)
-        );
-      }
+        error instanceof Error ? error.message : String(error)
+      );
     }
   }
   /**
@@ -2909,12 +1816,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);
@@ -2956,26 +1865,59 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const raw = await this.sdk.getPortfolio(this.getAddress());
     return mapBalances(raw, validChainId, smartWallet);
   }
+  earningsKey(state, chainId, smartWallet) {
+    return JSON.stringify([
+      state.walletAddress?.toLowerCase(),
+      chainId,
+      smartWallet.toLowerCase()
+    ]);
+  }
+  readEarnings(key2, smartWallet) {
+    const existing = this.earningsReads.get(key2);
+    if (existing) return existing;
+    const generation = this.earningsGeneration;
+    const pending = Promise.resolve().then(() => this.sdk.getOnchainEarnings(smartWallet)).then((raw) => {
+      if (generation === this.earningsGeneration) {
+        this.earningsSnapshot = { key: key2, raw, at: Date.now() };
+      }
+      return raw;
+    }).finally(() => {
+      if (this.earningsReads.get(key2) === pending)
+        this.earningsReads.delete(key2);
+    });
+    this.earningsReads.set(key2, pending);
+    return pending;
+  }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.sdk.getOnchainEarnings(smartWallet);
+    const raw = await this.readEarnings(
+      this.earningsKey(state, chainId, smartWallet),
+      smartWallet
+    );
     return mapEarnings(raw, smartWallet);
   }
   async refreshEarnings(state, chainId) {
-    if (this.earningsRefreshInFlight) return this.earningsRefreshInFlight;
-    this.earningsRefreshInFlight = (async () => {
-      const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-      const current = await this.sdk.getOnchainEarnings(smartWallet);
+    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
+    const key2 = this.earningsKey(state, chainId, smartWallet);
+    const existing = this.earningsRefreshes.get(key2);
+    if (existing) return existing;
+    const generation = this.earningsGeneration;
+    const pending = (async () => {
+      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 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);
-    })();
-    try {
-      return await this.earningsRefreshInFlight;
-    } finally {
-      this.earningsRefreshInFlight = null;
-    }
+    })().finally(() => {
+      if (this.earningsRefreshes.get(key2) === pending)
+        this.earningsRefreshes.delete(key2);
+    });
+    this.earningsRefreshes.set(key2, pending);
+    return pending;
   }
   async getAccountApy(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -3095,13 +2037,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 {
@@ -3137,10 +2137,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) };
@@ -3250,21 +2251,52 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem10 = 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",
@@ -3301,10 +2333,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",
@@ -3339,11 +2371,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 }
       }
@@ -3375,11 +2407,85 @@ async function getSponsorRelayerAddress(input) {
   return parsed.data.relayer;
 }
 
-// src/lib/sponsored-deposit.ts
-init_permit2();
+// src/lib/permit2.ts
+var import_viem4 = require("viem");
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: input.chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    types: {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    },
+    primaryType: "PermitTransferFrom",
+    message: input.message
+  };
+}
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt((0, import_viem4.bytesToHex)(bytes));
+}
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
 
 // src/lib/chain-guard.ts
-init_errors();
 var CHAIN_NAMES = {
   1: "Ethereum",
   8453: "Base",
@@ -3493,8 +2599,6 @@ function makeSponsoredDepositCallback(deps) {
 }
 
 // src/lib/sponsored-weth-deposit.ts
-init_errors();
-init_permit2();
 var PERMIT_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredWethCallback(deps) {
   const get = deps.httpGet ?? getSponsorRelayerAddress;
@@ -3579,7 +2683,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) {
@@ -3670,7 +2773,6 @@ function makeSponsoredCallsCallback(deps) {
 }
 
 // src/client.ts
-init_permit2();
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -3697,11 +2799,10 @@ 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 AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai"];
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -3730,11 +2831,21 @@ var OwneySDK = class {
   zyfaiRpcUrls;
   routingApiBaseUrl;
   referralSource;
-  surfliquidApiBaseUrl;
   cachedSponsoredCallback = null;
   cachedWethSponsoredCallback = null;
   paymasterServiceUrl;
   cachedSponsoredCallsCallbacks = /* @__PURE__ */ new Map();
+  agentReads = new AgentReads();
+  activationChecks = /* @__PURE__ */ new Map();
+  readAgent(agent, method, fetch2, params = null) {
+    const key2 = JSON.stringify([
+      this.state?.walletAddress.toLowerCase() ?? null,
+      this.state?.chainId ?? null,
+      method,
+      params
+    ]);
+    return this.agentReads.run(agent.id, key2, fetch2);
+  }
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
@@ -3743,7 +2854,6 @@ var OwneySDK = class {
     this.routingApiBaseUrl = config.routingApiBaseUrl;
     this.paymasterServiceUrl = config.paymasterServiceUrl;
     this.referralSource = config.referralSource;
-    this.surfliquidApiBaseUrl = config.surfliquidApiBaseUrl;
   }
   /**
    * Establish connection state for all subsequent SDK calls.
@@ -3762,6 +2872,8 @@ var OwneySDK = class {
         "No accounts found. Ensure the wallet is unlocked and connected."
       );
     }
+    this.agentReads.clearInFlight();
+    this.activationChecks.clear();
     this.state = { provider, walletAddress, chainId: null };
     this.cachedSponsoredCallback = null;
     this.cachedWethSponsoredCallback = null;
@@ -3777,6 +2889,8 @@ var OwneySDK = class {
     }
     this.activeAgents.clear();
     this.disabledAgents.clear();
+    this.agentReads.clearInFlight();
+    this.activationChecks.clear();
     this.state = null;
     this.cachedSponsoredCallback = null;
     this.cachedWethSponsoredCallback = null;
@@ -3843,14 +2957,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_viem10.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem10.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem10.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem10.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -3896,14 +3010,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_viem10.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem10.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem10.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem10.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -3979,8 +3093,8 @@ var OwneySDK = class {
           this.routingApiBaseUrl
         );
         this.disabledAgents.clear();
-        for (const { key: key2, agent_type, project_name, is_enabled } of agentKeys) {
-          const agent = await this.createAgent(agent_type, key2, project_name);
+        for (const { key: key2, agent_type, is_enabled } of agentKeys) {
+          const agent = this.createAgent(agent_type, key2);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -4001,25 +3115,42 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  async createAgent(agentId, key2, projectName) {
+  createAgent(agentId, key2) {
     if (agentId === "zyfai") {
       return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
     }
-    if (agentId === "surfliquid") {
-      if (!projectName) return null;
-      const { SurfLiquidAgent: SurfLiquidAgent2 } = await Promise.resolve().then(() => (init_surfliquid_agent(), surfliquid_agent_exports));
-      return new SurfLiquidAgent2({
-        projectName,
-        appId: key2,
-        // Same-origin proxy override — SurfLiquid auth is an httpOnly cookie,
-        // which WebKit (iOS) discards when it is third-party. See
-        // OwneySDKConfig.surfliquidApiBaseUrl.
-        apiBaseUrl: this.surfliquidApiBaseUrl,
-        apiKey: this.apiKey,
-        routingApiBaseUrl: this.routingApiBaseUrl
+    return null;
+  }
+  /**
+   * Discover the agents actually returned by routing for this organization.
+   * Consumers should use this instead of hardcoding a global agent roster.
+   */
+  async getAvailableAgents(options = {}) {
+    await this.ensureAgentsInitialized();
+    const { chainId, asset, includeDisabled = false } = options;
+    const available = [];
+    for (const [id, agent] of this.agents) {
+      const isEnabled = !this.isAgentDisabled(id);
+      if (!includeDisabled && !isEnabled) continue;
+      if (chainId !== void 0 && !agent.supportedChainIds.includes(chainId)) {
+        continue;
+      }
+      if (asset !== void 0) {
+        const supportsAsset = agent.supportedAssets.some(
+          (entry) => (chainId === void 0 || entry.chainId === chainId) && entry.assets.some((candidate) => candidate.symbol === asset)
+        );
+        if (!supportsAsset) {
+          continue;
+        }
+      }
+      available.push({
+        id,
+        isEnabled,
+        supportedChainIds: agent.supportedChainIds,
+        supportedAssets: agent.supportedAssets
       });
     }
-    return null;
+    return available;
   }
   // --- Account lifecycle ---
   /**
@@ -4068,9 +3199,7 @@ var OwneySDK = class {
         this.activeAgents.add(id);
       }
       state.chainId = chainId;
-      this.activateAgentsInTurn(agents, state, chainId).catch((error) => {
-        console.error("activateAgent background init failed:", error);
-      });
+      await this.activateAgentsInTurn(agents, state, chainId);
       return;
     }
     const compatible = [...this.agents.values()].filter(
@@ -4091,11 +3220,7 @@ var OwneySDK = class {
     const enabledCompatible = compatible.filter(
       (agent) => !this.isAgentDisabled(agent.id)
     );
-    this.activateAgentsInTurn(enabledCompatible, state, chainId).catch(
-      (error) => {
-        console.error("activateAgent background init failed:", error);
-      }
-    );
+    await this.activateAgentsInTurn(enabledCompatible, state, chainId);
   }
   /**
    * Activate agents ONE AT A TIME, each followed by its org policy.
@@ -4132,7 +3257,7 @@ var OwneySDK = class {
     if (firstError !== null) throw firstError;
   }
   /**
-   * Deposit funds into a specific agent, or split equally across all agents if agentId is omitted.
+   * Deposit into a specific agent, or distribute across all eligible agents.
    * Validates that the asset is supported and amount meets minimums for the target agent(s).
    * @param options - Deposit parameters
    * @param options.amount - Amount to deposit in smallest unit (e.g. "100000000" for 100 USDC)
@@ -4140,7 +3265,8 @@ var OwneySDK = class {
    * @param options.depositCallback - Callback that performs the token transfer and returns a tx hash.
    *   When agentId is omitted, this callback is invoked once per eligible agent with that agent's
    *   split amount and smart wallet address — expect multiple wallet prompts.
-   * @param options.agentId - Optional. Target agent. Omit to split equally across all agents.
+   * @param options.agentId - Optional explicit target. Otherwise split equally,
+   *   or fund remaining agents when a recovery deposit cannot meet every minimum.
    * @returns {OwneyDepositResult} for a single agent, or {OwneyMultiDepositResult} with per-agent results
    */
   async deposit(options) {
@@ -4178,7 +3304,7 @@ var OwneySDK = class {
     });
     const exemptFlags = await Promise.all(
       eligibleAgents.map(
-        (a) => this.hasExistingBalance(a, state, chainId, asset)
+        (a) => this.hasExistingBalance(a, state, chainId, asset, true)
       )
     );
     const exempt = new Set(
@@ -4192,15 +3318,42 @@ var OwneySDK = class {
       exempt
     );
     if (agentAmounts.length === 0) {
+      const agentsRequiringActivation = eligibleAgents.filter(
+        (agent) => !exempt.has(agent.id)
+      );
+      const perAgentMinimum = agentsRequiringActivation.reduce(
+        (highest, agent) => {
+          const minimum = this.getMinDepositAmount(agent, chainId, asset);
+          return minimum > highest ? minimum : highest;
+        },
+        0n
+      );
+      const minimumRequired = agentsRequiringActivation.length > 0 ? (perAgentMinimum > 0n ? perAgentMinimum : 1n) * BigInt(agentsRequiringActivation.length) : BigInt(eligibleAgents.length);
       throw new OwneyError(
         "DEPOSIT_AMOUNT_BELOW_MINIMUM",
-        `Amount "${amount}" cannot satisfy minimum deposit requirements for any eligible agent.`,
-        { amount }
+        `Amount "${amount}" cannot activate every eligible agent. The combined minimum is "${minimumRequired.toString()}" for ${asset}.`,
+        {
+          amount,
+          asset,
+          chainId,
+          minDepositAmount: minimumRequired.toString(),
+          perAgentDepositAmount: perAgentMinimum.toString(),
+          agentMinimums: agentsRequiringActivation.map((agent) => ({
+            agentId: agent.id,
+            minDepositAmount: this.getMinDepositAmount(
+              agent,
+              chainId,
+              asset
+            ).toString()
+          }))
+        }
       );
     }
     const agentResults = {};
-    const agentErrors = {};
-    for (const { agent, amount: agentAmount } of agentAmounts) {
+    for (const [
+      index,
+      { agent, amount: agentAmount }
+    ] of agentAmounts.entries()) {
       try {
         agentResults[agent.id] = await this.depositWithFallback(
           agent,
@@ -4212,17 +3365,22 @@ var OwneySDK = class {
           depositCallback
         );
       } catch (error) {
-        agentErrors[agent.id] = error instanceof Error ? error.message : String(error);
+        if (Object.keys(agentResults).length === 0) throw error;
+        throw new OwneyError(
+          "DEPOSIT_PARTIAL_FAILURE",
+          "Some deposits completed before another agent failed. Check activity and balances before depositing again; the failed transfer may still settle.",
+          {
+            agentResults,
+            failedAgentId: agent.id,
+            failedAmount: agentAmount,
+            unattemptedAgentIds: agentAmounts.slice(index + 1).map(({ agent: agent2 }) => agent2.id),
+            cause: error
+          },
+          agent.id
+        );
       }
     }
-    if (Object.keys(agentResults).length === 0) {
-      throw new OwneyError(
-        "DEPOSIT_ALL_FAILED",
-        `All ${agentAmounts.length} agent deposit(s) failed.`,
-        { agentErrors }
-      );
-    }
-    return Object.keys(agentErrors).length > 0 ? { agentResults, agentErrors } : { agentResults };
+    return { agentResults };
   }
   /**
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
@@ -4293,6 +3451,17 @@ var OwneySDK = class {
   }
   splitDepositAmount(totalAmount, agents, chainId, asset, exempt = /* @__PURE__ */ new Set()) {
     if (agents.length === 0) return [];
+    const agentsRequiringActivation = agents.filter(
+      (agent) => !exempt.has(agent.id)
+    );
+    if (agentsRequiringActivation.length === agents.length) {
+      const highestMinimum2 = agents.reduce((highest, agent) => {
+        const minimum = this.getMinDepositAmount(agent, chainId, asset);
+        return minimum > highest ? minimum : highest;
+      }, 0n);
+      const minimumRequired2 = (highestMinimum2 > 0n ? highestMinimum2 : 1n) * BigInt(agents.length);
+      if (totalAmount < minimumRequired2) return [];
+    }
     const perAgent = totalAmount / BigInt(agents.length);
     const remainder = totalAmount % BigInt(agents.length);
     const splits = agents.map((agent, i) => ({
@@ -4300,18 +3469,26 @@ var OwneySDK = class {
       amount: i === agents.length - 1 ? perAgent + remainder : perAgent
     }));
     const valid = splits.filter(
-      (s) => exempt.has(s.agent.id) || s.amount >= this.getMinDepositAmount(s.agent, chainId, asset)
+      (s) => s.amount > 0n && (exempt.has(s.agent.id) || s.amount >= this.getMinDepositAmount(s.agent, chainId, asset))
     );
     if (valid.length === agents.length) {
       return splits.map((s) => ({ agent: s.agent, amount: String(s.amount) }));
     }
-    return this.splitDepositAmount(
-      totalAmount,
-      valid.map((s) => s.agent),
-      chainId,
-      asset,
-      exempt
-    );
+    const targets = agentsRequiringActivation.length > 0 ? agentsRequiringActivation : agents;
+    const highestMinimum = targets.reduce((highest, agent) => {
+      const minimum = this.getMinDepositAmount(agent, chainId, asset);
+      return minimum > highest ? minimum : highest;
+    }, 0n);
+    const minimumRequired = (highestMinimum > 0n ? highestMinimum : 1n) * BigInt(targets.length);
+    if (totalAmount < minimumRequired) return [];
+    const targetShare = totalAmount / BigInt(targets.length);
+    const targetRemainder = totalAmount % BigInt(targets.length);
+    return targets.map((agent, index) => ({
+      agent,
+      amount: String(
+        targetShare + (index === targets.length - 1 ? targetRemainder : 0n)
+      )
+    }));
   }
   async validateMinDepositAmount(agent, state, chainId, asset, amount) {
     const minDepositAmount = this.getMinDepositAmount(agent, chainId, asset);
@@ -4336,14 +3513,29 @@ var OwneySDK = class {
    * per-agent minimum. Fails closed: any error reading balances returns
    * false, so the minimum is enforced as today.
    */
-  async hasExistingBalance(agent, state, chainId, asset) {
+  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
       );
-      return !!token && Number(token.amount) > 0;
-    } catch {
+      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 && p.asset.toLowerCase() === target && Number(p.amount) > 0;
+      });
+      return !!token && Number(token.amount) > 0 || !!position;
+    } catch (error) {
+      if (requireReliableRead) {
+        throw new OwneyError(
+          "DEPOSIT_BALANCE_UNAVAILABLE",
+          "Could not verify every agent balance. No deposit was submitted. Try again once balances are available.",
+          { agentId: agent.id, chainId, asset, cause: error },
+          agent.id
+        );
+      }
       return false;
     }
   }
@@ -4379,34 +3571,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.
@@ -4443,17 +3607,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((b) => b.balance > 0n);
       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) {
@@ -4475,10 +3631,9 @@ var OwneySDK = class {
           { asset, agentErrors: agentErrors2 }
         );
       }
-      const totalWithdrawn = funded.filter(({ agent }) => results2[agent.id] !== void 0).reduce((sum, { balance }) => sum + balance, 0n);
       return {
         agentResult: results2,
-        totalWithdrawn: totalWithdrawn.toString()
+        totalWithdrawn: sumWithdrawnAmount(results2).toString()
       };
     }
     const requested = BigInt(amount);
@@ -4583,7 +3738,8 @@ var OwneySDK = class {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      const result = await this.getAgent(agentId).getBalances(state, chainId);
+      const agent = this.getAgent(agentId);
+      const result = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
       return result;
     }
     let totalBalance = 0;
@@ -4591,12 +3747,13 @@ var OwneySDK = class {
     const entries = [...this.getActiveAgents().entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
-        const b = await agent.getBalances(state, chainId);
+        const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
         return [id, b];
       })
     );
     let successCount = 0;
     const agentErrors = {};
+    const agentFailures = [];
     for (let i = 0; i < balanceResults.length; i++) {
       const settledResult = balanceResults[i];
       const [agentId2] = entries[i];
@@ -4608,13 +3765,14 @@ var OwneySDK = class {
         continue;
       }
       const reason = settledResult.reason;
+      agentFailures.push(reason);
       agentErrors[agentId2] = reason instanceof Error ? reason.message : String(reason);
     }
     if (successCount === 0) {
       throw new OwneyError(
         "BALANCE_ALL_FAILED",
         "Failed to fetch balances for all active agents.",
-        { agentErrors }
+        { agentErrors, failures: agentFailures }
       );
     }
     return {
@@ -4632,14 +3790,15 @@ var OwneySDK = class {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getEarnings(state, chainId);
+      const agent = this.getAgent(agentId);
+      return this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
     }
     let totalEarnings = 0;
     const results = {};
     const entries = [...this.getActiveAgents().entries()];
     const earningsResults = await Promise.all(
       entries.map(async ([id, agent]) => {
-        const e = await agent.getEarnings(state, chainId);
+        const e = await this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
         return [id, e];
       })
     );
@@ -4659,7 +3818,11 @@ var OwneySDK = class {
   async refreshEarnings(agentId) {
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const refreshAgent = (agent) => agent.refreshEarnings?.(state, chainId) ?? agent.getEarnings(state, chainId);
+    const refreshAgent = (agent) => this.readAgent(
+      agent,
+      agent.refreshEarnings ? "refreshEarnings" : "earnings",
+      () => agent.refreshEarnings?.(state, chainId) ?? agent.getEarnings(state, chainId)
+    );
     if (agentId) return refreshAgent(this.getAgent(agentId));
     let totalEarnings = 0;
     const agentEarnings = {};
@@ -4690,11 +3853,12 @@ var OwneySDK = class {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getAccountApy(
-        state,
-        chainId,
-        days,
-        tokenSymbol
+      const agent = this.getAgent(agentId);
+      return this.readAgent(
+        agent,
+        "accountApy",
+        () => agent.getAccountApy(state, chainId, days, tokenSymbol),
+        { days, tokenSymbol }
       );
     }
     const activeAgents = this.getActiveAgents();
@@ -4702,18 +3866,18 @@ var OwneySDK = class {
     const [apyResults, balanceResults] = await Promise.all([
       Promise.all(
         entries.map(async ([id, agent]) => {
-          const apy = await agent.getAccountApy(
-            state,
-            chainId,
-            days,
-            tokenSymbol
+          const apy = await this.readAgent(
+            agent,
+            "accountApy",
+            () => agent.getAccountApy(state, chainId, days, tokenSymbol),
+            { days, tokenSymbol }
           );
           return [id, apy];
         })
       ),
       Promise.all(
         entries.map(async ([id, agent]) => {
-          const b = await agent.getBalances(state, chainId);
+          const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
           return [id, Number(b.totalBalance)];
         })
       )
@@ -4770,7 +3934,8 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     const { agentId, filters } = options ?? {};
     if (agentId) {
-      return this.getAgent(agentId).getHistory(state, chainId, filters);
+      const agent = this.getAgent(agentId);
+      return this.readAgent(agent, "history", () => agent.getHistory(state, chainId, filters), filters);
     }
     const activeAgents = [...this.getActiveAgents().values()];
     const cursorMap = filters?.cursor ? decodeMultiAgentCursor(filters.cursor) : {};
@@ -4780,10 +3945,13 @@ var OwneySDK = class {
         if (filters?.cursor && agentCursor === void 0) {
           return { agentId: agent.id, page: null };
         }
-        const page = await agent.getHistory(state, chainId, {
-          ...filters,
-          cursor: agentCursor
-        });
+        const agentFilters = { ...filters, cursor: agentCursor };
+        const page = await this.readAgent(
+          agent,
+          "history",
+          () => agent.getHistory(state, chainId, agentFilters),
+          agentFilters
+        );
         return { agentId: agent.id, page };
       })
     );
@@ -4823,13 +3991,14 @@ var OwneySDK = class {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getUserProfile(state, chainId);
+      const agent = this.getAgent(agentId);
+      return this.readAgent(agent, "profile", () => agent.getUserProfile(state, chainId));
     }
     const results = {};
     const entries = [...this.getActiveAgents().entries()];
     const profileResults = await Promise.all(
       entries.map(async ([id, agent]) => {
-        const p = await agent.getUserProfile(state, chainId);
+        const p = await this.readAgent(agent, "profile", () => agent.getUserProfile(state, chainId));
         return [id, p];
       })
     );
@@ -4852,7 +4021,20 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     const agent = this.getAgent(agentId);
     if (typeof agent.ensureAutoSelectProtocols !== "function") return false;
-    return agent.ensureAutoSelectProtocols(state, chainId, asset);
+    const key2 = JSON.stringify([
+      state.walletAddress.toLowerCase(),
+      agentId,
+      chainId,
+      asset
+    ]);
+    const existing = this.activationChecks.get(key2);
+    if (existing) return existing;
+    const pending = Promise.resolve().then(() => agent.ensureAutoSelectProtocols(state, chainId, asset)).finally(() => {
+      if (this.activationChecks.get(key2) === pending)
+        this.activationChecks.delete(key2);
+    });
+    this.activationChecks.set(key2, pending);
+    return pending;
   }
   /**
    * One-time, user-paid approval of Permit2 on the sponsored WETH token for
@@ -4875,10 +4057,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem10.createWalletClient)({
+    const wallet = (0, import_viem6.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem10.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -4888,9 +4070,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem10.createPublicClient)({
+    const publicClient = (0, import_viem6.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem10.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -4923,13 +4105,14 @@ var OwneySDK = class {
     await this.ensureAgentsInitialized();
     const agentOptions = { tokenSymbol, chainId };
     if (agentId) {
-      return this.getAgent(agentId).getAgentApy(days, agentOptions);
+      const agent = this.getAgent(agentId);
+      return this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
     }
     const results = {};
     const agentEntries = [...this.agents.entries()];
     const apyResults = await Promise.all(
       agentEntries.map(async ([id, agent]) => {
-        const apy = await agent.getAgentApy(days, agentOptions);
+        const apy = await this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
         return [id, apy];
       })
     );
@@ -4956,7 +4139,7 @@ var OwneySDK = class {
     const entries = [...activeAgents.entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
-        const b = await agent.getBalances(state, chainId);
+        const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
         return [id, b.positions ?? []];
       })
     );
@@ -4964,6 +4147,7 @@ var OwneySDK = class {
     const allPositions = [];
     let successCount = 0;
     const agentErrors = {};
+    const agentFailures = [];
     for (let i = 0; i < balanceResults.length; i++) {
       const settled = balanceResults[i];
       const [aid] = entries[i];
@@ -4978,6 +4162,7 @@ var OwneySDK = class {
         successCount += 1;
       } else {
         const reason = settled.reason;
+        agentFailures.push(reason);
         agentErrors[aid] = reason instanceof Error ? reason.message : String(reason);
         console.error(`getAllocationApy agent "${aid}" failed:`, reason);
       }
@@ -4986,7 +4171,7 @@ var OwneySDK = class {
       throw new OwneyError(
         "ALLOCATION_ALL_FAILED",
         "Failed to fetch allocation APY: all agents failed.",
-        { agentErrors }
+        { agentErrors, failures: agentFailures }
       );
     }
     const overall = computeAllocationApy(allPositions);
@@ -4998,12 +4183,8 @@ var OwneySDK = class {
   }
 };
 
-// src/index.ts
-init_errors();
-init_debug();
-
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem11 = require("viem");
+var import_viem7 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -5130,7 +4311,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem11.getAddress)(accountAddress),
+          address: (0, import_viem7.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,
@@ -5207,9 +4388,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
   });
 }