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

package/dist/lp/services/LpManagementService.d.ts

@@ -0,0 +1,116 @@
+import { type IAgentRuntime, type ILpService, type LpPositionDetails, type PoolInfo, Service, type TokenBalance, type TransactionResult } from "@elizaos/core";
+import type { Address } from "viem";
+import type { AddLiquidityConfig, EvmPoolInfo, IEvmLpService, RemoveLiquidityConfig } from "../types.ts";
+export declare const LP_MANAGEMENT_SERVICE_TYPE = "lp-management";
+export type LpProtocolChain = "solana" | "evm";
+export interface LpProtocolRequest {
+    chain?: LpProtocolChain | string;
+    dex?: string;
+    chainId?: number;
+}
+export interface LpListPoolsParams extends LpProtocolRequest {
+    tokenA?: string;
+    tokenB?: string;
+    feeTier?: number;
+}
+export interface LpPositionOperationParams extends LpProtocolRequest {
+    userVault?: object;
+    wallet?: {
+        address: Address;
+        privateKey: `0x${string}`;
+    };
+    owner?: string;
+    pool?: string | PoolInfo | EvmPoolInfo;
+    position?: string;
+    tokenId?: string | bigint;
+    amount?: string | number | bigint | {
+        value?: string | number | bigint;
+        tokenA?: string | number | bigint;
+        tokenB?: string | number | bigint;
+        lpToken?: string | number | bigint;
+        percentage?: number;
+    };
+    amounts?: {
+        tokenA?: string | number | bigint;
+        tokenB?: string | number | bigint;
+        lpToken?: string | number | bigint;
+    };
+    range?: {
+        tickLower?: number;
+        tickUpper?: number;
+        tickLowerIndex?: number;
+        tickUpperIndex?: number;
+        priceLower?: number;
+        priceUpper?: number;
+    };
+    slippageBps?: number;
+    deadline?: bigint;
+}
+export interface LpProtocolProvider {
+    id: string;
+    chain: LpProtocolChain;
+    dex: string;
+    label?: string;
+    service?: unknown;
+    supportedChainIds?: number[];
+    supportsRequest?: (request: LpProtocolRequest) => boolean;
+    listPools(params: LpListPoolsParams): Promise<PoolInfo[]>;
+    openPosition(params: LpPositionOperationParams): Promise<TransactionResult>;
+    closePosition(params: LpPositionOperationParams): Promise<TransactionResult>;
+    repositionPosition?(params: LpPositionOperationParams): Promise<TransactionResult>;
+    getPosition?(params: LpPositionOperationParams): Promise<LpPositionDetails | null>;
+    listPositions?(params: LpPositionOperationParams): Promise<LpPositionDetails[]>;
+    getMarketData?(poolIds: string[]): Promise<Record<string, Partial<PoolInfo>>>;
+}
+type SolanaLpServiceAdapter = Partial<ILpService> & {
+    repositionPosition?(params: LpPositionOperationParams): Promise<TransactionResult>;
+};
+export declare class NoMatchingLpProtocolError extends Error {
+    readonly code = "NO_MATCHING_LP_PROTOCOL";
+    constructor(request: LpProtocolRequest);
+}
+export declare class LpManagementService extends Service implements ILpService {
+    static readonly serviceType = "lp-management";
+    readonly capabilityDescription = "Provides standardized access to DEX liquidity pools.";
+    private protocols;
+    static start(runtime: IAgentRuntime): Promise<LpManagementService>;
+    stop(): Promise<void>;
+    getDexName(): string;
+    registerProtocol(provider: LpProtocolProvider): void;
+    unregisterProtocol(request: LpProtocolRequest): boolean;
+    listProtocols(request?: LpProtocolRequest): LpProtocolProvider[];
+    listPools(params?: LpListPoolsParams): Promise<PoolInfo[]>;
+    openPosition(params: LpPositionOperationParams): Promise<TransactionResult>;
+    closePosition(params: LpPositionOperationParams): Promise<TransactionResult>;
+    repositionPosition(params: LpPositionOperationParams): Promise<TransactionResult>;
+    getPosition(params: LpPositionOperationParams): Promise<LpPositionDetails | null>;
+    listPositions(params?: LpPositionOperationParams): Promise<LpPositionDetails[]>;
+    getPools(tokenAMint?: string, tokenBMint?: string): Promise<PoolInfo[]>;
+    addLiquidity(params: AddLiquidityConfig & {
+        chain?: string;
+    }): Promise<TransactionResult & {
+        lpTokensReceived?: TokenBalance;
+    }>;
+    removeLiquidity(params: RemoveLiquidityConfig & {
+        chain?: string;
+    }): Promise<TransactionResult & {
+        tokensReceived?: TokenBalance[];
+    }>;
+    getLpPositionDetails(userAccountPublicKey: string, poolOrPositionIdentifier: string): Promise<LpPositionDetails | null>;
+    getMarketDataForPools(poolIds: string[]): Promise<Record<string, Partial<PoolInfo>>>;
+    private matchingProtocols;
+    private resolveProtocol;
+}
+export declare function getLpManagementService(runtime: IAgentRuntime): Promise<LpManagementService | null>;
+export declare function registerLpProtocolProvider(runtime: IAgentRuntime, provider: LpProtocolProvider): Promise<void>;
+export declare function createSolanaLpProtocolProvider({ dex, label, service, }: {
+    dex: string;
+    label?: string;
+    service: SolanaLpServiceAdapter;
+}): LpProtocolProvider;
+export declare function createEvmLpProtocolProvider({ dex, label, service, }: {
+    dex: string;
+    label?: string;
+    service: IEvmLpService;
+}): LpProtocolProvider;
+export {};

package/dist/lp/services/UserLpProfileService.d.ts

@@ -0,0 +1,18 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { IUserLpProfileService, TrackedLpPosition, TrackedLpPositionInput, UserLpProfile } from "../types.ts";
+export declare class UserLpProfileService extends Service implements IUserLpProfileService {
+    static readonly serviceType = "UserLpProfileService";
+    readonly capabilityDescription = "Manages user profiles and preferences for LP management.";
+    private profiles;
+    start(_runtime?: IAgentRuntime): Promise<void>;
+    stop(_runtime?: IAgentRuntime): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<UserLpProfileService>;
+    static stop(_runtime: IAgentRuntime): Promise<void>;
+    ensureProfile(userId: string, vaultPublicKey: string, encryptedSecretKey: string, initialConfig?: Partial<UserLpProfile["autoRebalanceConfig"]>): Promise<UserLpProfile>;
+    getProfile(userId: string): Promise<UserLpProfile | null>;
+    updateProfile(userId: string, updates: Partial<Omit<UserLpProfile, "userId" | "createdAt" | "version">>): Promise<UserLpProfile>;
+    addTrackedPosition(userId: string, position: TrackedLpPositionInput): Promise<UserLpProfile>;
+    removeTrackedPosition(userId: string, positionIdentifier: string): Promise<UserLpProfile>;
+    getTrackedPositions(userId: string): Promise<TrackedLpPosition[]>;
+    getAllProfilesWithAutoRebalanceEnabled(): Promise<UserLpProfile[]>;
+}

package/dist/lp/services/VaultService.d.ts

@@ -0,0 +1,21 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import { Keypair } from "@solana/web3.js";
+import type { IVaultService, TokenBalance } from "../types.ts";
+export declare class VaultService extends Service implements IVaultService {
+    static readonly serviceType = "VaultService";
+    readonly capabilityDescription = "Manages secure vaults for user cryptographic keys.";
+    private connection;
+    private vaultCache;
+    static start(runtime: IAgentRuntime): Promise<VaultService>;
+    static stop(_runtime: IAgentRuntime): Promise<void>;
+    start(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    createVault(userId: string): Promise<{
+        publicKey: string;
+        secretKeyEncrypted: string;
+    }>;
+    getVaultKeypair(userId: string, encryptedSecretKey: string): Promise<Keypair>;
+    getVaultPublicKey(userId: string): Promise<string | null>;
+    getBalances(publicKey: string): Promise<TokenBalance[]>;
+    exportPrivateKey(userId: string, encryptedSecretKey: string, confirmationToken: string): Promise<string>;
+}

package/dist/lp/services/YieldOptimizationService.d.ts

@@ -0,0 +1,59 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { LpPositionDetails, OptimizationOpportunity, PoolInfo, TokenBalance } from "../types.ts";
+/**
+ * Interface for the YieldOptimizationService.
+ * This service is responsible for fetching data about available LP pools,
+ * finding better yield opportunities, and calculating the costs of rebalancing.
+ */
+export interface IYieldOptimizationService extends Service {
+    /**
+     * Fetches comprehensive data for all relevant pools across all supported DEXs.
+     * This data is used as the basis for finding optimization opportunities.
+     * @returns A promise that resolves to an array of PoolInfo objects.
+     */
+    fetchAllPoolData(): Promise<PoolInfo[]>;
+    /**
+     * Analyzes current LP positions and idle assets to find better yield opportunities.
+     * @param userId - The user's ID
+     * @param currentPositions - An array of the user's current LpPositionDetails.
+     * @param idleAssets - An array of the user's idle TokenBalance that could be deployed.
+     * @returns A promise that resolves to an array of OptimizationOpportunity objects.
+     */
+    findBestYieldOpportunities(userId: string, currentPositions: LpPositionDetails[], idleAssets: TokenBalance[]): Promise<OptimizationOpportunity[]>;
+    /**
+     * Calculates the estimated cost of moving liquidity from one position/pool to another.
+     * This includes transaction fees, swap fees (if tokens need to be swapped), and potential slippage.
+     * @param fromPosition - The user's current LpPositionDetails (if rebalancing an existing position).
+     * @param toPool - The target PoolInfo to move liquidity to.
+     * @param solPriceUsd - The current SOL price in USD
+     * @param amountToMoveLamports - Optional. The specific amount of LP value (in SOL or stablecoin equivalent) to move.
+     * @returns A promise that resolves to an object detailing the costs.
+     */
+    calculateRebalanceCost(fromPosition: LpPositionDetails | null, toPool: PoolInfo, solPriceUsd: number, amountToMoveLamports?: string, underlyingTokensToMove?: TokenBalance[]): Promise<{
+        costSolLamports: string;
+        costUsd?: number;
+        steps: string[];
+        error?: string;
+    }>;
+    findBestYield(userId: string, currentTokenA: string, currentTokenB: string): Promise<OptimizationOpportunity[]>;
+}
+export declare class YieldOptimizationService extends Service implements IYieldOptimizationService {
+    static readonly serviceType = "YieldOptimizationService";
+    readonly capabilityDescription = "Finds and evaluates yield optimization opportunities across DEXs.";
+    private dexInteractionService;
+    private userLpProfileService;
+    private solPriceUsdForCosting;
+    static start(runtime: IAgentRuntime): Promise<YieldOptimizationService>;
+    static stop(_runtime: IAgentRuntime): Promise<void>;
+    start(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    fetchAllPoolData(): Promise<PoolInfo[]>;
+    calculateRebalanceCost(fromPositionOrNull: LpPositionDetails | null, targetPool: PoolInfo, solPriceUsd: number, _valueOfLpTokensToMoveLamports?: string, underlyingTokensAvailable?: TokenBalance[]): Promise<{
+        costSolLamports: string;
+        costUsd?: number;
+        steps: string[];
+        error?: string;
+    }>;
+    findBestYieldOpportunities(userId: string, currentPositions: LpPositionDetails[], idleAssets: TokenBalance[]): Promise<OptimizationOpportunity[]>;
+    findBestYield(_userId: string, _currentTokenA: string, _currentTokenB: string): Promise<OptimizationOpportunity[]>;
+}

package/dist/lp/services/__tests__/MockLpService.d.ts

@@ -0,0 +1,17 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { AddLiquidityConfig, ILpService, LpPositionDetails, PoolInfo, RemoveLiquidityConfig, TransactionResult } from "../../types.ts";
+export declare class MockLpService extends Service implements ILpService {
+    private readonly dexName;
+    readonly capabilityDescription = "Provides standardized access to DEX liquidity pools.";
+    private positions;
+    constructor(runtime: IAgentRuntime, dexName?: string);
+    getDexName(): string;
+    getPools(tokenAMint?: string, tokenBMint?: string): Promise<PoolInfo[]>;
+    addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult>;
+    removeLiquidity(config: RemoveLiquidityConfig): Promise<TransactionResult>;
+    getLpPositionDetails(owner: string, poolOrPositionIdentifier: string): Promise<LpPositionDetails | null>;
+    getMarketDataForPools(poolIds: string[]): Promise<Record<string, Partial<PoolInfo>>>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function registerMockDexServices(runtime: IAgentRuntime): Promise<void>;

package/dist/lp/types.d.ts

@@ -0,0 +1,439 @@
+import type { IAgentRuntime, ILpService, LpPositionDetails, PoolInfo, Service, TokenBalance, TransactionResult } from "@elizaos/core";
+import type { Keypair as SolanaKeypair } from "@solana/web3.js";
+import type { Address, Hash } from "viem";
+export type { ILpService, LpPositionDetails, PoolInfo, TokenBalance, TransactionResult, } from "@elizaos/core";
+export type ChainType = "solana" | "evm";
+export type SolanaDex = "raydium" | "orca" | "meteora";
+export type EvmDex = "uniswap" | "pancakeswap" | "aerodrome";
+export type DexName = SolanaDex | EvmDex;
+export interface RpcConfig {
+    /** Primary RPC URL */
+    url: string;
+    /** Fallback RPC URLs */
+    fallbacks?: string[];
+    /** RPC provider name for identification */
+    provider?: "alchemy" | "infura" | "quicknode" | "public" | "custom";
+}
+export interface SolanaConfig {
+    /** Solana RPC configuration */
+    rpc: RpcConfig;
+    /** Private key (base58 encoded) */
+    privateKey?: string;
+    /** Enabled DEXs on Solana */
+    enabledDexes: SolanaDex[];
+}
+export interface EvmChainConfig {
+    /** Chain ID */
+    chainId: number;
+    /** Chain name for display */
+    name: string;
+    /** RPC configuration */
+    rpc: RpcConfig;
+    /** Enabled DEXs on this chain */
+    enabledDexes: EvmDex[];
+    /** Native currency symbol */
+    nativeCurrency: string;
+}
+export interface EvmConfig {
+    /** Private key (hex string with 0x prefix) */
+    privateKey?: string;
+    /** Chain configurations */
+    chains: Record<string, EvmChainConfig>;
+}
+export interface LpManagerConfig {
+    /** Solana configuration (optional) */
+    solana?: SolanaConfig;
+    /** EVM configuration (optional) */
+    evm?: EvmConfig;
+    /** Default slippage in basis points */
+    defaultSlippageBps?: number;
+    /** Auto-rebalance settings */
+    autoRebalance?: {
+        enabled: boolean;
+        checkIntervalMs: number;
+        minGainThresholdPercent: number;
+    };
+}
+export interface EvmWallet {
+    address: Address;
+    privateKey: `0x${string}`;
+}
+export type EvmPoolTokenInfo = PoolInfo["tokenA"] & {
+    /** EVM token contract address. Also mirrored to mint for core PoolInfo compatibility. */
+    address: Address;
+    mint: Address;
+    decimals: number;
+};
+export interface EvmPoolInfo extends Omit<PoolInfo, "tokenA" | "tokenB"> {
+    /** Chain ID where the pool exists */
+    chainId: number;
+    /** Chain name */
+    chainName: string;
+    /** Pool contract address */
+    poolAddress: Address;
+    /** Token A info with EVM address */
+    tokenA: EvmPoolTokenInfo;
+    /** Token B info with EVM address */
+    tokenB: EvmPoolTokenInfo;
+    /** Fee tier (for Uniswap V3 style pools) */
+    feeTier?: number;
+    /** Tick spacing (for concentrated liquidity) */
+    tickSpacing?: number;
+    /** Current tick */
+    currentTick?: number;
+    /** Current sqrt price X96 */
+    sqrtPriceX96?: bigint;
+}
+export interface EvmPositionDetails extends Omit<LpPositionDetails, "lpTokenBalance" | "underlyingTokens"> {
+    /** Chain ID */
+    chainId: number;
+    /** Position NFT token ID (for Uniswap V3 style) */
+    tokenId?: bigint;
+    /** Position owner address */
+    owner: Address;
+    /** Lower tick (concentrated liquidity) */
+    tickLower?: number;
+    /** Upper tick (concentrated liquidity) */
+    tickUpper?: number;
+    /** Liquidity amount */
+    liquidity?: bigint;
+    /** LP token balance with EVM address */
+    lpTokenBalance: {
+        address: Address;
+        balance: string;
+        decimals: number;
+        symbol?: string;
+        uiAmount?: number;
+        name?: string;
+        logoURI?: string;
+    };
+    /** Underlying tokens with EVM addresses */
+    underlyingTokens: Array<{
+        address: Address;
+        balance: string;
+        decimals: number;
+        symbol?: string;
+        uiAmount?: number;
+        name?: string;
+        logoURI?: string;
+    }>;
+}
+export interface EvmAddLiquidityParams {
+    /** Wallet/signer */
+    wallet: EvmWallet;
+    /** Chain ID */
+    chainId: number;
+    /** Pool address */
+    poolAddress: Address;
+    /** Token A amount (in wei) */
+    tokenAAmount: bigint;
+    /** Token B amount (in wei) */
+    tokenBAmount?: bigint;
+    /** Slippage tolerance in bps */
+    slippageBps: number;
+    /** Lower tick for concentrated liquidity */
+    tickLower?: number;
+    /** Upper tick for concentrated liquidity */
+    tickUpper?: number;
+    /** Deadline timestamp */
+    deadline?: bigint;
+}
+export interface EvmRemoveLiquidityParams {
+    /** Wallet/signer */
+    wallet: EvmWallet;
+    /** Chain ID */
+    chainId: number;
+    /** Pool address */
+    poolAddress: Address;
+    /** Position token ID (for NFT positions) */
+    tokenId?: bigint;
+    /** LP token amount to remove (for standard pools) */
+    lpTokenAmount?: bigint;
+    /** Percentage to remove (0-100) */
+    percentageToRemove?: number;
+    /** Slippage tolerance in bps */
+    slippageBps: number;
+    /** Deadline timestamp */
+    deadline?: bigint;
+}
+export interface EvmTransactionResult extends TransactionResult {
+    /** Transaction hash */
+    hash?: Hash;
+    /** Chain ID */
+    chainId?: number;
+    /** Block number */
+    blockNumber?: bigint;
+    /** Gas used */
+    gasUsed?: bigint;
+}
+export interface IEvmLpService extends Service {
+    /** Returns the DEX name */
+    getDexName(): EvmDex;
+    /** Returns supported chain IDs */
+    getSupportedChainIds(): number[];
+    /** Check if a chain is supported */
+    supportsChain(chainId: number): boolean;
+    /** Get pools on a specific chain */
+    getPools(chainId: number, tokenA?: Address, tokenB?: Address, feeTier?: number): Promise<EvmPoolInfo[]>;
+    /** Add liquidity to a pool */
+    addLiquidity(params: EvmAddLiquidityParams): Promise<EvmTransactionResult>;
+    /** Remove liquidity from a pool */
+    removeLiquidity(params: EvmRemoveLiquidityParams): Promise<EvmTransactionResult>;
+    /** Get position details */
+    getPositionDetails(chainId: number, owner: Address, poolAddress: Address, tokenId?: bigint): Promise<EvmPositionDetails | null>;
+    /** Get all positions for an address */
+    getAllPositions(chainId: number, owner: Address): Promise<EvmPositionDetails[]>;
+    /** Get market data for pools */
+    getMarketData(poolAddresses: Address[]): Promise<Record<string, Partial<EvmPoolInfo>>>;
+}
+export declare const SUPPORTED_EVM_CHAINS: {
+    readonly ethereum: {
+        readonly chainId: 1;
+        readonly name: "Ethereum";
+        readonly nativeCurrency: "ETH";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["ETHEREUM_RPC_URL", "ETH_RPC_URL", "EVM_PROVIDER_MAINNET"];
+    };
+    readonly base: {
+        readonly chainId: 8453;
+        readonly name: "Base";
+        readonly nativeCurrency: "ETH";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["BASE_RPC_URL", "EVM_PROVIDER_BASE"];
+    };
+    readonly arbitrum: {
+        readonly chainId: 42161;
+        readonly name: "Arbitrum One";
+        readonly nativeCurrency: "ETH";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["ARBITRUM_RPC_URL", "EVM_PROVIDER_ARBITRUM"];
+    };
+    readonly bsc: {
+        readonly chainId: 56;
+        readonly name: "BNB Smart Chain";
+        readonly nativeCurrency: "BNB";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["BSC_RPC_URL", "EVM_PROVIDER_BSC"];
+    };
+    readonly polygon: {
+        readonly chainId: 137;
+        readonly name: "Polygon";
+        readonly nativeCurrency: "MATIC";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["POLYGON_RPC_URL", "EVM_PROVIDER_POLYGON"];
+    };
+    readonly optimism: {
+        readonly chainId: 10;
+        readonly name: "Optimism";
+        readonly nativeCurrency: "ETH";
+        readonly supportedDexes: EvmDex[];
+        readonly rpcEnvKeys: readonly ["OPTIMISM_RPC_URL", "EVM_PROVIDER_OPTIMISM"];
+    };
+};
+export type SupportedEvmChain = keyof typeof SUPPORTED_EVM_CHAINS;
+export declare function getChainConfig(chainNameOrId: string | number): {
+    readonly chainId: 1;
+    readonly name: "Ethereum";
+    readonly nativeCurrency: "ETH";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["ETHEREUM_RPC_URL", "ETH_RPC_URL", "EVM_PROVIDER_MAINNET"];
+} | {
+    readonly chainId: 8453;
+    readonly name: "Base";
+    readonly nativeCurrency: "ETH";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["BASE_RPC_URL", "EVM_PROVIDER_BASE"];
+} | {
+    readonly chainId: 42161;
+    readonly name: "Arbitrum One";
+    readonly nativeCurrency: "ETH";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["ARBITRUM_RPC_URL", "EVM_PROVIDER_ARBITRUM"];
+} | {
+    readonly chainId: 56;
+    readonly name: "BNB Smart Chain";
+    readonly nativeCurrency: "BNB";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["BSC_RPC_URL", "EVM_PROVIDER_BSC"];
+} | {
+    readonly chainId: 137;
+    readonly name: "Polygon";
+    readonly nativeCurrency: "MATIC";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["POLYGON_RPC_URL", "EVM_PROVIDER_POLYGON"];
+} | {
+    readonly chainId: 10;
+    readonly name: "Optimism";
+    readonly nativeCurrency: "ETH";
+    readonly supportedDexes: EvmDex[];
+    readonly rpcEnvKeys: readonly ["OPTIMISM_RPC_URL", "EVM_PROVIDER_OPTIMISM"];
+} | undefined;
+export type OptimizationOpportunity = {
+    sourcePosition?: LpPositionDetails;
+    sourcePool?: PoolInfo;
+    targetPool: PoolInfo;
+    estimatedNewYield: number;
+    currentYield?: number;
+    estimatedCostToMoveLamports?: string;
+    estimatedCostToMoveUsd?: number;
+    netGainPercent?: number;
+    reason?: string;
+    actions?: string[];
+};
+export type UserLpProfile = {
+    userId: string;
+    vaultPublicKey: string;
+    encryptedSecretKey: string;
+    autoRebalanceConfig: {
+        enabled: boolean;
+        minGainThresholdPercent: number;
+        preferredDexes?: string[];
+        maxSlippageBps: number;
+        maxGasFeeLamports?: string;
+        cycleIntervalHours?: number;
+    };
+    trackedPositions?: TrackedLpPosition[];
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export interface TrackedLpPosition {
+    positionIdentifier: string;
+    dex: string;
+    poolAddress: string;
+    metadata?: Record<string, string | number | boolean | null>;
+    trackedAt: string;
+}
+export type TrackedLpPositionInput = Omit<TrackedLpPosition, "trackedAt">;
+export interface AddLiquidityConfig {
+    userVault: SolanaKeypair;
+    dexName: string;
+    poolId: string;
+    tokenAAmountLamports: string;
+    tokenBAmountLamports?: string;
+    slippageBps: number;
+    tickLowerIndex?: number;
+    tickUpperIndex?: number;
+}
+export interface RemoveLiquidityConfig {
+    userVault: SolanaKeypair;
+    dexName: string;
+    poolId: string;
+    lpTokenAmountLamports: string;
+    slippageBps: number;
+}
+export type LpManagementSubaction = "onboard" | "list_pools" | "open" | "close" | "reposition" | "list_positions" | "get_position" | "set_preferences";
+export interface LpActionParams {
+    subaction?: LpManagementSubaction;
+    chain?: ChainType | string;
+    chainId?: number;
+    dex?: string;
+    pool?: string;
+    position?: string;
+    amount?: string | number | {
+        value?: string | number;
+        tokenA?: string | number;
+        tokenB?: string | number;
+        lpToken?: string | number;
+        percentage?: number;
+    };
+    amounts?: {
+        tokenA?: string | number;
+        tokenB?: string | number;
+        lpToken?: string | number;
+    };
+    range?: {
+        tickLower?: number;
+        tickUpper?: number;
+        tickLowerIndex?: number;
+        tickUpperIndex?: number;
+        priceLower?: number;
+        priceUpper?: number;
+    };
+    tokenA?: string;
+    tokenB?: string;
+    feeTier?: number;
+    slippageBps?: number;
+    intent?: "onboard_lp" | "deposit_lp" | "withdraw_lp" | "show_lps" | "set_lp_preferences" | "create_concentrated_lp" | "rebalance_concentrated_lp" | "show_concentrated_lps";
+    userId?: string;
+    dexName?: string;
+    poolId?: string;
+    tokenAAmount?: string;
+    tokenBAmount?: string;
+    lpTokenAmount?: string;
+    percentage?: number;
+    autoRebalanceConfig?: Partial<UserLpProfile["autoRebalanceConfig"]>;
+    autoRebalanceEnabled?: boolean;
+    minGainThresholdPercent?: number;
+    maxSlippageBps?: number;
+    preferredDexes?: string[];
+    cycleIntervalHours?: number;
+    maxGasFeeLamports?: string;
+    tickLowerIndex?: number;
+    tickUpperIndex?: number;
+    priceLower?: number;
+    priceUpper?: number;
+    rangeWidthPercent?: number;
+    positionId?: string;
+}
+export interface IVaultService extends Service {
+    createVault(userId: string): Promise<{
+        publicKey: string;
+        secretKeyEncrypted: string;
+    }>;
+    getVaultKeypair(userId: string, encryptedSecretKey: string): Promise<SolanaKeypair>;
+    getVaultPublicKey(userId: string): Promise<string | null>;
+    getBalances(publicKey: string): Promise<TokenBalance[]>;
+    exportPrivateKey(userId: string, encryptedSecretKey: string, confirmationToken: string): Promise<string>;
+}
+export interface IUserLpProfileService extends Service {
+    ensureProfile(userId: string, vaultPublicKey: string, encryptedSecretKey: string, initialConfig?: Partial<UserLpProfile["autoRebalanceConfig"]>): Promise<UserLpProfile>;
+    getProfile(userId: string): Promise<UserLpProfile | null>;
+    updateProfile(userId: string, updates: Partial<Omit<UserLpProfile, "userId">>): Promise<UserLpProfile>;
+    addTrackedPosition(userId: string, position: TrackedLpPositionInput): Promise<UserLpProfile>;
+    removeTrackedPosition(userId: string, positionIdentifier: string): Promise<UserLpProfile>;
+    getTrackedPositions(userId: string): Promise<TrackedLpPosition[]>;
+    getAllProfilesWithAutoRebalanceEnabled(): Promise<UserLpProfile[]>;
+    start(runtime?: IAgentRuntime): Promise<void>;
+    stop(runtime?: IAgentRuntime): Promise<void>;
+}
+export interface IDexInteractionService extends Service {
+    registerDexService(dexService: ILpService): void;
+    getPools(dexName?: string, tokenAMint?: string, tokenBMint?: string): Promise<PoolInfo[]>;
+    addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult>;
+    removeLiquidity(config: RemoveLiquidityConfig): Promise<TransactionResult>;
+    getLpPosition(userId: string, poolIdOrPositionIdentifier: string, dexName: string): Promise<LpPositionDetails | null>;
+    getAllUserLpPositions(userId: string): Promise<LpPositionDetails[]>;
+}
+export interface IYieldOptimizationService extends Service {
+    fetchAllPoolData(): Promise<PoolInfo[]>;
+    findBestYieldOpportunities(userId: string, currentPositions: LpPositionDetails[], idleAssets: TokenBalance[]): Promise<OptimizationOpportunity[]>;
+    calculateRebalanceCost(fromPosition: LpPositionDetails | null, toPool: PoolInfo, solPriceUsd: number, amountToMoveLamports?: string, underlyingTokensToMove?: TokenBalance[]): Promise<{
+        costSolLamports: string;
+        costUsd?: number;
+        steps: string[];
+        error?: string;
+    }>;
+    findBestYield(userId: string, currentTokenA: string, currentTokenB: string): Promise<OptimizationOpportunity[]>;
+}
+export interface IConcentratedPosition extends LpPositionDetails {
+    priceLower: number;
+    priceUpper: number;
+    currentPrice: number;
+    inRange: boolean;
+    liquidityUtilization: number;
+}
+export interface IRangeParams {
+    poolAddress: string;
+    baseAmount?: number;
+    quoteAmount?: number;
+    priceLower?: number;
+    priceUpper?: number;
+    rangeWidthPercent?: number;
+    targetUtilization?: number;
+}
+export interface IConcentratedLiquidityService extends Service {
+    createConcentratedPosition(userId: string, params: IRangeParams): Promise<IConcentratedPosition>;
+    getConcentratedPositions(userId: string): Promise<IConcentratedPosition[]>;
+    rebalanceConcentratedPosition(userId: string, positionId: string, newRangeParams?: Partial<IRangeParams>): Promise<IConcentratedPosition>;
+}