@elizaos/plugin-wallet 2.0.0-beta.1

package/src/lp/services/__tests__/MockLpService.ts

@@ -0,0 +1,146 @@
+// @ts-nocheck — test-only mock for LP registry and E2E setup
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type {
+  AddLiquidityConfig,
+  ILpService,
+  LpPositionDetails,
+  PoolInfo,
+  RemoveLiquidityConfig,
+  TransactionResult,
+} from "../../types.ts";
+import {
+  createSolanaLpProtocolProvider,
+  getLpManagementService,
+} from "../LpManagementService.ts";
+
+export class MockLpService extends Service implements ILpService {
+  public readonly capabilityDescription =
+    "Test-only LP service for registry scenarios.";
+  private positions = new Map<string, LpPositionDetails[]>();
+
+  constructor(
+    runtime: IAgentRuntime,
+    private readonly dexName = "mock-dex",
+  ) {
+    super(runtime);
+  }
+
+  getDexName(): string {
+    return this.dexName;
+  }
+
+  async getPools(
+    tokenAMint?: string,
+    tokenBMint?: string,
+  ): Promise<PoolInfo[]> {
+    const pools: PoolInfo[] = [
+      {
+        id: `${this.dexName}-sol-usdc`,
+        displayName: `${this.dexName} SOL/USDC`,
+        dex: this.dexName,
+        tokenA: {
+          mint: "So11111111111111111111111111111111111111112",
+          symbol: "SOL",
+          decimals: 9,
+        },
+        tokenB: {
+          mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+          symbol: "USDC",
+          decimals: 6,
+        },
+        apr: 12,
+        tvl: 1000000,
+      },
+    ];
+
+    if (!tokenAMint && !tokenBMint) return pools;
+    return pools.filter((pool) => {
+      const mints = [pool.tokenA?.mint, pool.tokenB?.mint];
+      return (
+        (!tokenAMint || mints.includes(tokenAMint)) &&
+        (!tokenBMint || mints.includes(tokenBMint))
+      );
+    });
+  }
+
+  async addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult> {
+    const owner = config.userVault?.publicKey?.toBase58?.() || "test-owner";
+    const position: LpPositionDetails = {
+      poolId: config.poolId,
+      dex: this.dexName,
+      lpTokenBalance: {
+        address: `lp-${config.poolId}`,
+        balance: "1000",
+        decimals: 6,
+        symbol: "LP",
+      },
+      underlyingTokens: [],
+      accruedFees: [],
+      rewards: [],
+      valueUsd: 100,
+    };
+    this.positions.set(owner, [...(this.positions.get(owner) || []), position]);
+    return {
+      success: true,
+      transactionId: `mock-open-${this.dexName}`,
+      data: { poolId: config.poolId },
+    };
+  }
+
+  async removeLiquidity(
+    config: RemoveLiquidityConfig,
+  ): Promise<TransactionResult> {
+    const owner = config.userVault?.publicKey?.toBase58?.() || "test-owner";
+    this.positions.set(
+      owner,
+      (this.positions.get(owner) || []).filter(
+        (position) => position.poolId !== config.poolId,
+      ),
+    );
+    return {
+      success: true,
+      transactionId: `mock-close-${this.dexName}`,
+      data: { poolId: config.poolId },
+    };
+  }
+
+  async getLpPositionDetails(
+    owner: string,
+    poolOrPositionIdentifier: string,
+  ): Promise<LpPositionDetails | null> {
+    return (
+      (this.positions.get(owner) || []).find(
+        (position) => position.poolId === poolOrPositionIdentifier,
+      ) || null
+    );
+  }
+
+  async getMarketDataForPools(
+    poolIds: string[],
+  ): Promise<Record<string, Partial<PoolInfo>>> {
+    return Object.fromEntries(
+      poolIds.map((poolId) => [poolId, { apr: 12, tvl: 1000000 }]),
+    );
+  }
+
+  async start(): Promise<void> {}
+  async stop(): Promise<void> {}
+}
+
+export async function registerMockDexServices(
+  runtime: IAgentRuntime,
+): Promise<void> {
+  const registry = await getLpManagementService(runtime);
+  if (!registry) return;
+
+  for (const dex of ["raydium", "orca", "meteora"]) {
+    const service = new MockLpService(runtime, dex);
+    registry.registerProtocol(
+      createSolanaLpProtocolProvider({
+        dex,
+        label: dex,
+        service,
+      }),
+    );
+  }
+}

package/src/lp/tasks/LpAutoRebalanceTask.ts

@@ -0,0 +1,117 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import { type IAgentRuntime, logger } from "@elizaos/core";
+
+/**
+ * LpAutoRebalanceTask - Automated task for rebalancing LP positions
+ *
+ * This task monitors LP positions and triggers rebalancing when positions
+ * drift outside acceptable ranges.
+ */
+export class LpAutoRebalanceTask {
+	private runtime: IAgentRuntime | null = null;
+	private intervalId: ReturnType<typeof setInterval> | null = null;
+	private isRunning = false;
+
+	// Configuration
+	private checkIntervalMs = 60000; // Default: check every minute
+	private rebalanceThresholdBps = 500; // Default: 5% drift threshold
+
+	constructor(config?: {
+		checkIntervalMs?: number;
+		rebalanceThresholdBps?: number;
+	}) {
+		if (config?.checkIntervalMs) {
+			this.checkIntervalMs = config.checkIntervalMs;
+		}
+		if (config?.rebalanceThresholdBps) {
+			this.rebalanceThresholdBps = config.rebalanceThresholdBps;
+		}
+	}
+
+	/**
+	 * Start the auto-rebalance task
+	 */
+	async start(runtime: IAgentRuntime): Promise<void> {
+		if (this.isRunning) {
+			logger.warn("[LpAutoRebalanceTask] Task is already running");
+			return;
+		}
+
+		this.runtime = runtime;
+		this.isRunning = true;
+
+		logger.info(
+			`[LpAutoRebalanceTask] Starting with interval ${this.checkIntervalMs}ms and threshold ${this.rebalanceThresholdBps}bps`,
+		);
+
+		// Run initial check
+		await this.checkAndRebalance();
+
+		// Set up periodic checks
+		this.intervalId = setInterval(async () => {
+			await this.checkAndRebalance();
+		}, this.checkIntervalMs);
+	}
+
+	/**
+	 * Stop the auto-rebalance task
+	 */
+	stop(): void {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = null;
+		}
+		this.isRunning = false;
+		logger.info("[LpAutoRebalanceTask] Stopped");
+	}
+
+	/**
+	 * Check positions and rebalance if needed
+	 */
+	private async checkAndRebalance(): Promise<void> {
+		if (!this.runtime) {
+			logger.error("[LpAutoRebalanceTask] Runtime not initialized");
+			return;
+		}
+
+		try {
+			logger.debug("[LpAutoRebalanceTask] Checking positions...");
+
+			// Get DexInteractionService to check positions
+			const dexService = this.runtime.getService("dex-interaction");
+			if (!dexService) {
+				logger.debug(
+					"[LpAutoRebalanceTask] DexInteractionService not available",
+				);
+				return;
+			}
+
+			// The actual rebalancing logic would be implemented here
+			// This is a placeholder that can be extended with real DEX integration
+			logger.debug("[LpAutoRebalanceTask] Position check complete");
+		} catch (error: unknown) {
+			logger.error(
+				"[LpAutoRebalanceTask] Error checking positions:",
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	/**
+	 * Get current status of the task
+	 */
+	getStatus(): {
+		isRunning: boolean;
+		checkIntervalMs: number;
+		rebalanceThresholdBps: number;
+	} {
+		return {
+			isRunning: this.isRunning,
+			checkIntervalMs: this.checkIntervalMs,
+			rebalanceThresholdBps: this.rebalanceThresholdBps,
+		};
+	}
+}
+
+// Export a default instance for convenience
+export const lpAutoRebalanceTask = new LpAutoRebalanceTask();

package/src/lp/tasks/__tests__/LpAutoRebalanceTask.test.ts

@@ -0,0 +1,370 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+/// <reference types="vitest/globals" />
+import type { IAgentRuntime } from "@elizaos/core";
+import { Keypair as SolanaKeypair } from "@solana/web3.js";
+import {
+	beforeEach,
+	describe,
+	expect,
+	it,
+	type Mock,
+	type Mocked,
+	vi,
+} from "vitest";
+import type {
+	IDexInteractionService,
+	IUserLpProfileService,
+	IVaultService,
+	IYieldOptimizationService,
+	LpPositionDetails,
+	OptimizationOpportunity,
+	PoolInfo,
+	TokenBalance,
+	TransactionResult,
+	UserLpProfile,
+} from "../../types.ts";
+import { LpAutoRebalanceTask } from "../LpAutoRebalanceTask.ts";
+
+// Extended transaction results (matching the types in LpAutoRebalanceTask)
+interface RemoveLiquidityResult extends TransactionResult {
+	tokensReceived?: TokenBalance[];
+}
+
+interface AddLiquidityResult extends TransactionResult {
+	lpTokensReceived?: TokenBalance;
+}
+
+// Create a mock runtime with getService method
+const createMockRuntime = (services: Record<string, any>): IAgentRuntime => {
+	return {
+		getService: vi.fn((serviceName: string) => services[serviceName]),
+	} as any as IAgentRuntime;
+};
+
+const mockUserLpProfileService: Mocked<IUserLpProfileService> = {
+	ensureProfile: vi.fn(),
+	getProfile: vi.fn(),
+	updateProfile: vi.fn(),
+	addTrackedPosition: vi.fn(),
+	removeTrackedPosition: vi.fn(),
+	getTrackedPositions: vi.fn(),
+	getAllProfilesWithAutoRebalanceEnabled: vi.fn(),
+	start: vi.fn(),
+	stop: vi.fn(),
+	capabilityDescription: "Mock UserLpProfileService",
+} as any;
+
+const mockDexInteractionService: Mocked<IDexInteractionService> = {
+	registerDexService: vi.fn(),
+	getPools: vi.fn(),
+	addLiquidity: vi.fn(),
+	removeLiquidity: vi.fn(),
+	getLpPosition: vi.fn(),
+	getAllUserLpPositions: vi.fn(),
+	start: vi.fn(),
+	stop: vi.fn(),
+	capabilityDescription: "Mock DexInteractionService",
+} as any;
+
+const mockYieldOptimizationService: Mocked<IYieldOptimizationService> = {
+	fetchAllPoolData: vi.fn(),
+	findBestYieldOpportunities: vi.fn(),
+	calculateRebalanceCost: vi.fn(),
+	findBestYield: vi.fn(),
+	start: vi.fn(),
+	stop: vi.fn(),
+	capabilityDescription: "Mock YieldOptimizationService",
+} as any;
+
+const mockVaultService: Mocked<IVaultService> = {
+	createVault: vi.fn(),
+	getVaultKeypair: vi.fn(),
+	getVaultPublicKey: vi.fn(),
+	getBalances: vi.fn(),
+	exportPrivateKey: vi.fn(),
+	start: vi.fn(),
+	stop: vi.fn(),
+	capabilityDescription: "Mock VaultService",
+} as any;
+
+const testUserKeypair = SolanaKeypair.generate();
+
+const testUserId1 = "rebalanceUser1";
+const testUserProfile1: UserLpProfile = {
+	userId: testUserId1,
+	vaultPublicKey: testUserKeypair.publicKey.toBase58(),
+	encryptedSecretKey: "key1",
+	autoRebalanceConfig: {
+		enabled: true,
+		minGainThresholdPercent: 1,
+		maxSlippageBps: 50,
+		preferredDexes: ["meteora"],
+	},
+	version: 1,
+	createdAt: "now",
+	updatedAt: "now",
+	trackedPositions: [],
+};
+
+// Updated Mock Data with correct property names
+const SOL_MINT = "So11111111111111111111111111111111111111112";
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+
+const testLpPosition1: LpPositionDetails = {
+	poolId: "currentPool1",
+	dex: "orca",
+	valueUsd: 1000,
+	lpTokenBalance: {
+		address: "lpMint1",
+		balance: "100",
+		decimals: 6,
+		symbol: "ORCA_LP_SOL_USDC",
+		uiAmount: 0.0001,
+	},
+	underlyingTokens: [
+		{
+			address: SOL_MINT,
+			balance: "10",
+			decimals: 9,
+			symbol: "SOL",
+			uiAmount: 0.00000001,
+		},
+		{
+			address: USDC_MINT,
+			balance: "500",
+			decimals: 6,
+			symbol: "USDC",
+			uiAmount: 0.0005,
+		},
+	],
+};
+
+const targetPool1: PoolInfo = {
+	id: "targetPoolGood",
+	dex: "meteora",
+	tokenA: { mint: SOL_MINT, symbol: "SOL", decimals: 9 },
+	tokenB: { mint: USDC_MINT, symbol: "USDC", decimals: 6 },
+	apr: 0.25,
+	displayName: "Good Yield Pool (SOL/USDC)",
+};
+
+const goodOpportunity: OptimizationOpportunity = {
+	sourcePosition: testLpPosition1,
+	targetPool: targetPool1,
+	estimatedNewYield: 25,
+	currentYield: 10,
+	netGainPercent: 5,
+	actions: ["Withdraw from orca", "Deposit to meteora"],
+	estimatedCostToMoveLamports: "5000",
+};
+
+describe("LpAutoRebalanceTask", () => {
+	let task: LpAutoRebalanceTask;
+	let mockRuntime: IAgentRuntime;
+
+	beforeEach(async () => {
+		vi.clearAllMocks();
+
+		// Create mock runtime with services
+		mockRuntime = createMockRuntime({
+			UserLpProfileService: mockUserLpProfileService,
+			"dex-interaction": mockDexInteractionService,
+			YieldOptimizationService: mockYieldOptimizationService,
+			VaultService: mockVaultService,
+		});
+
+		// Create task and initialize it
+		task = new LpAutoRebalanceTask();
+		await task.onReady(mockRuntime);
+
+		// Setup default mock behaviors
+		(
+			mockUserLpProfileService.getAllProfilesWithAutoRebalanceEnabled as Mock
+		).mockResolvedValue([testUserProfile1]);
+		(mockDexInteractionService.getAllUserLpPositions as Mock).mockResolvedValue(
+			[testLpPosition1],
+		);
+		(
+			mockYieldOptimizationService.findBestYieldOpportunities as Mock
+		).mockResolvedValue([goodOpportunity]);
+		(mockVaultService.getVaultKeypair as Mock).mockImplementation(
+			async (userId, secret) => {
+				if (
+					userId === testUserId1 &&
+					secret === testUserProfile1.encryptedSecretKey
+				) {
+					return testUserKeypair;
+				}
+				console.error(
+					`MockVaultService.getVaultKeypair called with unexpected args: userId=${userId}, secret=${secret}`,
+				);
+				return null;
+			},
+		);
+
+		const removeResult: RemoveLiquidityResult = {
+			success: true,
+			tokensReceived: testLpPosition1.underlyingTokens,
+		};
+		(mockDexInteractionService.removeLiquidity as Mock).mockResolvedValue(
+			removeResult,
+		);
+
+		const addResult: AddLiquidityResult = {
+			success: true,
+			transactionId: "txAddLiq",
+		};
+		(mockDexInteractionService.addLiquidity as Mock).mockResolvedValue(
+			addResult,
+		);
+	});
+
+	describe("execute", () => {
+		it("should fetch enabled profiles and process them", async () => {
+			await task.execute();
+			expect(
+				mockUserLpProfileService.getAllProfilesWithAutoRebalanceEnabled,
+			).toHaveBeenCalled();
+			expect(
+				mockYieldOptimizationService.findBestYieldOpportunities,
+			).toHaveBeenCalledWith(testUserId1, [testLpPosition1], []);
+		});
+
+		it("should handle errors when processing a user profile", async () => {
+			const userProfile2 = { ...testUserProfile1, userId: "rebalanceUser2" };
+			(
+				mockUserLpProfileService.getAllProfilesWithAutoRebalanceEnabled as Mock
+			).mockResolvedValue([testUserProfile1, userProfile2]);
+			(mockDexInteractionService.getAllUserLpPositions as Mock)
+				.mockRejectedValueOnce(new Error("Failed to get positions for user1"))
+				.mockResolvedValueOnce([]); // For user2, no positions
+
+			await task.execute();
+			// Should continue processing other users despite error
+			expect(
+				mockDexInteractionService.getAllUserLpPositions,
+			).toHaveBeenCalledTimes(2);
+		});
+	});
+
+	describe("processUserProfile", () => {
+		it("should execute rebalance if a good opportunity is found and meets criteria", async () => {
+			// The task should find opportunities and execute rebalance
+			await task.execute();
+
+			expect(
+				mockYieldOptimizationService.findBestYieldOpportunities,
+			).toHaveBeenCalledWith(testUserProfile1.userId, [testLpPosition1], []);
+			expect(mockVaultService.getVaultKeypair).toHaveBeenCalledWith(
+				testUserProfile1.userId,
+				testUserProfile1.encryptedSecretKey,
+			);
+			expect(mockDexInteractionService.removeLiquidity).toHaveBeenCalledTimes(
+				1,
+			);
+			expect(mockDexInteractionService.addLiquidity).toHaveBeenCalledTimes(1);
+		});
+
+		it("should handle rebalance execution failures", async () => {
+			// Make addLiquidity fail
+			const addResult: AddLiquidityResult = {
+				success: false,
+				error: "DEX add liquidity failed",
+			};
+			(mockDexInteractionService.addLiquidity as Mock).mockResolvedValue(
+				addResult,
+			);
+
+			// Execute should complete without throwing
+			await task.execute();
+
+			// Verify error was handled gracefully
+			expect(mockDexInteractionService.removeLiquidity).toHaveBeenCalled();
+			expect(mockDexInteractionService.addLiquidity).toHaveBeenCalled();
+		});
+
+		it("should not execute if opportunity does not meet criteria", async () => {
+			// Create opportunity with low net gain
+			const lowGainOpp = { ...goodOpportunity, netGainPercent: 0.5 }; // Below 1% threshold
+			(
+				mockYieldOptimizationService.findBestYieldOpportunities as Mock
+			).mockResolvedValue([lowGainOpp]);
+
+			await task.execute();
+
+			// Should not execute rebalance
+			expect(mockDexInteractionService.removeLiquidity).not.toHaveBeenCalled();
+			expect(mockDexInteractionService.addLiquidity).not.toHaveBeenCalled();
+		});
+
+		it("should not execute if target DEX is not in preferred list", async () => {
+			// Create opportunity with non-preferred DEX
+			const nonPreferredDexOpp = {
+				...goodOpportunity,
+				targetPool: { ...targetPool1, dex: "raydium" },
+			};
+			(
+				mockYieldOptimizationService.findBestYieldOpportunities as Mock
+			).mockResolvedValue([nonPreferredDexOpp]);
+
+			await task.execute();
+
+			expect(mockDexInteractionService.removeLiquidity).not.toHaveBeenCalled();
+		});
+	});
+
+	describe("executeRebalance edge cases", () => {
+		it("should handle remove liquidity failures", async () => {
+			const removeResult: RemoveLiquidityResult = {
+				success: false,
+				error: "Remove failed",
+			};
+			(mockDexInteractionService.removeLiquidity as Mock).mockResolvedValue(
+				removeResult,
+			);
+
+			await task.execute();
+
+			// Should not proceed to add liquidity
+			expect(mockDexInteractionService.addLiquidity).not.toHaveBeenCalled();
+		});
+
+		it("should handle token mismatch scenarios", async () => {
+			const mismatchedTokens: TokenBalance[] = [
+				{
+					address: "otherToken1",
+					balance: "1",
+					decimals: 6,
+					uiAmount: 0.000001,
+				},
+				{
+					address: "otherToken2",
+					balance: "1",
+					decimals: 6,
+					uiAmount: 0.000001,
+				},
+			];
+			const removeResult: RemoveLiquidityResult = {
+				success: true,
+				tokensReceived: mismatchedTokens,
+			};
+			(mockDexInteractionService.removeLiquidity as Mock).mockResolvedValue(
+				removeResult,
+			);
+
+			await task.execute();
+
+			// Should not proceed to add liquidity due to token mismatch
+			expect(mockDexInteractionService.addLiquidity).not.toHaveBeenCalled();
+		});
+
+		it("should handle null vault keypair", async () => {
+			(mockVaultService.getVaultKeypair as Mock).mockResolvedValue(null);
+
+			await task.execute();
+
+			// Should not proceed with rebalance
+			expect(mockDexInteractionService.removeLiquidity).not.toHaveBeenCalled();
+		});
+	});
+});