@owney/sdk 0.6.9-beta.9 → 0.7.0

package/dist/index.js

@@ -1,17 +1,3 @@
-import {
-  AgentChainIncompatibleError,
-  AgentNotFoundError,
-  ERC20_ALLOWANCE_ABI,
-  MAX_UINT256,
-  NotConnectedError,
-  OwneyError,
-  PERMIT2_ADDRESS,
-  buildPermitTransferFromTypedData,
-  randomPermit2Nonce,
-  readErc20Balance,
-  readPermit2Allowance
-} from "./chunk-PWIKIQOX.js";
-
 // src/agents/zyfai/zyfai.agent.ts
 import { ZyfaiSDK } from "@zyfai/sdk";
 import { createPublicClient, http } from "viem";
@@ -70,6 +56,55 @@ 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
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
@@ -81,12 +116,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);
@@ -112,10 +141,6 @@ var DECIMALS_BY_SYMBOL = {
   wbtc: 8,
   cbbtc: 8
 };
-function canonicalSymbol(symbol) {
-  const upper = symbol.toUpperCase();
-  return upper === "ETH" ? "WETH" : upper;
-}
 function tokenDecimals(symbol, explicit) {
   if (typeof explicit === "number" && Number.isFinite(explicit))
     return explicit;
@@ -154,50 +179,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 = canonicalSymbol(p.token_symbol ?? "");
-    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", tokenDecimals(symbol, decimals));
+      const amount = hexToDecimal(balance || "0", decimals);
       totalBalance += amount;
       tokens.push({
-        chain: chainName,
+        chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
         asset: symbol,
         amount: String(amount)
       });
-      const detail = detailByKey.get(
-        `${positionChainId}:${canonicalSymbol(symbol)}`
-      );
-      positions.push({
-        chain: chainName,
-        protocol: detail?.protocol_name ?? detail?.protocol_id ?? "",
-        protocolId: detail?.protocol_id,
-        pool: detail?.pool,
-        // Report the token the way the rest of owney spells it ("WETH", as the
-        // pre-portfolioByChain mapper did), not Zyfai's internal "eth".
-        asset: canonicalSymbol(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),
@@ -359,9 +380,7 @@ function mapUserProfile(raw, userAddress) {
     chains: raw.chains || [],
     strategy: raw.strategy,
     hasActiveSessionKey: raw.hasActiveSessionKey || false,
-    protocols: raw.protocols || [],
-    splitting: raw.splitting,
-    minSplits: raw.minSplits
+    protocols: raw.protocols || []
   };
 }
 function mapApyByStrategy(raw) {
@@ -508,23 +527,23 @@ var readLegacySession = (store, address) => {
   const legacyKeys = [];
   try {
     for (let i = 0; i < store.length; i++) {
-      const key2 = store.key(i);
-      if (key2?.startsWith(prefix)) legacyKeys.push(key2);
+      const key = store.key(i);
+      if (key?.startsWith(prefix)) legacyKeys.push(key);
     }
   } catch {
     return null;
   }
   let adopted = null;
-  for (const key2 of legacyKeys) {
+  for (const key of legacyKeys) {
     if (!adopted) {
       try {
-        const parsed = JSON.parse(store.getItem(key2) ?? "");
+        const parsed = JSON.parse(store.getItem(key) ?? "");
         if (isFreshSession(parsed)) adopted = parsed;
       } catch {
       }
     }
     try {
-      store.removeItem(key2);
+      store.removeItem(key);
     } catch {
     }
   }
@@ -532,11 +551,11 @@ var readLegacySession = (store, address) => {
 };
 var readSession = (address, _chainId) => {
   if (typeof window === "undefined") return null;
-  const key2 = buildKey(address);
+  const key = buildKey(address);
   const store = storage();
   let raw = null;
   try {
-    raw = store?.getItem(key2) ?? null;
+    raw = store?.getItem(key) ?? null;
   } catch {
     raw = null;
   }
@@ -546,9 +565,9 @@ var readSession = (address, _chainId) => {
       if (isFreshSession(parsed)) return parsed;
     } catch {
     }
-    memorySessions.delete(key2);
+    memorySessions.delete(key);
     try {
-      store?.removeItem(key2);
+      store?.removeItem(key);
     } catch {
     }
     return null;
@@ -558,27 +577,27 @@ var readSession = (address, _chainId) => {
     writeSession(address, _chainId, legacy);
     return legacy;
   }
-  const cached = memorySessions.get(key2);
+  const cached = memorySessions.get(key);
   if (isFreshSession(cached)) return cached;
-  if (cached) memorySessions.delete(key2);
+  if (cached) memorySessions.delete(key);
   return null;
 };
 var writeSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key2 = buildKey(address);
-  memorySessions.set(key2, session);
+  const key = buildKey(address);
+  memorySessions.set(key, session);
   const store = storage();
   try {
-    store?.setItem(key2, JSON.stringify(session));
+    store?.setItem(key, JSON.stringify(session));
   } catch {
   }
 };
 var clearSession = (address, _chainId) => {
-  const key2 = buildKey(address);
-  memorySessions.delete(key2);
+  const key = buildKey(address);
+  memorySessions.delete(key);
   const store = storage();
   try {
-    store?.removeItem(key2);
+    store?.removeItem(key);
   } catch {
   }
   readLegacySession(store, address);
@@ -609,149 +628,6 @@ function buildProtocolMergeUpdate(available, current, asset) {
   };
 }
 
-// src/agents/zyfai/splitting.ts
-var MAX_MIN_SPLITS = 4;
-var MIN_FORCE_SPLITS = 2;
-var AUTOMATIC_MIN_SPLITS = 1;
-function toZyfaiSplitting(policy) {
-  switch (policy.splittingMode) {
-    case "none":
-      return { splitting: false };
-    case "automatic":
-      return { splitting: true, minSplits: AUTOMATIC_MIN_SPLITS };
-    case "force":
-      return {
-        splitting: true,
-        minSplits: clampForceSplits(policy.minSplits)
-      };
-  }
-}
-function clampForceSplits(minSplits) {
-  if (typeof minSplits !== "number" || !Number.isFinite(minSplits)) {
-    return MIN_FORCE_SPLITS;
-  }
-  const rounded = Math.round(minSplits);
-  if (rounded < MIN_FORCE_SPLITS) return MIN_FORCE_SPLITS;
-  if (rounded > MAX_MIN_SPLITS) return MAX_MIN_SPLITS;
-  return rounded;
-}
-function splittingNeedsUpdate(current, desired) {
-  if (!current) return true;
-  if (current.splitting !== desired.splitting) return true;
-  if (desired.minSplits === void 0) return false;
-  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) {
-  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/agents/zyfai/zyfai.agent.ts
 var DEFAULT_ZYFAI_RPC_URLS = {
   8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
@@ -764,12 +640,6 @@ var WETH_ADDRESS_BY_CHAIN = {
   1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
 var VIEM_CHAIN = { 8453: base, 42161: arbitrum, 1: 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);
-}
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161, 1];
@@ -996,71 +866,21 @@ var ZyfaiAgent = class {
       return await this.sdk.connectAccount(provider, chainId);
     }
   }
-  /** Full connect: SIWE auth + Safe deploy check + session key. */
-  async connectFull(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const validChainId = isValidChainId(chainId);
-    const address = this.getAddress();
-    const wallet = await this.sdk.getSmartWalletAddress(address, validChainId);
-    this.smartWalletCache.set(`${address}_${validChainId}`, wallet.address);
-    if (!wallet.isDeployed) {
-      await this.sdk.deploySafe(address, validChainId, "aggressive", false);
-      try {
-        if (validChainId === 42161) {
-          await this.sdk.updateUserProfile({
-            asset: "WETH",
-            chains: [validChainId],
-            protocols: ["c24a33fa-4a87-4376-b756-93bd3957d3ea"],
-            // AAVE protocol ID
-            autoSelectProtocols: false
-          });
-        }
-      } catch (err) {
-        console.warn(
-          "Failed to configure AAVE protocol after Safe deployment:",
-          err instanceof Error ? err.message : String(err)
-        );
-      }
-    }
-    await this.ensureSessionKey(state, address, validChainId);
-  }
   /**
-   * Ensures the user has an active session key, creating one if absent.
-   *
-   * The Zyfai session key is a single **per-user** record, not per-chain: its
-   * config (`/session-keys/config`) spans every supported chain and is signed
-   * in one shot, and the backend rejects `POST /session-keys/add` with 400
-   * "User already has an active session key" if one exists. So we must NOT try
-   * to (re)create a key per chain — that 400s and blocks the deposit. We only
-   * create when the user has none.
-   *
-   * The one wrapper-side hardening that IS needed: a chain/account switch can
-   * fire the provider's `accountsChanged` → `disconnectAccount`, tearing down
-   * the zyfai connection (walletClient + authenticatedUserId both null) while
-   * our own `connectAuth` guard still believes this chain is connected and
-   * early-returns without reconnecting. `createSessionKey` then fails with
-   * "No account connected". Detect that and reconnect first.
-   *
-   * NOTE: whether a globally-active session key actually authorizes activity on
-   * a freshly-deployed Safe on a new chain is a backend/zyf question — the
-   * wrapper cannot force per-chain activation given the global 400 guard.
-   * See [[zyfai-per-chain-session-key]].
+   * Reconnect if the Zyfai connection was torn down behind our back: a
+   * chain/account switch fires the provider's `accountsChanged` →
+   * `disconnectAccount` (nulls walletClient + authenticatedUserId) while our
+   * own `connectAuth` guard still believes this chain is connected and
+   * early-returns. Without this, authenticated calls (depositFunds,
+   * withdrawFunds) fail with "No account connected".
    */
-  async ensureSessionKey(state, address, chainId) {
+  async ensureConnected(state, chainId) {
+    await this.connectAuth(state, chainId);
     const internals = this.sdk;
     if (!internals.walletClient || internals.authenticatedUserId === null) {
       this.connectedChainId = null;
       await this.connectAuth(state, chainId);
     }
-    const user = await this.sdk.getUserDetails();
-    if (!user.hasActiveSessionKey) {
-      try {
-        await this.sdk.createSessionKey(address, chainId);
-      } catch (error) {
-        if (!isAlreadyActiveSessionKeyError(error)) throw error;
-        internals.hasActiveSessionKey = true;
-      }
-    }
   }
   /**
    * Sync newly-available protocols onto an existing user's profile at wallet
@@ -1130,211 +950,10 @@ var ZyfaiAgent = class {
       throw error;
     }
   }
-  /**
-   * Apply the org's capital splitting policy to this user's Zyfai profile.
-   *
-   * Per ASSET, not per chain: Zyfai stores splitting under
-   * `assetTypeSettings[asset]`, so one call would only configure USDC and leave a
-   * WETH holder's real setting untouched.
-   *
-   * Non-fatal throughout. This is a side effect of connecting, so a Zyfai hiccup
-   * must leave the user connected with their profile unchanged, never fail
-   * activation.
-   */
-  async applyOrgPolicy(_state, _chainId, policy) {
-    debugLog("zyfai:splitting", "applying org policy", {
-      policy,
-      // Per asset because Zyfai stores splitting under assetTypeSettings[asset].
-      assets: SPLITTING_ASSETS
-    });
-    await Promise.all(
-      SPLITTING_ASSETS.map((asset) => this.applySplitting(asset, policy))
-    );
-    if (policy.poolPolicy) {
-      await this.applyPoolPolicy(policy.poolPolicy);
-    }
-  }
-  async applySplitting(asset, policy) {
-    try {
-      const desired = toZyfaiSplitting(policy);
-      const current = await this.sdk.getUserDetails(asset);
-      const currentSplitting = {
-        splitting: current?.splitting,
-        minSplits: current?.minSplits
-      };
-      const needsUpdate = splittingNeedsUpdate(current, desired);
-      debugLog("zyfai:splitting", `${asset}: comparing`, {
-        mode: policy.splittingMode,
-        current: currentSplitting,
-        desired,
-        // Spelled out because the "why" is the non-obvious part: minSplits is
-        // what separates automatic (1) from force (2-4), not `splitting`.
-        decision: needsUpdate ? "will write \u2014 profile differs from the org policy" : "skipping \u2014 profile already matches"
-      });
-      if (!needsUpdate) return;
-      const result = await this.sdk.updateUserProfile({ asset, ...desired });
-      debugLog("zyfai:splitting", `${asset}: wrote updateUserProfile`, {
-        sent: { asset, ...desired },
-        // updateUserProfile re-reads the profile after PATCHing, so this is
-        // Zyfai's own view of the result rather than an echo of what we sent.
-        zyfaiNowReports: {
-          splitting: result?.splitting,
-          minSplits: result?.minSplits
-        }
-      });
-    } catch (error) {
-      console.warn(
-        `[zyfai] applyOrgPolicy(${asset}) failed (non-fatal):`,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * 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)
-      );
-    }
-  }
-  /**
-   * 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)
-        );
-      }
-    }
-  }
   async deposit(state, chainId, amount, asset, depositCallback) {
     try {
-      await this.connectFull(state, chainId);
       const validChainId = isValidChainId(chainId);
+      await this.ensureConnected(state, validChainId);
       if (depositCallback) {
         const wallet = await this.sdk.getSmartWalletAddress(
           this.getAddress(),
@@ -1346,19 +965,22 @@ var ZyfaiAgent = class {
           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: wallet.address, amount };
       }
       const raw = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
         amount,
-        asset
+        asset,
+        "aggressive"
       );
       return mapDeposit(raw);
     } catch (error) {
@@ -1367,8 +989,8 @@ var ZyfaiAgent = class {
   }
   // --- IAgent: Fund operations ---
   async withdraw(state, chainId, token, amount) {
-    await this.connectFull(state, chainId);
     const validChainId = isValidChainId(chainId);
+    await this.ensureConnected(state, validChainId);
     const raw = await this.sdk.withdrawFunds(
       this.getAddress(),
       validChainId,
@@ -1447,19 +1069,7 @@ var ZyfaiAgent = class {
   }
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, chainId);
-    const validChainId = isValidChainId(chainId);
     const raw = await this.sdk.getUserDetails();
-    debugLog("zyfai:profile", "getUserProfile \u2014 Zyfai reports", {
-      asset: "USDC (default \u2014 no asset passed)",
-      splitting: raw.splitting,
-      minSplits: raw.minSplits,
-      strategy: raw.strategy,
-      chains: raw.chains,
-      protocolCount: raw.protocols?.length,
-      hasActiveSessionKey: raw.hasActiveSessionKey,
-      smartWallet: raw.smartWallet
-    });
-    await this.ensureSessionKey(state, this.getAddress(), validChainId);
     return mapUserProfile(raw, this.connectedAddress);
   }
   async ensureAutoSelectProtocols(state, chainId, asset) {
@@ -1492,40 +1102,6 @@ var ZyfaiAgent = class {
 
 // src/lib/routing-api.ts
 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`;
-  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) {
   const url = `${ROUTING_API_BASE_URL}/api/v1/agent/keys`;
   const res = await fetch(url, {
@@ -1590,10 +1166,11 @@ async function withFailureReporting(apiKey, agentType, fn) {
 // src/lib/helpers/withdraw-helper.ts
 import { parseUnits } from "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: parseUnits(tokenBalance.amount, decimals) };
@@ -1863,6 +1440,84 @@ async function getSponsorRelayerAddress(input) {
   return parsed.data.relayer;
 }
 
+// src/lib/permit2.ts
+import { bytesToHex as bytesToHex2 } from "viem";
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: input.chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    types: {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    },
+    primaryType: "PermitTransferFrom",
+    message: input.message
+  };
+}
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt(bytesToHex2(bytes));
+}
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
+
 // src/lib/sponsored-deposit.ts
 var AUTH_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredDepositCallback(deps) {
@@ -2045,7 +1700,6 @@ var VIEM_CHAIN2 = {
   42161: arbitrum2,
   1: mainnet2
 };
-var AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai", "sail"];
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -2065,26 +1719,17 @@ var OwneySDK = class {
   disabledAgents = /* @__PURE__ */ new Set();
   state = null;
   apiKey;
-  // The org's agent policy, fetched once per client. Applied to each agent on
-  // activation (ROUT-229). `undefined` means "not fetched yet", `null` means
-  // "fetched, and the partner has no policy" — which is a real answer meaning
-  // leave every user's agent profile alone.
-  orgAgentConfig;
-  orgAgentConfigPromise = null;
   zyfaiRpcUrls;
   routingApiBaseUrl;
   referralSource;
-  surfliquidApiBaseUrl;
   cachedSponsoredCallback = null;
   cachedWethSponsoredCallback = null;
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
-    if (config.debug) setOwneyDebug(true);
     this.zyfaiRpcUrls = config.zyfaiRpcUrls;
     this.routingApiBaseUrl = config.routingApiBaseUrl;
     this.referralSource = config.referralSource;
-    this.surfliquidApiBaseUrl = config.surfliquidApiBaseUrl;
   }
   /**
    * Establish connection state for all subsequent SDK calls.
@@ -2243,57 +1888,14 @@ var OwneySDK = class {
     }
     return active;
   }
-  /**
-   * Read the org's agent policy once and reuse it. fetchOrgAgentConfig never
-   * throws — it degrades to null — so this cannot break activation.
-   */
-  async getOrgAgentConfig() {
-    if (this.orgAgentConfig !== void 0) return this.orgAgentConfig;
-    if (!this.orgAgentConfigPromise) {
-      this.orgAgentConfigPromise = fetchOrgAgentConfig(this.apiKey).then(
-        (config) => {
-          this.orgAgentConfig = config;
-          return config;
-        }
-      );
-    }
-    return this.orgAgentConfigPromise;
-  }
-  /**
-   * Apply the org policy to one agent, after it has activated.
-   *
-   * Sequenced after activation rather than alongside it because applying the
-   * policy needs the authenticated session activation establishes. Every failure
-   * mode is swallowed: a partner's splitting preference is not worth failing a
-   * user's connect over.
-   */
-  async applyOrgPolicyTo(agent, state, chainId) {
-    if (!agent.applyOrgPolicy) {
-      debugLog(
-        "owney-sdk",
-        `${agent.id}: no applyOrgPolicy \u2014 agent has no org-level knobs, skipping`
-      );
-      return;
-    }
-    try {
-      const policy = await this.getOrgAgentConfig();
-      if (!policy) return;
-      await agent.applyOrgPolicy(state, chainId, policy);
-    } catch (error) {
-      console.warn(
-        `[owney-sdk] applyOrgPolicy(${agent.id}) failed (non-fatal):`,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
   async ensureAgentsInitialized() {
     if (this.agents.size > 0) return;
     if (!this.initializingAgentsPromise) {
       this.initializingAgentsPromise = (async () => {
         const agentKeys = await fetchAgentKeys(this.apiKey);
         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, agent_type, is_enabled } of agentKeys) {
+          const agent = this.createAgent(agent_type, key);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -2314,21 +1916,9 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  async createAgent(agentId, key2, projectName) {
+  createAgent(agentId, key) {
     if (agentId === "zyfai") {
-      return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
-    }
-    if (agentId === "surfliquid") {
-      if (!projectName) return null;
-      const { SurfLiquidAgent } = await import("./surfliquid.agent-VNGQUSXN.js");
-      return new SurfLiquidAgent({
-        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 new ZyfaiAgent(key, this.zyfaiRpcUrls, this.referralSource);
     }
     return null;
   }
@@ -2382,7 +1972,6 @@ var OwneySDK = class {
       Promise.all(
         agents.map(async (agent) => {
           await agent.activateAgent(state, chainId);
-          await this.applyOrgPolicyTo(agent, state, chainId);
         })
       ).catch((error) => {
         console.error("activateAgent background init failed:", error);
@@ -2410,7 +1999,6 @@ var OwneySDK = class {
     Promise.all(
       enabledCompatible.map(async (agent) => {
         await agent.activateAgent(state, chainId);
-        await this.applyOrgPolicyTo(agent, state, chainId);
       })
     ).catch((error) => {
       console.error("activateAgent background init failed:", error);
@@ -2484,30 +2072,18 @@ var OwneySDK = class {
       );
     }
     const agentResults = {};
-    const agentErrors = {};
     for (const { agent, amount: agentAmount } of agentAmounts) {
-      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 }
+      agentResults[agent.id] = await this.depositWithFallback(
+        agent,
+        state,
+        chainId,
+        agentAmount,
+        asset,
+        effectiveCallback,
+        depositCallback
       );
     }
-    return Object.keys(agentErrors).length > 0 ? { agentResults, agentErrors } : { agentResults };
+    return { agentResults };
   }
   /**
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
@@ -2623,8 +2199,9 @@ var OwneySDK = class {
   async hasExistingBalance(agent, state, chainId, asset) {
     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 {
@@ -2663,34 +2240,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.
@@ -2726,17 +2275,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) {
@@ -2753,10 +2294,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);
@@ -3273,22 +2813,22 @@ var readLegacySiwxSession = (store, address) => {
   const legacyKeys = [];
   try {
     for (let i = 0; i < store.length; i++) {
-      const key2 = store.key(i);
-      if (key2?.startsWith(prefix)) legacyKeys.push(key2);
+      const key = store.key(i);
+      if (key?.startsWith(prefix)) legacyKeys.push(key);
     }
   } catch {
     return null;
   }
   let adopted = null;
-  for (const key2 of legacyKeys) {
+  for (const key of legacyKeys) {
     if (!adopted) {
       try {
-        adopted = JSON.parse(store.getItem(key2) ?? "");
+        adopted = JSON.parse(store.getItem(key) ?? "");
       } catch {
       }
     }
     try {
-      store.removeItem(key2);
+      store.removeItem(key);
     } catch {
     }
   }
@@ -3296,11 +2836,11 @@ var readLegacySiwxSession = (store, address) => {
 };
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
-  const key2 = buildKey2(address);
+  const key = buildKey2(address);
   const store = storage2();
   let raw = null;
   try {
-    raw = store?.getItem(key2) ?? null;
+    raw = store?.getItem(key) ?? null;
   } catch {
     raw = null;
   }
@@ -3308,9 +2848,9 @@ var readSiwxSession = (address, chainId) => {
     try {
       return JSON.parse(raw);
     } catch {
-      memorySiwxSessions.delete(key2);
+      memorySiwxSessions.delete(key);
       try {
-        store?.removeItem(key2);
+        store?.removeItem(key);
       } catch {
       }
       return null;
@@ -3321,24 +2861,24 @@ var readSiwxSession = (address, chainId) => {
     writeSiwxSession(address, chainId, legacy);
     return legacy;
   }
-  return memorySiwxSessions.get(key2) ?? null;
+  return memorySiwxSessions.get(key) ?? null;
 };
 var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key2 = buildKey2(address);
-  memorySiwxSessions.set(key2, session);
+  const key = buildKey2(address);
+  memorySiwxSessions.set(key, session);
   const store = storage2();
   try {
-    store?.setItem(key2, JSON.stringify(session));
+    store?.setItem(key, JSON.stringify(session));
   } catch {
   }
 };
 var clearSiwxSession = (address, _chainId) => {
-  const key2 = buildKey2(address);
-  memorySiwxSessions.delete(key2);
+  const key = buildKey2(address);
+  memorySiwxSessions.delete(key);
   const store = storage2();
   try {
-    store?.removeItem(key2);
+    store?.removeItem(key);
   } catch {
   }
   readLegacySiwxSession(store, address);
@@ -3467,6 +3007,5 @@ export {
   NotConnectedError,
   OwneyError,
   OwneySDK,
-  createOwneySIWX,
-  setOwneyDebug
+  createOwneySIWX
 };