@elizaos/plugin-wallet 2.0.0-beta.1

package/src/lp/lp-manager-entry.ts

@@ -0,0 +1,303 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import {
+  type IAgentRuntime,
+  logger,
+  type Plugin,
+  promoteSubactionsToActions,
+} from "@elizaos/core";
+import { liquidityAction } from "./actions/liquidity.ts";
+import { realTokenTestsSuite } from "./e2e/real-token-tests.ts";
+import { lpManagerScenariosSuite } from "./e2e/scenarios.ts";
+import { ConcentratedLiquidityService } from "./services/ConcentratedLiquidityService.ts";
+import { DexInteractionService } from "./services/DexInteractionService.ts";
+import { LpManagementService } from "./services/LpManagementService.ts";
+import { UserLpProfileService } from "./services/UserLpProfileService.ts";
+import { VaultService } from "./services/VaultService.ts";
+import { YieldOptimizationService } from "./services/YieldOptimizationService.ts";
+// LpAutoRebalanceTask import removed - file doesn't exist
+import type { EvmDex, SolanaDex } from "./types.ts";
+
+// It's good practice to define a unique name for the plugin
+export const LP_MANAGER_PLUGIN_NAME = "@elizaos/plugin-lp-manager";
+
+/**
+ * Determines which DEXes to load based on available credentials and configuration
+ */
+function getDexConfiguration(runtime: IAgentRuntime): {
+  solanaDexes: SolanaDex[];
+  evmDexes: EvmDex[];
+  hasSolana: boolean;
+  hasEvm: boolean;
+} {
+  const solanaPrivateKey = runtime.getSetting("SOLANA_PRIVATE_KEY");
+  const evmPrivateKey = runtime.getSetting("EVM_PRIVATE_KEY");
+
+  // Check for chain-specific RPC URLs to determine which chains are configured
+  const hasEthereumRpc = !!(
+    runtime.getSetting("ETHEREUM_RPC_URL") ||
+    runtime.getSetting("EVM_PROVIDER_MAINNET")
+  );
+  const hasBaseRpc = !!(
+    runtime.getSetting("BASE_RPC_URL") ||
+    runtime.getSetting("EVM_PROVIDER_BASE")
+  );
+  const hasBscRpc = !!(
+    runtime.getSetting("BSC_RPC_URL") || runtime.getSetting("EVM_PROVIDER_BSC")
+  );
+  const hasArbitrumRpc = !!(
+    runtime.getSetting("ARBITRUM_RPC_URL") ||
+    runtime.getSetting("EVM_PROVIDER_ARBITRUM")
+  );
+  const hasSolanaRpc = !!runtime.getSetting("SOLANA_RPC_URL");
+
+  const hasSolanaWallet = !!(
+    solanaPrivateKey && typeof solanaPrivateKey === "string"
+  );
+  const hasEvmWallet = !!(evmPrivateKey && typeof evmPrivateKey === "string");
+  const hasSolana = hasSolanaWallet || hasSolanaRpc;
+  const hasEvm =
+    hasEvmWallet || hasEthereumRpc || hasBaseRpc || hasBscRpc || hasArbitrumRpc;
+
+  // Determine Solana DEXes to load
+  const solanaDexes: SolanaDex[] = [];
+  if (hasSolana) {
+    // Check for specific DEX preferences from config, otherwise load all
+    const preferredSolanaDexes = runtime.getSetting("LP_SOLANA_DEXES");
+    if (preferredSolanaDexes && typeof preferredSolanaDexes === "string") {
+      const dexList = preferredSolanaDexes
+        .split(",")
+        .map((d) => d.trim().toLowerCase() as SolanaDex);
+      solanaDexes.push(
+        ...dexList.filter((d) => ["raydium", "orca", "meteora"].includes(d)),
+      );
+    } else {
+      // Default: load all Solana DEXes
+      solanaDexes.push("raydium", "orca", "meteora");
+    }
+  }
+
+  // Determine EVM DEXes to load based on available RPCs
+  const evmDexes: EvmDex[] = [];
+  if (hasEvm) {
+    const preferredEvmDexes = runtime.getSetting("LP_EVM_DEXES");
+    if (preferredEvmDexes && typeof preferredEvmDexes === "string") {
+      const dexList = preferredEvmDexes
+        .split(",")
+        .map((d) => d.trim().toLowerCase() as EvmDex);
+      evmDexes.push(
+        ...dexList.filter((d) =>
+          ["uniswap", "pancakeswap", "aerodrome"].includes(d),
+        ),
+      );
+    } else {
+      // Auto-detect based on configured RPCs
+      if (hasEthereumRpc || hasArbitrumRpc) {
+        evmDexes.push("uniswap");
+      }
+      if (hasBscRpc || hasArbitrumRpc) {
+        evmDexes.push("pancakeswap");
+      }
+      if (hasBaseRpc) {
+        evmDexes.push("aerodrome");
+        if (!evmDexes.includes("uniswap")) {
+          evmDexes.push("uniswap"); // Uniswap is also on Base
+        }
+      }
+    }
+  }
+
+  return { solanaDexes, evmDexes, hasSolana, hasEvm };
+}
+
+/**
+ * Dynamically loads Solana DEX plugins
+ */
+async function loadSolanaDexes(
+  dexes: SolanaDex[],
+  config: Record<string, string>,
+  runtime: IAgentRuntime,
+): Promise<void> {
+  for (const dex of dexes) {
+    try {
+      switch (dex) {
+        case "raydium": {
+          const { raydiumPlugin } = await import(
+            "../chains/solana/dex/raydium/index.ts"
+          );
+          if (raydiumPlugin.init) {
+            await raydiumPlugin.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded Raydium DEX`);
+          break;
+        }
+        case "orca": {
+          const { orcaPlugin } = await import(
+            "../chains/solana/dex/orca/index.ts"
+          );
+          if (orcaPlugin.init) {
+            await orcaPlugin.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded Orca DEX`);
+          break;
+        }
+        case "meteora": {
+          const meteoraPlugin = await import(
+            "../chains/solana/dex/meteora/index.ts"
+          );
+          if (meteoraPlugin.default?.init) {
+            await meteoraPlugin.default.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded Meteora DEX`);
+          break;
+        }
+      }
+    } catch (error: unknown) {
+      logger.warn(
+        `[LP Manager] Failed to load ${dex} DEX:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+}
+
+/**
+ * Dynamically loads EVM DEX plugins
+ */
+async function loadEvmDexes(
+  dexes: EvmDex[],
+  config: Record<string, string>,
+  runtime: IAgentRuntime,
+): Promise<void> {
+  for (const dex of dexes) {
+    try {
+      switch (dex) {
+        case "uniswap": {
+          const { uniswapPlugin } = await import(
+            "../chains/evm/dex/uniswap/index.ts"
+          );
+          if (uniswapPlugin.init) {
+            await uniswapPlugin.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded Uniswap V3 DEX`);
+          break;
+        }
+        case "pancakeswap": {
+          const { pancakeswapPlugin } = await import(
+            "../chains/evm/dex/pancakeswp/index.ts"
+          );
+          if (pancakeswapPlugin.init) {
+            await pancakeswapPlugin.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded PancakeSwap V3 DEX`);
+          break;
+        }
+        case "aerodrome": {
+          const { aerodromePlugin } = await import(
+            "../chains/evm/dex/aerodrome/index.ts"
+          );
+          if (aerodromePlugin.init) {
+            await aerodromePlugin.init(config, runtime);
+          }
+          logger.info(`[LP Manager] Loaded Aerodrome DEX`);
+          break;
+        }
+      }
+    } catch (error: unknown) {
+      logger.warn(
+        `[LP Manager] Failed to load ${dex} DEX:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+}
+
+const lpManagerPlugin: Plugin = {
+  name: LP_MANAGER_PLUGIN_NAME,
+  description:
+    "Unified Liquidity Pool manager for Solana DEXs (Raydium, Orca, Meteora) and EVM DEXs (Uniswap, PancakeSwap, Aerodrome).",
+  actions: [...promoteSubactionsToActions(liquidityAction)],
+  services: [
+    LpManagementService,
+    VaultService,
+    UserLpProfileService,
+    DexInteractionService,
+    YieldOptimizationService,
+    ConcentratedLiquidityService,
+  ],
+  tests: [lpManagerScenariosSuite, realTokenTestsSuite],
+
+  init: async (
+    config: Record<string, string>,
+    runtime: IAgentRuntime,
+  ): Promise<void> => {
+    logger.info(`[LP Manager] Initializing ${LP_MANAGER_PLUGIN_NAME}...`);
+
+    // Determine which DEXes to load based on configuration
+    const { solanaDexes, evmDexes, hasSolana, hasEvm } =
+      getDexConfiguration(runtime);
+
+    logger.info(`[LP Manager] Configuration detected:`);
+    logger.info(
+      `  - Solana: ${hasSolana ? "enabled" : "disabled"} (DEXes: ${solanaDexes.join(", ") || "none"})`,
+    );
+    logger.info(
+      `  - EVM: ${hasEvm ? "enabled" : "disabled"} (DEXes: ${evmDexes.join(", ") || "none"})`,
+    );
+
+    if (!hasSolana && !hasEvm) {
+      logger.warn(
+        `[LP Manager] No LP chain configuration found. Set SOLANA_RPC_URL, an EVM RPC URL, SOLANA_PRIVATE_KEY, or EVM_PRIVATE_KEY.`,
+      );
+      logger.warn(
+        `[LP Manager] No production mock LP services will be registered.`,
+      );
+      return;
+    }
+
+    // Load Solana DEXes
+    if (solanaDexes.length > 0) {
+      await loadSolanaDexes(solanaDexes, config, runtime);
+    }
+
+    // Load EVM DEXes
+    if (evmDexes.length > 0) {
+      await loadEvmDexes(evmDexes, config, runtime);
+    }
+
+    logger.info(
+      `[LP Manager] Plugin ${LP_MANAGER_PLUGIN_NAME} initialized successfully.`,
+    );
+  },
+};
+
+export default lpManagerPlugin;
+
+export {
+  AerodromeLpService,
+  aerodromePlugin,
+} from "../chains/evm/dex/aerodrome/index.ts";
+export {
+  PancakeSwapV3LpService,
+  pancakeswapPlugin,
+} from "../chains/evm/dex/pancakeswp/index.ts";
+// Export sub-plugins for direct use
+export {
+  UniswapV3LpService,
+  uniswapPlugin,
+} from "../chains/evm/dex/uniswap/index.ts";
+export { orcaPlugin } from "../chains/solana/dex/orca/index.ts";
+export { raydiumPlugin } from "../chains/solana/dex/raydium/index.ts";
+// Export types
+export * from "./types.ts";
+// Export all services and utilities
+// Back-compat alias for older imports.
+export {
+  ConcentratedLiquidityService,
+  DexInteractionService,
+  LpManagementService,
+  liquidityAction,
+  liquidityAction as LpManagementAgentAction,
+  UserLpProfileService,
+  VaultService,
+  YieldOptimizationService,
+};

package/src/lp/services/ConcentratedLiquidityService.ts

@@ -0,0 +1,120 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type {
+  IConcentratedLiquidityService,
+  IConcentratedPosition,
+  IRangeParams,
+} from "../types";
+
+/**
+ * ConcentratedLiquidityService provides foundation support for concentrated liquidity positions.
+ * This is a placeholder implementation that will be expanded when DEX plugins add concentrated liquidity support.
+ */
+export class ConcentratedLiquidityService
+  extends Service
+  implements IConcentratedLiquidityService
+{
+  public static readonly serviceType = "concentrated-liquidity";
+  public readonly capabilityDescription =
+    "Manages concentrated liquidity positions with range selection and automated rebalancing";
+
+  static async start(
+    runtime: IAgentRuntime,
+  ): Promise<ConcentratedLiquidityService> {
+    const service = new ConcentratedLiquidityService();
+    await service.start(runtime);
+    return service;
+  }
+
+  static async stop(_runtime: IAgentRuntime): Promise<void> {
+    // No cleanup needed for static stop
+  }
+
+  async start(_runtime: IAgentRuntime): Promise<void> {
+    // Service initialization
+    this.isInitialized = true;
+    console.info(
+      "ConcentratedLiquidityService started - awaiting DEX integration",
+    );
+  }
+
+  async stop(): Promise<void> {
+    this.isInitialized = false;
+  }
+
+  async createConcentratedPosition(
+    _userId: string,
+    _params: IRangeParams,
+  ): Promise<IConcentratedPosition> {
+    // Placeholder implementation
+    throw new Error(
+      "Concentrated liquidity positions are coming soon! This feature requires DEX integration.",
+    );
+  }
+
+  async getConcentratedPositions(
+    userId: string,
+  ): Promise<IConcentratedPosition[]> {
+    // Placeholder implementation
+    console.info(`Getting concentrated positions for user ${userId}`);
+    return [];
+  }
+
+  async rebalanceConcentratedPosition(
+    _userId: string,
+    _positionId: string,
+    _newRangeParams?: Partial<IRangeParams>,
+  ): Promise<IConcentratedPosition> {
+    // Placeholder implementation
+    throw new Error("Concentrated position rebalancing is coming soon!");
+  }
+
+  /**
+   * Calculate optimal price range based on volatility and target utilization
+   */
+  calculateOptimalRange(
+    currentPrice: number,
+    rangeWidthPercent: number,
+    _targetUtilization: number = 80,
+  ): { priceLower: number; priceUpper: number } {
+    // Simple symmetric range calculation
+    const halfWidth = rangeWidthPercent / 2;
+    const priceLower = currentPrice * (1 - halfWidth / 100);
+    const priceUpper = currentPrice * (1 + halfWidth / 100);
+
+    return { priceLower, priceUpper };
+  }
+
+  /**
+   * Check if current price is within the position's range
+   */
+  isPriceInRange(
+    currentPrice: number,
+    priceLower: number,
+    priceUpper: number,
+  ): boolean {
+    return currentPrice >= priceLower && currentPrice <= priceUpper;
+  }
+
+  /**
+   * Calculate how much of the liquidity is currently active
+   */
+  calculateUtilization(
+    currentPrice: number,
+    priceLower: number,
+    priceUpper: number,
+  ): number {
+    if (!this.isPriceInRange(currentPrice, priceLower, priceUpper)) {
+      return 0;
+    }
+
+    const priceRange = priceUpper - priceLower;
+    const distanceFromLower = currentPrice - priceLower;
+    const distanceFromUpper = priceUpper - currentPrice;
+
+    // Liquidity utilization is highest when price is in the middle of the range
+    const utilization =
+      (Math.min(distanceFromLower, distanceFromUpper) / (priceRange / 2)) * 100;
+    return Math.min(utilization, 100);
+  }
+}

package/src/lp/services/DexInteractionService.ts

@@ -0,0 +1,226 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import { type IAgentRuntime, logger, Service } from "@elizaos/core";
+import type {
+  AddLiquidityConfig,
+  IEvmLpService,
+  ILpService,
+  IUserLpProfileService,
+  LpPositionDetails,
+  PoolInfo,
+  RemoveLiquidityConfig,
+  TransactionResult,
+} from "../types.ts";
+import {
+  createEvmLpProtocolProvider,
+  createSolanaLpProtocolProvider,
+  getLpManagementService,
+  type LpManagementService,
+} from "./LpManagementService.ts";
+import type { UserLpProfileService } from "./UserLpProfileService.ts";
+import type { VaultService } from "./VaultService.ts";
+
+/**
+ * Backward-compatible facade for older LP manager internals.
+ * New routing and protocol ownership live in LpManagementService.
+ */
+export interface IDexInteractionService extends Service {
+  registerDexService(dexService: ILpService | IEvmLpService): 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 class DexInteractionService
+  extends Service
+  implements IDexInteractionService
+{
+  public static override readonly serviceType = "dex-interaction";
+  public readonly capabilityDescription =
+    "Compatibility facade for registered LP protocol providers.";
+
+  private lpManagementService!: LpManagementService;
+  private userLpProfileService!: IUserLpProfileService;
+
+  static async start(runtime: IAgentRuntime): Promise<DexInteractionService> {
+    const service = new DexInteractionService(runtime);
+    await service.start(runtime);
+    return service;
+  }
+
+  static async stop(_runtime: IAgentRuntime): Promise<void> {
+    // No static cleanup needed.
+  }
+
+  async start(runtime: IAgentRuntime): Promise<void> {
+    const vaultService = runtime.getService<VaultService>("VaultService");
+    const userLpProfileService = runtime.getService<UserLpProfileService>(
+      "UserLpProfileService",
+    );
+    const lpManagementService = await getLpManagementService(runtime);
+
+    if (!vaultService || !userLpProfileService || !lpManagementService) {
+      throw new Error(
+        "Required services (VaultService, UserLpProfileService, LpManagementService) not available.",
+      );
+    }
+
+    this.userLpProfileService = userLpProfileService;
+    this.lpManagementService = lpManagementService;
+  }
+
+  async stop(): Promise<void> {
+    // No-op; protocol providers are owned by LpManagementService.
+  }
+
+  rediscoverServices(): void {
+    // Retained for callers that used to trigger name-based discovery.
+  }
+
+  registerDexService(dexService: ILpService | IEvmLpService): void {
+    const dexName = dexService.getDexName();
+    const isEvm =
+      typeof (dexService as IEvmLpService).getSupportedChainIds === "function";
+
+    this.lpManagementService.registerProtocol(
+      isEvm
+        ? createEvmLpProtocolProvider({
+            dex: dexName,
+            label: dexName,
+            service: dexService as IEvmLpService,
+          })
+        : createSolanaLpProtocolProvider({
+            dex: dexName,
+            label: dexName,
+            service: dexService as ILpService,
+          }),
+    );
+  }
+
+  getLpService(dexName: string): ILpService | IEvmLpService | undefined {
+    return this.lpManagementService.listProtocols({ dex: dexName })[0]
+      ?.service as ILpService | IEvmLpService | undefined;
+  }
+
+  getLpServices(): Array<ILpService | IEvmLpService> {
+    return this.lpManagementService
+      .listProtocols()
+      .map((protocol) => protocol.service)
+      .filter(Boolean) as Array<ILpService | IEvmLpService>;
+  }
+
+  getDexService(dexName: string): ILpService | IEvmLpService {
+    const service = this.getLpService(dexName);
+    if (!service) {
+      throw new Error(`No service registered for DEX '${dexName}'`);
+    }
+    return service;
+  }
+
+  async getPools(
+    dexName?: string,
+    tokenAMint?: string,
+    tokenBMint?: string,
+  ): Promise<PoolInfo[]> {
+    try {
+      return await this.lpManagementService.listPools({
+        dex: dexName,
+        tokenA: tokenAMint,
+        tokenB: tokenBMint,
+      });
+    } catch (error) {
+      logger.warn(
+        "[DexInteractionService] Failed to list LP pools",
+        error instanceof Error ? error.message : String(error),
+      );
+      return [];
+    }
+  }
+
+  async addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult> {
+    return this.lpManagementService.openPosition({
+      chain: "solana",
+      dex: config.dexName,
+      userVault: config.userVault,
+      pool: config.poolId,
+      amount: {
+        tokenA: config.tokenAAmountLamports,
+        tokenB: config.tokenBAmountLamports,
+      },
+      range: {
+        tickLowerIndex: config.tickLowerIndex,
+        tickUpperIndex: config.tickUpperIndex,
+      },
+      slippageBps: config.slippageBps,
+    });
+  }
+
+  async removeLiquidity(
+    config: RemoveLiquidityConfig,
+  ): Promise<TransactionResult> {
+    return this.lpManagementService.closePosition({
+      chain: "solana",
+      dex: config.dexName,
+      userVault: config.userVault,
+      pool: config.poolId,
+      amount: { lpToken: config.lpTokenAmountLamports },
+      slippageBps: config.slippageBps,
+    });
+  }
+
+  async getLpPosition(
+    userId: string,
+    poolIdOrPositionIdentifier: string,
+    dexName: string,
+  ): Promise<LpPositionDetails | null> {
+    const profile = await this.userLpProfileService.getProfile(userId);
+    if (!profile?.vaultPublicKey) {
+      throw new Error(
+        `User profile or vault public key not found for user ${userId}.`,
+      );
+    }
+    return this.lpManagementService.getPosition({
+      dex: dexName,
+      owner: profile.vaultPublicKey,
+      pool: poolIdOrPositionIdentifier,
+      position: poolIdOrPositionIdentifier,
+    });
+  }
+
+  async getAllUserLpPositions(userId: string): Promise<LpPositionDetails[]> {
+    const profile = await this.userLpProfileService.getProfile(userId);
+    if (!profile) return [];
+
+    const trackedPositions =
+      await this.userLpProfileService.getTrackedPositions(userId);
+
+    const positions: LpPositionDetails[] = [];
+    for (const tracked of trackedPositions) {
+      try {
+        const position = await this.lpManagementService.getPosition({
+          dex: tracked.dex,
+          owner: profile.vaultPublicKey,
+          pool: tracked.poolAddress,
+          position: tracked.positionIdentifier,
+        });
+        if (position) positions.push(position);
+      } catch (error) {
+        logger.warn(
+          `[DexInteractionService] Failed to fetch LP position ${tracked.positionIdentifier}`,
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    }
+
+    return positions;
+  }
+}