@elizaos/plugin-wallet 2.0.0-beta.1 → 2.0.3-beta.6

package/dist/analytics/lpinfo/kamino/services/kaminoLiquidityService.d.ts

@@ -0,0 +1,203 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { Service } from "@elizaos/core";
+export interface KaminoStrategy {
+    address: string;
+    strategyType: string;
+    estimatedTvl: number;
+    volume24h: number;
+    apy: number;
+    tokenA: string;
+    tokenB: string;
+    feeTier: string;
+    rebalancing: string;
+    lastRebalance: string;
+    positions: KaminoPosition[];
+    detailedInfo?: {
+        creationDate: string;
+        totalDeposits: number;
+        totalWithdrawals: number;
+        activeUsers: number;
+        performanceHistory: Array<{
+            date: string;
+            apy: number;
+        }>;
+    };
+}
+export interface KaminoPosition {
+    type: string;
+    range: string;
+    liquidity: number;
+    feesEarned: number;
+}
+export interface TokenLiquidityStats {
+    tokenIdentifier: string;
+    normalizedToken: string;
+    tokenName: string;
+    timestamp: string;
+    strategies: KaminoStrategy[];
+    totalTvl: number;
+    totalVolume: number;
+    apyRange: {
+        min: number;
+        max: number;
+    };
+    poolCount: number;
+}
+export interface TokenInfo {
+    name: string;
+    symbol: string;
+    address: string;
+    price?: number;
+    liquidity?: number;
+    decimals?: number;
+    marketCap?: number;
+    volume24h?: number;
+    priceChange24h?: number;
+}
+interface KaminoMarketStatistics {
+    timestamp: string;
+    stakingYields: {
+        total: number;
+        averageApy: number;
+        maxApy: number;
+        minApy: number;
+    };
+    medianYields: {
+        total: number;
+        averageApy: number;
+    };
+    limoTrades: {
+        total: number;
+        totalVolume: number;
+        averageTip: number;
+        averageSurplus: number;
+    };
+}
+export interface KaminoPoolInfoWithStrategy {
+    address: string;
+    strategy: KaminoStrategy;
+    tokenInfo: TokenInfo | null;
+    timestamp: string;
+    metrics: {
+        totalValueLocked: number;
+        volume24h: number;
+        apy: number;
+        feeTier: string;
+        rebalancing: string;
+        lastRebalance: string;
+        positionCount: number;
+    };
+}
+export interface KaminoPoolInfoTokenFallback {
+    address: string;
+    tokenInfo: TokenInfo;
+    timestamp: string;
+    note: string;
+}
+export type KaminoPoolByAddressResult = KaminoPoolInfoWithStrategy | KaminoPoolInfoTokenFallback | null;
+interface KaminoLiquidityConnectionTest {
+    apiBaseUrl: string;
+    programId: string;
+    rpcEndpoint: string;
+    connectionTest: boolean;
+    stakingYieldsTest: boolean;
+    limoTradesTest: boolean;
+    strategyCount: number;
+    timestamp: string;
+}
+interface StakingYield {
+    apy: string;
+    tokenMint: string;
+}
+interface LimoTrade {
+    updatedOn: string;
+    inMint: string;
+    outMint: string;
+    sizeUsd: string;
+    tipAmountUsd: string;
+    surplusUsd: string;
+    order: string;
+}
+/**
+ * Kamino Liquidity Protocol Service
+ * Handles interactions with Kamino liquidity protocol using the official API
+ */
+export declare class KaminoLiquidityService extends Service {
+    private isRunning;
+    private apiBaseUrl;
+    static serviceType: string;
+    static serviceName: string;
+    capabilityDescription: "Provides detailed access to Kamino liquidity protocol pools and strategies for specific tokens via the official API.";
+    constructor(runtime?: IAgentRuntime);
+    /**
+     * Make a rate-limited API request to Kamino
+     */
+    private makeApiRequest;
+    /**
+     * Resolve token information using Birdeye API
+     */
+    resolveTokenWithBirdeye(tokenIdentifier: string): Promise<TokenInfo | null>;
+    /**
+     * Get staking yields for tokens
+     */
+    getStakingYields(): Promise<StakingYield[]>;
+    /**
+     * Get median staking yields
+     */
+    getMedianStakingYields(): Promise<StakingYield[]>;
+    /**
+     * Get Limo trades for a specific token pair
+     */
+    getLimoTrades(inTokenMint?: string, outTokenMint?: string): Promise<LimoTrade[]>;
+    /**
+     * Get real-time market statistics from Kamino API
+     */
+    getMarketStatistics(): Promise<KaminoMarketStatistics | null>;
+    /**
+     * Get all available Kamino strategies (not filtered by token)
+     */
+    getAllStrategies(): Promise<KaminoStrategy[]>;
+    /**
+     * Get a specific strategy by its address
+     */
+    getStrategyByAddress(strategyAddress: string): Promise<KaminoStrategy | null>;
+    /**
+     * Get detailed pool information by pool address
+     */
+    getPoolByAddress(poolAddress: string): Promise<KaminoPoolByAddressResult>;
+    /**
+     * Get token liquidity information from Kamino
+     */
+    getTokenLiquidityStats(tokenIdentifier: string): Promise<TokenLiquidityStats>;
+    /**
+     * Calculate APY for Limo trading strategy using real API data
+     */
+    private calculateLimoApy;
+    /**
+     * Calculate fee tier for Limo trading strategy based on real market data
+     */
+    private calculateLimoFeeTier;
+    /**
+     * Determine rebalancing strategy based on real market data and trade patterns
+     */
+    private determineRebalancingStrategy;
+    /**
+     * Determine trading range based on trade data
+     */
+    private determineTradingRange;
+    /**
+     * Normalize token identifier (handle symbols, addresses, etc.)
+     */
+    normalizeTokenIdentifier(identifier: string): string;
+    /**
+     * Test connection and basic functionality
+     */
+    testConnection(): Promise<KaminoLiquidityConnectionTest>;
+    static create(runtime: IAgentRuntime): Promise<KaminoLiquidityService>;
+    static start(runtime: IAgentRuntime): Promise<KaminoLiquidityService>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isServiceRunning(): boolean;
+}
+export {};

package/dist/analytics/lpinfo/kamino/services/kaminoService.d.ts

@@ -0,0 +1,171 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { Service } from "@elizaos/core";
+interface KaminoUserMarketRef {
+    address: string;
+    discovered: boolean;
+}
+export interface KaminoUserPosition {
+    token?: string;
+    amount?: number;
+    value?: number;
+    apy?: number;
+    market?: string;
+}
+interface KaminoUserPositionsOk {
+    lending: KaminoUserPosition[];
+    borrowing: KaminoUserPosition[];
+    totalValue: number;
+    markets: KaminoUserMarketRef[];
+    userAccounts: number;
+    walletAddress: string;
+}
+interface KaminoUserPositionsErr {
+    lending: KaminoUserPosition[];
+    borrowing: KaminoUserPosition[];
+    totalValue: number;
+    error: string;
+}
+export type KaminoUserPositions = KaminoUserPositionsOk | KaminoUserPositionsErr;
+export interface KaminoMarketOverviewRow {
+    address: string;
+    marketName: string;
+    dataSize: number;
+    lamports: number;
+    owner: string;
+    executable: boolean;
+}
+interface KaminoMarketOverviewOk {
+    totalMarkets: number;
+    totalTvl: number;
+    totalBorrowed: number;
+    markets: KaminoMarketOverviewRow[];
+    programId: string;
+    multisig: string;
+    stakingYields?: number;
+    avgApy?: number;
+    maxApy?: number;
+    minApy?: number;
+    totalVolume?: number;
+    limoTrades?: number;
+}
+interface KaminoMarketOverviewErr {
+    totalMarkets: number;
+    totalTvl: number;
+    totalBorrowed: number;
+    markets: KaminoMarketOverviewRow[];
+    error: string;
+}
+type KaminoMarketOverview = KaminoMarketOverviewOk | KaminoMarketOverviewErr;
+export interface KaminoReserve {
+    market: string;
+    marketName: string;
+    dataSize: number;
+    lamports: number;
+    owner: string;
+    supplyApy: number;
+    borrowApy: number;
+    totalSupply: number;
+    totalBorrow: number;
+    utilization: number;
+}
+interface KaminoProgramInfo {
+    programId: string;
+    multisig: string;
+    dataSize: number;
+    lamports: number;
+    owner: string;
+    executable: boolean;
+    rentEpoch: number;
+}
+interface KaminoConnectionTestResult {
+    apiBaseUrl: string;
+    programId: string;
+    connectionTest: boolean;
+    stakingYieldsTest: boolean;
+    limoTradesTest: boolean;
+    marketCount: number;
+    timestamp: string;
+}
+/**
+ * Kamino Lending Protocol Service
+ * Handles interactions with Kamino lending protocol using the official API
+ */
+export declare class KaminoService extends Service {
+    private isRunning;
+    private apiBaseUrl;
+    static serviceType: string;
+    static serviceName: string;
+    capabilityDescription: "Provides standardized access to Kamino lending protocol via the official API.";
+    constructor(runtime?: IAgentRuntime);
+    /**
+     * Make a rate-limited API request to Kamino
+     */
+    private makeApiRequest;
+    /**
+     * Get all user positions (lending and borrowing) for a wallet address
+     */
+    getUserPositions(walletAddress: string): Promise<KaminoUserPositions>;
+    /**
+     * Discover all Kamino markets by querying available API endpoints
+     */
+    discoverMarkets(): Promise<string[]>;
+    /**
+     * Get market overview and statistics
+     */
+    getMarketOverview(): Promise<KaminoMarketOverview>;
+    /**
+     * Get available reserves for lending/borrowing
+     */
+    getAvailableReserves(): Promise<KaminoReserve[]>;
+    /**
+     * Get program account info for debugging
+     */
+    getProgramInfo(): Promise<KaminoProgramInfo>;
+    /**
+     * Calculate borrow APY based on supply APY
+     */
+    private calculateBorrowApy;
+    /**
+     * Estimate total supply based on staking yield data
+     */
+    private estimateTotalSupply;
+    /**
+     * Estimate total borrow based on staking yield data
+     */
+    private estimateTotalBorrow;
+    /**
+     * Calculate utilization rate based on staking yield data
+     */
+    private calculateUtilization;
+    /**
+     * Calculate Limo supply APY based on real market data
+     */
+    private calculateLimoSupplyApy;
+    /**
+     * Calculate Limo borrow APY based on trade data
+     */
+    private calculateLimoBorrowApy;
+    /**
+     * Estimate Limo borrow amount based on trade data
+     */
+    private estimateLimoBorrow;
+    /**
+     * Calculate Limo utilization rate based on trade data
+     */
+    private calculateLimoUtilization;
+    /**
+     * Estimate TVL from APY using real market data patterns
+     */
+    private estimateTvlFromApy;
+    /**
+     * Test connection and basic functionality
+     */
+    testConnection(): Promise<KaminoConnectionTestResult>;
+    static create(runtime: IAgentRuntime): Promise<KaminoService>;
+    static start(runtime: IAgentRuntime): Promise<KaminoService>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isServiceRunning(): boolean;
+}
+export {};

package/dist/analytics/lpinfo/steer/index.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@elizaos/core";
+/**
+ * Steer Finance Protocol Plugin
+ * Provides comprehensive access to Steer Finance vaults and staking pools
+ */
+export declare const steerPlugin: Plugin;
+export default steerPlugin;

package/dist/analytics/lpinfo/steer/providers/steerLiquidityProvider.d.ts

@@ -0,0 +1,6 @@
+import type { Provider } from "@elizaos/core";
+/**
+ * Steer Finance Liquidity Protocol Provider
+ * Provides information about Steer Finance vaults and staking pools
+ */
+export declare const steerLiquidityProvider: Provider;

package/dist/analytics/lpinfo/steer/services/steerLiquidityService.d.ts

@@ -0,0 +1,208 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { Service } from "@elizaos/core";
+import type { StakingPool } from "@steerprotocol/sdk";
+import { StakingClient, VaultClient } from "@steerprotocol/sdk";
+import type { SteerStakingPoolDetailInput, SteerVaultDetailInput } from "../steer-display-types.js";
+type SteerEarnedRewardsResult = Awaited<ReturnType<StakingClient["earned"]>>;
+type SteerStakingSupplyResult = Awaited<ReturnType<StakingClient["totalSupply"]>>;
+type SteerStakingBalanceResult = Awaited<ReturnType<StakingClient["balanceOf"]>>;
+type SteerPreviewDepositResult = Awaited<ReturnType<VaultClient["previewSingleAssetDeposit"]>>;
+type SteerSingleDepositResult = Awaited<ReturnType<VaultClient["singleAssetDeposit"]>>;
+interface TokenLiquidityStats {
+    tokenIdentifier: string;
+    normalizedToken: string;
+    tokenName: string;
+    timestamp: string;
+    vaults: SteerVaultDetailInput[];
+    stakingPools: SteerStakingPoolDetailInput[];
+    totalTvl: number;
+    totalVolume: number;
+    apyRange: {
+        min: number;
+        max: number;
+    };
+    vaultCount: number;
+    stakingPoolCount: number;
+}
+interface ConnectionTestResult {
+    connectionTest: boolean;
+    supportedChains: number[];
+    vaultCount: number;
+    stakingPoolCount: number;
+    error?: string;
+}
+interface GraphQLVaultData {
+    id: string;
+    name: string;
+    token0: string;
+    token1: string;
+    pool: string;
+    weeklyFeeAPR: string;
+    token0Symbol: string;
+    token0Decimals: string;
+    token1Symbol: string;
+    token1Decimals: string;
+    token0Balance: string;
+    token1Balance: string;
+    totalLPTokensIssued: string;
+    feeTier: string;
+    fees0: string;
+    fees1: string;
+    strategyToken: {
+        id: string;
+        name: string;
+        creator: {
+            id: string;
+        };
+        admin: string;
+        executionBundle: string;
+    };
+    beaconName: string;
+    payloadIpfs: string;
+    deployer: string;
+}
+/**
+ * Steer Finance Liquidity Protocol Service
+ * Handles interactions with Steer Finance protocol using the official SDK
+ */
+export declare class SteerLiquidityService extends Service {
+    private isRunning;
+    private supportedChains;
+    private vaultClients;
+    private stakingClients;
+    private cache;
+    private readonly CACHE_TTL;
+    static serviceType: string;
+    static serviceName: string;
+    capabilityDescription: "Provides detailed access to Steer Finance vaults and staking pools for specific tokens using the official SDK.";
+    constructor(runtime?: IAgentRuntime);
+    /**
+     * Get the appropriate Viem chain object for a given chain ID
+     */
+    private getViemChain;
+    /**
+     * Initialize vault and staking clients for each supported chain
+     */
+    private initializeChainClients;
+    /**
+     * Get token liquidity information from Steer Finance across all supported chains or a specific chain
+     */
+    getTokenLiquidityStats(tokenIdentifier: string, targetChainId?: number | null): Promise<TokenLiquidityStats>;
+    /**
+     * Get all vaults for a specific chain using the SDK
+     */
+    private getAllVaultsForChain;
+    /**
+     * Get vaults for a specific token on a specific chain using SDK
+     */
+    private getVaultsForToken;
+    /**
+     * Check if a vault contains a specific token
+     */
+    private vaultContainsToken;
+    /**
+     * Process vault data from SDK response
+     */
+    private processVaultData;
+    /**
+     * Get vault details by address using GraphQL (preferred) or SDK fallback
+     */
+    getVaultDetails(vaultAddress: string, chainId: number): Promise<SteerVaultDetailInput | null>;
+    /**
+     * Get vault details by address using SDK (fallback method)
+     */
+    private getVaultDetailsFromSDK;
+    /**
+     * Get token prices for TVL calculation
+     */
+    getTokenPrices(_tokenAddresses: string[], chainId: number): Promise<{
+        [address: string]: number;
+    } | null>;
+    /**
+     * Get pool data including TVL, volume, and fee information
+     */
+    getPoolData(poolAddress: string, chainId: number): Promise<{
+        tvl: number;
+        volume24h: number;
+        fee: number;
+        liquidity: number;
+    } | null>;
+    /**
+     * Get staking pool details by address using SDK
+     */
+    getStakingPoolDetails(poolAddress: string, chainId: number): Promise<StakingPool | null>;
+    /**
+     * Test GraphQL connection specifically
+     */
+    testGraphQLConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Test GraphQL vault query with a specific vault address
+     */
+    testGraphQLVaultQuery(vaultAddress: string): Promise<{
+        success: boolean;
+        data?: GraphQLVaultData;
+        error?: string;
+    }>;
+    /**
+     * Test connection to Steer Finance services using SDK
+     */
+    testConnection(): Promise<ConnectionTestResult>;
+    /**
+     * Normalize token identifier (handle different formats)
+     */
+    private normalizeTokenIdentifier;
+    /**
+     * Get token name from identifier
+     */
+    private getTokenName;
+    /**
+     * Get chain name from chain ID
+     */
+    private getChainName;
+    /**
+     * Clear expired cache entries
+     */
+    private clearExpiredCache;
+    static create(runtime: IAgentRuntime): Promise<SteerLiquidityService>;
+    static start(runtime: IAgentRuntime): Promise<SteerLiquidityService>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isServiceRunning(): boolean;
+    /**
+     * Preview single-asset deposit for a vault using SDK
+     */
+    previewSingleAssetDeposit(vaultAddress: string, chainId: number, assets: bigint, isToken0: boolean, depositSlippagePercent?: bigint, swapSlippageBP?: number): Promise<SteerPreviewDepositResult>;
+    /**
+     * Execute single-asset deposit for a vault using SDK
+     */
+    executeSingleAssetDeposit(vaultAddress: string, chainId: number, assets: bigint, receiver: string, isToken0: boolean, depositSlippagePercent?: bigint, swapSlippageBP?: number): Promise<SteerSingleDepositResult>;
+    /**
+     * Get earned rewards for a staking pool using SDK
+     */
+    getEarnedRewards(poolAddress: string, accountAddress: string, chainId: number): Promise<SteerEarnedRewardsResult>;
+    /**
+     * Get total supply of a staking pool using SDK
+     */
+    getStakingPoolTotalSupply(poolAddress: string, chainId: number): Promise<SteerStakingSupplyResult>;
+    /**
+     * Get balance of a user in a staking pool using SDK
+     */
+    getStakingPoolBalance(poolAddress: string, accountAddress: string, chainId: number): Promise<SteerStakingBalanceResult>;
+    /**
+     * Fetch detailed vault data from Steer Protocol GraphQL subgraph
+     */
+    getVaultDataFromGraphQL(vaultAddress: string): Promise<GraphQLVaultData | null>;
+    /**
+     * Enrich vault data with GraphQL information
+     */
+    enrichVaultWithGraphQLData(vault: SteerVaultDetailInput, _chainId: number): Promise<SteerVaultDetailInput>;
+    /**
+     * Calculate TVL from token balances using LP tokens as proxy
+     */
+    private calculateTvlFromBalances;
+}
+export {};

package/dist/analytics/lpinfo/steer/steer-display-types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Display-layer shapes for Steer vaults/pools rendered in steerLiquidityProvider.
+ * These mirror the enriched objects built in SteerLiquidityService.
+ */
+export interface SteerGraphqlTokenRef {
+    name: string;
+    creator: {
+        id: string;
+    };
+    admin: string;
+    executionBundle?: string;
+}
+export interface SteerGraphqlEnrichment {
+    weeklyFeeAPR: number;
+    token0Symbol: string;
+    token0Decimals: number;
+    token1Symbol: string;
+    token1Decimals: number;
+    token0Balance: string;
+    token1Balance: string;
+    totalLPTokensIssued: string;
+    feeTier: number;
+    fees0: string;
+    fees1: string;
+    strategyToken?: SteerGraphqlTokenRef;
+    beaconName: string;
+    payloadIpfs: string;
+    deployer: string;
+}
+export interface SteerVaultPositionRow {
+    type: string;
+    range: string;
+    liquidity: number;
+}
+/** Token slot may be raw address string or `{ address?: string }` */
+export type SteerVaultTokenSide = string | {
+    address?: string;
+};
+export interface SteerVaultDetailInput {
+    address: string;
+    /** Present on some SDK responses alongside `address` */
+    vaultAddress?: string;
+    name: string;
+    chainId: number;
+    tvl: number;
+    volume24h: number;
+    apy: number;
+    strategyType: string;
+    fee: number;
+    createdAt: number;
+    isActive: boolean;
+    token0?: SteerVaultTokenSide | "Unknown";
+    token1?: SteerVaultTokenSide | "Unknown";
+    graphqlData?: SteerGraphqlEnrichment;
+    calculatedTvl?: number;
+    positions?: SteerVaultPositionRow[];
+    /** Present on some SDK/GraphQL paths for downstream transactions */
+    poolAddress?: string;
+    singleAssetDepositContract?: `0x${string}`;
+    weeklyFeeAPR?: number;
+    /** Flattened GraphQL fields sometimes attached on `getVaultDetails` results */
+    token0Symbol?: string;
+    token1Symbol?: string;
+    token0Balance?: string;
+    token1Balance?: string;
+    totalLPTokensIssued?: string;
+    feeTier?: number;
+    fees0?: string;
+    fees1?: string;
+    strategyToken?: SteerGraphqlTokenRef;
+    beaconName?: string;
+    deployer?: string;
+    /** Extra SDK fields merged in `processVaultData` */
+    ammType?: string | number;
+    protocol?: string;
+    protocolBaseType?: string;
+    targetProtocol?: string;
+    apr?: number;
+    apr1d?: number;
+    apr7d?: number;
+    apr14d?: number;
+    feeApr?: number;
+    stakingApr?: number;
+    merklApr?: number;
+}
+export interface SteerStakingPoolDetailInput {
+    address: string;
+    name: string;
+    chainId: number;
+    totalStakedUSD: number;
+    apr: number;
+    stakingToken: string;
+    rewardToken: string;
+    rewardRate: number;
+    periodFinish: number;
+    isActive: boolean;
+}