@elizaos/plugin-wallet 2.0.0-beta.1

package/dist/raydium-rfaM9yEf.mjs

@@ -0,0 +1,539 @@
+import { n as __exportAll } from "./chunk-hT5z_Zn9.mjs";
+import { i as createSolanaLpProtocolProvider, o as registerLpProtocolProvider } from "./LpManagementService-BWrQ5-cO.mjs";
+import { Service, logger, validateActionKeywords, validateActionRegex } from "@elizaos/core";
+import { Connection } from "@solana/web3.js";
+//#region src/chains/solana/dex/raydium/providers/positionProvider.ts
+const POSITION_LIMIT = 20;
+async function loadRaydiumPositionApi() {
+	const sdk = await import("@raydium-io/raydium-sdk");
+	const clmm = sdk.Clmm;
+	const position = sdk.Position;
+	if (typeof clmm?.getPool !== "function" || typeof position?.getPositionsByOwner !== "function") {
+		logger.warn("Raydium LP position helper is unavailable in the installed Raydium SDK; returning no Raydium LP positions.");
+		return null;
+	}
+	return {
+		clmm: { getPool: clmm.getPool.bind(clmm) },
+		position: { getPositionsByOwner: position.getPositionsByOwner.bind(position) }
+	};
+}
+const raydiumPositionProvider = {
+	name: "raydium-lp-position-provider",
+	description: "Provides Raydium LP position status.",
+	descriptionCompressed: "Raydium LP positions status.",
+	dynamic: true,
+	contexts: [
+		"finance",
+		"crypto",
+		"wallet"
+	],
+	contextGate: { anyOf: [
+		"finance",
+		"crypto",
+		"wallet"
+	] },
+	cacheStable: false,
+	cacheScope: "turn",
+	roleGate: { minRole: "OWNER" },
+	relevanceKeywords: [
+		"raydium",
+		"position",
+		"raydiumpositionprovider",
+		"plugin",
+		"manager",
+		"status",
+		"state",
+		"context",
+		"info",
+		"details",
+		"chat",
+		"conversation",
+		"agent",
+		"room"
+	],
+	get: async (runtime, message, state) => {
+		const __providerKeywords = [
+			"raydium",
+			"position",
+			"raydiumpositionprovider",
+			"plugin",
+			"manager",
+			"status",
+			"state",
+			"context",
+			"info",
+			"details",
+			"chat",
+			"conversation",
+			"agent",
+			"room"
+		];
+		const __providerRegex = new RegExp(`\\b(${__providerKeywords.join("|")})\\b`, "i");
+		const __recentMessages = state?.recentMessagesData || [];
+		if (!(validateActionKeywords(message, __recentMessages, __providerKeywords) || validateActionRegex(message, __recentMessages, __providerRegex))) return { text: "" };
+		if (!state) state = await runtime.composeState(message);
+		else state = await runtime.updateRecentMessageState(state);
+		try {
+			const privateKey = runtime.getSetting("SOLANA_PRIVATE_KEY");
+			if (!privateKey || typeof privateKey !== "string") {
+				logger.warn("SOLANA_PRIVATE_KEY not configured");
+				return {
+					text: "Raydium LP positions unavailable.",
+					data: {
+						positions: [],
+						error: "SOLANA_PRIVATE_KEY not configured"
+					},
+					values: {
+						positionCount: 0,
+						hasPositions: false
+					}
+				};
+			}
+			const bs58 = await import("bs58");
+			const { Keypair } = await import("@solana/web3.js");
+			const secretKey = bs58.default.decode(privateKey);
+			const ownerAddress = Keypair.fromSecretKey(secretKey).publicKey;
+			const positions = await fetchPositions(new Connection(runtime.getSetting("SOLANA_RPC_URL") || "https://api.mainnet-beta.solana.com"), ownerAddress);
+			return {
+				text: formatPositionsForPrompt(positions.slice(0, POSITION_LIMIT)),
+				data: { positions: positions.slice(0, POSITION_LIMIT) }
+			};
+		} catch (error) {
+			logger.error("Error in Raydium position provider:", error);
+			return {
+				text: "Raydium LP positions unavailable.",
+				data: {
+					positions: [],
+					error: error instanceof Error ? error.message : String(error)
+				},
+				values: {
+					positionCount: 0,
+					hasPositions: false
+				}
+			};
+		}
+	}
+};
+function formatPositionsForPrompt(positions) {
+	if (positions.length === 0) return "Raydium LP positions:\npositions:";
+	const lines = ["Raydium LP positions:"];
+	positions.forEach((position, index) => {
+		lines.push(`positions[${index}]{poolAddress,positionNftMint,inRange,distanceCenterPositionFromPoolPriceBps,positionWidthBps}: ${position.poolAddress.toString()},${position.positionNftMint.toString()},${position.inRange},${position.distanceCenterPositionFromPoolPriceBps},${position.positionWidthBps}`);
+	});
+	return lines.join("\n");
+}
+const fetchPositions = async (connection, ownerAddress) => {
+	try {
+		const api = await loadRaydiumPositionApi();
+		if (!api) return [];
+		const { clmm, position: positionApi } = api;
+		const positions = await positionApi.getPositionsByOwner(connection, ownerAddress);
+		const poolsMap = /* @__PURE__ */ new Map();
+		for (const position of positions) if (!poolsMap.has(position.poolId.toString())) {
+			const poolInfo = await clmm.getPool(connection, position.poolId);
+			poolsMap.set(position.poolId.toString(), poolInfo);
+		}
+		return await Promise.all(positions.map(async (position) => {
+			const pool = poolsMap.get(position.poolId.toString());
+			if (!pool) throw new Error(`Missing pool metadata for pool ID ${position.poolId.toString()}`);
+			const currentPrice = pool.currentPrice;
+			const positionLowerPrice = pool.tickArrayLower;
+			const positionUpperPrice = pool.tickArrayUpper;
+			const inRange = position.tickLower <= pool.currentTickIndex && pool.currentTickIndex <= position.tickUpper;
+			const positionCenterPrice = (positionLowerPrice + positionUpperPrice) / 2;
+			const distanceCenterPositionFromPoolPriceBps = Math.abs(currentPrice - positionCenterPrice) / currentPrice * 1e4;
+			const positionWidthBps = (positionUpperPrice - positionLowerPrice) / positionCenterPrice * 1e4 / 2;
+			return {
+				poolAddress: position.poolId,
+				positionNftMint: position.nftMint,
+				inRange,
+				distanceCenterPositionFromPoolPriceBps,
+				positionWidthBps
+			};
+		}));
+	} catch (error) {
+		logger.error("Error during fetching Raydium positions:", error);
+		throw new Error("Error during fetching positions");
+	}
+};
+//#endregion
+//#region src/chains/solana/dex/raydium/services/srv_raydium.ts
+const Position = {
+	getPositionsByOwner: unsupportedRaydiumPositionMethod,
+	create: unsupportedRaydiumPositionMethod,
+	close: unsupportedRaydiumPositionMethod,
+	update: unsupportedRaydiumPositionMethod
+};
+function unsupportedRaydiumPositionMethod() {
+	throw new Error("Raydium position helpers are unavailable in the installed Raydium SDK");
+}
+var RaydiumService = class RaydiumService extends Service {
+	isRunning = false;
+	registry = {};
+	static serviceType = "RAYDIUM_SERVICE";
+	capabilityDescription = "Provides Raydium DEX integration for token swaps";
+	CONFIRMATION_CONFIG = {
+		MAX_ATTEMPTS: 12,
+		INITIAL_TIMEOUT: 2e3,
+		MAX_TIMEOUT: 2e4,
+		getDelayForAttempt: (attempt) => Math.min(2e3 * 1.5 ** attempt, 2e4)
+	};
+	constructor(runtime) {
+		super(runtime);
+		this.registry = {};
+		console.log("RAYDIUM_SERVICE cstr");
+	}
+	async registerProvider(provider) {
+		const id = Object.values(this.registry).length + 1;
+		console.log("registered", provider.name, `as Raydium provider #${id}`);
+		this.registry[id] = provider;
+		return id;
+	}
+	async getQuote({ inputMint, outputMint, amount, slippageBps }) {
+		try {
+			const quoteResponse = await fetch(`https://api.raydium.io/v2/main/quote?inputMint=${inputMint}&outputMint=${outputMint}&amount=${amount}&slippageBps=${slippageBps}`);
+			if (!quoteResponse.ok) {
+				const error = await quoteResponse.text();
+				logger.warn("Quote request failed:", {
+					status: quoteResponse.status,
+					error
+				});
+				throw new Error(`Failed to get quote: ${error}`);
+			}
+			return await quoteResponse.json();
+		} catch (error) {
+			logger.error("Error getting Raydium quote:", error);
+			throw error;
+		}
+	}
+	async executeSwap({ quoteResponse, userPublicKey, slippageBps }) {
+		try {
+			const swapResponse = await fetch("https://api.raydium.io/v2/main/swap", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					quoteResponse: {
+						...quoteResponse,
+						slippageBps
+					},
+					userPublicKey,
+					wrapAndUnwrapSol: true,
+					computeUnitPriceMicroLamports: 5e6,
+					dynamicComputeUnitLimit: true
+				})
+			});
+			if (!swapResponse.ok) {
+				const error = await swapResponse.text();
+				throw new Error(`Failed to get swap transaction: ${error}`);
+			}
+			return await swapResponse.json();
+		} catch (error) {
+			logger.error("Error executing Raydium swap:", error);
+			throw error;
+		}
+	}
+	async confirmTransaction(connection, signature) {
+		for (let i = 0; i < this.CONFIRMATION_CONFIG.MAX_ATTEMPTS; i++) try {
+			const status = await connection.getSignatureStatus(signature);
+			if (status.value?.confirmationStatus === "confirmed" || status.value?.confirmationStatus === "finalized") return true;
+			const delay = this.CONFIRMATION_CONFIG.getDelayForAttempt(i);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		} catch (error) {
+			logger.warn(`Confirmation check ${i + 1} failed:`, error);
+			if (i === this.CONFIRMATION_CONFIG.MAX_ATTEMPTS - 1) throw new Error("Could not confirm transaction status");
+			const delay = this.CONFIRMATION_CONFIG.getDelayForAttempt(i);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+		return false;
+	}
+	async getTokenPrice(tokenMint, quoteMint = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", inputDecimals = 6) {
+		try {
+			const baseAmount = 10 ** inputDecimals;
+			const quote = await this.getQuote({
+				inputMint: tokenMint,
+				outputMint: quoteMint,
+				amount: baseAmount,
+				slippageBps: 50
+			});
+			return Number(quote.outAmount) / 10 ** inputDecimals;
+		} catch (error) {
+			logger.error("Failed to get token price:", error);
+			return 0;
+		}
+	}
+	async getBestRoute({ inputMint, outputMint, amount }) {
+		try {
+			return (await this.getQuote({
+				inputMint,
+				outputMint,
+				amount,
+				slippageBps: 50
+			})).routePlan;
+		} catch (error) {
+			logger.error("Failed to get best route:", error);
+			throw error;
+		}
+	}
+	async getPriceImpact({ inputMint, outputMint, amount }) {
+		try {
+			const quote = await this.getQuote({
+				inputMint,
+				outputMint,
+				amount,
+				slippageBps: 50
+			});
+			return Number(quote.priceImpactPct);
+		} catch (error) {
+			logger.error("Failed to get price impact:", error);
+			throw error;
+		}
+	}
+	async getMinimumReceived({ inputMint, outputMint, amount, slippageBps }) {
+		try {
+			const quote = await this.getQuote({
+				inputMint,
+				outputMint,
+				amount,
+				slippageBps
+			});
+			return Number(quote.outAmount) * (1 - slippageBps / 1e4);
+		} catch (error) {
+			logger.error("Failed to calculate minimum received:", error);
+			throw error;
+		}
+	}
+	async estimateGasFees({ inputMint, outputMint, amount }) {
+		try {
+			const estimatedFee = (await this.getQuote({
+				inputMint,
+				outputMint,
+				amount,
+				slippageBps: 50
+			})).otherAmountThreshold || 5e3;
+			return {
+				lamports: estimatedFee,
+				sol: estimatedFee / 1e9
+			};
+		} catch (error) {
+			logger.error("Failed to estimate gas fees:", error);
+			throw error;
+		}
+	}
+	async findBestSlippage({ inputMint, outputMint, amount }) {
+		try {
+			const quote = await this.getQuote({
+				inputMint,
+				outputMint,
+				amount,
+				slippageBps: 50
+			});
+			const priceImpact = Number(quote.priceImpactPct);
+			let recommendedSlippage;
+			if (priceImpact < .5) recommendedSlippage = 50;
+			else if (priceImpact < 1) recommendedSlippage = 100;
+			else recommendedSlippage = 200;
+			return recommendedSlippage;
+		} catch (error) {
+			logger.error("Failed to find best slippage:", error);
+			throw error;
+		}
+	}
+	async getTokenPair({ inputMint, outputMint }) {
+		try {
+			const response = await fetch(`https://api.raydium.io/v2/main/pairs/${inputMint}/${outputMint}`);
+			if (!response.ok) throw new Error("Failed to fetch token pair data");
+			return await response.json();
+		} catch (error) {
+			logger.error("Failed to get token pair information:", error);
+			throw error;
+		}
+	}
+	async getHistoricalPrices({ inputMint, outputMint, timeframe = "24h" }) {
+		try {
+			const response = await fetch(`https://api.raydium.io/v2/main/prices/${inputMint}/${outputMint}?timeframe=${timeframe}`);
+			if (!response.ok) throw new Error("Failed to fetch historical prices");
+			return await response.json();
+		} catch (error) {
+			logger.error("Failed to get historical prices:", error);
+			throw error;
+		}
+	}
+	async findArbitragePaths({ startingMint, amount, maxHops: _maxHops = 3 }) {
+		try {
+			const commonTokens = [
+				"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+				"So11111111111111111111111111111111111111112",
+				"Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
+			];
+			const paths = [];
+			for (const token1 of commonTokens) {
+				if (token1 === startingMint) continue;
+				const quote1 = await this.getQuote({
+					inputMint: startingMint,
+					outputMint: token1,
+					amount,
+					slippageBps: 50
+				});
+				for (const token2 of commonTokens) {
+					if (token2 === token1 || token2 === startingMint) continue;
+					const quote2 = await this.getQuote({
+						inputMint: token1,
+						outputMint: token2,
+						amount: Number(quote1.outAmount),
+						slippageBps: 50
+					});
+					const finalQuote = await this.getQuote({
+						inputMint: token2,
+						outputMint: startingMint,
+						amount: Number(quote2.outAmount),
+						slippageBps: 50
+					});
+					const expectedReturn = Number(finalQuote.outAmount) - amount;
+					const totalPriceImpact = Number(quote1.priceImpactPct) + Number(quote2.priceImpactPct) + Number(finalQuote.priceImpactPct);
+					if (expectedReturn > 0) paths.push({
+						path: [
+							startingMint,
+							token1,
+							token2,
+							startingMint
+						],
+						expectedReturn,
+						priceImpact: totalPriceImpact
+					});
+				}
+			}
+			return paths.sort((a, b) => b.expectedReturn - a.expectedReturn);
+		} catch (error) {
+			logger.error("Failed to find arbitrage paths:", error);
+			throw error;
+		}
+	}
+	async getPositions(connection, ownerAddress) {
+		try {
+			return await Position.getPositionsByOwner(connection, ownerAddress);
+		} catch (error) {
+			logger.error("Error fetching positions:", error);
+			throw error;
+		}
+	}
+	async createPosition(connection, pool, owner, lowerTick, upperTick, tokenAmountA, tokenAmountB) {
+		try {
+			return await Position.create({
+				connection,
+				poolId: pool.id,
+				ownerInfo: {
+					wallet: owner,
+					tokenAccountA: pool.tokenAccountA,
+					tokenAccountB: pool.tokenAccountB
+				},
+				tickLower: lowerTick,
+				tickUpper: upperTick,
+				tokenAmountA,
+				tokenAmountB
+			});
+		} catch (error) {
+			logger.error("Error creating position:", error);
+			throw error;
+		}
+	}
+	async closePosition(connection, positionInfo, owner) {
+		try {
+			return await Position.close({
+				connection,
+				positionId: positionInfo.id,
+				owner
+			});
+		} catch (error) {
+			logger.error("Error closing position:", error);
+			throw error;
+		}
+	}
+	async updatePosition(connection, positionInfo, owner, liquidityDelta) {
+		try {
+			return await Position.update({
+				connection,
+				positionId: positionInfo.id,
+				owner,
+				liquidityDelta
+			});
+		} catch (error) {
+			logger.error("Error updating position:", error);
+			throw error;
+		}
+	}
+	static async start(runtime) {
+		console.log("RAYDIUM_SERVICE trying to start");
+		const service = new RaydiumService(runtime);
+		await service.start();
+		return service;
+	}
+	static async stop(runtime) {
+		const service = runtime.getService(RaydiumService.serviceType);
+		if (!service) throw new Error(`${RaydiumService.serviceType} service not found`);
+		await service.stop();
+	}
+	async start() {
+		if (this.isRunning) {
+			logger.warn("Raydium service is already running");
+			return;
+		}
+		console.log("RAYDIUM_SERVICE starting");
+		try {
+			logger.info("Starting Raydium service...");
+			this.isRunning = true;
+			logger.info("Raydium service started successfully");
+		} catch (error) {
+			logger.error("Error starting Raydium service:", error);
+			throw error;
+		}
+	}
+	async stop() {
+		if (!this.isRunning) {
+			logger.warn("Raydium service is not running");
+			return;
+		}
+		try {
+			logger.info("Stopping Raydium service...");
+			this.isRunning = false;
+			logger.info("Raydium service stopped successfully");
+		} catch (error) {
+			logger.error("Error stopping Raydium service:", error);
+			throw error;
+		}
+	}
+	isServiceRunning() {
+		return this.isRunning;
+	}
+};
+//#endregion
+//#region src/chains/solana/dex/raydium/index.ts
+var raydium_exports = /* @__PURE__ */ __exportAll({
+	RaydiumService: () => RaydiumService,
+	default: () => raydiumPlugin,
+	raydiumPlugin: () => raydiumPlugin
+});
+function hasExchangeRegistry(service) {
+	return service !== null && typeof service === "object" && typeof service.registerExchange === "function";
+}
+const raydiumPlugin = {
+	name: "@elizaos/plugin-lp-manager/raydium",
+	description: "Raydium CLMM LP management plugin for Solana",
+	actions: [],
+	providers: [raydiumPositionProvider],
+	services: [RaydiumService],
+	init: async (_config, runtime) => {
+		console.info("Raydium Plugin initialized");
+		await registerLpProtocolProvider(runtime, createSolanaLpProtocolProvider({
+			dex: "raydium",
+			label: "Raydium",
+			service: runtime.getService(RaydiumService.serviceType) ?? await RaydiumService.start(runtime)
+		}));
+		const solanaService = runtime.getService("solana");
+		if (hasExchangeRegistry(solanaService)) {
+			solanaService.registerExchange({ name: "Raydium DEX services" });
+			console.info("Raydium registered with Solana service");
+		}
+	}
+};
+//#endregion
+export { raydium_exports as n, raydiumPlugin as t };