@owney/sdk 0.7.0-beta.1 → 0.7.1

package/dist/index.cjs

@@ -9,9 +9,9 @@ var __export = (target, all) => {
 };
 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;
 };
@@ -26,7 +26,8 @@ __export(index_exports, {
   NotConnectedError: () => NotConnectedError,
   OwneyError: () => OwneyError,
   OwneySDK: () => OwneySDK,
-  createOwneySIWX: () => createOwneySIWX
+  createOwneySIWX: () => createOwneySIWX,
+  setOwneyDebug: () => setOwneyDebug
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -412,7 +413,9 @@ function mapUserProfile(raw, userAddress) {
     chains: raw.chains || [],
     strategy: raw.strategy,
     hasActiveSessionKey: raw.hasActiveSessionKey || false,
-    protocols: raw.protocols || []
+    protocols: raw.protocols || [],
+    splitting: raw.splitting,
+    minSplits: raw.minSplits
   };
 }
 function mapApyByStrategy(raw) {
@@ -559,23 +562,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 {
     }
   }
@@ -583,11 +586,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;
   }
@@ -597,9 +600,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;
@@ -609,27 +612,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);
@@ -660,6 +663,149 @@ 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",
@@ -672,6 +818,8 @@ var WETH_ADDRESS_BY_CHAIN = {
   1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
 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];
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161, 1];
@@ -982,6 +1130,176 @@ 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)
+      );
+    }
+  }
   async deposit(state, chainId, amount, asset, depositCallback) {
     try {
       const validChainId = isValidChainId(chainId);
@@ -1102,6 +1420,16 @@ var ZyfaiAgent = class {
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, 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
+    });
     return mapUserProfile(raw, this.connectedAddress);
   }
   async ensureAutoSelectProtocols(state, chainId, asset) {
@@ -1134,6 +1462,40 @@ 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, {
@@ -1747,6 +2109,12 @@ 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;
@@ -1755,6 +2123,7 @@ var OwneySDK = class {
   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;
@@ -1916,14 +2285,57 @@ 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, agent_type, is_enabled } of agentKeys) {
-          const agent = this.createAgent(agent_type, key);
+        for (const { key: key2, agent_type, is_enabled } of agentKeys) {
+          const agent = this.createAgent(agent_type, key2);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -1944,9 +2356,9 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  createAgent(agentId, key) {
+  createAgent(agentId, key2) {
     if (agentId === "zyfai") {
-      return new ZyfaiAgent(key, this.zyfaiRpcUrls, this.referralSource);
+      return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
     }
     return null;
   }
@@ -2000,6 +2412,7 @@ 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);
@@ -2027,6 +2440,7 @@ 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);
@@ -2841,22 +3255,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 {
     }
   }
@@ -2864,11 +3278,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;
   }
@@ -2876,9 +3290,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;
@@ -2889,24 +3303,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);
@@ -3036,5 +3450,6 @@ function createOwneySIWX(config) {
   NotConnectedError,
   OwneyError,
   OwneySDK,
-  createOwneySIWX
+  createOwneySIWX,
+  setOwneyDebug
 });