@zyfai/sdk 0.2.30 → 0.2.32

package/dist/cli/index.js

@@ -0,0 +1,3981 @@
+#!/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();