@zyfai/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,769 @@
+import { Chain, PublicClient } from 'viem';
+
+/**
+ * ZyFAI SDK Types
+ */
+type Address = `0x${string}`;
+type Hex = `0x${string}`;
+type Environment = "staging" | "production";
+interface SDKConfig {
+    /** API key for the Execution API (Utkir's backend) */
+    apiKey: string;
+    /** API key for the Data API (Sunny's backend) - defaults to apiKey if not provided */
+    dataApiKey?: string;
+    /** Environment: 'staging' or 'production' (default: 'production') */
+    environment?: Environment;
+    /** Bundler API key for Safe deployment (e.g., Pimlico) */
+    bundlerApiKey?: string;
+}
+interface DeploySafeResponse {
+    success: boolean;
+    safeAddress: Address;
+    txHash: string;
+    status: "deployed" | "failed";
+}
+/** @internal */
+interface UpdateUserProfileRequest {
+    smartWallet?: string;
+    chains?: number[];
+    protocols?: string[];
+    autoSelectProtocols?: boolean;
+}
+/** @internal */
+interface UpdateUserProfileResponse {
+    success: boolean;
+    userId: string;
+    smartWallet?: Address;
+    chains?: number[];
+}
+/** @internal */
+interface AddSessionKeyResponse {
+    id: string;
+    hash: string;
+    signer: string;
+    nonces: number[];
+    expiresAt: string;
+    txHash?: string;
+    isActive: boolean;
+    isEnabled: boolean;
+    permissionId?: string;
+    permissionEnableHash?: string;
+    customHash?: string;
+}
+interface SessionKeyResponse {
+    success: boolean;
+    sessionKeyAddress: Address;
+    signature: Hex;
+    sessionNonces?: bigint[];
+    userId?: string;
+    sessionActivation?: AddSessionKeyResponse;
+}
+interface SmartWalletResponse {
+    address: Address;
+    isDeployed: boolean;
+}
+interface Protocol {
+    id: string;
+    name: string;
+    type: string;
+    description?: string;
+    imageUrl?: string;
+    website?: string;
+    strategies?: string[];
+    chains: number[];
+    pools?: Pool[];
+}
+interface Pool {
+    id: string;
+    name: string;
+    asset: string;
+    apy?: number;
+    tvl?: string;
+}
+interface ProtocolsResponse {
+    success: boolean;
+    chainId: number;
+    protocols: Protocol[];
+}
+interface Position {
+    id?: string;
+    chain?: string;
+    strategy?: string;
+    smartWallet?: Address;
+    positions: PositionSlot[];
+    hasActiveSessionKey?: boolean;
+    hasBalance?: boolean;
+    crosschainStrategy?: boolean;
+}
+interface PositionSlot {
+    chain?: string;
+    protocol_id?: string;
+    protocol_name?: string;
+    pool?: string;
+    token_id?: string;
+    token_symbol?: string;
+    token_icon?: string;
+    amount?: string;
+    underlyingAmount?: string;
+    pool_apy?: number;
+    pool_tvl?: string;
+}
+interface PositionsResponse {
+    success: boolean;
+    userAddress: string;
+    totalValueUsd: number;
+    positions: Position[];
+}
+interface UserDetails {
+    id: string;
+    address: string;
+    smartWallet: string;
+    chains: number[];
+    protocols: Protocol[];
+    hasActiveSessionKey: boolean;
+    email?: string;
+    strategy?: string;
+    telegramId?: string;
+    walletType?: string;
+    autoSelectProtocols: boolean;
+    autocompounding?: boolean;
+    omniAccount?: boolean;
+    crosschainStrategy?: boolean;
+    agentName?: string;
+    customization?: Record<string, string[]>;
+}
+interface UserDetailsResponse {
+    success: boolean;
+    user: UserDetails;
+}
+interface TVLResponse {
+    success: boolean;
+    totalTvl: number;
+    byChain?: Record<string, number>;
+}
+interface VolumeResponse {
+    success: boolean;
+    volumeInUSD: string;
+}
+interface ActiveWallet {
+    smartWallet: string;
+    chains: number[];
+    hasBalance: boolean;
+}
+interface ActiveWalletsResponse {
+    success: boolean;
+    chainId: number;
+    wallets: ActiveWallet[];
+    count: number;
+}
+interface SmartWalletsByEOAResponse {
+    success: boolean;
+    eoa: string;
+    smartWallets: string[];
+}
+interface FirstTopupResponse {
+    success: boolean;
+    walletAddress: string;
+    date: string;
+    amount?: string;
+    chainId?: number;
+}
+interface HistoryEntry {
+    id?: string;
+    timestamp: string;
+    type: string;
+    amount: string;
+    token?: string;
+    txHash?: string;
+    chainId?: number;
+    protocol?: string;
+    pool?: string;
+}
+interface HistoryResponse {
+    success: boolean;
+    walletAddress: string;
+    data: HistoryEntry[];
+    total: number;
+}
+interface OnchainEarnings {
+    walletAddress: string;
+    totalEarnings: number;
+    currentEarnings: number;
+    lifetimeEarnings: number;
+    unrealizedEarnings?: number;
+    currentEarningsByChain?: Record<string, number>;
+    unrealizedEarningsByChain?: Record<string, number>;
+    lastCheckTimestamp?: string;
+}
+interface OnchainEarningsResponse {
+    success: boolean;
+    data: OnchainEarnings;
+}
+interface DailyEarning {
+    date: string;
+    earnings: number;
+    balance?: number;
+    apy?: number;
+}
+interface DailyEarningsResponse {
+    success: boolean;
+    walletAddress: string;
+    data: DailyEarning[];
+    count: number;
+    filters: {
+        startDate: string | null;
+        endDate: string | null;
+    };
+}
+interface PortfolioToken {
+    symbol: string;
+    amount: number;
+    valueUsd: number;
+    price?: number;
+}
+interface ChainPortfolio {
+    chainId: number;
+    chainName: string;
+    totalValueUsd: number;
+    tokens: PortfolioToken[];
+}
+interface DebankPortfolioResponse {
+    success: boolean;
+    walletAddress: string;
+    totalValueUsd: number;
+    chains: Record<string, ChainPortfolio>;
+}
+interface Opportunity {
+    id: string;
+    protocolId: string;
+    protocolName: string;
+    poolName: string;
+    chainId: number;
+    apy: number;
+    tvl?: number;
+    asset?: string;
+    risk?: string;
+    strategyType: "safe" | "degen";
+    status?: string;
+}
+interface OpportunitiesResponse {
+    success: boolean;
+    chainId?: number;
+    strategyType: "safe" | "degen";
+    data: Opportunity[];
+}
+interface DailyApyEntry {
+    date: string;
+    apy: number;
+    weightedApy?: number;
+    balance?: number;
+    protocol?: string;
+    pool?: string;
+}
+interface DailyApyHistoryResponse {
+    success: boolean;
+    walletAddress: string;
+    history: Record<string, DailyApyEntry>;
+    totalDays: number;
+    requestedDays?: number;
+    averageWeightedApy?: number;
+}
+interface RebalanceInfo {
+    id: string;
+    timestamp: string;
+    fromProtocol?: string;
+    toProtocol?: string;
+    fromPool?: string;
+    toPool?: string;
+    amount?: string;
+    isCrossChain: boolean;
+    fromChainId?: number;
+    toChainId?: number;
+}
+interface RebalanceInfoResponse {
+    success: boolean;
+    data: RebalanceInfo[];
+    count: number;
+}
+interface RebalanceFrequencyResponse {
+    success: boolean;
+    walletAddress: string;
+    tier: string;
+    frequency: number;
+    description?: string;
+}
+interface DepositResponse {
+    success: boolean;
+    txHash: string;
+    smartWallet: string;
+    amount: string;
+    status: "pending" | "confirmed" | "failed";
+}
+interface WithdrawResponse {
+    success: boolean;
+    txHash: string;
+    type: "full" | "partial";
+    amount: string;
+    receiver: string;
+    status: "pending" | "confirmed" | "failed";
+}
+interface PolicyData {
+    policy: Address;
+    initData: Hex;
+}
+interface ERC7739Context {
+    appDomainSeparator: Hex;
+    contentName: string[];
+}
+interface ERC7739Data {
+    allowedERC7739Content: ERC7739Context[];
+    erc1271Policies: PolicyData[];
+}
+interface ActionData {
+    actionTargetSelector: Hex;
+    actionTarget: Address;
+    actionPolicies: PolicyData[];
+}
+interface Session {
+    sessionValidator: Address;
+    sessionValidatorInitData: Hex;
+    salt: Hex;
+    userOpPolicies: PolicyData[];
+    erc7739Policies: ERC7739Data;
+    actions: ActionData[];
+    permitERC4337Paymaster: boolean;
+    chainId: bigint;
+}
+
+type SupportedChainId = 8453 | 42161 | 9745;
+interface ChainConfig {
+    chain: Chain;
+    rpcUrl: string;
+    publicClient: PublicClient;
+}
+/**
+ * Get chain configuration for a given chain ID
+ */
+declare const getChainConfig: (chainId: SupportedChainId) => ChainConfig;
+/**
+ * Check if a chain ID is supported
+ */
+declare const isSupportedChain: (chainId: number) => chainId is SupportedChainId;
+/**
+ * Get all supported chain IDs
+ */
+declare const getSupportedChainIds: () => SupportedChainId[];
+
+/**
+ * ZyFAI SDK Main Class
+ */
+
+declare class ZyfaiSDK {
+    private httpClient;
+    private signer;
+    private walletClient;
+    private bundlerApiKey?;
+    private isAuthenticated;
+    private authenticatedUserId;
+    private environment;
+    constructor(config: SDKConfig | string);
+    /**
+     * 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
+     */
+    private authenticateUser;
+    /**
+     * 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],
+     * });
+     * ```
+     */
+    updateUserProfile(request: UpdateUserProfileRequest): Promise<UpdateUserProfileResponse>;
+    /**
+     * 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);
+     */
+    connectAccount(account: string | any, chainId?: SupportedChainId): Promise<Address>;
+    /**
+     * Get wallet client (throws if not connected)
+     * @private
+     */
+    private getWalletClient;
+    /**
+     * 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
+     */
+    getSmartWalletAddress(userAddress: string, chainId: SupportedChainId): Promise<SmartWalletResponse>;
+    /**
+     * 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
+     */
+    deploySafe(userAddress: string, chainId: SupportedChainId): Promise<DeploySafeResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    createSessionKey(userAddress: string, chainId: SupportedChainId): Promise<SessionKeyResponse>;
+    /**
+     * Internal method to sign session key
+     * @private
+     */
+    private signSessionKey;
+    /**
+     * Activate session key via ZyFAI API
+     */
+    private activateSessionKey;
+    /**
+     * Convert session nonces from bigint[] to number[]
+     */
+    private normalizeSessionNonces;
+    /**
+     * 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
+     * );
+     * ```
+     */
+    depositFunds(userAddress: string, chainId: SupportedChainId, tokenAddress: string, amount: string): Promise<DepositResponse>;
+    /**
+     * 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..."
+     * );
+     * ```
+     */
+    withdrawFunds(userAddress: string, chainId: SupportedChainId, amount?: string, receiver?: string): Promise<WithdrawResponse>;
+    /**
+     * 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`);
+     * });
+     * ```
+     */
+    getAvailableProtocols(chainId: SupportedChainId): Promise<ProtocolsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getPositions(userAddress: string, chainId?: SupportedChainId): Promise<PositionsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getUserDetails(): Promise<UserDetailsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getTVL(): Promise<TVLResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getVolume(): Promise<VolumeResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getActiveWallets(chainId: number): Promise<ActiveWalletsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getSmartWalletsByEOA(eoaAddress: string): Promise<SmartWalletsByEOAResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getFirstTopup(walletAddress: string, chainId: number): Promise<FirstTopupResponse>;
+    /**
+     * 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));
+     * ```
+     */
+    getHistory(walletAddress: string, chainId: SupportedChainId, options?: {
+        limit?: number;
+        offset?: number;
+        fromDate?: string;
+        toDate?: string;
+    }): Promise<HistoryResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getOnchainEarnings(walletAddress: string): Promise<OnchainEarningsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    calculateOnchainEarnings(walletAddress: string): Promise<OnchainEarningsResponse>;
+    /**
+     * 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));
+     * ```
+     */
+    getDailyEarnings(walletAddress: string, startDate?: string, endDate?: string): Promise<DailyEarningsResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getDebankPortfolio(walletAddress: string): Promise<DebankPortfolioResponse>;
+    /**
+     * 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));
+     * ```
+     */
+    getSafeOpportunities(chainId?: number): Promise<OpportunitiesResponse>;
+    /**
+     * 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));
+     * ```
+     */
+    getDegenStrategies(chainId?: number): Promise<OpportunitiesResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getDailyApyHistory(walletAddress: string, days?: "7D" | "14D" | "30D"): Promise<DailyApyHistoryResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getRebalanceInfo(isCrossChain?: boolean): Promise<RebalanceInfoResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getRebalanceFrequency(walletAddress: string): Promise<RebalanceFrequencyResponse>;
+}
+
+export { type ActionData, type ActiveWallet, type ActiveWalletsResponse, type Address, type ChainConfig, type ChainPortfolio, type DailyApyEntry, type DailyApyHistoryResponse, type DailyEarning, type DailyEarningsResponse, type DebankPortfolioResponse, type DeploySafeResponse, type DepositResponse, type ERC7739Context, type ERC7739Data, type Environment, type FirstTopupResponse, type Hex, type HistoryEntry, type HistoryResponse, type OnchainEarnings, type OnchainEarningsResponse, type OpportunitiesResponse, type Opportunity, type PolicyData, type Pool, type PortfolioToken, type Position, type PositionSlot, type PositionsResponse, type Protocol, type ProtocolsResponse, type RebalanceFrequencyResponse, type RebalanceInfo, type RebalanceInfoResponse, type SDKConfig, type Session, type SessionKeyResponse, type SmartWalletResponse, type SmartWalletsByEOAResponse, type SupportedChainId, type TVLResponse, type UserDetails, type UserDetailsResponse, type VolumeResponse, type WithdrawResponse, ZyfaiSDK, getChainConfig, getSupportedChainIds, isSupportedChain };