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

package/dist/index.cjs

@@ -3,20 +3,500 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors.ts
+var OwneyError, AgentNotFoundError, NotConnectedError, AgentChainIncompatibleError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    OwneyError = class extends Error {
+      code;
+      details;
+      agentId;
+      constructor(code, message, details, agentId) {
+        const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+        super(`${prefix} ${message}`);
+        this.name = "OwneyError";
+        this.code = code;
+        this.details = details;
+        this.agentId = agentId;
+      }
+    };
+    AgentNotFoundError = class extends OwneyError {
+      constructor(agentId, available) {
+        super(
+          "AGENT_NOT_FOUND",
+          `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+          { agentId, available },
+          agentId
+        );
+        this.name = "AgentNotFoundError";
+      }
+    };
+    NotConnectedError = class extends OwneyError {
+      constructor() {
+        super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+        this.name = "NotConnectedError";
+      }
+    };
+    AgentChainIncompatibleError = class extends OwneyError {
+      incompatibleAgents;
+      connectedChainId;
+      constructor(incompatibleAgents, connectedChainId) {
+        const details = incompatibleAgents.map(
+          ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+        ).join("; ");
+        super(
+          "AGENT_CHAIN_INCOMPATIBLE",
+          `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+          { incompatibleAgents, connectedChainId }
+        );
+        this.name = "AgentChainIncompatibleError";
+        this.incompatibleAgents = incompatibleAgents;
+        this.connectedChainId = connectedChainId;
+      }
+    };
+  }
+});
+
+// src/agents/surfliquid/surfliquid.constants.ts
+var SURFLIQUID_CHAIN_ID, SURFLIQUID_CHAIN_NAME, SURFLIQUID_USDC_ADDRESS, SURFLIQUID_USDC_DECIMALS, SURFLIQUID_MIN_DEPOSIT, SURFLIQUID_SUPPORTED_ASSETS, SURFLIQUID_ACTION_MAP;
+var init_surfliquid_constants = __esm({
+  "src/agents/surfliquid/surfliquid.constants.ts"() {
+    "use strict";
+    SURFLIQUID_CHAIN_ID = 8453;
+    SURFLIQUID_CHAIN_NAME = "BASE";
+    SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    SURFLIQUID_USDC_DECIMALS = 6;
+    SURFLIQUID_MIN_DEPOSIT = "0";
+    SURFLIQUID_SUPPORTED_ASSETS = [
+      {
+        chainId: SURFLIQUID_CHAIN_ID,
+        chain: SURFLIQUID_CHAIN_NAME,
+        assets: [{ symbol: "USDC", minDepositAmount: SURFLIQUID_MIN_DEPOSIT }]
+      }
+    ];
+    SURFLIQUID_ACTION_MAP = {
+      // INITIAL_DEPOSIT is the user's real first deposit, so surface it like any
+      // other funding ("Top up"). The mini-app intentionally hides the "Deposit"
+      // action (it marks Zyfai's smart-account-creation event), which would
+      // otherwise drop a SurfLiquid user's only history row.
+      INITIAL_DEPOSIT: "Top up",
+      DEPOSIT: "Top up",
+      USER_DEPOSIT: "Top up",
+      WITHDRAWAL: "Withdraw",
+      USER_WITHDRAWAL: "Withdraw",
+      REBALANCE: "Rebalance",
+      REBALANCE_COMPLETED: "Rebalance",
+      CROSS_CHAIN_REBALANCE: "Rebalance",
+      MERKL_CLAIM: "Earned"
+    };
+  }
+});
+
+// src/agents/surfliquid/surfliquid.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 fetchMorphoVaultStats(vaultAddress, chainId) {
+  try {
+    const res = await fetch(MORPHO_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: VAULT_STATS_QUERY,
+        variables: { address: vaultAddress, chainId }
+      })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (json.errors) return null;
+    const vault = json.data?.vaultByAddress;
+    const tvlUsd = vault?.state?.totalAssetsUsd;
+    const liquidityUsd = vault?.liquidity?.usd;
+    if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
+      return null;
+    }
+    const name = typeof vault?.name === "string" ? vault.name : null;
+    return { name, tvlUsd, liquidityUsd };
+  } catch (error) {
+    console.warn("surfliquid: Morpho vault stats fetch failed", {
+      vaultAddress,
+      chainId,
+      error
+    });
+    return null;
+  }
+}
+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;
+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 }
+    }
+  }
+`;
+  }
+});
+
+// src/agents/surfliquid/surfliquid.agent.ts
+var surfliquid_agent_exports = {};
+__export(surfliquid_agent_exports, {
+  SurfLiquidAgent: () => SurfLiquidAgent
+});
+var import_core_sdk2, import_viem5, 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_viem5 = require("viem");
+    init_errors();
+    init_surfliquid_constants();
+    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;
+      }
+      // --- IAgent: lifecycle ---
+      async disconnect() {
+        if (this.surf) {
+          await this.surf.disconnectWallet();
+        }
+        this.connectedAddress = null;
+      }
+      async activateAgent(state) {
+        await this.connect(state);
+      }
+      // --- IAgent: funds (user-pays; asset is always USDC, callback ignored) ---
+      async deposit(state, _chainId, amount, _asset, _depositCallback) {
+        const surf = await this.connect(state);
+        const human = (0, import_viem5.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
+        const smartWallet = await this.resolveVaultAddress(
+          surf,
+          state.walletAddress
+        );
+        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 human = amount != null ? (0, import_viem5.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
+        );
+        return mapHistory(result, chainId);
+      }
+      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 };
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -89,56 +569,8 @@ var SupportedAssets = [
   }
 ];
 
-// src/errors.ts
-var OwneyError = class extends Error {
-  code;
-  details;
-  agentId;
-  constructor(code, message, details, agentId) {
-    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
-    super(`${prefix} ${message}`);
-    this.name = "OwneyError";
-    this.code = code;
-    this.details = details;
-    this.agentId = agentId;
-  }
-};
-var AgentNotFoundError = class extends OwneyError {
-  constructor(agentId, available) {
-    super(
-      "AGENT_NOT_FOUND",
-      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
-      { agentId, available },
-      agentId
-    );
-    this.name = "AgentNotFoundError";
-  }
-};
-var NotConnectedError = class extends OwneyError {
-  constructor() {
-    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
-    this.name = "NotConnectedError";
-  }
-};
-var AgentChainIncompatibleError = class extends OwneyError {
-  incompatibleAgents;
-  connectedChainId;
-  constructor(incompatibleAgents, connectedChainId) {
-    const details = incompatibleAgents.map(
-      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
-    ).join("; ");
-    super(
-      "AGENT_CHAIN_INCOMPATIBLE",
-      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
-      { incompatibleAgents, connectedChainId }
-    );
-    this.name = "AgentChainIncompatibleError";
-    this.incompatibleAgents = incompatibleAgents;
-    this.connectedChainId = connectedChainId;
-  }
-};
-
 // src/lib/utils.ts
+init_errors();
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
     throw new OwneyError(
@@ -212,46 +644,46 @@ function resolveChainId(chain) {
 function mapBalances(raw, _chainId, smartWallet) {
   const portfolio = raw.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
+  const rawPositions = portfolio.positions ?? [];
+  const detailByKey = /* @__PURE__ */ new Map();
+  for (const p of rawPositions) {
+    const cid = resolveChainId(p.chain ?? "");
+    const symbol = (p.token_symbol ?? "").toUpperCase();
+    if (Number.isFinite(cid) && symbol) detailByKey.set(`${cid}:${symbol}`, p);
+  }
   let totalBalance = 0;
   const tokens = [];
+  const positions = [];
   for (const [chainIdKey, tokensBySymbol] of Object.entries(portfolioByChain)) {
     const positionChainId = Number(chainIdKey);
+    const chainName = CHAIN_ID_TO_NAME[positionChainId] ?? "BASE";
     for (const [symbol, { balance, decimals }] of Object.entries(
       tokensBySymbol ?? {}
     )) {
-      const amount = hexToDecimal(balance || "0", decimals);
+      const amount = hexToDecimal(balance || "0", tokenDecimals(symbol, decimals));
       totalBalance += amount;
       tokens.push({
-        chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
+        chain: chainName,
         chainId: positionChainId,
         asset: symbol,
         amount: String(amount)
       });
+      const detail = detailByKey.get(`${positionChainId}:${symbol.toUpperCase()}`);
+      positions.push({
+        chain: chainName,
+        protocol: detail?.protocol_name ?? detail?.protocol_id ?? "",
+        protocolId: detail?.protocol_id,
+        pool: detail?.pool,
+        asset: symbol,
+        amount: String(amount),
+        apy: detail?.pool_apy,
+        tvl: detail?.pool_tvl,
+        // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
+        // structural read keeps it undefined today and auto-populates later.
+        liquidity: detail?.liquidity
+      });
     }
   }
-  const positions = (portfolio.positions ?? []).map((p) => ({
-    chain: p.chain ?? "",
-    protocol: p.protocol_name ?? p.protocol_id ?? "",
-    protocolId: p.protocol_id,
-    pool: p.pool,
-    asset: p.token_symbol ?? "",
-    // Position amount is hex-encoded base units (like the token balances
-    // above). `PositionSlot` doesn't type a `decimals` field, but runtime
-    // getBalances payloads often carry one (e.g. 18 for WETH) — prefer that
-    // when present, otherwise fall back to the per-symbol lookup so
-    // non-6-decimal assets like WETH don't render 1e12 too large.
-    amount: String(
-      hexToDecimal(
-        p.amount || "0",
-        tokenDecimals(p.token_symbol, p.decimals)
-      )
-    ),
-    apy: p.pool_apy,
-    tvl: p.pool_tvl,
-    // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
-    // structural read keeps it undefined today and auto-populates later.
-    liquidity: p.liquidity
-  }));
   return {
     smartWallet,
     totalBalance: String(totalBalance),
@@ -528,6 +960,9 @@ 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 = () => {
@@ -562,23 +997,23 @@ var readLegacySession = (store, address) => {
   const legacyKeys = [];
   try {
     for (let i = 0; i < store.length; i++) {
-      const key = store.key(i);
-      if (key?.startsWith(prefix)) legacyKeys.push(key);
+      const key2 = store.key(i);
+      if (key2?.startsWith(prefix)) legacyKeys.push(key2);
     }
   } catch {
     return null;
   }
   let adopted = null;
-  for (const key of legacyKeys) {
+  for (const key2 of legacyKeys) {
     if (!adopted) {
       try {
-        const parsed = JSON.parse(store.getItem(key) ?? "");
+        const parsed = JSON.parse(store.getItem(key2) ?? "");
         if (isFreshSession(parsed)) adopted = parsed;
       } catch {
       }
     }
     try {
-      store.removeItem(key);
+      store.removeItem(key2);
     } catch {
     }
   }
@@ -586,11 +1021,11 @@ var readLegacySession = (store, address) => {
 };
 var readSession = (address, _chainId) => {
   if (typeof window === "undefined") return null;
-  const key = buildKey(address);
+  const key2 = buildKey(address);
   const store = storage();
   let raw = null;
   try {
-    raw = store?.getItem(key) ?? null;
+    raw = store?.getItem(key2) ?? null;
   } catch {
     raw = null;
   }
@@ -600,9 +1035,9 @@ var readSession = (address, _chainId) => {
       if (isFreshSession(parsed)) return parsed;
     } catch {
     }
-    memorySessions.delete(key);
+    memorySessions.delete(key2);
     try {
-      store?.removeItem(key);
+      store?.removeItem(key2);
     } catch {
     }
     return null;
@@ -612,27 +1047,27 @@ var readSession = (address, _chainId) => {
     writeSession(address, _chainId, legacy);
     return legacy;
   }
-  const cached = memorySessions.get(key);
+  const cached = memorySessions.get(key2);
   if (isFreshSession(cached)) return cached;
-  if (cached) memorySessions.delete(key);
+  if (cached) memorySessions.delete(key2);
   return null;
 };
 var writeSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key = buildKey(address);
-  memorySessions.set(key, session);
+  const key2 = buildKey(address);
+  memorySessions.set(key2, session);
   const store = storage();
   try {
-    store?.setItem(key, JSON.stringify(session));
+    store?.setItem(key2, JSON.stringify(session));
   } catch {
   }
 };
 var clearSession = (address, _chainId) => {
-  const key = buildKey(address);
-  memorySessions.delete(key);
+  const key2 = buildKey(address);
+  memorySessions.delete(key2);
   const store = storage();
   try {
-    store?.removeItem(key);
+    store?.removeItem(key2);
   } catch {
   }
   readLegacySession(store, address);
@@ -696,6 +1131,99 @@ function splittingNeedsUpdate(current, desired) {
   return current.minSplits !== desired.minSplits;
 }
 
+// src/agents/zyfai/pool-policy.ts
+function toZyfaiCustomizations(policy, availableByProtocol, chainsByProtocol) {
+  const selectionByKey = /* @__PURE__ */ new Map();
+  for (const selection of policy.selections) {
+    selectionByKey.set(key(selection.protocolId, selection.chainId), selection);
+  }
+  const customizations = [];
+  for (const [protocolId, chainIds] of Object.entries(chainsByProtocol)) {
+    const available = availableByProtocol.get(protocolId);
+    if (available === void 0) {
+      continue;
+    }
+    const availableSet = new Set(available);
+    for (const chainId of chainIds) {
+      const stored = selectionByKey.get(key(protocolId, chainId));
+      if (stored === void 0) {
+        customizations.push({
+          protocolId,
+          chainId,
+          pools: [],
+          autoselect: true
+        });
+        continue;
+      }
+      const pools = stored.pools.filter((pool) => availableSet.has(pool));
+      customizations.push({
+        protocolId,
+        chainId,
+        pools,
+        autoselect: false
+      });
+    }
+  }
+  return customizations;
+}
+function deriveProtocols(policy, universe, chainsByProtocol) {
+  if (policy.selections.length === 0) {
+    return null;
+  }
+  const selectionByKey = /* @__PURE__ */ new Map();
+  for (const selection of policy.selections) {
+    selectionByKey.set(key(selection.protocolId, selection.chainId), selection);
+  }
+  return universe.filter((protocolId) => {
+    const chainIds = chainsByProtocol[protocolId];
+    if (chainIds === void 0 || chainIds.length === 0) {
+      return true;
+    }
+    const fullyDisabled = chainIds.every((chainId) => {
+      const stored = selectionByKey.get(key(protocolId, chainId));
+      return stored !== void 0 && stored.pools.length === 0;
+    });
+    return !fullyDisabled;
+  });
+}
+function key(protocolId, chainId) {
+  return `${protocolId}:${chainId}`;
+}
+function buildChainsByProtocol(protocols, dashboardChainIds) {
+  const allowed = new Set(dashboardChainIds);
+  const result = {};
+  for (const protocol of protocols) {
+    result[protocol.id] = (protocol.chains ?? []).filter(
+      (chainId) => allowed.has(chainId)
+    );
+  }
+  return result;
+}
+function flattenAvailablePools(raw) {
+  const byChain = raw ?? {};
+  const names = [];
+  for (const byToken of Object.values(byChain ?? {})) {
+    for (const entry of Object.values(byToken ?? {})) {
+      for (const pool of entry?.pools ?? []) {
+        if (pool?.name) names.push(pool.name);
+      }
+    }
+  }
+  return names;
+}
+function protocolListsEqual(a, b) {
+  const left = [...a ?? []].sort();
+  const right = [...b ?? []].sort();
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}
+function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect) {
+  if (!current) return true;
+  if (current.autoSelectProtocols !== desiredAutoSelect) return true;
+  if (desiredProtocols === null) return false;
+  return !protocolListsEqual(current.protocols, desiredProtocols);
+}
+
 // src/lib/debug.ts
 var configuredDebug = false;
 function setOwneyDebug(enabled) {
@@ -726,6 +1254,7 @@ var WETH_ADDRESS_BY_CHAIN = {
 };
 var VIEM_CHAIN = { 8453: import_chains.base, 42161: import_chains.arbitrum, 1: import_chains.mainnet };
 var SPLITTING_ASSETS = ["USDC", "WETH"];
+var POOL_POLICY_CHAIN_IDS = [8453, 42161, 1];
 function isAlreadyActiveSessionKeyError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /already has an active session key/i.test(message);
@@ -1110,6 +1639,9 @@ var ZyfaiAgent = class {
     await Promise.all(
       SPLITTING_ASSETS.map((asset) => this.applySplitting(asset, policy))
     );
+    if (policy.poolPolicy) {
+      await this.applyPoolPolicy(policy.poolPolicy);
+    }
   }
   async applySplitting(asset, policy) {
     try {
@@ -1146,6 +1678,117 @@ var ZyfaiAgent = class {
       );
     }
   }
+  /**
+   * Apply the org's protocol/pool policy to this user's Zyfai profile.
+   *
+   * Two Zyfai writes, in a strict order:
+   *   1. `updateUserProfile({ protocols, autoSelectProtocols })` per asset —
+   *      the explicit allow-list. Chain-agnostic, mirrors `applySplitting`.
+   *   2. `customizeBatch(...)` once — per (protocol, chain), asset-agnostic
+   *      pool narrowing.
+   *
+   * Order matters: constraining a protocol's pools (step 2) while that
+   * protocol is not yet in the allow-list (step 1 not yet applied) lands the
+   * constraint on something the rebalance engine isn't considering.
+   *
+   * Wrapped so a failure anywhere is non-fatal — this runs as a side effect of
+   * connecting, so a Zyfai hiccup must leave the user connected with their
+   * profile unchanged, never fail activation.
+   */
+  async applyPoolPolicy(policy) {
+    try {
+      const { protocols: universe } = await this.sdk.getAvailableProtocols(
+        this.supportedChainIds[0]
+      );
+      const universeIds = universe.map((p) => p.id);
+      const chainsByProtocol = buildChainsByProtocol(
+        universe,
+        POOL_POLICY_CHAIN_IDS
+      );
+      debugLog("zyfai:pools", "protocol universe", {
+        universeIds,
+        chainsByProtocol
+      });
+      let strategy;
+      const desiredProtocols = deriveProtocols(
+        policy,
+        universeIds,
+        chainsByProtocol
+      );
+      const desiredAutoSelect = policy.autoApproveProtocols;
+      for (const asset of SPLITTING_ASSETS) {
+        const current = await this.sdk.getUserDetails(asset);
+        if (strategy === void 0 && (current.strategy === "conservative" || current.strategy === "aggressive")) {
+          strategy = current.strategy;
+        }
+        const needsUpdate = protocolsPolicyNeedsUpdate(
+          current,
+          desiredProtocols,
+          desiredAutoSelect
+        );
+        debugLog("zyfai:pools", `${asset}: comparing protocols`, {
+          current: {
+            protocols: current.protocols,
+            autoSelectProtocols: current.autoSelectProtocols
+          },
+          desired: {
+            protocols: desiredProtocols,
+            autoSelectProtocols: desiredAutoSelect
+          },
+          decision: needsUpdate ? "will write \u2014 profile differs from the org policy" : "skipping \u2014 profile already matches"
+        });
+        if (!needsUpdate) continue;
+        const update = {
+          asset,
+          autoSelectProtocols: desiredAutoSelect
+        };
+        if (desiredProtocols !== null) update.protocols = desiredProtocols;
+        await this.sdk.updateUserProfile(update);
+        debugLog("zyfai:pools", `${asset}: wrote protocols update`, update);
+      }
+      const poolResults = await Promise.all(
+        universe.map(async (protocol) => {
+          try {
+            const raw = await this.sdk.getAvailablePools(protocol.id, strategy);
+            return [protocol.id, flattenAvailablePools(raw)];
+          } catch (error) {
+            console.warn(
+              `[zyfai] applyPoolPolicy: getAvailablePools(${protocol.id}) failed, skipping this protocol (non-fatal):`,
+              error instanceof Error ? error.message : String(error)
+            );
+            return null;
+          }
+        })
+      );
+      const availableByProtocol = /* @__PURE__ */ new Map();
+      for (const result of poolResults) {
+        if (result) availableByProtocol.set(result[0], result[1]);
+      }
+      const customizations = toZyfaiCustomizations(
+        policy,
+        availableByProtocol,
+        chainsByProtocol
+      );
+      debugLog("zyfai:pools", "derived customizeBatch payload", {
+        strategy,
+        availableProtocolCount: availableByProtocol.size,
+        customizations
+      });
+      if (customizations.length === 0) {
+        debugLog("zyfai:pools", "skipping customizeBatch \u2014 nothing to send");
+        return;
+      }
+      await this.sdk.customizeBatch(customizations);
+      debugLog("zyfai:pools", "wrote customizeBatch", {
+        count: customizations.length
+      });
+    } catch (error) {
+      console.warn(
+        "[zyfai] applyPoolPolicy failed (non-fatal):",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
   async deposit(state, chainId, amount, asset, depositCallback) {
     try {
       await this.connectFull(state, chainId);
@@ -1307,7 +1950,11 @@ var ZyfaiAgent = class {
   }
 };
 
+// src/client.ts
+init_errors();
+
 // src/lib/routing-api.ts
+init_errors();
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function fetchOrgAgentConfig(apiKey) {
   const url = `${ROUTING_API_BASE_URL}/api/v1/agent/org-config`;
@@ -1372,6 +2019,7 @@ async function fetchAgentKeys(apiKey) {
 }
 
 // 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) {
   try {
@@ -1521,9 +2169,12 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 var import_chains2 = require("viem/chains");
 
+// src/lib/sponsored-deposit.ts
+init_errors();
+
 // src/lib/transfer-auth.ts
 var import_viem3 = require("viem");
 var ERC20_META_ABI = [
@@ -1561,6 +2212,7 @@ function randomAuthNonce() {
 }
 
 // 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 base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
@@ -1829,6 +2481,7 @@ function makeSponsoredDepositCallback(deps) {
 }
 
 // src/lib/sponsored-weth-deposit.ts
+init_errors();
 var PERMIT_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredWethCallback(deps) {
   const get = deps.httpGet ?? getSponsorRelayerAddress;
@@ -1937,6 +2590,7 @@ var VIEM_CHAIN2 = {
   42161: import_chains2.arbitrum,
   1: import_chains2.mainnet
 };
+var AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai", "sail"];
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -1965,6 +2619,7 @@ var OwneySDK = class {
   zyfaiRpcUrls;
   routingApiBaseUrl;
   referralSource;
+  surfliquidApiBaseUrl;
   cachedSponsoredCallback = null;
   cachedWethSponsoredCallback = null;
   initializingAgentsPromise = null;
@@ -1974,6 +2629,7 @@ var OwneySDK = class {
     this.zyfaiRpcUrls = config.zyfaiRpcUrls;
     this.routingApiBaseUrl = config.routingApiBaseUrl;
     this.referralSource = config.referralSource;
+    this.surfliquidApiBaseUrl = config.surfliquidApiBaseUrl;
   }
   /**
    * Establish connection state for all subsequent SDK calls.
@@ -2071,14 +2727,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_viem5.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem5.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -2104,14 +2760,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_viem5.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem5.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -2181,8 +2837,8 @@ var OwneySDK = class {
       this.initializingAgentsPromise = (async () => {
         const agentKeys = await fetchAgentKeys(this.apiKey);
         this.disabledAgents.clear();
-        for (const { key, agent_type, is_enabled } of agentKeys) {
-          const agent = this.createAgent(agent_type, key);
+        for (const { key: key2, agent_type, project_name, is_enabled } of agentKeys) {
+          const agent = await this.createAgent(agent_type, key2, project_name);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -2203,9 +2859,21 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  createAgent(agentId, key) {
+  async createAgent(agentId, key2, projectName) {
     if (agentId === "zyfai") {
-      return new ZyfaiAgent(key, this.zyfaiRpcUrls, this.referralSource);
+      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
+      });
     }
     return null;
   }
@@ -2361,18 +3029,30 @@ var OwneySDK = class {
       );
     }
     const agentResults = {};
+    const agentErrors = {};
     for (const { agent, amount: agentAmount } of agentAmounts) {
-      agentResults[agent.id] = await this.depositWithFallback(
-        agent,
-        state,
-        chainId,
-        agentAmount,
-        asset,
-        effectiveCallback,
-        depositCallback
+      try {
+        agentResults[agent.id] = await this.depositWithFallback(
+          agent,
+          state,
+          chainId,
+          agentAmount,
+          asset,
+          effectiveCallback,
+          depositCallback
+        );
+      } catch (error) {
+        agentErrors[agent.id] = error instanceof Error ? error.message : String(error);
+      }
+    }
+    if (Object.keys(agentResults).length === 0) {
+      throw new OwneyError(
+        "DEPOSIT_ALL_FAILED",
+        `All ${agentAmounts.length} agent deposit(s) failed.`,
+        { agentErrors }
       );
     }
-    return { agentResults };
+    return Object.keys(agentErrors).length > 0 ? { agentResults, agentErrors } : { agentResults };
   }
   /**
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
@@ -2529,6 +3209,34 @@ 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.
@@ -2564,9 +3272,17 @@ 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 eligibleAgents) {
+      for (const { agent } of funded) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
@@ -2583,9 +3299,10 @@ 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: sumWithdrawnAmount(results2).toString()
+        totalWithdrawn: totalWithdrawn.toString()
       };
     }
     const requested = BigInt(amount);
@@ -2955,10 +3672,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem5.createWalletClient)({
+    const wallet = (0, import_viem6.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem5.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -2968,9 +3685,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem5.createPublicClient)({
+    const publicClient = (0, import_viem6.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem5.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -3078,8 +3795,11 @@ var OwneySDK = class {
   }
 };
 
+// src/index.ts
+init_errors();
+
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -3102,22 +3822,22 @@ var readLegacySiwxSession = (store, address) => {
   const legacyKeys = [];
   try {
     for (let i = 0; i < store.length; i++) {
-      const key = store.key(i);
-      if (key?.startsWith(prefix)) legacyKeys.push(key);
+      const key2 = store.key(i);
+      if (key2?.startsWith(prefix)) legacyKeys.push(key2);
     }
   } catch {
     return null;
   }
   let adopted = null;
-  for (const key of legacyKeys) {
+  for (const key2 of legacyKeys) {
     if (!adopted) {
       try {
-        adopted = JSON.parse(store.getItem(key) ?? "");
+        adopted = JSON.parse(store.getItem(key2) ?? "");
       } catch {
       }
     }
     try {
-      store.removeItem(key);
+      store.removeItem(key2);
     } catch {
     }
   }
@@ -3125,11 +3845,11 @@ var readLegacySiwxSession = (store, address) => {
 };
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
-  const key = buildKey2(address);
+  const key2 = buildKey2(address);
   const store = storage2();
   let raw = null;
   try {
-    raw = store?.getItem(key) ?? null;
+    raw = store?.getItem(key2) ?? null;
   } catch {
     raw = null;
   }
@@ -3137,9 +3857,9 @@ var readSiwxSession = (address, chainId) => {
     try {
       return JSON.parse(raw);
     } catch {
-      memorySiwxSessions.delete(key);
+      memorySiwxSessions.delete(key2);
       try {
-        store?.removeItem(key);
+        store?.removeItem(key2);
       } catch {
       }
       return null;
@@ -3150,24 +3870,24 @@ var readSiwxSession = (address, chainId) => {
     writeSiwxSession(address, chainId, legacy);
     return legacy;
   }
-  return memorySiwxSessions.get(key) ?? null;
+  return memorySiwxSessions.get(key2) ?? null;
 };
 var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key = buildKey2(address);
-  memorySiwxSessions.set(key, session);
+  const key2 = buildKey2(address);
+  memorySiwxSessions.set(key2, session);
   const store = storage2();
   try {
-    store?.setItem(key, JSON.stringify(session));
+    store?.setItem(key2, JSON.stringify(session));
   } catch {
   }
 };
 var clearSiwxSession = (address, _chainId) => {
-  const key = buildKey2(address);
-  memorySiwxSessions.delete(key);
+  const key2 = buildKey2(address);
+  memorySiwxSessions.delete(key2);
   const store = storage2();
   try {
-    store?.removeItem(key);
+    store?.removeItem(key2);
   } catch {
   }
   readLegacySiwxSession(store, address);
@@ -3206,7 +3926,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem6.getAddress)(accountAddress),
+          address: (0, import_viem7.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,