@zyfai/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1869 @@
+// src/utils/http-client.ts
+import axios from "axios";
+
+// src/config/endpoints.ts
+var API_ENDPOINTS = {
+  staging: "https://staging-api.zyf.ai",
+  production: "https://api.zyf.ai"
+};
+var DATA_API_ENDPOINTS = {
+  staging: "https://staging-defiapi.zyf.ai",
+  production: "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",
+  // Session Keys
+  SESSION_KEYS_CONFIG: "/session-keys/config",
+  SESSION_KEYS_ADD: "/session-keys/add",
+  // Protocols
+  PROTOCOLS: (chainId) => `/protocols?chainId=${chainId}`,
+  // Data (v1)
+  DATA_POSITION: (walletAddress) => `/data/position?walletAddress=${walletAddress}`,
+  DATA_HISTORY: (walletAddress, chainId) => `/data/history?walletAddress=${walletAddress}&chainId=${chainId}`,
+  DATA_TVL: "/data/tvl",
+  DATA_VOLUME: "/data/volume",
+  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}`
+};
+var DATA_ENDPOINTS = {
+  // Earnings
+  ONCHAIN_EARNINGS: (walletAddress) => `/usercheck/onchain-earnings?walletAddress=${walletAddress}`,
+  CALCULATE_ONCHAIN_EARNINGS: "/usercheck/calculate-onchain-earnings",
+  DAILY_EARNINGS: (walletAddress, startDate, endDate) => {
+    let url = `/usercheck/daily-earnings?walletAddress=${walletAddress}`;
+    if (startDate) url += `&startDate=${startDate}`;
+    if (endDate) url += `&endDate=${endDate}`;
+    return url;
+  },
+  // Portfolio
+  DEBANK_PORTFOLIO_MULTICHAIN: (address) => `/debank/portfolio/multichain/${address}`,
+  // Opportunities
+  OPPORTUNITIES_SAFE: (chainId) => chainId ? `/opportunities/safes?chainId=${chainId}` : "/opportunities/safes",
+  OPPORTUNITIES_DEGEN: (chainId) => chainId ? `/opportunities/degen-strategies?chainId=${chainId}` : "/opportunities/degen-strategies",
+  // APY History
+  DAILY_APY_HISTORY_WEIGHTED: (walletAddress, days) => `/daily-apy-history/weighted/${walletAddress}${days ? `?days=${days}` : ""}`,
+  // Rebalance
+  REBALANCE_INFO: (isCrossChain) => isCrossChain !== void 0 ? `/rebalance/rebalance-info?isCrossChain=${isCrossChain}` : "/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 Execution API (Utkir's backend)
+   * @param environment - 'staging' or 'production'
+   * @param dataApiKey - API key for Data API (Sunny's backend) - defaults to apiKey
+   */
+  constructor(apiKey, environment = "production", dataApiKey) {
+    this.authToken = null;
+    this.apiKey = apiKey;
+    this.dataApiKey = dataApiKey || apiKey;
+    const endpoint = API_ENDPOINTS[environment];
+    const parsedUrl = new URL(endpoint);
+    this.origin = parsedUrl.origin;
+    this.host = parsedUrl.host;
+    this.client = axios.create({
+      baseURL: `${endpoint}${API_VERSION}`,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey,
+        Origin: this.origin
+      },
+      timeout: 3e4
+    });
+    const dataEndpoint = DATA_API_ENDPOINTS[environment];
+    this.dataClient = axios.create({
+      baseURL: `${dataEndpoint}${DATA_API_VERSION}`,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.dataApiKey
+      },
+      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;
+        config.headers["Origin"] = this.origin;
+        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("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;
+  }
+  setupDataInterceptors() {
+    this.dataClient.interceptors.request.use(
+      (config) => {
+        config.headers["X-API-Key"] = this.dataApiKey;
+        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 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" }]
+  }
+];
+
+// src/core/ZyfaiSDK.ts
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  createWalletClient,
+  custom,
+  http as http3
+} from "viem";
+
+// src/config/chains.ts
+import { createPublicClient, http } from "viem";
+import { arbitrum, base } from "viem/chains";
+import { defineChain } from "viem";
+var plasma = defineChain({
+  id: 9745,
+  name: "Plasma",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Plasma",
+    symbol: "PLSM"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.plasma.io"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Plasma Explorer",
+      url: "https://explorer.plasma.io"
+    }
+  }
+});
+var DEFAULT_RPC_URLS = {
+  8453: "https://mainnet.base.org",
+  42161: "https://arb1.arbitrum.io/rpc",
+  9745: "https://rpc.plasma.io"
+};
+var CHAINS = {
+  8453: base,
+  42161: arbitrum,
+  9745: plasma
+};
+var getChainConfig = (chainId) => {
+  const chain = CHAINS[chainId];
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  const rpcUrl = DEFAULT_RPC_URLS[chainId];
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(rpcUrl)
+  });
+  return {
+    chain,
+    rpcUrl,
+    publicClient
+  };
+};
+var isSupportedChain = (chainId) => {
+  return chainId in CHAINS;
+};
+var getSupportedChainIds = () => {
+  return Object.keys(CHAINS).map(Number);
+};
+var getBundlerUrl = (chainId, bundlerApiKey, bundlerProvider = "pimlico") => {
+  if (!bundlerApiKey) {
+    throw new Error("Bundler API key is required for Safe deployment");
+  }
+  switch (bundlerProvider) {
+    case "pimlico":
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${bundlerApiKey}`;
+    case "custom":
+      return bundlerApiKey;
+    default:
+      throw new Error(`Unsupported bundler provider: ${bundlerProvider}`);
+  }
+};
+
+// src/utils/safe-account.ts
+import {
+  RHINESTONE_ATTESTER_ADDRESS,
+  getOwnableValidator,
+  getAccount,
+  getEnableSessionDetails,
+  getPermissionId,
+  getSessionNonce
+} from "@rhinestone/module-sdk";
+import { createSmartAccountClient } from "permissionless";
+import { getAccountNonce } from "permissionless/actions";
+import { erc7579Actions } from "permissionless/actions/erc7579";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { toSafeSmartAccount } from "permissionless/accounts";
+import {
+  http as http2,
+  fromHex,
+  pad,
+  toHex
+} from "viem";
+import {
+  entryPoint07Address,
+  getUserOperationHash
+} from "viem/account-abstraction";
+var SAFE_7579_ADDRESS = "0x7579EE8307284F293B1927136486880611F20002";
+var ERC7579_LAUNCHPAD_ADDRESS = "0x7579011aB74c46090561ea277Ba79D510c6C00ff";
+var DEFAULT_ACCOUNT_SALT = "zyfai-staging";
+var getSafeAccount = async (config) => {
+  const {
+    owner,
+    safeOwnerAddress,
+    publicClient,
+    accountSalt = DEFAULT_ACCOUNT_SALT
+  } = config;
+  if (!owner || !owner.account) {
+    throw new Error("Wallet not connected. Please connect your wallet first.");
+  }
+  const actualOwnerAddress = safeOwnerAddress || owner.account.address;
+  const ownableValidator = getOwnableValidator({
+    owners: [actualOwnerAddress],
+    threshold: 1
+  });
+  const saltHex = fromHex(toHex(accountSalt), "bigint");
+  const safeAccount = await toSafeSmartAccount({
+    client: publicClient,
+    owners: [owner.account],
+    // Use connected wallet for signing
+    version: "1.4.1",
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    },
+    safe4337ModuleAddress: SAFE_7579_ADDRESS,
+    erc7579LaunchpadAddress: ERC7579_LAUNCHPAD_ADDRESS,
+    attesters: [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";
+    }
+    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 getSmartAccountClient = async (config) => {
+  const { publicClient, chain, bundlerUrl } = config;
+  const safeAccount = await getSafeAccount(config);
+  const bundlerClient = createPimlicoClient({
+    transport: http2(bundlerUrl),
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  const smartAccountClient = createSmartAccountClient({
+    account: safeAccount,
+    chain,
+    bundlerTransport: http2(bundlerUrl),
+    paymaster: bundlerClient,
+    userOperation: {
+      estimateFeesPerGas: async () => {
+        return (await bundlerClient.getUserOperationGasPrice()).fast;
+      }
+    }
+  }).extend(erc7579Actions());
+  return smartAccountClient;
+};
+var deploySafeAccount = async (config) => {
+  try {
+    const { owner, publicClient } = config;
+    if (!owner || !owner.account) {
+      throw new Error(
+        "Wallet not connected. Please connect your wallet first."
+      );
+    }
+    const safeAddress = await getDeterministicSafeAddress(config);
+    const isDeployed = await isSafeDeployed(safeAddress, publicClient);
+    if (isDeployed) {
+      return {
+        safeAddress,
+        isDeployed: true
+      };
+    }
+    const smartAccountClient = await getSmartAccountClient(config);
+    const userOpHash = await smartAccountClient.sendUserOperation({
+      calls: [
+        {
+          to: safeAddress,
+          value: BigInt(0),
+          data: "0x"
+        }
+      ]
+    });
+    const receipt = await smartAccountClient.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    return {
+      safeAddress,
+      txHash: receipt.receipt.transactionHash,
+      isDeployed: true
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to deploy Safe account: ${error.message}`
+    );
+  }
+};
+var signSessionKey = async (config, sessions) => {
+  const { owner, publicClient, chain } = config;
+  if (!owner || !owner.account) {
+    throw new Error("Wallet not connected. Please connect your wallet first.");
+  }
+  const safeAccount = await getSafeAccount(config);
+  const account = getAccount({
+    address: safeAccount.address,
+    type: "safe"
+  });
+  const sessionNonces = await Promise.all(
+    sessions.map(
+      (session) => getSessionNonce({
+        client: publicClient,
+        account,
+        permissionId: getPermissionId({
+          session
+        })
+      })
+    )
+  );
+  const sessionDetails = await getEnableSessionDetails({
+    sessions,
+    account,
+    clients: [publicClient],
+    permitGenericPolicy: true,
+    sessionNonces
+  });
+  const signature = await owner.signMessage({
+    account: owner.account,
+    message: {
+      raw: sessionDetails.permissionEnableHash
+    }
+  });
+  return {
+    signature,
+    sessionNonces
+  };
+};
+
+// src/core/ZyfaiSDK.ts
+import { SiweMessage } from "siwe";
+var ZyfaiSDK = class {
+  // TODO: The encironment should be removed. Having the same key for staging and production is not ideal, but for now it's fine.
+  constructor(config) {
+    this.signer = null;
+    this.walletClient = null;
+    this.isAuthenticated = false;
+    // TODO: Check with Utkir for how long the authentication token is valid for.
+    this.authenticatedUserId = null;
+    const sdkConfig = typeof config === "string" ? { apiKey: config } : config;
+    const { apiKey, dataApiKey, environment, bundlerApiKey } = sdkConfig;
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    this.environment = environment || "production";
+    this.httpClient = new HttpClient(apiKey, this.environment, dataApiKey);
+    this.bundlerApiKey = bundlerApiKey;
+  }
+  /**
+   * 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.isAuthenticated) {
+        return;
+      }
+      const walletClient = this.getWalletClient();
+      const userAddress = walletClient.account.address;
+      const chainId = walletClient.chain?.id || 8453;
+      const challengeResponse = await this.httpClient.post(ENDPOINTS.AUTH_CHALLENGE, {});
+      const domain = API_ENDPOINTS[this.environment].split("//")[1];
+      const uri = API_ENDPOINTS[this.environment];
+      const messageObj = new 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
+        },
+        {
+          headers: {
+            Origin: uri
+          }
+        }
+      );
+      const authToken = loginResponse.accessToken || loginResponse.token;
+      if (!authToken) {
+        throw new Error("Authentication response missing access token");
+      }
+      this.httpClient.setAuthToken(authToken);
+      this.authenticatedUserId = loginResponse.userId || null;
+      this.isAuthenticated = true;
+    } 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, 42161],
+   * });
+   * ```
+   */
+  async updateUserProfile(request) {
+    try {
+      await this.authenticateUser();
+      const response = await this.httpClient.patch(
+        ENDPOINTS.USER_ME,
+        request
+      );
+      return {
+        success: true,
+        userId: response.userId || response.id,
+        smartWallet: response.smartWallet,
+        chains: response.chains
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to update user profile: ${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: 42161 - Arbitrum)
+   * @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 = 42161) {
+    if (!isSupportedChain(chainId)) {
+      throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    this.isAuthenticated = false;
+    this.httpClient.clearAuthToken();
+    const chainConfig = getChainConfig(chainId);
+    if (typeof account === "string") {
+      let privateKey = account;
+      if (!privateKey.startsWith("0x")) {
+        privateKey = `0x${privateKey}`;
+      }
+      this.signer = privateKeyToAccount(privateKey);
+      this.walletClient = createWalletClient({
+        account: this.signer,
+        chain: chainConfig.chain,
+        transport: http3(chainConfig.rpcUrl)
+      });
+      return this.signer.address;
+    }
+    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 = createWalletClient({
+        account: accounts[0],
+        chain: chainConfig.chain,
+        transport: custom(provider)
+      });
+      return accounts[0];
+    }
+    if (provider.account && provider.transport) {
+      this.walletClient = createWalletClient({
+        account: provider.account,
+        chain: chainConfig.chain,
+        transport: provider.transport
+      });
+      return provider.account.address;
+    }
+    throw new Error(
+      "Invalid wallet provider. Expected EIP-1193 provider or viem WalletClient."
+    );
+  }
+  /**
+   * Get wallet client (throws if not connected)
+   * @private
+   */
+  getWalletClient(chainId) {
+    if (this.signer) {
+      return createWalletClient({
+        account: this.signer,
+        chain: getChainConfig(chainId || 8453).chain,
+        transport: http3(getChainConfig(chainId || 8453).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 walletClient = this.getWalletClient();
+    const chainConfig = getChainConfig(chainId);
+    const safeAddress = await getDeterministicSafeAddress({
+      owner: walletClient,
+      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
+   * @returns Deployment response with Safe address and transaction hash
+   */
+  async deploySafe(userAddress, chainId) {
+    try {
+      if (!userAddress) {
+        throw new Error("User address is required");
+      }
+      if (!isSupportedChain(chainId)) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+      }
+      if (!this.bundlerApiKey) {
+        throw new Error(
+          "Bundler API key is required for Safe deployment. Please provide bundlerApiKey in SDK configuration."
+        );
+      }
+      const walletClient = this.getWalletClient(chainId);
+      const chainConfig = getChainConfig(chainId);
+      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.`
+        );
+      }
+      const bundlerUrl = getBundlerUrl(chainId, this.bundlerApiKey);
+      const deploymentResult = await deploySafeAccount({
+        owner: walletClient,
+        safeOwnerAddress: userAddress,
+        chain: chainConfig.chain,
+        publicClient: chainConfig.publicClient,
+        bundlerUrl
+      });
+      try {
+        await this.updateUserProfile({
+          smartWallet: deploymentResult.safeAddress,
+          chains: [chainId]
+        });
+      } catch (updateError) {
+        console.warn(
+          "Failed to update user profile after Safe deployment:",
+          updateError.message
+        );
+      }
+      return {
+        success: true,
+        safeAddress: deploymentResult.safeAddress,
+        txHash: deploymentResult.txHash || "0x0",
+        status: "deployed"
+      };
+    } 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."
+        );
+      }
+      const walletClient = this.getWalletClient();
+      const chainConfig = getChainConfig(chainId);
+      const safeAddress = await getDeterministicSafeAddress({
+        owner: walletClient,
+        safeOwnerAddress: userAddress,
+        chain: chainConfig.chain,
+        publicClient: chainConfig.publicClient
+      });
+      const sessionConfig = await this.httpClient.get(
+        ENDPOINTS.SESSION_KEYS_CONFIG
+      );
+      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 signatureResult = await this.signSessionKey(
+        userAddress,
+        chainId,
+        sessions
+      );
+      const activation = await this.activateSessionKey(
+        signatureResult.signature,
+        signatureResult.sessionNonces
+      );
+      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) {
+    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);
+      const accountType = await getAccountType(
+        userAddress,
+        chainConfig.publicClient
+      );
+      if (accountType !== "EOA") {
+        throw new Error(
+          `Invalid account type for ${userAddress}. Must be an EOA.`
+        );
+      }
+      const { signature, sessionNonces } = await signSessionKey(
+        {
+          owner: walletClient,
+          safeOwnerAddress: userAddress,
+          chain: chainConfig.chain,
+          publicClient: chainConfig.publicClient
+        },
+        sessions
+      );
+      const safeAddress = await getDeterministicSafeAddress({
+        owner: walletClient,
+        safeOwnerAddress: userAddress,
+        chain: chainConfig.chain,
+        publicClient: chainConfig.publicClient
+      });
+      return {
+        success: true,
+        sessionKeyAddress: safeAddress,
+        signature,
+        sessionNonces
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to sign session key: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Activate session key via ZyFAI API
+   */
+  async activateSessionKey(signature, sessionNonces) {
+    const nonces = this.normalizeSessionNonces(sessionNonces);
+    const payload = {
+      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
+   *
+   * @param userAddress - User's address (owner of the Safe)
+   * @param chainId - Target chain ID
+   * @param tokenAddress - Token contract address to deposit
+   * @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 Arbitrum
+   * const result = await sdk.depositFunds(
+   *   "0xUser...",
+   *   42161,
+   *   "0xaf88d065e77c8cc2239327c5edb3a432268e5831", // USDC
+   *   "100000000" // 100 USDC = 100 * 10^6
+   * );
+   * ```
+   */
+  async depositFunds(userAddress, chainId, tokenAddress, amount) {
+    try {
+      if (!userAddress) {
+        throw new Error("User address is required");
+      }
+      if (!isSupportedChain(chainId)) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+      }
+      if (!tokenAddress) {
+        throw new Error("Token address is required");
+      }
+      if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
+        throw new Error("Valid amount is required");
+      }
+      const walletClient = this.getWalletClient();
+      const chainConfig = getChainConfig(chainId);
+      const safeAddress = await getDeterministicSafeAddress({
+        owner: walletClient,
+        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: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "transfer",
+        args: [safeAddress, amountBigInt],
+        chain: chainConfig.chain,
+        account: walletClient.account
+      });
+      const receipt = await chainConfig.publicClient.waitForTransactionReceipt({
+        hash: txHash
+      });
+      if (receipt.status !== "success") {
+        throw new Error("Deposit transaction failed");
+      }
+      return {
+        success: true,
+        txHash,
+        smartWallet: safeAddress,
+        amount: amountBigInt.toString(),
+        status: "confirmed"
+      };
+    } catch (error) {
+      throw new Error(`Deposit failed: ${error.message}`);
+    }
+  }
+  /**
+   * Withdraw funds from Safe smart wallet
+   * Triggers a withdrawal request to the ZyFAI API
+   *
+   * @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
+   * @param receiver - Optional: Receiver address. If not specified, sends to Safe owner
+   * @returns Withdraw response with transaction hash
+   *
+   * @example
+   * ```typescript
+   * // Full withdrawal
+   * const result = await sdk.withdrawFunds("0xUser...", 42161);
+   *
+   * // Partial withdrawal of 50 USDC (6 decimals)
+   * const result = await sdk.withdrawFunds(
+   *   "0xUser...",
+   *   42161,
+   *   "50000000", // 50 USDC = 50 * 10^6
+   *   "0xReceiver..."
+   * );
+   * ```
+   */
+  async withdrawFunds(userAddress, chainId, amount, receiver) {
+    try {
+      if (!userAddress) {
+        throw new Error("User address is required");
+      }
+      if (!isSupportedChain(chainId)) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+      }
+      const walletClient = this.getWalletClient();
+      const chainConfig = getChainConfig(chainId);
+      const safeAddress = await getDeterministicSafeAddress({
+        owner: walletClient,
+        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,
+          receiver: receiver || userAddress
+        });
+      } else {
+        response = await this.httpClient.get(ENDPOINTS.USER_WITHDRAW, {
+          params: { chainId }
+        });
+      }
+      const success = response?.success ?? true;
+      return {
+        success,
+        txHash: response?.txHash || response?.transactionHash || "pending",
+        type: amount ? "partial" : "full",
+        amount: amount || "all",
+        receiver: receiver || userAddress,
+        status: success ? "pending" : "failed"
+      };
+    } 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(42161);
+   * 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 arbPositions = await sdk.getPositions(userAddress, 42161);
+   * ```
+   */
+  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 walletClient = this.getWalletClient(chainId);
+      const chainConfig = getChainConfig(chainId ?? 8453);
+      const safeAddress = await getDeterministicSafeAddress({
+        owner: walletClient,
+        safeOwnerAddress: userAddress,
+        chain: chainConfig.chain,
+        publicClient: chainConfig.publicClient
+      });
+      const response = await this.httpClient.get(
+        ENDPOINTS.DATA_POSITION(safeAddress)
+      );
+      return {
+        success: true,
+        userAddress,
+        totalValueUsd: 0,
+        // API doesn't return this yet
+        positions: response ? [response] : []
+      };
+    } 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() {
+    try {
+      await this.authenticateUser();
+      const response = await this.httpClient.get(ENDPOINTS.USER_ME);
+      return {
+        success: true,
+        user: {
+          id: response.id,
+          address: response.address,
+          smartWallet: response.smartWallet,
+          chains: response.chains || [],
+          protocols: response.protocols || [],
+          hasActiveSessionKey: response.hasActiveSessionKey || false,
+          email: response.email,
+          strategy: response.strategy,
+          telegramId: response.telegramId,
+          walletType: response.walletType,
+          autoSelectProtocols: response.autoSelectProtocols || false,
+          autocompounding: response.autocompounding,
+          omniAccount: response.omniAccount,
+          crosschainStrategy: response.crosschainStrategy,
+          agentName: response.agentName,
+          customization: response.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.totalTvl || response.tvl || 0,
+        byChain: response.byChain
+      };
+    } catch (error) {
+      throw new Error(`Failed to get TVL: ${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() {
+    try {
+      const response = await this.httpClient.get(ENDPOINTS.DATA_VOLUME);
+      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.getSmartWalletsByEOA("0x...");
+   * console.log("Smart wallets:", result.smartWallets);
+   * ```
+   */
+  async getSmartWalletsByEOA(eoaAddress) {
+    try {
+      if (!eoaAddress) {
+        throw new Error("EOA address is required");
+      }
+      const response = await this.httpClient.get(
+        ENDPOINTS.DATA_BY_EOA(eoaAddress)
+      );
+      const smartWallets = Array.isArray(response) ? response : response.smartWallets || [response.smartWallet].filter(Boolean);
+      return {
+        success: true,
+        eoa: eoaAddress,
+        smartWallets
+      };
+    } 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);
+      return {
+        success: true,
+        walletAddress,
+        data: response.data || [],
+        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 including total, current, and lifetime
+   *
+   * @example
+   * ```typescript
+   * const earnings = await sdk.getOnchainEarnings("0x...");
+   * console.log("Total earnings:", earnings.data.totalEarnings);
+   * ```
+   */
+  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,
+          totalEarnings: response.total_earnings || response.totalEarnings || 0,
+          currentEarnings: response.current_earnings || response.currentEarnings || 0,
+          lifetimeEarnings: response.lifetime_earnings || response.lifetimeEarnings || 0,
+          unrealizedEarnings: response.unrealized_earnings,
+          currentEarningsByChain: response.current_earnings_by_chain,
+          unrealizedEarningsByChain: response.unrealized_earnings_by_chain,
+          lastCheckTimestamp: response.last_check_timestamp
+        }
+      };
+    } 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
+   *
+   * @example
+   * ```typescript
+   * const earnings = await sdk.calculateOnchainEarnings("0x...");
+   * console.log("Calculated earnings:", earnings.data.totalEarnings);
+   * ```
+   */
+  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,
+          totalEarnings: data.total_earnings || data.totalEarnings || 0,
+          currentEarnings: data.current_earnings || data.currentEarnings || 0,
+          lifetimeEarnings: data.lifetime_earnings || data.lifetimeEarnings || 0,
+          unrealizedEarnings: data.unrealized_earnings,
+          lastCheckTimestamp: data.last_check_timestamp
+        }
+      };
+    } 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.date, d.earnings));
+   * ```
+   */
+  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)
+      );
+      return {
+        success: true,
+        walletAddress,
+        data: response.data || [],
+        count: response.count || 0,
+        filters: {
+          startDate: startDate || null,
+          endDate: endDate || null
+        }
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get daily earnings: ${error.message}`
+      );
+    }
+  }
+  // ============================================================================
+  // Portfolio Methods (Data API v2)
+  // ============================================================================
+  /**
+   * Get Debank portfolio for a wallet across multiple chains
+   * Note: This is a paid endpoint and may require authorization
+   *
+   * @param walletAddress - Smart wallet address
+   * @returns Multi-chain portfolio data
+   *
+   * @example
+   * ```typescript
+   * const portfolio = await sdk.getDebankPortfolio("0x...");
+   * console.log("Total value:", portfolio.totalValueUsd);
+   * ```
+   */
+  async getDebankPortfolio(walletAddress) {
+    try {
+      if (!walletAddress) {
+        throw new Error("Wallet address is required");
+      }
+      const response = await this.httpClient.dataGet(
+        DATA_ENDPOINTS.DEBANK_PORTFOLIO_MULTICHAIN(walletAddress)
+      );
+      const data = response.data || response;
+      return {
+        success: true,
+        walletAddress,
+        totalValueUsd: data.totalValueUsd || 0,
+        chains: data.chains || data
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get Debank portfolio: ${error.message}`
+      );
+    }
+  }
+  // ============================================================================
+  // Opportunities Methods (Data API v2)
+  // ============================================================================
+  /**
+   * Get safe (low-risk) yield opportunities
+   *
+   * @param chainId - Optional chain ID filter
+   * @returns List of safe yield opportunities
+   *
+   * @example
+   * ```typescript
+   * const opportunities = await sdk.getSafeOpportunities(8453);
+   * opportunities.data.forEach(o => console.log(o.protocolName, o.apy));
+   * ```
+   */
+  async getSafeOpportunities(chainId) {
+    try {
+      const response = await this.httpClient.dataGet(
+        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId)
+      );
+      const data = response.data || response || [];
+      return {
+        success: true,
+        chainId,
+        strategyType: "safe",
+        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.apy || o.pool_apy || 0,
+          tvl: o.tvl || o.zyfiTvl,
+          asset: o.asset || o.underlying_token,
+          risk: o.risk,
+          strategyType: "safe",
+          status: o.status
+        })) : []
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get safe opportunities: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get degen (high-risk, high-reward) yield strategies
+   *
+   * @param chainId - Optional chain ID filter
+   * @returns List of degen strategies
+   *
+   * @example
+   * ```typescript
+   * const strategies = await sdk.getDegenStrategies(8453);
+   * strategies.data.forEach(s => console.log(s.protocolName, s.apy));
+   * ```
+   */
+  async getDegenStrategies(chainId) {
+    try {
+      const response = await this.httpClient.dataGet(
+        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId)
+      );
+      const data = response.data || response || [];
+      return {
+        success: true,
+        chainId,
+        strategyType: "degen",
+        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.apy || o.pool_apy || 0,
+          tvl: o.tvl || o.zyfiTvl,
+          asset: o.asset || o.underlying_token,
+          risk: o.risk,
+          strategyType: "degen",
+          status: o.status
+        })) : []
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get degen strategies: ${error.message}`
+      );
+    }
+  }
+  // ============================================================================
+  // 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 weighted averages
+   *
+   * @example
+   * ```typescript
+   * const apyHistory = await sdk.getDailyApyHistory("0x...", "30D");
+   * console.log("Average APY:", apyHistory.averageWeightedApy);
+   * ```
+   */
+  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,
+        averageWeightedApy: data.average_final_weighted_apy_after_fee || data.averageWeightedApy || 0
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get daily APY history: ${error.message}`
+      );
+    }
+  }
+  // ============================================================================
+  // Rebalance Methods
+  // ============================================================================
+  /**
+   * Get rebalance information
+   * Shows yield generated by rebalancing strategies
+   *
+   * @param isCrossChain - Filter by cross-chain or same-chain rebalances
+   * @returns List of rebalance events
+   *
+   * @example
+   * ```typescript
+   * // Get same-chain rebalance info
+   * const rebalances = await sdk.getRebalanceInfo(false);
+   * console.log("Rebalance count:", rebalances.count);
+   * ```
+   */
+  async getRebalanceInfo(isCrossChain) {
+    try {
+      const response = await this.httpClient.dataGet(
+        DATA_ENDPOINTS.REBALANCE_INFO(isCrossChain)
+      );
+      const data = response.data || response || [];
+      return {
+        success: true,
+        data: Array.isArray(data) ? data.map((r) => ({
+          id: r.id,
+          timestamp: r.timestamp || r.created_at,
+          fromProtocol: r.from_protocol || r.fromProtocol,
+          toProtocol: r.to_protocol || r.toProtocol,
+          fromPool: r.from_pool || r.fromPool,
+          toPool: r.to_pool || r.toPool,
+          amount: r.amount,
+          isCrossChain: r.is_cross_chain ?? r.isCrossChain ?? false,
+          fromChainId: r.from_chain_id || r.fromChainId,
+          toChainId: r.to_chain_id || r.toChainId
+        })) : [],
+        count: data.length
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get rebalance info: ${error.message}`
+      );
+    }
+  }
+  /**
+   * 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}`
+      );
+    }
+  }
+};
+export {
+  ZyfaiSDK,
+  getChainConfig,
+  getSupportedChainIds,
+  isSupportedChain
+};