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

package/src/lp/tasks/LpAutoRebalanceTask.ts

@@ -1,117 +0,0 @@
-// @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

@@ -1,370 +0,0 @@
-// @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();
-		});
-	});
-});