@zyfai/sdk 0.2.32 → 0.2.34

package/dist/cli/index.js

@@ -1,3981 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __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 });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli/index.ts
-var import_commander = require("commander");
-
-// src/cli/utils/config.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
-var CONFIG_DIR = path.join(os.homedir(), ".config", "zyfai");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  }
-}
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const content = fs.readFileSync(CONFIG_FILE, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return {};
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
-    mode: 384
-  });
-}
-function getConfigValue(key) {
-  const config = loadConfig();
-  return config[key];
-}
-function setConfigValue(key, value) {
-  const config = loadConfig();
-  config[key] = value;
-  saveConfig(config);
-}
-function getApiKey() {
-  console.log("configKey");
-  const configKey = getConfigValue("apiKey");
-  if (configKey) {
-    return configKey;
-  }
-  throw new Error(
-    "API key not found. Set it with: zyfai config set api-key YOUR_KEY\nOr set ZYFAI_API_KEY environment variable"
-  );
-}
-function getDefaultChain() {
-  return getConfigValue("defaultChain") || "base";
-}
-function clearConfig() {
-  if (fs.existsSync(CONFIG_FILE)) {
-    fs.unlinkSync(CONFIG_FILE);
-  }
-}
-function getConfigPath() {
-  return CONFIG_FILE;
-}
-
-// src/cli/utils/output.ts
-function outputSuccess(data) {
-  const result = {
-    success: true,
-    data
-  };
-  console.log(JSON.stringify(result, null, 2));
-}
-function outputError(error) {
-  const message = error instanceof Error ? error.message : error;
-  const result = {
-    success: false,
-    error: message
-  };
-  console.log(JSON.stringify(result, null, 2));
-  process.exit(1);
-}
-
-// src/cli/commands/config.ts
-function registerConfigCommand(program2) {
-  const configCmd = program2.command("config").description("Manage Zyfai CLI configuration");
-  configCmd.command("set <key> <value>").description("Set a configuration value (api-key, default-chain, default-wallet)").action((key, value) => {
-    try {
-      const normalizedKey = key.replace(/-/g, "");
-      switch (normalizedKey) {
-        case "apikey":
-          setConfigValue("apiKey", value);
-          outputSuccess({ message: "API key saved", path: getConfigPath() });
-          break;
-        case "defaultchain":
-          if (!["base", "arbitrum", "plasma"].includes(value.toLowerCase())) {
-            throw new Error("Invalid chain. Supported: base, arbitrum, plasma");
-          }
-          setConfigValue("defaultChain", value.toLowerCase());
-          outputSuccess({ message: `Default chain set to ${value}` });
-          break;
-        case "defaultwallet":
-          setConfigValue("defaultWallet", value);
-          outputSuccess({ message: `Default wallet set to ${value}` });
-          break;
-        default:
-          throw new Error(
-            `Unknown config key: ${key}. Supported: api-key, default-chain, default-wallet`
-          );
-      }
-    } catch (error) {
-      outputError(error);
-    }
-  });
-  configCmd.command("get [key]").description("Get configuration value(s)").action((key) => {
-    try {
-      const config = loadConfig();
-      if (key) {
-        const normalizedKey = key.replace(/-/g, "");
-        let value;
-        switch (normalizedKey) {
-          case "apikey":
-            value = config.apiKey ? "***" + config.apiKey.slice(-4) : void 0;
-            break;
-          case "defaultchain":
-            value = config.defaultChain;
-            break;
-          case "defaultwallet":
-            value = config.defaultWallet;
-            break;
-          default:
-            throw new Error(`Unknown config key: ${key}`);
-        }
-        outputSuccess({ [key]: value });
-      } else {
-        outputSuccess({
-          apiKey: config.apiKey ? "***" + config.apiKey.slice(-4) : void 0,
-          defaultChain: config.defaultChain,
-          defaultWallet: config.defaultWallet,
-          path: getConfigPath()
-        });
-      }
-    } catch (error) {
-      outputError(error);
-    }
-  });
-  configCmd.command("clear").description("Clear all configuration").action(() => {
-    try {
-      clearConfig();
-      outputSuccess({ message: "Configuration cleared" });
-    } catch (error) {
-      outputError(error);
-    }
-  });
-  configCmd.command("path").description("Show configuration file path").action(() => {
-    outputSuccess({ path: getConfigPath() });
-  });
-}
-
-// src/utils/http-client.ts
-var import_axios = __toESM(require("axios"));
-
-// src/config/endpoints.ts
-var API_ENDPOINT = "https://api.zyf.ai";
-var DATA_API_ENDPOINT = "https://defiapi.zyf.ai";
-var API_VERSION = "/api/v1";
-var DATA_API_VERSION = "/api/v2";
-var ENDPOINTS = {
-  // Auth
-  AUTH_LOGIN: "/auth/login",
-  AUTH_CHALLENGE: "/auth/challenge",
-  // User
-  USER_ME: "/users/me",
-  USER_WITHDRAW: "/users/withdraw",
-  PARTIAL_WITHDRAW: "/users/partial-withdraw",
-  LOG_DEPOSIT: "/users/log_deposit",
-  // Safe Deployment (single endpoint)
-  SAFE_DEPLOY: "/users/safe-deploy",
-  // Session Keys
-  SESSION_KEYS_CONFIG: "/session-keys/config",
-  SESSION_KEYS_ADD: "/session-keys/add",
-  // Protocols
-  PROTOCOLS: (chainId) => chainId ? `/protocols?chainId=${chainId}` : "/protocols",
-  // Data (v1)
-  DATA_POSITION: (walletAddress) => `/data/position?walletAddress=${walletAddress}`,
-  DATA_PORTFOLIO: (walletAddress) => `/data/wallet-portfolio?walletAddress=${walletAddress}`,
-  DATA_HISTORY: (walletAddress, chainId) => `/data/history?walletAddress=${walletAddress}&chainId=${chainId}`,
-  DATA_TVL: "/data/usd-tvl",
-  DATA_VOLUME: (assetType) => `/data/volume?assetType=${assetType}`,
-  DATA_FIRST_TOPUP: (walletAddress, chainId) => `/data/first-topup?walletAddress=${walletAddress}&chainId=${chainId}`,
-  DATA_ACTIVE_WALLETS: (chainId) => `/data/active-wallets?chainId=${chainId}`,
-  DATA_BY_EOA: (address) => `/data/by-eoa?address=${address}`,
-  DATA_REBALANCE_FREQUENCY: (walletAddress) => `/data/rebalance-frequency?walletAddress=${walletAddress}`,
-  // SDK Keys
-  SDK_ALLOWED_WALLETS: "/data/sdk-allowed-wallets",
-  SDK_TVL: "/data/sdk-tvl",
-  // Agent Identity Registry
-  AGENT_TOKEN_URI: "/users/me/agent-token-uri",
-  // Customization
-  CUSTOMIZE_BATCH: "/customization/customize-batch",
-  CUSTOMIZATION_POOLS: (protocolId, strategy) => `/customization/pools?protocolId=${protocolId}${strategy ? `&strategy=${strategy}` : ""}`,
-  CUSTOMIZATION_SELECTED_POOLS: (protocolId, chainId) => `/customization/selected-pools?protocolId=${protocolId}&chainId=${chainId}`
-};
-var DATA_ENDPOINTS = {
-  // User Initialization
-  USER_INITIALIZE: "/api/earnings/initialize",
-  // Earnings
-  ONCHAIN_EARNINGS: (walletAddress) => `/onchain-earnings/onchain-earnings?walletAddress=${walletAddress}`,
-  CALCULATE_ONCHAIN_EARNINGS: "/onchain-earnings/calculate-onchain-earnings",
-  DAILY_EARNINGS: (walletAddress, startDate, endDate) => {
-    let url = `/onchain-earnings/daily-earnings?walletAddress=${walletAddress}`;
-    if (startDate) url += `&startDate=${startDate}`;
-    if (endDate) url += `&endDate=${endDate}`;
-    return url;
-  },
-  // Opportunities
-  OPPORTUNITIES_SAFE: (chainId, asset, status) => {
-    const params = [];
-    if (chainId !== void 0) params.push(`chainId=${chainId}`);
-    if (asset) params.push(`asset=${asset}`);
-    if (status) params.push(`status=${status}`);
-    return params.length > 0 ? `/opportunities/safe?${params.join("&")}` : "/opportunities/safe";
-  },
-  OPPORTUNITIES_DEGEN: (chainId, asset, status) => {
-    const params = [];
-    if (chainId !== void 0) params.push(`chainId=${chainId}`);
-    if (asset) params.push(`asset=${asset}`);
-    if (status) params.push(`status=${status}`);
-    return params.length > 0 ? `/opportunities/degen-strategies?${params.join("&")}` : "/opportunities/degen-strategies";
-  },
-  // APY History
-  DAILY_APY_HISTORY_WEIGHTED: (walletAddress, days) => `/daily-apy-history/weighted-multi-asset/${walletAddress}${days ? `?days=${days}` : ""}`,
-  // Rebalance
-  REBALANCE_INFO: (options) => {
-    const params = [];
-    if (options?.isCrossChain !== void 0) params.push(`isCrossChain=${options.isCrossChain}`);
-    if (options?.tokenSymbol) params.push(`tokenSymbol=${options.tokenSymbol}`);
-    return params.length > 0 ? `/rebalance/rebalance-info?${params.join("&")}` : "/rebalance/rebalance-info";
-  },
-  // APY Per Strategy
-  APY_PER_STRATEGY: (options = {}) => {
-    const params = [];
-    if (options.isCrossChain !== void 0) params.push(`isCrossChain=${options.isCrossChain}`);
-    if (options.days !== void 0) params.push(`days=${options.days}`);
-    if (options.strategy) params.push(`strategy=${options.strategy}`);
-    if (options.chainId !== void 0) params.push(`chainId=${options.chainId}`);
-    if (options.tokenSymbol) params.push(`tokenSymbol=${options.tokenSymbol}`);
-    return params.length > 0 ? `/rebalance/rebalance-info?${params.join("&")}` : "/rebalance/rebalance-info";
-  }
-};
-
-// src/utils/http-client.ts
-var HttpClient = class {
-  /**
-   * Create HTTP client for both Execution API and Data API
-   *
-   * @param apiKey - API key for both Execution API and Data API
-   */
-  constructor(apiKey) {
-    this.authToken = null;
-    this.apiKey = apiKey;
-    const parsedUrl = new URL(API_ENDPOINT);
-    this.origin = parsedUrl.origin;
-    this.host = parsedUrl.host;
-    this.client = import_axios.default.create({
-      baseURL: `${API_ENDPOINT}${API_VERSION}`,
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-Key": this.apiKey
-      },
-      timeout: 3e4
-    });
-    this.dataClient = import_axios.default.create({
-      baseURL: `${DATA_API_ENDPOINT}${DATA_API_VERSION}`,
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-Key": this.apiKey
-      },
-      timeout: 3e4
-    });
-    this.setupInterceptors();
-    this.setupDataInterceptors();
-  }
-  setAuthToken(token) {
-    this.authToken = token;
-  }
-  clearAuthToken() {
-    this.authToken = null;
-  }
-  getOrigin() {
-    return this.origin;
-  }
-  getHost() {
-    return this.host;
-  }
-  setupInterceptors() {
-    this.client.interceptors.request.use(
-      (config) => {
-        config.headers["X-API-Key"] = this.apiKey;
-        if (this.authToken) {
-          config.headers["Authorization"] = `Bearer ${this.authToken}`;
-        }
-        return config;
-      },
-      (error) => {
-        return Promise.reject(error);
-      }
-    );
-    this.client.interceptors.response.use(
-      (response) => response,
-      (error) => {
-        if (error.response) {
-          const status = error.response.status;
-          const data = error.response.data;
-          switch (status) {
-            case 401:
-              throw new Error("Unauthorized: Invalid API key");
-            case 403:
-              throw new Error("Forbidden: Access denied");
-            case 404:
-              throw new Error(
-                `Not found: ${data.message || "Resource not found"}`
-              );
-            case 429:
-              throw new Error("Rate limit exceeded. Please try again later.");
-            case 500:
-              throw new Error(data?.message || data?.error || "Internal server error. Please try again later.");
-            default:
-              throw new Error(data.message || "An error occurred");
-          }
-        } else if (error.request) {
-          throw new Error("Network error: Unable to reach the server");
-        } else {
-          throw new Error(`Request error: ${error.message}`);
-        }
-      }
-    );
-  }
-  async get(url, config) {
-    const response = await this.client.get(url, config);
-    return response.data;
-  }
-  async post(url, data, config) {
-    const response = await this.client.post(url, data, config);
-    return response.data;
-  }
-  async patch(url, data, config) {
-    const response = await this.client.patch(url, data, config);
-    return response.data;
-  }
-  async delete(url, config) {
-    const response = await this.client.delete(url, config);
-    return response.data;
-  }
-  // Data API methods (v2)
-  async dataGet(url, config) {
-    const response = await this.dataClient.get(url, config);
-    return response.data;
-  }
-  async dataPost(url, data, config) {
-    const response = await this.dataClient.post(url, data, config);
-    return response.data;
-  }
-  /**
-   * Make a POST request to Data API with a custom path (bypasses /api/v2 baseURL)
-   * Useful for endpoints that don't follow the /api/v2 pattern
-   *
-   * @param path - API path (e.g., "/api/earnings/initialize")
-   * @param data - Request body
-   * @param config - Additional axios config
-   */
-  async dataPostCustom(path2, data, config) {
-    const fullUrl = `${DATA_API_ENDPOINT}${path2}`;
-    const headers = {
-      "Content-Type": "application/json",
-      "X-API-Key": this.apiKey,
-      ...config?.headers
-    };
-    if (this.authToken) {
-      headers["Authorization"] = `Bearer ${this.authToken}`;
-    }
-    const response = await import_axios.default.post(fullUrl, data, {
-      ...config,
-      headers,
-      timeout: config?.timeout || 3e4
-    });
-    return response.data;
-  }
-  setupDataInterceptors() {
-    this.dataClient.interceptors.request.use(
-      (config) => {
-        config.headers["X-API-Key"] = this.apiKey;
-        if (this.authToken) {
-          config.headers["Authorization"] = `Bearer ${this.authToken}`;
-        }
-        return config;
-      },
-      (error) => Promise.reject(error)
-    );
-    this.dataClient.interceptors.response.use(
-      (response) => response,
-      (error) => {
-        if (error.response) {
-          const status = error.response.status;
-          const data = error.response.data;
-          switch (status) {
-            case 401:
-              throw new Error("Unauthorized: Invalid API key");
-            case 403:
-              throw new Error("Forbidden: Access denied to data API");
-            case 404:
-              throw new Error(
-                `Not found: ${data.message || data.error || "Resource not found"}`
-              );
-            case 429:
-              throw new Error("Rate limit exceeded. Please try again later.");
-            case 500:
-              throw new Error(
-                data.error || "Internal server error. Please try again later."
-              );
-            default:
-              throw new Error(
-                data.message || data.error || "An error occurred"
-              );
-          }
-        } else if (error.request) {
-          throw new Error("Network error: Unable to reach the data server");
-        } else {
-          throw new Error(`Request error: ${error.message}`);
-        }
-      }
-    );
-  }
-};
-
-// src/config/abis.ts
-var import_viem = require("viem");
-var ERC20_ABI = [
-  {
-    name: "transfer",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    name: "approve",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    name: "allowance",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "balanceOf",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "decimals",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }]
-  },
-  {
-    name: "symbol",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
-  },
-  {
-    name: "name",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
-  },
-  {
-    name: "totalSupply",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }]
-  }
-];
-var IDENTITY_REGISTRY_ABI = (0, import_viem.parseAbi)([
-  "function register() external returns (uint256 agentId)",
-  "function register(string tokenUri) external returns (uint256 agentId)",
-  "function register(string tokenUri, (string key, bytes value)[] metadata) external returns (uint256 agentId)"
-]);
-var IDENTITY_REGISTRY_ADDRESS = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
-var VAULT_ABI = [
-  {
-    name: "deposit",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "assets", type: "uint256" },
-      { name: "receiver", type: "address" }
-    ],
-    outputs: [{ name: "shares", type: "uint256" }]
-  },
-  {
-    name: "requestRedeem",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "shares", type: "uint256" },
-      { name: "controller", type: "address" },
-      { name: "owner", type: "address" }
-    ],
-    outputs: [{ name: "requestId", type: "uint256" }]
-  },
-  {
-    name: "claim",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "withdrawKey", type: "bytes32" }],
-    outputs: [{ name: "assets", type: "uint256" }]
-  },
-  {
-    name: "getWithdrawKey",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "user", type: "address" },
-      { name: "nonce", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bytes32" }]
-  },
-  {
-    name: "nonces",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "isClaimable",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "withdrawKey", type: "bytes32" }],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    name: "isClaimed",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "withdrawKey", type: "bytes32" }],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    name: "maxRequestRedeem",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "owner", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "balanceOf",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "symbol",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
-  }
-];
-var VAULT_ADDRESS = "0xD580071c47d4a667858B5FafAb85BC9C609beC5D";
-
-// src/core/ZyfaiSDK.ts
-var import_accounts2 = require("viem/accounts");
-var import_viem5 = require("viem");
-
-// src/config/chains.ts
-var import_viem2 = require("viem");
-var import_chains = require("viem/chains");
-var import_viem3 = require("viem");
-var plasma = (0, import_viem3.defineChain)({
-  id: 9745,
-  name: "Plasma",
-  nativeCurrency: {
-    decimals: 18,
-    name: "Plasma",
-    symbol: "PLSM"
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.plasma.to"]
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: "Plasma Explorer",
-      url: "https://explorer.plasma.io"
-    }
-  }
-});
-var ASSET_CONFIGS = {
-  USDC: {
-    symbol: "USDC",
-    assetType: "usdc",
-    displayName: "USDC",
-    icon: "/ai-dashboard/usdc-token.png",
-    decimals: 6,
-    tokenSymbols: ["USDC", "USDC.e", "USDT", "USDT0"],
-    tokenSymbolsByChainId: {
-      8453: "USDC",
-      42161: "USDC",
-      9745: "USDT0",
-      146: "USDC.e",
-      1: "USDC"
-    },
-    addresses: {
-      8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      // Base
-      42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-      // Arbitrum
-      9745: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
-      // Plasma
-      146: "0x29219dd400f2bf60e5a23d13be72b486d4038894",
-      // Sonic
-      59144: "0x176211869ca2b568f2a7d4ee941e073a821ee1ff",
-      // Linea
-      1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
-      // Ethereum
-    },
-    enabled: true
-  },
-  WETH: {
-    symbol: "WETH",
-    assetType: "eth",
-    displayName: "WETH",
-    icon: "/ai-dashboard/eth-token.png",
-    decimals: 18,
-    tokenSymbols: ["WETH", "ETH"],
-    tokenSymbolsByChainId: {
-      8453: "WETH",
-      42161: "WETH",
-      9745: "WETH",
-      146: "WETH",
-      59144: "WETH",
-      1: "WETH"
-    },
-    addresses: {
-      8453: "0x4200000000000000000000000000000000000006",
-      // Base
-      42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-      // Arbitrum
-      9745: "0x4200000000000000000000000000000000000006",
-      // Plasma
-      146: "0x039e64f90d4199560e7533692f69448878db85c7",
-      // Sonic
-      59144: "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
-      // Linea
-      1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-      // Ethereum
-    },
-    enabled: true
-  }
-};
-var getDefaultTokenAddress = (chainId, asset) => {
-  const address = ASSET_CONFIGS[asset || "USDC"]?.addresses[chainId];
-  if (!address || address === "0x0000000000000000000000000000000000000000") {
-    throw new Error(
-      `Default token address not configured for chain ${chainId}. Please provide tokenAddress explicitly.`
-    );
-  }
-  return address;
-};
-var DEFAULT_RPC_URLS = {
-  8453: "https://mainnet.base.org",
-  42161: "https://arb1.arbitrum.io/rpc",
-  9745: "https://rpc.plasma.to"
-};
-var CHAINS = {
-  8453: import_chains.base,
-  42161: import_chains.arbitrum,
-  9745: plasma
-};
-var getChainConfig = (chainId, rpcUrls) => {
-  const chain = CHAINS[chainId];
-  if (!chain) {
-    throw new Error(`Unsupported chain ID: ${chainId}`);
-  }
-  const rpcUrl = rpcUrls && rpcUrls[chainId] || DEFAULT_RPC_URLS[chainId];
-  const publicClient = (0, import_viem2.createPublicClient)({
-    chain,
-    transport: (0, import_viem2.http)(rpcUrl)
-  });
-  return {
-    chain,
-    rpcUrl,
-    publicClient
-  };
-};
-var isSupportedChain = (chainId) => {
-  return chainId in CHAINS;
-};
-
-// src/utils/safe-account.ts
-var import_module_sdk = require("@rhinestone/module-sdk");
-var import_accounts = require("permissionless/accounts");
-var import_viem4 = require("viem");
-var import_account_abstraction = require("viem/account-abstraction");
-var SAFE_7579_ADDRESS = "0x7579EE8307284F293B1927136486880611F20002";
-var ERC7579_LAUNCHPAD_ADDRESS = "0x7579011aB74c46090561ea277Ba79D510c6C00ff";
-var ACCOUNT_SALT = "zyfai";
-var getSafeAccount = async (config) => {
-  const { safeOwnerAddress, publicClient } = config;
-  if (!safeOwnerAddress) {
-    throw new Error("Safe owner address is required");
-  }
-  const formattedOwnerAddress = (0, import_viem4.getAddress)(safeOwnerAddress);
-  const ownableValidator = (0, import_module_sdk.getOwnableValidator)({
-    owners: [formattedOwnerAddress],
-    threshold: 1
-  });
-  const saltHex = (0, import_viem4.fromHex)((0, import_viem4.toHex)(ACCOUNT_SALT), "bigint");
-  const tempOwner = {
-    address: formattedOwnerAddress,
-    type: "json-rpc"
-  };
-  const safeAccount = await (0, import_accounts.toSafeSmartAccount)({
-    client: publicClient,
-    owners: [tempOwner],
-    version: "1.4.1",
-    entryPoint: {
-      address: import_account_abstraction.entryPoint07Address,
-      version: "0.7"
-    },
-    safe4337ModuleAddress: SAFE_7579_ADDRESS,
-    erc7579LaunchpadAddress: ERC7579_LAUNCHPAD_ADDRESS,
-    attesters: [import_module_sdk.RHINESTONE_ATTESTER_ADDRESS],
-    attestersThreshold: 1,
-    validators: [
-      {
-        address: ownableValidator.address,
-        context: ownableValidator.initData
-      }
-    ],
-    saltNonce: saltHex
-  });
-  return safeAccount;
-};
-var getDeterministicSafeAddress = async (config) => {
-  try {
-    const safeAccount = await getSafeAccount(config);
-    return await safeAccount.getAddress();
-  } catch (error) {
-    throw new Error(
-      `Failed to get deterministic Safe address: ${error.message}`
-    );
-  }
-};
-var isSafeDeployed = async (address, publicClient) => {
-  try {
-    const code = await publicClient.getCode({ address });
-    return !!code && code !== "0x";
-  } catch (error) {
-    console.error("Error checking if Safe is deployed:", error);
-    return false;
-  }
-};
-var getAccountType = async (address, publicClient) => {
-  try {
-    const code = await publicClient.getCode({ address });
-    if (!code || code === "0x" || code.length === 2) {
-      return "EOA";
-    }
-    if (code.startsWith("0xef01")) {
-      return "EOA";
-    }
-    try {
-      const threshold = await publicClient.readContract({
-        address,
-        abi: [
-          {
-            inputs: [],
-            name: "getThreshold",
-            outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-            stateMutability: "view",
-            type: "function"
-          }
-        ],
-        functionName: "getThreshold"
-      });
-      if (threshold !== void 0) {
-        return "Safe";
-      }
-    } catch {
-    }
-    return "Unknown";
-  } catch (error) {
-    console.error("Error checking account type:", error);
-    return "Unknown";
-  }
-};
-var deploySafeAccount = async (config) => {
-  try {
-    const { owner, httpClient, chainId, strategy = "safe_strategy" } = config;
-    if (!owner || !owner.account) {
-      throw new Error(
-        "Wallet not connected. Please connect your wallet first."
-      );
-    }
-    const prepareResponse = await httpClient.post(
-      `${ENDPOINTS.SAFE_DEPLOY}?chainId=${chainId}`,
-      { strategy }
-    );
-    if (!prepareResponse.userOpHashToSign) {
-      throw new Error(
-        "Backend did not return userOpHashToSign. Response: " + JSON.stringify(prepareResponse)
-      );
-    }
-    const userOpHashToSign = prepareResponse.userOpHashToSign;
-    const userOpSignature = await owner.signMessage({
-      account: owner.account,
-      message: { raw: userOpHashToSign }
-    });
-    const deployResponse = await httpClient.post(
-      `${ENDPOINTS.SAFE_DEPLOY}?chainId=${chainId}`,
-      { userOpSignature, strategy }
-    );
-    if (!deployResponse.success) {
-      throw new Error(
-        `Safe deployment failed: ${JSON.stringify(deployResponse)}`
-      );
-    }
-    return {
-      safeAddress: deployResponse.safeAddress || "0x",
-      txHash: deployResponse.txHash,
-      isDeployed: true
-    };
-  } catch (error) {
-    throw new Error(
-      `Failed to deploy Safe account: ${error.message}`
-    );
-  }
-};
-var signSessionKey = async (config, sessions, allPublicClients, signingParams) => {
-  const { owner, publicClient } = config;
-  if (!owner || !owner.account) {
-    throw new Error("Wallet not connected. Please connect your wallet first.");
-  }
-  const safeAccount = await getSafeAccount(config);
-  const account = (0, import_module_sdk.getAccount)({
-    address: safeAccount.address,
-    type: "safe"
-  });
-  const clients = allPublicClients || [publicClient];
-  const sessionNonces = await Promise.all(
-    sessions.map((session) => {
-      const sessionChainId = Number(session.chainId);
-      const client = clients.find((c) => c.chain?.id === sessionChainId) || publicClient;
-      return (0, import_module_sdk.getSessionNonce)({
-        client,
-        account,
-        permissionId: (0, import_module_sdk.getPermissionId)({
-          session
-        })
-      });
-    })
-  );
-  const sessionDetails = await (0, import_module_sdk.getEnableSessionDetails)({
-    sessions,
-    account,
-    clients,
-    permitGenericPolicy: signingParams?.permitGenericPolicy ?? true,
-    sessionNonces,
-    ignoreSecurityAttestations: signingParams?.ignoreSecurityAttestations ?? false
-  });
-  const signature = await owner.signMessage({
-    account: owner.account,
-    message: {
-      raw: sessionDetails.permissionEnableHash
-    }
-  });
-  return {
-    signature,
-    sessionNonces
-  };
-};
-
-// src/utils/strategy.ts
-function toInternalStrategy(publicStrategy) {
-  switch (publicStrategy) {
-    case "conservative":
-      return "safe_strategy";
-    case "aggressive":
-      return "degen_strategy";
-    default:
-      throw new Error(
-        `Invalid public strategy: ${publicStrategy}. Must be "conservative" or "aggressive".`
-      );
-  }
-}
-function toPublicStrategy(internalStrategy) {
-  if (internalStrategy === "safe_strategy" || internalStrategy === "safe") {
-    return "conservative";
-  }
-  if (internalStrategy === "degen_strategy" || internalStrategy === "degen") {
-    return "aggressive";
-  }
-  throw new Error(
-    `Invalid internal strategy: ${internalStrategy}. Must be "safe_strategy" or "degen_strategy".`
-  );
-}
-function isValidPublicStrategy(strategy) {
-  return strategy === "conservative" || strategy === "aggressive";
-}
-function convertStrategyToPublic(obj) {
-  if (!obj.strategy) {
-    const result = { ...obj };
-    if ("hasStaleBalance" in result) {
-      delete result.hasStaleBalance;
-    }
-    return result;
-  }
-  try {
-    const result = {
-      ...obj,
-      strategy: toPublicStrategy(
-        obj.strategy
-      )
-    };
-    if ("hasStaleBalance" in result) {
-      delete result.hasStaleBalance;
-    }
-    if ("staleBalances" in result) {
-      result.staleBalances = result.staleBalances?.filter((staleBalance) => staleBalance.balance !== "0x0");
-    }
-    return result;
-  } catch {
-    const result = { ...obj };
-    if ("hasStaleBalance" in result) {
-      delete result.hasStaleBalance;
-    }
-    return result;
-  }
-}
-function removeUnusedFields(obj) {
-  const result = { ...obj };
-  if ("hasStaleBalance" in result) {
-    delete result.hasStaleBalance;
-  }
-  return result;
-}
-function convertAssetInternally(asset) {
-  if (asset === "USDC") {
-    return "usdc";
-  }
-  if (asset === "WETH") {
-    return "eth";
-  }
-  throw new Error(`Invalid asset: ${asset}. Must be "USDC" or "WETH".`);
-}
-function convertStrategiesToPublic(array) {
-  return array.map((item) => convertStrategyToPublic(item));
-}
-function convertStrategyToPublicAndNaming(obj) {
-  const result = { ...obj };
-  if (result.strategy) {
-    try {
-      result.strategy = toPublicStrategy(result.strategy);
-    } catch {
-    }
-  }
-  if (result.average_apy_without_fee !== void 0) {
-    result.average_apy_with_fee = result.average_apy_without_fee;
-    delete result.average_apy_without_fee;
-  }
-  if (result.average_apy_with_rzfi_without_fee !== void 0) {
-    result.average_apy_with_rzfi_with_fee = result.average_apy_with_rzfi_without_fee;
-    delete result.average_apy_with_rzfi_without_fee;
-  }
-  if (result.events_average_apy_without_fee !== void 0) {
-    result.events_average_apy_with_fee = result.events_average_apy_without_fee;
-    delete result.events_average_apy_without_fee;
-  }
-  if (result.events_average_apy_with_rzfi_without_fee !== void 0) {
-    result.events_average_apy_with_rzfi_with_fee = result.events_average_apy_with_rzfi_without_fee;
-    delete result.events_average_apy_with_rzfi_without_fee;
-  }
-  return result;
-}
-function convertStrategiesToPublicAndNaming(array) {
-  return array.map((item) => convertStrategyToPublicAndNaming(item));
-}
-
-// src/core/ZyfaiSDK.ts
-var import_siwe = require("siwe");
-var _ZyfaiSDK = class _ZyfaiSDK {
-  constructor(config) {
-    this.signer = null;
-    this.walletClient = null;
-    this.authenticatedUserId = null;
-    this.hasActiveSessionKey = false;
-    this.currentProvider = null;
-    this.currentChainId = null;
-    const sdkConfig = typeof config === "string" ? { apiKey: config } : config;
-    const { apiKey, rpcUrls, referralSource } = sdkConfig;
-    if (!apiKey) {
-      throw new Error("API key is required");
-    }
-    this.httpClient = new HttpClient(apiKey);
-    this.rpcUrls = rpcUrls;
-    this.referralSource = referralSource;
-  }
-  /**
-   * Authenticate user with SIWE (Sign-In with Ethereum) & JWT token
-   * This is required for accessing user-specific endpoints like session-keys/config
-   * Uses the connected wallet address for authentication
-   *
-   * @returns Promise that resolves when authentication is complete
-   */
-  async authenticateUser() {
-    try {
-      if (this.authenticatedUserId !== null) {
-        return;
-      }
-      const walletClient = this.getWalletClient();
-      const userAddress = (0, import_viem5.getAddress)(walletClient.account.address);
-      const chainId = this.currentChainId || walletClient.chain?.id || 8453;
-      const challengeResponse = await this.httpClient.post(ENDPOINTS.AUTH_CHALLENGE, {});
-      let uri;
-      let domain;
-      const globalWindow = typeof globalThis !== "undefined" ? globalThis.window : void 0;
-      const isNodeJs = !globalWindow?.location?.origin;
-      if (globalWindow?.location?.origin) {
-        uri = globalWindow.location.origin;
-        domain = globalWindow.location.host;
-      } else {
-        uri = API_ENDPOINT;
-        domain = API_ENDPOINT.split("//")[1];
-      }
-      const messageObj = new import_siwe.SiweMessage({
-        address: userAddress,
-        chainId,
-        domain,
-        nonce: challengeResponse.nonce,
-        statement: "Sign in with Ethereum",
-        uri,
-        version: "1",
-        issuedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const messageString = messageObj.prepareMessage();
-      const signature = await walletClient.signMessage({
-        account: walletClient.account,
-        message: messageString
-      });
-      const loginResponse = await this.httpClient.post(
-        ENDPOINTS.AUTH_LOGIN,
-        {
-          message: messageObj,
-          signature,
-          referralSource: this.referralSource
-        },
-        // Set Origin header in Node.js to match message.uri (required by backend validation)
-        isNodeJs ? {
-          headers: {
-            Origin: uri
-          }
-        } : void 0
-      );
-      const authToken = loginResponse.accessToken;
-      if (!authToken) {
-        throw new Error("Authentication response missing access token");
-      }
-      this.httpClient.setAuthToken(authToken);
-      this.authenticatedUserId = loginResponse.userId || null;
-      this.hasActiveSessionKey = loginResponse.hasActiveSessionKey || false;
-    } catch (error) {
-      throw new Error(
-        `Failed to authenticate user: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Update user profile with Smart Wallet address and chain configuration
-   * This method requires SIWE authentication and is automatically called after deploySafe
-   *
-   * @param request - User profile update data
-   * @returns Updated user profile information
-   *
-   * @example
-   * ```typescript
-   * await sdk.updateUserProfile({
-   *   smartWallet: "0x1396730...",
-   *   chains: [8453],
-   * });
-   * ```
-   */
-  async updateUserProfile(request) {
-    try {
-      await this.authenticateUser();
-      const asset = request.asset || "USDC";
-      const internalAsset = convertAssetInternally(asset);
-      let rebalanceStrategy;
-      if (request.strategy) {
-        if (!isValidPublicStrategy(request.strategy)) {
-          throw new Error(
-            `Invalid strategy: ${request.strategy}. Must be "conservative" or "aggressive".`
-          );
-        }
-        rebalanceStrategy = toInternalStrategy(
-          request.strategy
-        );
-      }
-      const assetSettings = {};
-      if (rebalanceStrategy !== void 0) assetSettings.rebalanceStrategy = rebalanceStrategy;
-      if (request.autocompounding !== void 0) assetSettings.autocompounding = request.autocompounding;
-      if (request.crosschainStrategy !== void 0) assetSettings.crosschainStrategy = request.crosschainStrategy;
-      if (request.splitting !== void 0) assetSettings.splitting = request.splitting;
-      if (request.minSplits !== void 0) assetSettings.minSplits = request.minSplits;
-      if (request.chains !== void 0) assetSettings.chains = request.chains;
-      if (request.autoSelectProtocols !== void 0) assetSettings.autoSelectProtocols = request.autoSelectProtocols;
-      if (request.protocols !== void 0) assetSettings.protocols = request.protocols;
-      const payload = {
-        assetTypeSettings: {
-          [internalAsset]: assetSettings
-        }
-      };
-      if (request.omniAccount !== void 0) payload.omniAccount = request.omniAccount;
-      if (request.agentName !== void 0) payload.agentName = request.agentName;
-      await this.httpClient.patch(
-        ENDPOINTS.USER_ME,
-        payload
-      );
-      return await this.getUserDetails(asset);
-    } catch (error) {
-      throw new Error(
-        `Failed to update user profile: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Pause the agent by clearing all protocols
-   * Sets the user's protocols to an empty array, effectively pausing automated operations
-   *
-   * @returns Response indicating success and updated user details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-   *
-   * // Connect account first
-   * await sdk.connectAccount();
-   *
-   * // Pause the agent
-   * const result = await sdk.pauseAgent();
-   * console.log('Agent paused:', result.success);
-   * ```
-   */
-  async pauseAgent() {
-    try {
-      await this.updateUserProfile({
-        asset: "USDC",
-        protocols: []
-      });
-      const response = await this.updateUserProfile({
-        asset: "WETH",
-        protocols: []
-      });
-      return response;
-    } catch (error) {
-      throw new Error(`Failed to pause agent: ${error.message}`);
-    }
-  }
-  /**
-   * Resume the agent by restoring protocols based on user's strategy for each asset
-   * Fetches available protocols and assigns them based on each asset's strategy
-   *
-   * @returns Response indicating success and updated user details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-   *
-   * // Connect account first
-   * await sdk.connectAccount();
-   *
-   * // Resume the agent
-   * const result = await sdk.resumeAgent();
-   * console.log('Agent resumed:', result.success);
-   * ```
-   */
-  async resumeAgent() {
-    try {
-      const userDetailsUSDC = await this.getUserDetails("USDC");
-      const userDetailsETH = await this.getUserDetails("WETH");
-      const chains = userDetailsUSDC.chains && userDetailsUSDC.chains.length > 0 ? userDetailsUSDC.chains : [8453, 42161];
-      const allProtocols = await this.httpClient.get(
-        ENDPOINTS.PROTOCOLS()
-      );
-      const usdcStrategy = userDetailsUSDC.strategy || "safe_strategy";
-      const ethStrategy = userDetailsETH.strategy || "safe_strategy";
-      const filterProtocolsByStrategy = (strategy) => {
-        return allProtocols.filter((protocol) => {
-          const hasMatchingChain = protocol.chains.some(
-            (chain) => chains.includes(chain)
-          );
-          if (!hasMatchingChain) {
-            return false;
-          }
-          if (strategy === "degen_strategy") {
-            return protocol.strategies?.includes("safe_strategy") || protocol.strategies?.includes("degen_strategy");
-          }
-          return protocol.strategies?.includes("safe_strategy");
-        }).map((protocol) => protocol.id);
-      };
-      const usdcProtocols = filterProtocolsByStrategy(usdcStrategy);
-      const ethProtocols = filterProtocolsByStrategy(ethStrategy);
-      await this.updateUserProfile({
-        asset: "USDC",
-        protocols: usdcProtocols
-      });
-      const updatedUserDetailsETH = await this.updateUserProfile({
-        asset: "WETH",
-        protocols: ethProtocols
-      });
-      return updatedUserDetailsETH;
-    } catch (error) {
-      throw new Error(`Failed to resume agent: ${error.message}`);
-    }
-  }
-  /**
-   * Enable splitting for the user's account
-   * When enabled, deposits are split across multiple protocols based on minSplits setting
-   *
-   * @param minSplits - Optional minimum number of protocols to split across (default: 3)
-   * @returns Response indicating success and updated user details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-   *
-   * // Connect account first
-   * await sdk.connectAccount(privateKey, chainId);
-   *
-   * // Enable splitting with minimum 3 protocols
-   * const result = await sdk.enableSplitting(3);
-   * console.log('Splitting enabled:', result.success);
-   * ```
-   */
-  async enableSplitting(minSplits = 1) {
-    if (minSplits > 4) {
-      throw new Error("minSplits cannot exceed 4");
-    }
-    try {
-      const response = await this.updateUserProfile({
-        splitting: true,
-        minSplits
-      });
-      return response;
-    } catch (error) {
-      throw new Error(`Failed to enable splitting: ${error.message}`);
-    }
-  }
-  /**
-   * Disable splitting for the user's account
-   * When disabled, deposits will not be split across multiple protocols
-   *
-   * @returns Response indicating success and updated user details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-   *
-   * // Connect account first
-   * await sdk.connectAccount(privateKey, chainId);
-   *
-   * // Disable splitting
-   * const result = await sdk.disableSplitting();
-   * console.log('Splitting disabled:', result.success);
-   * ```
-   */
-  async disableSplitting() {
-    try {
-      const response = await this.updateUserProfile({
-        splitting: false
-      });
-      return response;
-    } catch (error) {
-      throw new Error(`Failed to disable splitting: ${error.message}`);
-    }
-  }
-  /**
-   * Update the minimum number of splits for the user's account
-   * This controls across how many protocols deposits should be distributed
-   *
-   * @param minSplits - Minimum number of protocols to split across
-   * @returns Response indicating success and updated user details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-   *
-   * // Connect account first
-   * await sdk.connectAccount(privateKey, chainId);
-   *
-   * // Update minimum splits to 5
-   * const result = await sdk.updateMinSplits(5);
-   * console.log('Min splits updated:', result.success);
-   * ```
-   */
-  async updateMinSplits(minSplits) {
-    try {
-      if (minSplits < 1) {
-        throw new Error("minSplits must be at least 1");
-      }
-      const response = await this.updateUserProfile({
-        minSplits
-      });
-      return response;
-    } catch (error) {
-      throw new Error(`Failed to update min splits: ${error.message}`);
-    }
-  }
-  /**
-   * Initialize user after Safe deployment
-   * This method is automatically called after deploySafe to initialize user state
-   *
-   * @param smartWallet - Safe smart wallet address
-   * @param chainId - Target chain ID
-   * @returns Initialization response
-   *
-   * @example
-   * ```typescript
-   * await sdk.initializeUser("0x1396730...", 8453);
-   * ```
-   * @internal
-   */
-  async initializeUser(smartWallet, chainId) {
-    try {
-      await this.authenticateUser();
-      const responseData = await this.httpClient.dataPostCustom(
-        DATA_ENDPOINTS.USER_INITIALIZE,
-        {
-          walletAddress: smartWallet
-        }
-      );
-      return {
-        success: responseData.status === "success" || true,
-        userId: responseData.userId || responseData.id,
-        smartWallet: responseData.smartWallet || smartWallet,
-        chainId: responseData.chainId || chainId,
-        message: responseData.message || responseData.status || "User initialized successfully"
-      };
-    } catch (error) {
-      throw new Error(`Failed to initialize user: ${error.message}`);
-    }
-  }
-  /**
-   * Handle account changes from wallet provider
-   * Resets authentication state when wallet is switched
-   * @private
-   */
-  async handleAccountsChanged(accounts) {
-    if (!accounts || accounts.length === 0) {
-      await this.disconnectAccount();
-      return;
-    }
-    const newAddress = accounts[0];
-    const currentAddress = this.walletClient?.account?.address;
-    if (currentAddress && newAddress.toLowerCase() === currentAddress.toLowerCase()) {
-      return;
-    }
-    this.authenticatedUserId = null;
-    this.hasActiveSessionKey = false;
-    this.httpClient.clearAuthToken();
-    if (this.walletClient && this.currentProvider) {
-      const chainConfig = getChainConfig(
-        this.walletClient.chain?.id || 8453,
-        this.rpcUrls
-      );
-      this.walletClient = (0, import_viem5.createWalletClient)({
-        account: newAddress,
-        chain: chainConfig.chain,
-        transport: (0, import_viem5.custom)(this.currentProvider)
-      });
-      this.currentChainId = this.walletClient.chain?.id || null;
-      try {
-        await this.authenticateUser();
-      } catch (error) {
-        console.warn(
-          "Failed to authenticate after wallet switch:",
-          error.message
-        );
-      }
-    }
-  }
-  /**
-   * Connect account for signing transactions
-   * Accepts either a private key string or a modern wallet provider
-   *
-   * @param account - Private key string or wallet provider object
-   * @param chainId - Target chain ID (default: 8453 - Base)
-   * @returns The connected EOA address
-   *
-   * @example
-   * // With private key
-   * await sdk.connectAccount('0x...');
-   *
-   * @example
-   * // With wallet provider (e.g., from wagmi, web3-react, etc.)
-   * const provider = await connector.getProvider();
-   * await sdk.connectAccount(provider);
-   */
-  async connectAccount(account, chainId = 8453) {
-    if (!isSupportedChain(chainId)) {
-      throw new Error(`Unsupported chain ID: ${chainId}`);
-    }
-    this.authenticatedUserId = null;
-    this.currentChainId = null;
-    this.httpClient.clearAuthToken();
-    if (this.currentProvider?.removeAllListeners) {
-      try {
-        this.currentProvider.removeAllListeners("accountsChanged");
-      } catch (error) {
-      }
-    }
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    let connectedAddress;
-    if (typeof account === "string") {
-      let privateKey = account;
-      if (!privateKey.startsWith("0x")) {
-        privateKey = `0x${privateKey}`;
-      }
-      this.signer = (0, import_accounts2.privateKeyToAccount)(privateKey);
-      this.currentChainId = chainId;
-      this.walletClient = (0, import_viem5.createWalletClient)({
-        account: this.signer,
-        chain: chainConfig.chain,
-        transport: (0, import_viem5.http)(chainConfig.rpcUrl)
-      });
-      connectedAddress = this.signer.address;
-      this.currentProvider = null;
-    } else {
-      const provider = account;
-      if (!provider) {
-        throw new Error(
-          "Invalid account parameter. Expected private key string or wallet provider."
-        );
-      }
-      if (provider.request) {
-        const accounts = await provider.request({
-          method: "eth_requestAccounts"
-        });
-        if (!accounts || accounts.length === 0) {
-          throw new Error("No accounts found in wallet provider");
-        }
-        this.walletClient = (0, import_viem5.createWalletClient)({
-          account: accounts[0],
-          chain: chainConfig.chain,
-          transport: (0, import_viem5.custom)(provider)
-        });
-        connectedAddress = accounts[0];
-        this.currentProvider = provider;
-        this.currentChainId = chainId;
-        if (provider.on) {
-          provider.on("accountsChanged", this.handleAccountsChanged.bind(this));
-        }
-      } else if (provider.account && provider.transport) {
-        this.walletClient = (0, import_viem5.createWalletClient)({
-          account: provider.account,
-          chain: chainConfig.chain,
-          transport: provider.transport
-        });
-        connectedAddress = provider.account.address;
-        this.currentProvider = null;
-        this.currentChainId = chainId;
-      } else {
-        throw new Error(
-          "Invalid wallet provider. Expected EIP-1193 provider or viem WalletClient."
-        );
-      }
-    }
-    await this.authenticateUser();
-    return connectedAddress;
-  }
-  /**
-   * Disconnect account and clear authentication state
-   * Resets wallet connection, JWT token, and all authentication-related state
-   *
-   * @example
-   * ```typescript
-   * await sdk.disconnectAccount();
-   * console.log("Account disconnected");
-   * ```
-   */
-  async disconnectAccount() {
-    if (this.currentProvider?.removeAllListeners) {
-      try {
-        this.currentProvider.removeAllListeners("accountsChanged");
-      } catch (error) {
-      }
-    }
-    this.signer = null;
-    this.walletClient = null;
-    this.currentProvider = null;
-    this.currentChainId = null;
-    this.authenticatedUserId = null;
-    this.hasActiveSessionKey = false;
-    this.httpClient.clearAuthToken();
-  }
-  /**
-   * Get wallet client (throws if not connected)
-   * @private
-   */
-  getWalletClient(chainId) {
-    if (this.signer) {
-      const targetChainId = chainId || this.currentChainId || 8453;
-      const targetChainConfig = getChainConfig(
-        targetChainId,
-        this.rpcUrls
-      );
-      return (0, import_viem5.createWalletClient)({
-        account: this.signer,
-        chain: targetChainConfig.chain,
-        transport: (0, import_viem5.http)(targetChainConfig.rpcUrl)
-      });
-    } else {
-      if (!this.walletClient) {
-        throw new Error("No account connected. Call connectAccount() first");
-      }
-      return this.walletClient;
-    }
-  }
-  /**
-   * Get smart wallet address for a user
-   * Returns the deterministic Safe address for an EOA, or the address itself if already a Safe
-   *
-   * @param userAddress - User's EOA address
-   * @param chainId - Target chain ID
-   * @returns Smart wallet information including address and deployment status
-   */
-  async getSmartWalletAddress(userAddress, chainId) {
-    if (!userAddress) {
-      throw new Error("User address is required");
-    }
-    if (!isSupportedChain(chainId)) {
-      throw new Error(`Unsupported chain ID: ${chainId}`);
-    }
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    try {
-      const smartWalletInfo = await this.getSmartWalletByEOA(userAddress);
-      if (smartWalletInfo.smartWallet) {
-        const isDeployed2 = await isSafeDeployed(
-          smartWalletInfo.smartWallet,
-          chainConfig.publicClient
-        );
-        return {
-          address: smartWalletInfo.smartWallet,
-          isDeployed: isDeployed2
-        };
-      }
-    } catch {
-    }
-    const safeAddress = await getDeterministicSafeAddress({
-      safeOwnerAddress: userAddress,
-      chain: chainConfig.chain,
-      publicClient: chainConfig.publicClient
-    });
-    const isDeployed = await isSafeDeployed(
-      safeAddress,
-      chainConfig.publicClient
-    );
-    return {
-      address: safeAddress,
-      isDeployed
-    };
-  }
-  /**
-   * Deploy Safe Smart Wallet for a user
-   *
-   * @param userAddress - User's EOA address (the connected EOA, not the smart wallet address)
-   * @param chainId - Target chain ID
-   * @param strategy - Optional strategy selection: "conservative" (default) or "aggressive"
-   * @param createSessionKey - If true, automatically creates a session key after deployment (default: false)
-   * @returns Deployment response with Safe address and transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Deploy with default conservative strategy
-   * await sdk.deploySafe(userAddress, 8453);
-   *
-   * // Deploy with aggressive strategy
-   * await sdk.deploySafe(userAddress, 8453, "aggressive");
-   *
-   * // Deploy and automatically create session key
-   * await sdk.deploySafe(userAddress, 8453, "conservative", true);
-   * ```
-   */
-  async deploySafe(userAddress, chainId, strategy, createSessionKey) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      await this.authenticateUser();
-      const walletClient = this.getWalletClient(chainId);
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      const safeAddress = await getDeterministicSafeAddress({
-        safeOwnerAddress: userAddress,
-        chain: chainConfig.chain,
-        publicClient: chainConfig.publicClient
-      });
-      const alreadyDeployed = await isSafeDeployed(
-        safeAddress,
-        chainConfig.publicClient
-      );
-      if (!alreadyDeployed) {
-        const accountType = await getAccountType(
-          userAddress,
-          chainConfig.publicClient
-        );
-        if (accountType !== "EOA") {
-          throw new Error(
-            `Address ${userAddress} is not an EOA. Only EOA addresses can deploy Safe smart wallets.`
-          );
-        }
-      }
-      if (alreadyDeployed) {
-        let sessionKeyCreated2 = false;
-        if (createSessionKey) {
-          try {
-            await this.createSessionKey(userAddress, chainId);
-            sessionKeyCreated2 = true;
-          } catch (sessionKeyError) {
-            console.warn(
-              "Failed to create session key:",
-              sessionKeyError.message
-            );
-          }
-        }
-        return {
-          success: true,
-          safeAddress,
-          txHash: "0x0",
-          status: "deployed",
-          sessionKeyCreated: sessionKeyCreated2
-        };
-      }
-      const internalStrategy = strategy ? toInternalStrategy(strategy) : "safe_strategy";
-      const deploymentResult = await deploySafeAccount({
-        owner: walletClient,
-        safeOwnerAddress: userAddress,
-        chain: chainConfig.chain,
-        publicClient: chainConfig.publicClient,
-        chainId,
-        httpClient: this.httpClient,
-        strategy: internalStrategy
-      });
-      this.hasActiveSessionKey = false;
-      try {
-        await this.initializeUser(deploymentResult.safeAddress, chainId);
-      } catch (initError) {
-        console.warn(
-          "Failed to initialize user after Safe deployment:",
-          initError.message
-        );
-      }
-      let sessionKeyCreated = false;
-      if (createSessionKey) {
-        try {
-          await this.createSessionKey(userAddress, chainId);
-          sessionKeyCreated = true;
-        } catch (sessionKeyError) {
-          console.warn(
-            "Failed to create session key after Safe deployment:",
-            sessionKeyError.message
-          );
-        }
-      }
-      return {
-        success: true,
-        safeAddress: deploymentResult.safeAddress,
-        txHash: deploymentResult.txHash || "0x0",
-        status: "deployed",
-        sessionKeyCreated
-      };
-    } catch (error) {
-      console.error("Safe deployment failed:", error);
-      throw new Error(`Safe deployment failed: ${error.message}`);
-    }
-  }
-  /**
-   * Create session key with auto-fetched configuration from Zyfai API
-   * This is the simplified method that automatically fetches session configuration
-   *
-   * @param userAddress - User's EOA or Safe address
-   * @param chainId - Target chain ID
-   * @returns Session key response with signature and nonces
-   *
-   * @example
-   * ```typescript
-   * // Simple usage - no need to configure sessions manually
-   * const result = await sdk.createSessionKey(userAddress, 8453);
-   * console.log("Session created:", result.signature);
-   * ```
-   */
-  async createSessionKey(userAddress, chainId) {
-    try {
-      await this.authenticateUser();
-      if (!this.authenticatedUserId) {
-        throw new Error(
-          "User ID not available. Please ensure authentication completed successfully."
-        );
-      }
-      if (this.hasActiveSessionKey) {
-        return {
-          success: true,
-          userId: this.authenticatedUserId,
-          message: "Session key already exists and is active",
-          alreadyActive: true
-        };
-      }
-      const sessionConfigResponse = await this.httpClient.get(
-        ENDPOINTS.SESSION_KEYS_CONFIG
-      );
-      const sessionConfig = Array.isArray(sessionConfigResponse) ? sessionConfigResponse : sessionConfigResponse.sessions;
-      if (!sessionConfig || sessionConfig.length === 0) {
-        throw new Error("No session configuration available from API");
-      }
-      const sessions = sessionConfig.map((session) => ({
-        ...session,
-        chainId: BigInt(session.chainId)
-      }));
-      const DEFAULT_ACTION_TARGET = "0x0000000000000000000000000000000000000001";
-      const DEFAULT_ACTION_SELECTOR = "0x00000001";
-      const permitGenericPolicy = sessionConfig.some(
-        (session) => session.actions?.some(
-          (action) => action.actionTarget === DEFAULT_ACTION_TARGET && action.actionTargetSelector === DEFAULT_ACTION_SELECTOR
-        )
-      );
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      const accountType = await getAccountType(
-        userAddress,
-        chainConfig.publicClient
-      );
-      const signingParams = {
-        permitGenericPolicy,
-        ignoreSecurityAttestations: accountType === "Safe"
-      };
-      const signatureResult = await this.signSessionKey(
-        userAddress,
-        chainId,
-        sessions,
-        signingParams
-      );
-      if (!signatureResult.signature) {
-        throw new Error("Failed to obtain session key signature");
-      }
-      await this.updateUserProtocols(chainId);
-      const signer = sessions[0].sessionValidator;
-      console.log("Session validator:", signer);
-      const activation = await this.activateSessionKey(
-        signer,
-        signatureResult.signature,
-        signatureResult.sessionNonces
-      );
-      this.hasActiveSessionKey = true;
-      return {
-        ...signatureResult,
-        userId: this.authenticatedUserId,
-        sessionActivation: activation
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to create session key: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Internal method to sign session key
-   * @private
-   */
-  async signSessionKey(userAddress, chainId, sessions, signingParams) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      if (!sessions || sessions.length === 0) {
-        throw new Error("At least one session configuration is required");
-      }
-      const walletClient = this.getWalletClient();
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      const accountType = await getAccountType(
-        userAddress,
-        chainConfig.publicClient
-      );
-      if (accountType !== "EOA") {
-        throw new Error(
-          `Invalid account type for ${userAddress}. Must be an EOA.`
-        );
-      }
-      const sessionChainIds = [
-        ...new Set(sessions.map((s) => Number(s.chainId)))
-      ];
-      const allPublicClients = sessionChainIds.filter(isSupportedChain).map((id) => getChainConfig(id, this.rpcUrls).publicClient);
-      const { signature, sessionNonces } = await signSessionKey(
-        {
-          owner: walletClient,
-          safeOwnerAddress: userAddress,
-          chain: chainConfig.chain,
-          publicClient: chainConfig.publicClient
-        },
-        sessions,
-        allPublicClients,
-        signingParams
-      );
-      return {
-        success: true,
-        signature,
-        sessionNonces
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to sign session key: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Update user protocols with available protocols from the chain
-   * This method is automatically called before activating session key
-   *
-   * @param chainId - Target chain ID
-   * @internal
-   */
-  async updateUserProtocols(chainId) {
-    try {
-      const protocolsResponse = await this.getAvailableProtocols(chainId);
-      const userDetails = await this.getUserDetails();
-      const filteredProtocols = userDetails.strategy ? protocolsResponse.protocols.filter((p) => p.strategies?.includes(userDetails.strategy)) : protocolsResponse.protocols;
-      if (!filteredProtocols || filteredProtocols.length === 0) {
-        console.warn(`No protocols available for chain ${chainId}`);
-        return;
-      }
-      const protocolIds = filteredProtocols.map((p) => p.id);
-      await this.updateUserProfile({
-        protocols: protocolIds
-      });
-      await this.updateUserProfile({
-        protocols: protocolIds,
-        asset: "WETH"
-      });
-    } catch (error) {
-      console.warn(
-        `Failed to update user protocols: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Activate session key via Zyfai API
-   */
-  async activateSessionKey(signer, signature, sessionNonces) {
-    const nonces = this.normalizeSessionNonces(sessionNonces);
-    const payload = {
-      signer,
-      hash: signature,
-      nonces
-    };
-    return await this.httpClient.post(
-      ENDPOINTS.SESSION_KEYS_ADD,
-      payload
-    );
-  }
-  /**
-   * Convert session nonces from bigint[] to number[]
-   */
-  normalizeSessionNonces(sessionNonces) {
-    if (!sessionNonces || sessionNonces.length === 0) {
-      throw new Error(
-        "Session nonces missing from signature result. Cannot register session key."
-      );
-    }
-    return sessionNonces.map((nonce) => {
-      const value = Number(nonce);
-      if (!Number.isFinite(value) || value < 0) {
-        throw new Error(`Invalid session nonce value: ${nonce.toString()}`);
-      }
-      return value;
-    });
-  }
-  /**
-   * Deposit funds from EOA to Safe smart wallet
-   * Transfers tokens from the connected wallet to the user's Safe and logs the deposit
-   *
-   * Token is automatically selected based on chain:
-   * - Base (8453) and Arbitrum (42161): USDC
-   * - Plasma (9745): USDT
-   *
-   * @param userAddress - User's address (owner of the Safe)
-   * @param chainId - Target chain ID
-   * @param amount - Amount in least decimal units (e.g., "100000000" for 100 USDC with 6 decimals)
-   * @returns Deposit response with transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Deposit 100 USDC (6 decimals) to Safe on Base
-   * const result = await sdk.depositFunds(
-   *   "0xUser...",
-   *   8453,
-   *   "100000000" // 100 USDC = 100 * 10^6
-   * );
-   * ```
-   */
-  async depositFunds(userAddress, chainId, amount, asset) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
-        throw new Error("Valid amount is required");
-      }
-      const token = getDefaultTokenAddress(chainId, asset);
-      const walletClient = this.getWalletClient();
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      const safeAddress = await getDeterministicSafeAddress({
-        safeOwnerAddress: userAddress,
-        chain: chainConfig.chain,
-        publicClient: chainConfig.publicClient
-      });
-      const isDeployed = await isSafeDeployed(
-        safeAddress,
-        chainConfig.publicClient
-      );
-      if (!isDeployed) {
-        throw new Error(
-          `Safe not deployed for ${userAddress}. Please deploy the Safe first using deploySafe().`
-        );
-      }
-      const amountBigInt = BigInt(amount);
-      const txHash = await walletClient.writeContract({
-        address: token,
-        abi: ERC20_ABI,
-        functionName: "transfer",
-        args: [safeAddress, amountBigInt],
-        chain: chainConfig.chain,
-        account: walletClient.account
-      });
-      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
-        hash: txHash
-      });
-      try {
-        await this.httpClient.post(ENDPOINTS.LOG_DEPOSIT, {
-          chainId,
-          transaction: txHash,
-          token,
-          amount
-        });
-      } catch (logError) {
-        console.warn("Failed to log deposit:", logError.message);
-      }
-      if (receipt.status !== "success") {
-        throw new Error("Deposit transaction failed");
-      }
-      return {
-        success: true,
-        txHash,
-        smartWallet: safeAddress,
-        amount: amountBigInt.toString()
-      };
-    } catch (error) {
-      throw new Error(`Deposit failed: ${error.message}`);
-    }
-  }
-  /**
-   * Log a deposit that was executed client-side
-   *
-   * Use this method when you execute the deposit transaction yourself (e.g., with Privy,
-   * sponsored transactions, or any custom wallet implementation) and need to register
-   * the deposit with the Zyfai backend for tracking and yield optimization.
-   *
-   * This is useful for partners who:
-   * - Use sponsored/gasless transactions (Privy, Biconomy, etc.)
-   * - Have custom wallet implementations
-   * - Need more control over transaction execution
-   *
-   * Token is automatically selected based on chain if not provided:
-   * - Base (8453) and Arbitrum (42161): USDC
-   * - Plasma (9745): USDT
-   *
-   * @param chainId - Chain ID where the deposit was made
-   * @param txHash - Transaction hash of the deposit
-   * @param amount - Amount in least decimal units (e.g., "100000000" for 100 USDC with 6 decimals)
-   * @param tokenAddress - Optional: Token address (auto-selected based on chain if not provided)
-   * @returns Log deposit response with success status
-   *
-   * @example
-   * ```typescript
-   * // Execute deposit with Privy (sponsored transaction)
-   * const txHash = await privyWallet.sendTransaction({
-   *   to: safeAddress,
-   *   data: transferData,
-   * });
-   *
-   * // Log the deposit to Zyfai backend
-   * const result = await sdk.logDeposit(
-   *   8453,           // chainId
-   *   txHash,         // transaction hash from Privy
-   *   "100000000"     // 100 USDC
-   * );
-   * console.log(result.success); // true
-   * ```
-   */
-  async logDeposit(chainId, txHash, amount, tokenAddress) {
-    try {
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      if (!txHash || !txHash.startsWith("0x")) {
-        throw new Error("Valid transaction hash is required");
-      }
-      if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
-        throw new Error("Valid amount is required");
-      }
-      const token = tokenAddress || getDefaultTokenAddress(chainId);
-      await this.httpClient.post(ENDPOINTS.LOG_DEPOSIT, {
-        chainId,
-        transaction: txHash,
-        token,
-        amount
-      });
-      return {
-        success: true,
-        message: "Deposit logged successfully"
-      };
-    } catch (error) {
-      throw new Error(`Log deposit failed: ${error.message}`);
-    }
-  }
-  /**
-   * Withdraw funds from Safe smart wallet
-   * Initiates a withdrawal request to the Zyfai API
-   * Note: The withdrawal is processed asynchronously, so txHash may not be immediately available
-   * Funds are always withdrawn to the Safe owner's address (userAddress)
-   *
-   * @param userAddress - User's address (owner of the Safe)
-   * @param chainId - Target chain ID
-   * @param amount - Optional: Amount in least decimal units to withdraw (partial withdrawal). If not specified, withdraws all funds
-   * @returns Withdraw response with message and optional transaction hash (available once processed)
-   *
-   * @example
-   * ```typescript
-   * // Full withdrawal
-   * const result = await sdk.withdrawFunds("0xUser...", 8453);
-   * console.log(result.message); // "Withdrawal request sent"
-   *
-   * // Partial withdrawal of 50 USDC (6 decimals)
-   * const result = await sdk.withdrawFunds(
-   *   "0xUser...",
-   *   8453,
-   *   "50000000" // 50 USDC = 50 * 10^6
-   * );
-   * ```
-   */
-  async withdrawFunds(userAddress, chainId, amount, tokenSymbol) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      let safeAddress;
-      try {
-        const smartWalletInfo = await this.getSmartWalletByEOA(userAddress);
-        if (smartWalletInfo.smartWallet) {
-          safeAddress = smartWalletInfo.smartWallet;
-        } else {
-          safeAddress = await getDeterministicSafeAddress({
-            safeOwnerAddress: userAddress,
-            chain: chainConfig.chain,
-            publicClient: chainConfig.publicClient
-          });
-        }
-      } catch {
-        safeAddress = await getDeterministicSafeAddress({
-          safeOwnerAddress: userAddress,
-          chain: chainConfig.chain,
-          publicClient: chainConfig.publicClient
-        });
-      }
-      const isDeployed = await isSafeDeployed(
-        safeAddress,
-        chainConfig.publicClient
-      );
-      if (!isDeployed) {
-        throw new Error(
-          `Safe not deployed for ${userAddress}. Please deploy the Safe first using deploySafe().`
-        );
-      }
-      await this.authenticateUser();
-      let response = {};
-      if (amount) {
-        response = await this.httpClient.post(ENDPOINTS.PARTIAL_WITHDRAW, {
-          chainId,
-          amount,
-          tokenSymbol
-        });
-      } else {
-        console.log("Full withdrawal", tokenSymbol);
-        response = await this.httpClient.get(ENDPOINTS.USER_WITHDRAW, {
-          params: { chainId, tokenSymbol }
-        });
-        console.log(JSON.stringify(response, null, 2));
-      }
-      const success = response?.success ?? true;
-      const message = response?.message || "Withdrawal request sent";
-      const txHash = response?.txHash || response?.transactionHash;
-      return {
-        success,
-        message,
-        txHash,
-        type: amount ? "partial" : "full",
-        amount: amount || "all"
-      };
-    } catch (error) {
-      throw new Error(`Withdrawal failed: ${error.message}`);
-    }
-  }
-  /**
-   * Get available DeFi protocols and pools for a specific chain
-   *
-   * @param chainId - Target chain ID
-   * @returns List of available protocols with their pools and APY data
-   *
-   * @example
-   * ```typescript
-   * const protocols = await sdk.getAvailableProtocols(8453);
-   * protocols.forEach(protocol => {
-   *   console.log(`${protocol.name}: ${protocol.minApy}% - ${protocol.maxApy}% APY`);
-   * });
-   * ```
-   */
-  async getAvailableProtocols(chainId) {
-    try {
-      if (!isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.PROTOCOLS(chainId)
-      );
-      return {
-        success: true,
-        chainId,
-        protocols: response
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get available protocols: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get all active DeFi positions for a user
-   *
-   * @param userAddress - User's EOA address
-   * @param chainId - Optional: Filter by specific chain ID
-   * @returns User's positions across all protocols
-   *
-   * @example
-   * ```typescript
-   * // Get all positions across all chains
-   * const positions = await sdk.getPositions(userAddress);
-   *
-   * // Get positions on a specific chain
-   * const basePositions = await sdk.getPositions(userAddress, 8453);
-   * ```
-   */
-  async getPositions(userAddress, chainId) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      if (chainId && !isSupportedChain(chainId)) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-      }
-      const smartWalletInfo = await this.getSmartWalletByEOA(userAddress);
-      if (!smartWalletInfo.smartWallet) {
-        return {
-          success: true,
-          userAddress,
-          portfolio: {}
-        };
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_POSITION(smartWalletInfo.smartWallet)
-      );
-      const convertedPosition = response ? convertStrategyToPublic(response) : void 0;
-      return {
-        success: true,
-        userAddress,
-        portfolio: convertedPosition
-      };
-    } catch (error) {
-      throw new Error(`Failed to get positions: ${error.message}`);
-    }
-  }
-  /**
-   * Get all active positions and portfolio for a user
-   *
-   * @param userAddress - User's EOA address
-   * @param chainId - Optional: Filter by specific chain ID
-   * @returns User's positions across all protocols
-   *
-   * @example
-   * ```typescript
-   * // Get all positions across all chains
-   * const positions = await sdk.getPositions(userAddress);
-   *
-   * // Get positions on a specific chain
-   * const basePositions = await sdk.getPositions(userAddress, 8453);
-   * ```
-   */
-  async getPortfolio(userAddress) {
-    try {
-      if (!userAddress) {
-        throw new Error("User address is required");
-      }
-      const smartWalletInfo = await this.getSmartWalletByEOA(userAddress);
-      if (!smartWalletInfo.smartWallet) {
-        return {
-          success: true,
-          userAddress,
-          portfolio: {}
-        };
-      }
-      console.log("Getting portfolio for", smartWalletInfo.smartWallet);
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_PORTFOLIO(smartWalletInfo.smartWallet)
-      );
-      const convertedResponse = removeUnusedFields(response);
-      return {
-        success: true,
-        userAddress,
-        portfolio: convertedResponse
-      };
-    } catch (error) {
-      throw new Error(`Failed to get positions: ${error.message}`);
-    }
-  }
-  // ============================================================================
-  // User Details Methods
-  // ============================================================================
-  /**
-   * Get current authenticated user details
-   * Requires SIWE authentication
-   *
-   * @returns User details including smart wallet, chains, protocols, etc.
-   *
-   * @example
-   * ```typescript
-   * await sdk.connectAccount(privateKey, chainId);
-   * const user = await sdk.getUserDetails();
-   * console.log("Smart Wallet:", user.user.smartWallet);
-   * console.log("Chains:", user.user.chains);
-   * ```
-   */
-  async getUserDetails(asset = "USDC") {
-    try {
-      await this.authenticateUser();
-      const response = await this.httpClient.get(ENDPOINTS.USER_ME);
-      const internalAsset = convertAssetInternally(asset);
-      const convertedResponse = convertStrategyToPublic(response);
-      return {
-        success: true,
-        agentName: convertedResponse.agentName,
-        smartWallet: convertedResponse.smartWallet,
-        chains: convertedResponse.assetTypeSettings?.[internalAsset]?.chains || [],
-        hasActiveSessionKey: convertedResponse.hasActiveSessionKey || false,
-        omniAccount: convertedResponse.omniAccount,
-        asset,
-        autoSelectProtocols: convertedResponse.assetTypeSettings?.[internalAsset]?.autoSelectProtocols,
-        strategy: convertedResponse.assetTypeSettings?.[internalAsset]?.rebalanceStrategy,
-        autocompounding: convertedResponse.assetTypeSettings?.[internalAsset]?.autocompounding,
-        crosschainStrategy: convertedResponse.assetTypeSettings?.[internalAsset]?.crosschainStrategy,
-        splitting: convertedResponse.assetTypeSettings?.[internalAsset]?.splitting,
-        minSplits: convertedResponse.assetTypeSettings?.[internalAsset]?.minSplits || 0,
-        protocols: convertedResponse.assetTypeSettings?.[internalAsset]?.protocols || [],
-        customization: convertedResponse.customization
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get user details: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // TVL & Volume Methods
-  // ============================================================================
-  /**
-   * Get total value locked (TVL) across all Zyfai accounts
-   *
-   * @returns Total TVL in USD and breakdown by chain
-   *
-   * @example
-   * ```typescript
-   * const tvl = await sdk.getTVL();
-   * console.log("Total TVL:", tvl.totalTvl);
-   * ```
-   */
-  async getTVL() {
-    try {
-      const response = await this.httpClient.get(ENDPOINTS.DATA_TVL);
-      return {
-        success: true,
-        totalTvl: response.total || 0
-      };
-    } catch (error) {
-      throw new Error(`Failed to get TVL: ${error.message}`);
-    }
-  }
-  // ============================================================================
-  // APY Per Strategy Methods
-  // ============================================================================
-  /**
-   * Get APY per strategy for a specific chain
-   *
-   * @param crossChain - Whether to get cross-chain APY (true = omni account, false = simple account)
-   * @param days - Time period: 7, 14, or 30
-   * @param strategy - Strategy type: "conservative" (default) or "aggressive"
-   * @param chainId - Optional chain ID filter
-   * @param tokenSymbol - Optional token symbol filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns APY per strategy for a specific chain
-   *
-   * @example
-   * ```typescript
-   * const apyPerStrategy = await sdk.getAPYPerStrategy(false, 7, "conservative", 8453, "USDC");
-   * console.log("APY per strategy per chain:", apyPerStrategy.data);
-   * ```
-   */
-  async getAPYPerStrategy(crossChain = false, days = 7, strategy = "conservative", chainId, tokenSymbol) {
-    try {
-      const internalStrategy = toInternalStrategy(strategy);
-      const internalStrategyShort = internalStrategy === "safe_strategy" ? "safe" : "degen";
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.APY_PER_STRATEGY({
-          isCrossChain: crossChain,
-          days,
-          strategy: internalStrategyShort,
-          chainId,
-          tokenSymbol
-        })
-      );
-      const convertedData = convertStrategiesToPublicAndNaming(
-        response.data || []
-      );
-      return {
-        success: true,
-        count: response.count || 0,
-        data: convertedData
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get APY per strategy: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get total volume across all Zyfai accounts
-   *
-   * @returns Total volume in USD
-   *
-   * @example
-   * ```typescript
-   * const volume = await sdk.getVolume();
-   * console.log("Total Volume:", volume.volumeInUSD);
-   * ```
-   */
-  async getVolume(assetType = "usdc") {
-    try {
-      const response = await this.httpClient.get(ENDPOINTS.DATA_VOLUME(assetType));
-      return {
-        success: true,
-        volumeInUSD: response.volumeInUSD || "0"
-      };
-    } catch (error) {
-      throw new Error(`Failed to get volume: ${error.message}`);
-    }
-  }
-  // ============================================================================
-  // Active Wallets Methods
-  // ============================================================================
-  /**
-   * Get active wallets for a specific chain
-   *
-   * @param chainId - Chain ID to filter wallets
-   * @returns List of active wallets on the specified chain
-   *
-   * @example
-   * ```typescript
-   * const wallets = await sdk.getActiveWallets(8453); // Base
-   * console.log("Active wallets:", wallets.count);
-   * ```
-   */
-  async getActiveWallets(chainId) {
-    try {
-      if (!chainId) {
-        throw new Error("Chain ID is required");
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_ACTIVE_WALLETS(chainId)
-      );
-      const wallets = Array.isArray(response) ? response : response.wallets || [];
-      return {
-        success: true,
-        chainId,
-        wallets: wallets.map((w) => ({
-          smartWallet: w.smartWallet || w,
-          chains: w.chains || [chainId],
-          hasBalance: w.hasBalance ?? true
-        })),
-        count: wallets.length
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get active wallets: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get smart wallets associated with an EOA address
-   *
-   * @param eoaAddress - EOA (externally owned account) address
-   * @returns List of smart wallets owned by the EOA
-   *
-   * @example
-   * ```typescript
-   * const result = await sdk.getSmartWalletByEOA("0x...");
-   * console.log("Smart wallets:", result.smartWallets);
-   * ```
-   */
-  async getSmartWalletByEOA(eoaAddress) {
-    try {
-      if (!eoaAddress) {
-        throw new Error("EOA address is required");
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_BY_EOA(eoaAddress)
-      );
-      const smartWallet = response.agent || null;
-      const chains = response.chains || [];
-      return {
-        success: true,
-        eoa: eoaAddress,
-        smartWallet,
-        chains
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get smart wallets by EOA: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // First Topup & History Methods
-  // ============================================================================
-  /**
-   * Get the first topup (deposit) information for a wallet
-   *
-   * @param walletAddress - Smart wallet address
-   * @param chainId - Chain ID
-   * @returns First topup date and details
-   *
-   * @example
-   * ```typescript
-   * const firstTopup = await sdk.getFirstTopup("0x...", 8453);
-   * console.log("First deposit date:", firstTopup.date);
-   * ```
-   */
-  async getFirstTopup(walletAddress, chainId) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      if (!chainId) {
-        throw new Error("Chain ID is required");
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_FIRST_TOPUP(walletAddress, chainId)
-      );
-      return {
-        success: true,
-        walletAddress,
-        date: response.date || response.firstTopup?.date || "",
-        amount: response.amount,
-        chainId: response.chainId || chainId
-      };
-    } catch (error) {
-      throw new Error(`Failed to get first topup: ${error.message}`);
-    }
-  }
-  /**
-   * Get transaction history for a wallet
-   *
-   * @param walletAddress - Smart wallet address
-   * @param chainId - Chain ID
-   * @param options - Optional pagination and date filters
-   * @returns Transaction history
-   *
-   * @example
-   * ```typescript
-   * const history = await sdk.getHistory("0x...", 8453, { limit: 50 });
-   * history.data.forEach(tx => console.log(tx.type, tx.amount));
-   * ```
-   */
-  async getHistory(walletAddress, chainId, options) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      if (!chainId) {
-        throw new Error("Chain ID is required");
-      }
-      let endpoint = ENDPOINTS.DATA_HISTORY(walletAddress, chainId);
-      if (options?.limit) endpoint += `&limit=${options.limit}`;
-      if (options?.offset) endpoint += `&offset=${options.offset}`;
-      if (options?.fromDate) endpoint += `&fromDate=${options.fromDate}`;
-      if (options?.toDate) endpoint += `&toDate=${options.toDate}`;
-      const response = await this.httpClient.get(endpoint);
-      const convertedData = convertStrategiesToPublic(response.data || []);
-      return {
-        success: true,
-        walletAddress,
-        data: convertedData,
-        total: response.total || 0
-      };
-    } catch (error) {
-      throw new Error(`Failed to get history: ${error.message}`);
-    }
-  }
-  // ============================================================================
-  // Onchain Earnings Methods (Data API v2)
-  // ============================================================================
-  /**
-   * Get onchain earnings for a wallet
-   *
-   * @param walletAddress - Smart wallet address
-   * @returns Onchain earnings data with per-token breakdowns
-   *
-   * @example
-   * ```typescript
-   * const earnings = await sdk.getOnchainEarnings("0x...");
-   * console.log("Total USDC:", earnings.data.totalEarningsByToken["USDC"]);
-   * ```
-   */
-  async getOnchainEarnings(walletAddress) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.ONCHAIN_EARNINGS(walletAddress)
-      );
-      return {
-        success: true,
-        data: {
-          walletAddress,
-          totalEarningsByToken: response.total_earnings_by_token || {},
-          lastCheckTimestamp: response.last_check_timestamp,
-          lastLogDate: response.last_log_date
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get onchain earnings: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Calculate/refresh onchain earnings for a wallet
-   * This triggers a recalculation of earnings on the backend
-   *
-   * @param walletAddress - Smart wallet address
-   * @returns Updated onchain earnings data with per-token breakdowns
-   *
-   * @example
-   * ```typescript
-   * const earnings = await sdk.calculateOnchainEarnings("0x...");
-   * console.log("Total USDC:", earnings.data.totalEarningsByToken["USDC"]);
-   * ```
-   */
-  async calculateOnchainEarnings(walletAddress) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.dataPost(
-        DATA_ENDPOINTS.CALCULATE_ONCHAIN_EARNINGS,
-        { walletAddress }
-      );
-      const data = response.data || response;
-      return {
-        success: true,
-        data: {
-          walletAddress,
-          totalEarningsByToken: data.total_earnings_by_token || {},
-          lastCheckTimestamp: data.last_check_timestamp,
-          lastLogDate: data.last_log_date
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to calculate onchain earnings: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get daily earnings for a wallet within a date range
-   *
-   * @param walletAddress - Smart wallet address
-   * @param startDate - Start date (YYYY-MM-DD format)
-   * @param endDate - End date (YYYY-MM-DD format)
-   * @returns Daily earnings breakdown
-   *
-   * @example
-   * ```typescript
-   * const daily = await sdk.getDailyEarnings("0x...", "2024-01-01", "2024-01-31");
-   * daily.data.forEach(d => console.log(d.snapshot_date, d.total_earnings_by_token));
-   * ```
-   */
-  async getDailyEarnings(walletAddress, startDate, endDate) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.DAILY_EARNINGS(walletAddress, startDate, endDate)
-      );
-      const filteredData = (response.data || []).map((entry) => ({
-        wallet_address: entry.wallet_address,
-        snapshot_date: entry.snapshot_date,
-        total_earnings_by_token: entry.total_earnings_by_token,
-        daily_total_delta_by_token: entry.daily_total_delta_by_token,
-        created_at: entry.created_at
-      }));
-      return {
-        success: true,
-        walletAddress,
-        data: filteredData,
-        count: response.count || 0,
-        filters: {
-          startDate: startDate || null,
-          endDate: endDate || null
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get daily earnings: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // Opportunities Methods (Data API v2)
-  // ============================================================================
-  /**
-   * Get conservative (low-risk) yield opportunities
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns List of conservative yield opportunities
-   *
-   * @example
-   * ```typescript
-   * const opportunities = await sdk.getConservativeOpportunities(8453, "USDC");
-   * opportunities.data.forEach(o => console.log(o.protocolName, o.apy));
-   * ```
-   */
-  async getConservativeOpportunities(chainId, asset, status) {
-    try {
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId, asset, status)
-      );
-      const data = response.data || response || [];
-      return {
-        success: true,
-        chainId,
-        strategyType: "conservative",
-        data: Array.isArray(data) ? data.map((o) => ({
-          id: o.id,
-          protocolId: o.protocol_id || o.protocolId,
-          protocolName: o.protocol_name || o.protocolName,
-          poolName: o.pool_name || o.poolName,
-          chainId: o.chain_id || o.chainId,
-          apy: o.combined_apy || 0,
-          tvl: o.tvl || o.zyfiTvl,
-          asset: o.asset || o.underlying_token,
-          risk: o.risk,
-          strategyType: "conservative",
-          status: o.status
-        })) : []
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get safe opportunities: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get aggressive (high-risk, high-reward) yield opportunities
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns List of aggressive opportunities
-   *
-   * @example
-   * ```typescript
-   * const opportunities = await sdk.getAggressiveOpportunities(8453, "WETH");
-   * opportunities.data.forEach(o => console.log(o.protocolName, o.apy));
-   * ```
-   */
-  async getAggressiveOpportunities(chainId, asset, status) {
-    try {
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId, asset, status)
-      );
-      const data = response.data || response || [];
-      return {
-        success: true,
-        chainId,
-        strategyType: "aggressive",
-        data: Array.isArray(data) ? data.map((o) => ({
-          id: o.id,
-          protocolId: o.protocol_id || o.protocolId,
-          protocolName: o.protocol_name || o.protocolName,
-          poolName: o.pool_name || o.poolName,
-          chainId: o.chain_id || o.chainId,
-          apy: o.combined_apy || 0,
-          tvl: o.tvl || o.zyfiTvl,
-          asset: o.asset || o.underlying_token,
-          risk: o.risk,
-          strategyType: "aggressive",
-          status: o.status
-        })) : []
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get aggressive opportunities: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get active conservative opportunities (status = "live") with risk and utilization data
-   * Returns pool info, liquidity depth (true if > 1M), utilization rate, stability metrics, avg APY, and collateral
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns Active conservative opportunities with risk data
-   *
-   * @example
-   * ```typescript
-   * const opps = await sdk.getActiveConservativeOppsRisk(8453);
-   * console.log(JSON.stringify(opps, null, 2));
-   * ```
-   */
-  async getActiveConservativeOppsRisk(chainId, asset) {
-    try {
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId, asset)
-      );
-      const data = response.data || response || [];
-      const active = Array.isArray(data) ? data.filter((o) => o.status === "live").map((o) => {
-        const tvl = o.tvl || 0;
-        const liquidity = o.liquidity || 0;
-        const utilizationRate = tvl > 0 ? (tvl - liquidity) / tvl : 0;
-        return {
-          poolName: o.pool_name,
-          protocolName: o.protocol_name,
-          chainId: o.chain_id,
-          liquidityDepth: liquidity > 1e7 ? "deep" : liquidity > 1e6 ? "moderate" : "shallow",
-          utilizationRate: Math.round(utilizationRate * 1e4) / 100,
-          tvlStability: o.isTvlStable ?? null,
-          apyStability: o.isApyStable30Days ?? null,
-          tvlApyCombinedRisk: o.isApyTvlStable ?? null,
-          avgCombinedApy7d: o.averageCombinedApy7Days ?? null,
-          avgCombinedApy15d: o.averageCombinedApy15Days ?? null,
-          avgCombinedApy30d: o.averageCombinedApy30Days ?? null,
-          collateralSymbols: o.collateral_symbols || []
-        };
-      }) : [];
-      return active;
-    } catch (error) {
-      throw new Error(
-        `Failed to get active conservative opportunities risk: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get active aggressive opportunities (status = "live") with risk and utilization data
-   * Returns pool info, liquidity depth (true if > 1M), utilization rate, stability metrics, avg APY, and collateral
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns Active aggressive opportunities with risk data
-   *
-   * @example
-   * ```typescript
-   * const opps = await sdk.getActiveAggressiveOppsRisk(8453);
-   * console.log(JSON.stringify(opps, null, 2));
-   * ```
-   */
-  async getActiveAggressiveOppsRisk(chainId, asset) {
-    try {
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId, asset)
-      );
-      const data = response.data || response || [];
-      const active = Array.isArray(data) ? data.filter((o) => o.status === "live").map((o) => {
-        const tvl = o.tvl || 0;
-        const liquidity = o.liquidity || 0;
-        const utilizationRate = tvl > 0 ? (tvl - liquidity) / tvl : 0;
-        return {
-          poolName: o.pool_name,
-          protocolName: o.protocol_name,
-          chainId: o.chain_id,
-          liquidityDepth: liquidity > 1e7 ? "deep" : liquidity > 1e6 ? "moderate" : "shallow",
-          utilizationRate: Math.round(utilizationRate * 1e4) / 100,
-          tvlStability: o.isTvlStable ?? null,
-          apyStability: o.isApyStable30Days ?? null,
-          tvlApyCombinedRisk: o.isApyTvlStable ?? null,
-          avgCombinedApy7d: o.averageCombinedApy7Days ?? null,
-          avgCombinedApy15d: o.averageCombinedApy15Days ?? null,
-          avgCombinedApy30d: o.averageCombinedApy30Days ?? null,
-          collateralSymbols: o.collateral_symbols || []
-        };
-      }) : [];
-      return active;
-    } catch (error) {
-      throw new Error(
-        `Failed to get active aggressive opportunities risk: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get conservative pool status with derived health, risk, APY trend, and yield consistency
-   * Builds on getActiveConservativeOppsRisk and computes higher-level status indicators
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns Conservative pools with status data
-   */
-  async getConservativePoolStatus(chainId, asset) {
-    const pools = await this.getActiveConservativeOppsRisk(chainId, asset);
-    return pools.map((p) => this.derivePoolStatus(p));
-  }
-  /**
-   * Get aggressive pool status with derived health, risk, APY trend, and yield consistency
-   * Builds on getActiveAggressiveOppsRisk and computes higher-level status indicators
-   *
-   * @param chainId - Optional chain ID filter
-   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
-   * @returns Aggressive pools with status data
-   */
-  async getAggressivePoolStatus(chainId, asset) {
-    const pools = await this.getActiveAggressiveOppsRisk(chainId, asset);
-    return pools.map((p) => this.derivePoolStatus(p));
-  }
-  derivePoolStatus(p) {
-    let riskSignals = 0;
-    if (p.tvlStability === false) riskSignals++;
-    if (p.apyStability === false) riskSignals++;
-    if (p.tvlApyCombinedRisk === false) riskSignals++;
-    if (p.liquidityDepth === "shallow") riskSignals++;
-    if (p.utilizationRate > 90) riskSignals++;
-    const riskLevel = riskSignals >= 3 ? "high" : riskSignals >= 1 ? "medium" : "low";
-    const stabilityScore = (p.tvlStability === true ? 1 : 0) + (p.apyStability === true ? 1 : 0) + (p.tvlApyCombinedRisk === true ? 1 : 0);
-    const liquidityBonus = p.liquidityDepth === "deep" ? 1 : p.liquidityDepth === "moderate" ? 0.5 : 0;
-    const healthTotal = stabilityScore + liquidityBonus;
-    const healthScore = healthTotal >= 3 ? "healthy" : healthTotal >= 1.5 ? "moderate" : "risky";
-    const apy7d = p.avgCombinedApy7d;
-    const apy30d = p.avgCombinedApy30d;
-    let apyTrend = "stable";
-    if (apy7d != null && apy30d != null && apy30d !== 0) {
-      const change = (apy7d - apy30d) / apy30d;
-      if (change > 0.1) apyTrend = "rising";
-      else if (change < -0.1) apyTrend = "falling";
-    }
-    let yieldConsistency = "consistent";
-    if (apy7d != null && apy30d != null && apy30d !== 0) {
-      const spread = Math.abs(apy7d - apy30d) / apy30d;
-      if (spread > 0.3) yieldConsistency = "volatile";
-      else if (spread > 0.1) yieldConsistency = "mixed";
-    }
-    return {
-      poolName: p.poolName,
-      protocolName: p.protocolName,
-      chainId: p.chainId,
-      healthScore,
-      riskLevel,
-      apyTrend,
-      yieldConsistency,
-      liquidityDepth: p.liquidityDepth,
-      avgCombinedApy7d: p.avgCombinedApy7d
-    };
-  }
-  // ============================================================================
-  // APY History Methods (Data API v2)
-  // ============================================================================
-  /**
-   * Get daily APY history with weighted average for a wallet
-   *
-   * @param walletAddress - Smart wallet address
-   * @param days - Period: "7D", "14D", or "30D" (default: "7D")
-   * @returns Daily APY history with per-position breakdowns and weighted averages
-   *
-   * @example
-   * ```typescript
-   * const apyHistory = await sdk.getDailyApyHistory("0x...", "30D");
-   * console.log("Weighted APY after fee:", apyHistory.weightedApyAfterFee); // { "USDC": 4.64, "WETH": 1.94 }
-   * ```
-   */
-  async getDailyApyHistory(walletAddress, days = "7D") {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.DAILY_APY_HISTORY_WEIGHTED(walletAddress, days)
-      );
-      const data = response.data || response;
-      return {
-        success: true,
-        walletAddress,
-        history: data.history || {},
-        totalDays: data.total_days || data.totalDays || 0,
-        requestedDays: data.requested_days || data.requestedDays,
-        weightedApyWithRzfiAfterFee: data.average_final_weighted_apy_after_fee_with_rzfi,
-        weightedApyAfterFee: data.average_final_weighted_apy_after_fee
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get daily APY history: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // Rebalance Methods
-  // ============================================================================
-  /**
-   * Get rebalance frequency/tier for a wallet
-   * Determines how often the wallet can be rebalanced based on tier
-   *
-   * @param walletAddress - Smart wallet address
-   * @returns Rebalance frequency tier and details
-   *
-   * @example
-   * ```typescript
-   * const frequency = await sdk.getRebalanceFrequency("0x...");
-   * console.log("Tier:", frequency.tier);
-   * console.log("Max rebalances/day:", frequency.frequency);
-   * ```
-   */
-  async getRebalanceFrequency(walletAddress) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.DATA_REBALANCE_FREQUENCY(walletAddress)
-      );
-      return {
-        success: true,
-        walletAddress,
-        tier: response.tier || "standard",
-        frequency: response.frequency || response.rebalanceFrequency || 1,
-        description: response.description
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get rebalance frequency: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // SDK Key Methods
-  // ============================================================================
-  /**
-   * Get allowed wallets for the current SDK API key
-   * Returns the list of smart wallet addresses created via this SDK key
-   *
-   * @returns List of allowed wallet addresses with metadata
-   *
-   * @example
-   * ```typescript
-   * const result = await sdk.getSdkAllowedWallets();
-   * console.log("Allowed wallets:", result.allowedWallets);
-   * console.log("Total count:", result.metadata.walletsCount);
-   * ```
-   */
-  async getSdkAllowedWallets() {
-    try {
-      const response = await this.httpClient.get(
-        ENDPOINTS.SDK_ALLOWED_WALLETS
-      );
-      return {
-        success: response.success || true,
-        allowedWallets: response.allowedWallets || [],
-        metadata: response.metadata || {
-          sdkKeyId: "",
-          clientName: "",
-          walletsCount: 0
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get SDK allowed wallets: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get total TVL for all wallets under the current SDK API key
-   * This method calculates the total value locked across all wallets created via this SDK key
-   *
-   * @returns SDK key TVL information including allowed wallets and their individual/total TVL
-   *
-   * @example
-   * ```typescript
-   * const sdkTvl = await sdk.getSdkKeyTVL();
-   * console.log("Total TVL across all SDK wallets:", sdkTvl.totalTvl);
-   * console.log("Number of wallets:", sdkTvl.allowedWallets.length);
-   * console.log("TVL by wallet:", sdkTvl.tvlByWallet);
-   * ```
-   */
-  async getSdkKeyTVL() {
-    try {
-      const response = await this.httpClient.get(ENDPOINTS.SDK_TVL);
-      return {
-        success: response.success || true,
-        allowedWallets: response.allowedWallets || [],
-        totalTvl: response.totalTvl || 0,
-        tvlByWallet: response.tvlByWallet || [],
-        metadata: response.metadata || {
-          sdkKeyId: "",
-          clientName: "",
-          walletsCount: 0
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get SDK key TVL: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
-  // Protocol/Pool Customization
-  // ============================================================================
-  /**
-   * Configure protocol and pool customizations in batch.
-   *
-   * Allows granular control over which pools to use for each protocol on each chain.
-   * This is useful for advanced users who want to target specific pools with desired APY/risk profiles.
-   *
-   * @param customizations - Array of customization configurations
-   * @returns Response indicating success
-   *
-   * @example
-   * ```typescript
-   * // Configure multiple protocols across different chains
-   * await sdk.customizeBatch([
-   *   {
-   *     protocolId: "protocol-uuid-1",
-   *     pools: ["USDC Pool", "WETH Pool"],
-   *     chainId: 8453,  // Base
-   *     autoselect: false
-   *   },
-   *   {
-   *     protocolId: "protocol-uuid-1",
-   *     pools: ["USDC Vault"],
-   *     chainId: 42161,  // Arbitrum
-   *     autoselect: false
-   *   },
-   *   {
-   *     protocolId: "protocol-uuid-2",
-   *     pools: [],  // Empty array when autoselect is true
-   *     chainId: 8453,
-   *     autoselect: true  // Let engine auto-select best pools
-   *   }
-   * ]);
-   * ```
-   */
-  async customizeBatch(customizations) {
-    try {
-      await this.authenticateUser();
-      const response = await this.httpClient.post(
-        ENDPOINTS.CUSTOMIZE_BATCH,
-        customizations
-      );
-      return response;
-    } catch (error) {
-      throw new Error(
-        `Failed to save customizations: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get available pools for a protocol.
-   *
-   * Returns the list of pools available for a given protocol, optionally filtered by strategy.
-   *
-   * @param protocolId - The protocol UUID
-   * @param strategy - Optional strategy filter ("conservative" or "aggressive")
-   * @returns List of available pool names
-   *
-   * @example
-   * ```typescript
-   * // Get all available pools for a protocol
-   * const pools = await sdk.getAvailablePools("protocol-uuid");
-   * console.log("Available pools:", pools.pools);
-   *
-   * // Get pools for conservative strategy only
-   * const conservativePools = await sdk.getAvailablePools(
-   *   "protocol-uuid",
-   *   "conservative"
-   * );
-   * ```
-   */
-  async getAvailablePools(protocolId, strategy) {
-    try {
-      let internalStrategy;
-      if (strategy) {
-        if (!isValidPublicStrategy(strategy)) {
-          throw new Error(
-            `Invalid strategy: ${strategy}. Must be "conservative" or "aggressive".`
-          );
-        }
-        internalStrategy = toInternalStrategy(strategy);
-      }
-      const response = await this.httpClient.get(
-        ENDPOINTS.CUSTOMIZATION_POOLS(protocolId, internalStrategy)
-      );
-      return response;
-    } catch (error) {
-      throw new Error(
-        `Failed to get available pools: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Get currently selected pools for a protocol on a specific chain.
-   *
-   * Returns the pools that are currently configured for the authenticated user
-   * for a given protocol and chain combination.
-   *
-   * @param protocolId - The protocol UUID
-   * @param chainId - The chain ID
-   * @returns Currently selected pools and autoselect status
-   *
-   * @example
-   * ```typescript
-   * const selected = await sdk.getSelectedPools(
-   *   "protocol-uuid",
-   *   8453  // Base
-   * );
-   *
-   * console.log("Selected pools:", selected.pools);
-   * console.log("Autoselect enabled:", selected.autoselect);
-   * ```
-   */
-  async getSelectedPools(protocolId, chainId) {
-    try {
-      await this.authenticateUser();
-      const response = await this.httpClient.get(
-        ENDPOINTS.CUSTOMIZATION_SELECTED_POOLS(protocolId, chainId)
-      );
-      return response;
-    } catch (error) {
-      throw new Error(
-        `Failed to get selected pools: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Check if a chain ID supports the Identity Registry
-   */
-  isSupportedIdentityRegistryChain(chainId) {
-    return _ZyfaiSDK.IDENTITY_REGISTRY_CHAIN_IDS.includes(chainId);
-  }
-  /**
-   * Register an agent on the Identity Registry (ERC-8004)
-   *
-   * Fetches a tokenUri from the Zyfai API for the given smart wallet,
-   * then calls `register(tokenUri)` on the Identity Registry contract.
-   *
-   * @param smartWallet - The smart wallet address to register as an agent
-   * @param chainId - Chain ID to register on (only Base 8453 and Arbitrum 42161 supported)
-   * @returns Response with transaction hash and registration details
-   *
-   * @example
-   * ```typescript
-   * const sdk = new ZyfaiSDK({ apiKey: "your-api-key" });
-   * await sdk.connectAccount(privateKey, 8453);
-   *
-   * const result = await sdk.registerAgentOnIdentityRegistry("0xSmartWallet", 8453);
-   * console.log("Tx hash:", result.txHash);
-   * ```
-   */
-  async registerAgentOnIdentityRegistry(smartWallet, chainId) {
-    if (!smartWallet) {
-      throw new Error("Smart wallet address is required");
-    }
-    if (!this.isSupportedIdentityRegistryChain(chainId)) {
-      throw new Error(
-        `Chain ${chainId} is not supported for Identity Registry. Supported chains: Base (8453), Arbitrum (42161)`
-      );
-    }
-    try {
-      const tokenUriResponse = await this.httpClient.post(
-        ENDPOINTS.AGENT_TOKEN_URI,
-        { smartWallet }
-      );
-      if (!tokenUriResponse.tokenUri) {
-        throw new Error("API did not return a tokenUri");
-      }
-      const callData = (0, import_viem5.encodeFunctionData)({
-        abi: IDENTITY_REGISTRY_ABI,
-        functionName: "register",
-        args: [tokenUriResponse.tokenUri]
-      });
-      const walletClient = this.getWalletClient(chainId);
-      const chainConfig = getChainConfig(chainId, this.rpcUrls);
-      const txHash = await walletClient.sendTransaction({
-        to: IDENTITY_REGISTRY_ADDRESS,
-        data: callData,
-        chain: chainConfig.chain,
-        account: walletClient.account
-      });
-      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
-        hash: txHash
-      });
-      if (receipt.status !== "success") {
-        throw new Error("Identity Registry registration transaction failed");
-      }
-      return {
-        success: true,
-        txHash,
-        chainId,
-        smartWallet
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to register agent on Identity Registry: ${error.message}`
-      );
-    }
-  }
-  // ============================================
-  // Vault Methods (Base only)
-  // ============================================
-  /**
-   * Deposit assets into the Zyfai Vault
-   * Currently only supports USDC on Base chain
-   *
-   * @param amount - Amount to deposit (in human readable format, e.g., "100" for 100 USDC)
-   * @param asset - Asset to deposit (default: "USDC")
-   * @returns Deposit transaction result
-   *
-   * @example
-   * ```typescript
-   * const result = await sdk.vaultDeposit("100", "USDC");
-   * console.log("Deposited:", result.txHash);
-   * ```
-   */
-  async vaultDeposit(amount, asset = "USDC", chainId = 8453) {
-    if (!this.walletClient?.account) {
-      throw new Error("Wallet not connected. Call connectAccount first.");
-    }
-    if (Number(amount) <= 2) {
-      throw new Error("Minimum deposit amount is 2.00 USDC");
-    }
-    const userAddress = this.walletClient.account.address;
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    const tokenAddress = getDefaultTokenAddress(chainId, asset);
-    const decimals = 6;
-    const parsedAmount = BigInt(Math.floor(parseFloat(amount) * 10 ** decimals));
-    try {
-      const allowance = await chainConfig.publicClient.readContract({
-        address: tokenAddress,
-        abi: ERC20_ABI,
-        functionName: "allowance",
-        args: [userAddress, VAULT_ADDRESS]
-      });
-      if (allowance < parsedAmount) {
-        const approveTx = await this.walletClient.writeContract({
-          address: tokenAddress,
-          abi: ERC20_ABI,
-          functionName: "approve",
-          args: [VAULT_ADDRESS, parsedAmount],
-          chain: chainConfig.chain,
-          account: this.walletClient.account
-        });
-        await chainConfig.publicClient.waitForTransactionReceipt({
-          hash: approveTx
-        });
-      }
-      const depositTx = await this.walletClient.writeContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "deposit",
-        args: [parsedAmount, userAddress],
-        chain: chainConfig.chain,
-        account: this.walletClient.account
-      });
-      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
-        hash: depositTx
-      });
-      if (receipt.status !== "success") {
-        throw new Error("Vault deposit transaction failed");
-      }
-      return {
-        success: true,
-        txHash: depositTx,
-        amount,
-        asset,
-        vaultAddress: VAULT_ADDRESS
-      };
-    } catch (error) {
-      throw new Error(`Vault deposit failed: ${error.message}`);
-    }
-  }
-  /**
-   * Request withdrawal from the Zyfai Vault
-   * Withdrawals are async - use getVaultWithdrawStatus and vaultClaim after
-   *
-   * @param shares - Amount of shares to redeem (optional, defaults to all shares)
-   * @returns Withdraw request result with withdrawKey
-   *
-   * @example
-   * ```typescript
-   * const result = await sdk.vaultWithdraw();
-   * console.log("Withdraw key:", result.withdrawKey);
-   * // Later, check status and claim
-   * ```
-   */
-  async vaultWithdraw(shares, chainId = 8453) {
-    if (!this.walletClient?.account) {
-      throw new Error("Wallet not connected. Call connectAccount first.");
-    }
-    const userAddress = this.walletClient.account.address;
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    try {
-      let sharesToRedeem;
-      if (shares) {
-        sharesToRedeem = BigInt(shares);
-      } else {
-        const maxShares = await chainConfig.publicClient.readContract({
-          address: VAULT_ADDRESS,
-          abi: VAULT_ABI,
-          functionName: "maxRequestRedeem",
-          args: [userAddress]
-        });
-        if (maxShares === 0n) {
-          throw new Error("No shares available to redeem or withdrawals are paused");
-        }
-        sharesToRedeem = maxShares;
-      }
-      const redeemTx = await this.walletClient.writeContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "requestRedeem",
-        args: [sharesToRedeem, userAddress, userAddress],
-        chain: chainConfig.chain,
-        account: this.walletClient.account
-      });
-      await chainConfig.publicClient.waitForTransactionReceipt({
-        hash: redeemTx
-      });
-      const nonceResult = await chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "nonces",
-        args: [userAddress]
-      });
-      const nonce = BigInt(nonceResult);
-      if (nonce === 0n) {
-        throw new Error("Nonce is 0 after requestRedeem - unexpected state");
-      }
-      const withdrawKey = await chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "getWithdrawKey",
-        args: [userAddress, nonce - 1n]
-      });
-      const isClaimable = await chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "isClaimable",
-        args: [withdrawKey]
-      });
-      return {
-        success: true,
-        txHash: redeemTx,
-        withdrawKey,
-        status: isClaimable ? "claimable" : "pending"
-      };
-    } catch (error) {
-      throw new Error(`Vault withdraw request failed: ${error.message}`);
-    }
-  }
-  /**
-   * Get the status of a pending withdrawal
-   *
-   * @param withdrawKey - The withdraw key to check (optional, gets latest if not provided)
-   * @returns Withdraw status
-   *
-   * @example
-   * ```typescript
-   * const status = await sdk.getVaultWithdrawStatus();
-   * if (status.isClaimable) {
-   *   await sdk.vaultClaim(status.withdrawKey);
-   * }
-   * ```
-   */
-  async getVaultWithdrawStatus(withdrawKey, chainId = 8453) {
-    if (!this.walletClient?.account) {
-      throw new Error("Wallet not connected. Call connectAccount first.");
-    }
-    const userAddress = this.walletClient.account.address;
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    try {
-      const nonceResult = await chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "nonces",
-        args: [userAddress]
-      });
-      const nonce = BigInt(nonceResult);
-      if (nonce === 0n) {
-        return {
-          success: true,
-          withdrawKey: null,
-          isClaimable: false,
-          isPending: false,
-          nonce: 0n
-        };
-      }
-      let keyToCheck = withdrawKey;
-      if (!keyToCheck) {
-        keyToCheck = await chainConfig.publicClient.readContract({
-          address: VAULT_ADDRESS,
-          abi: VAULT_ABI,
-          functionName: "getWithdrawKey",
-          args: [userAddress, nonce - 1n]
-        });
-      }
-      const [isClaimable, isClaimed] = await Promise.all([
-        chainConfig.publicClient.readContract({
-          address: VAULT_ADDRESS,
-          abi: VAULT_ABI,
-          functionName: "isClaimable",
-          args: [keyToCheck]
-        }),
-        chainConfig.publicClient.readContract({
-          address: VAULT_ADDRESS,
-          abi: VAULT_ABI,
-          functionName: "isClaimed",
-          args: [keyToCheck]
-        })
-      ]);
-      if (isClaimed) {
-        return {
-          success: true,
-          withdrawKey: null,
-          isClaimable: false,
-          isPending: false,
-          nonce
-        };
-      }
-      return {
-        success: true,
-        withdrawKey: keyToCheck,
-        isClaimable,
-        isPending: !isClaimable,
-        nonce
-      };
-    } catch (error) {
-      throw new Error(`Failed to get withdraw status: ${error.message}`);
-    }
-  }
-  /**
-   * Claim a completed withdrawal from the Zyfai Vault
-   *
-   * @param withdrawKey - The withdraw key to claim
-   * @returns Claim transaction result
-   *
-   * @example
-   * ```typescript
-   * const status = await sdk.getVaultWithdrawStatus();
-   * if (status.isClaimable) {
-   *   const claim = await sdk.vaultClaim(status.withdrawKey);
-   *   console.log("Claimed:", claim.txHash);
-   * }
-   * ```
-   */
-  async vaultClaim(withdrawKey, chainId = 8453) {
-    if (!this.walletClient?.account) {
-      throw new Error("Wallet not connected. Call connectAccount first.");
-    }
-    if (!withdrawKey) {
-      throw new Error("Withdraw key is required");
-    }
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    try {
-      const isClaimable = await chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "isClaimable",
-        args: [withdrawKey]
-      });
-      if (!isClaimable) {
-        const isClaimed = await chainConfig.publicClient.readContract({
-          address: VAULT_ADDRESS,
-          abi: VAULT_ABI,
-          functionName: "isClaimed",
-          args: [withdrawKey]
-        });
-        if (isClaimed) {
-          throw new Error("This withdrawal has already been claimed");
-        }
-        throw new Error("Withdrawal is not yet claimable. Please wait for processing.");
-      }
-      const claimTx = await this.walletClient.writeContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "claim",
-        args: [withdrawKey],
-        chain: chainConfig.chain,
-        account: this.walletClient.account
-      });
-      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
-        hash: claimTx
-      });
-      if (receipt.status !== "success") {
-        throw new Error("Vault claim transaction failed");
-      }
-      return {
-        success: true,
-        txHash: claimTx,
-        claimed: true
-      };
-    } catch (error) {
-      throw new Error(`Vault claim failed: ${error.message}`);
-    }
-  }
-  /**
-   * Get vault shares info for the connected wallet
-   *
-   * @param userAddress - Optional user address (defaults to connected wallet)
-   * @returns Vault shares balance and token symbol
-   *
-   * @example
-   * ```typescript
-   * const { shares, symbol } = await sdk.getVaultShares();
-   * console.log(`Balance: ${shares} ${symbol}`);
-   * ```
-   */
-  async getVaultShares(userAddress, chainId = 8453) {
-    const address = userAddress || this.walletClient?.account?.address;
-    if (!address) {
-      throw new Error("User address required. Provide address or connect wallet first.");
-    }
-    const chainConfig = getChainConfig(chainId, this.rpcUrls);
-    const [shareBalance, tokenSymbol] = await Promise.all([
-      chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "balanceOf",
-        args: [address]
-      }),
-      chainConfig.publicClient.readContract({
-        address: VAULT_ADDRESS,
-        abi: VAULT_ABI,
-        functionName: "symbol"
-      })
-    ]);
-    return {
-      success: true,
-      shares: shareBalance,
-      symbol: tokenSymbol
-    };
-  }
-};
-// ============================================================================
-// Agent Identity Registry
-// ============================================================================
-/**
- * Supported chain IDs for the Identity Registry (ERC-8004)
- */
-_ZyfaiSDK.IDENTITY_REGISTRY_CHAIN_IDS = [8453, 42161];
-var ZyfaiSDK = _ZyfaiSDK;
-
-// src/cli/utils/sdk-wrapper.ts
-var import_viem6 = require("viem");
-var import_chains3 = require("viem/chains");
-
-// src/cli/utils/moonpay.ts
-var import_child_process = require("child_process");
-function sanitizeShellArg(arg) {
-  if (!/^[a-zA-Z0-9._-]+$/.test(arg)) {
-    throw new Error(`Invalid argument: "${arg}". Only alphanumeric characters, dots, dashes, and underscores are allowed.`);
-  }
-  return arg;
-}
-function execMoonPay(args) {
-  try {
-    const command = ["mp", ...args, "--json"].join(" ");
-    const result = (0, import_child_process.execSync)(command, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return result.trim();
-  } catch (error) {
-    const execError = error;
-    const stderr = execError.stderr || execError.message || "Unknown error";
-    throw new Error(`MoonPay CLI error: ${stderr}`);
-  }
-}
-function checkMoonPayCli() {
-  try {
-    (0, import_child_process.execSync)("mp --version", { stdio: ["pipe", "pipe", "pipe"] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getWallet(walletName) {
-  const safeName = sanitizeShellArg(walletName);
-  const result = execMoonPay(["wallet", "retrieve", "--wallet", safeName]);
-  return JSON.parse(result);
-}
-function getWalletAddress(walletName) {
-  const wallet = getWallet(walletName);
-  const ethAddress = wallet.addresses?.ethereum;
-  if (!ethAddress) {
-    throw new Error(`Wallet "${walletName}" does not have an Ethereum address`);
-  }
-  return ethAddress;
-}
-function signMessage(walletName, message, chain = "base") {
-  const safeName = sanitizeShellArg(walletName);
-  const safeChain = sanitizeShellArg(chain);
-  const fs2 = require("fs");
-  const os2 = require("os");
-  const path2 = require("path");
-  const tempFile = path2.join(os2.tmpdir(), `zyfai-siwe-${Date.now()}.txt`);
-  try {
-    fs2.writeFileSync(tempFile, message, { encoding: "utf-8" });
-    const result = (0, import_child_process.execSync)(
-      `mp message sign --wallet ${safeName} --chain ${safeChain} --message "$(cat ${tempFile})" --json`,
-      {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        shell: "/bin/bash"
-      }
-    );
-    const parsed = JSON.parse(result.trim());
-    return parsed.signature;
-  } catch (error) {
-    const execError = error;
-    throw new Error(`MoonPay sign error: ${execError.stderr || execError.message}`);
-  } finally {
-    try {
-      fs2.unlinkSync(tempFile);
-    } catch {
-    }
-  }
-}
-function signTypedData(walletName, typedData, chain = "base") {
-  const safeName = sanitizeShellArg(walletName);
-  const safeChain = sanitizeShellArg(chain);
-  const typedDataJson = JSON.stringify(typedData);
-  const fs2 = require("fs");
-  const os2 = require("os");
-  const path2 = require("path");
-  const tempFile = path2.join(os2.tmpdir(), `zyfai-typed-${Date.now()}.json`);
-  try {
-    fs2.writeFileSync(tempFile, typedDataJson, { encoding: "utf-8" });
-    const result = (0, import_child_process.execSync)(
-      `mp message sign --wallet ${safeName} --chain ${safeChain} --typedData "$(cat ${tempFile})" --json`,
-      {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        shell: "/bin/bash"
-      }
-    );
-    const parsed = JSON.parse(result.trim());
-    return parsed.signature;
-  } catch (error) {
-    const execError = error;
-    throw new Error(`MoonPay sign error: ${execError.stderr || execError.message}`);
-  } finally {
-    try {
-      fs2.unlinkSync(tempFile);
-    } catch {
-    }
-  }
-}
-function chainIdToMoonPayChain(chainId) {
-  switch (chainId) {
-    case 8453:
-      return "base";
-    case 42161:
-      return "arbitrum";
-    case 9745:
-      return "plasma";
-    default:
-      throw new Error(`Unsupported chain ID: ${chainId}`);
-  }
-}
-function moonPayChainToChainId(chain) {
-  switch (chain.toLowerCase()) {
-    case "base":
-      return 8453;
-    case "arbitrum":
-      return 42161;
-    case "plasma":
-      return 9745;
-    default:
-      throw new Error(`Unsupported chain: ${chain}`);
-  }
-}
-
-// src/cli/utils/sdk-wrapper.ts
-function createMoonPayAccount(walletName, chainId) {
-  const address = (0, import_viem6.getAddress)(getWalletAddress(walletName));
-  const moonPayChain = chainIdToMoonPayChain(chainId);
-  console.error("[DEBUG] Created MoonPay account:", address);
-  return {
-    address,
-    type: "local",
-    // Sign a message (EIP-191)
-    signMessage: async ({ message }) => {
-      console.error("[DEBUG] signMessage called with:", typeof message);
-      let messageStr;
-      if (typeof message === "string") {
-        console.error("[DEBUG] Message is string, length:", message.length);
-        messageStr = message;
-      } else if ("raw" in message) {
-        const raw = message.raw;
-        console.error("[DEBUG] Message is raw, type:", typeof raw, "isHex:", typeof raw === "string" && raw.startsWith("0x"));
-        if (typeof raw === "string") {
-          messageStr = raw;
-        } else {
-          messageStr = "0x" + Buffer.from(raw).toString("hex");
-        }
-        console.error("[DEBUG] Raw message to sign:", messageStr.substring(0, 50) + "...");
-      } else {
-        messageStr = message.toString();
-      }
-      console.error("[DEBUG] Calling MoonPay to sign message...");
-      const signature = signMessage(walletName, messageStr, moonPayChain);
-      console.error("[DEBUG] Got signature:", signature.substring(0, 20) + "...");
-      return signature;
-    },
-    // Sign typed data (EIP-712)
-    signTypedData: async (typedData) => {
-      console.error("[DEBUG] signTypedData called");
-      console.error("[DEBUG] TypedData:", JSON.stringify(typedData, null, 2).substring(0, 200) + "...");
-      const signature = signTypedData(walletName, typedData, moonPayChain);
-      console.error("[DEBUG] Got signature:", signature.substring(0, 20) + "...");
-      return signature;
-    },
-    // Sign a transaction - not implemented (we use backend for tx execution)
-    signTransaction: async () => {
-      console.error("[DEBUG] signTransaction called - NOT SUPPORTED");
-      throw new Error("Transaction signing not supported via MoonPay CLI. Use backend execution.");
-    }
-  };
-}
-async function createAuthenticatedSdk(walletName, chainId) {
-  console.error("[DEBUG] createAuthenticatedSdk starting...");
-  console.error("[DEBUG] Wallet:", walletName, "Chain:", chainId);
-  const apiKey = getApiKey();
-  console.error("[DEBUG] API Key:", apiKey.substring(0, 15) + "...");
-  const sdk = new ZyfaiSDK({ apiKey });
-  console.error("[DEBUG] Creating MoonPay account...");
-  const account = createMoonPayAccount(walletName, chainId);
-  const walletLike = {
-    account,
-    transport: (0, import_viem6.http)()
-    // http() returns a transport factory function
-  };
-  console.error("[DEBUG] Connecting account to SDK...");
-  await sdk.connectAccount(walletLike, chainId);
-  console.error("[DEBUG] Account connected successfully!");
-  return { sdk, userAddress: account.address };
-}
-function createReadOnlySdk() {
-  const apiKey = getApiKey();
-  return new ZyfaiSDK({ apiKey });
-}
-function parseChainArg(chain) {
-  if (/^\d+$/.test(chain)) {
-    const chainId = parseInt(chain, 10);
-    if (chainId === 8453 || chainId === 42161 || chainId === 9745) {
-      return chainId;
-    }
-    throw new Error(`Unsupported chain ID: ${chainId}. Supported: 8453 (base), 42161 (arbitrum), 9745 (plasma)`);
-  }
-  return moonPayChainToChainId(chain);
-}
-
-// src/cli/commands/deploy.ts
-function registerDeployCommand(program2) {
-  program2.command("deploy").description("Deploy a Safe smart wallet for yield optimization").requiredOption("--wallet <name>", "MoonPay wallet name to use for signing").option("--chain <chain>", "Chain to deploy on (base, arbitrum, plasma)", getDefaultChain()).option("--strategy <strategy>", "Yield strategy: conservative or aggressive", "conservative").action(async (options) => {
-    try {
-      const chainId = parseChainArg(options.chain);
-      const strategy = options.strategy;
-      if (!["conservative", "aggressive"].includes(strategy)) {
-        throw new Error("Invalid strategy. Must be 'conservative' or 'aggressive'");
-      }
-      const { sdk, userAddress } = await createAuthenticatedSdk(options.wallet, chainId);
-      const result = await sdk.deploySafe(
-        userAddress,
-        chainId,
-        strategy,
-        true
-        // createSessionKey
-      );
-      outputSuccess({
-        safeAddress: result.safeAddress,
-        status: result.status,
-        sessionKeyCreated: result.sessionKeyCreated,
-        txHash: result.txHash,
-        chain: options.chain,
-        chainId,
-        userAddress
-      });
-    } catch (error) {
-      outputError(error);
-    }
-  });
-}
-
-// src/cli/commands/deposit.ts
-function registerDepositCommand(program2) {
-  program2.command("deposit").description("Deposit tokens to Safe for yield optimization").requiredOption("--wallet <name>", "MoonPay wallet name").requiredOption("--amount <amount>", "Amount in token units (e.g., 100000000 for 100 USDC)").option("--chain <chain>", "Chain for deposit (base, arbitrum, plasma)", getDefaultChain()).option("--asset <asset>", "Asset to deposit: USDC or WETH", "USDC").action(async (options) => {
-    try {
-      const chainId = parseChainArg(options.chain);
-      const userAddress = getWalletAddress(options.wallet);
-      const { sdk } = await createAuthenticatedSdk(options.wallet, chainId);
-      const result = await sdk.depositFunds(
-        userAddress,
-        chainId,
-        options.amount,
-        options.asset
-      );
-      outputSuccess({
-        txHash: result.txHash,
-        smartWallet: result.smartWallet,
-        amount: result.amount,
-        asset: options.asset,
-        chain: options.chain,
-        chainId
-      });
-    } catch (error) {
-      outputError(error);
-    }
-  });
-}
-
-// src/cli/commands/withdraw.ts
-function registerWithdrawCommand(program2) {
-  program2.command("withdraw").description("Withdraw funds from Safe (full or partial)").requiredOption("--wallet <name>", "MoonPay wallet name").option("--chain <chain>", "Chain to withdraw from (base, arbitrum, plasma)", getDefaultChain()).option("--amount <amount>", "Amount to withdraw (omit for full withdrawal)").option("--asset <asset>", "Asset to withdraw: USDC or WETH", "USDC").action(async (options) => {
-    try {
-      const chainId = parseChainArg(options.chain);
-      const userAddress = getWalletAddress(options.wallet);
-      const { sdk } = await createAuthenticatedSdk(options.wallet, chainId);
-      const result = await sdk.withdrawFunds(
-        userAddress,
-        chainId,
-        options.amount,
-        options.asset
-      );
-      outputSuccess({
-        type: result.type,
-        amount: result.amount,
-        message: result.message,
-        txHash: result.txHash,
-        asset: options.asset,
-        chain: options.chain,
-        chainId
-      });
-    } catch (error) {
-      outputError(error);
-    }
-  });
-}
-
-// src/cli/commands/earnings.ts
-function registerEarningsCommand(program2) {
-  program2.command("earnings").description("Get onchain earnings for a Smart Wallet").requiredOption("--user <address>", "Smart Wallet address (not EOA)").action(async (options) => {
-    try {
-      const sdk = createReadOnlySdk();
-      const result = await sdk.getOnchainEarnings(options.user);
-      outputSuccess({
-        walletAddress: result.data.walletAddress,
-        totalEarningsByToken: result.data.totalEarningsByToken,
-        lastCheckTimestamp: result.data.lastCheckTimestamp,
-        lastLogDate: result.data.lastLogDate
-      });
-    } catch (error) {
-      outputError(error);
-    }
-  });
-}
-
-// src/cli/index.ts
-var program = new import_commander.Command();
-program.name("zyfai").description(
-  "Zyfai CLI - DeFi yield optimization with Safe smart wallets\n\nCommands that modify state (deploy, deposit, withdraw) require a MoonPay wallet.\nRead-only commands (earnings) only need the API key."
-).version("0.2.31").hook("preAction", (thisCommand) => {
-  const commandName = thisCommand.args[0];
-  const needsMoonPay = ["deploy", "deposit", "withdraw"].includes(commandName);
-  if (needsMoonPay && !checkMoonPayCli()) {
-    outputError(
-      "MoonPay CLI not found.\n\nInstall with: npm install -g @moonpay/cli\nThen authenticate: mp login && mp verify\nCreate a wallet: mp wallet create --name zyfai"
-    );
-  }
-});
-registerConfigCommand(program);
-registerDeployCommand(program);
-registerDepositCommand(program);
-registerWithdrawCommand(program);
-registerEarningsCommand(program);
-program.parse();