@elizaos/plugin-wallet 2.0.0-beta.1

package/dist/orca-Bybp1HXO.mjs

@@ -0,0 +1,249 @@
+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 { getMint } from "@solana/spl-token";
+import { Connection, Keypair, PublicKey, clusterApiUrl } from "@solana/web3.js";
+import bs58 from "bs58";
+import { PoolUtil, buildWhirlpoolClient } from "@orca-so/whirlpools-sdk";
+//#region src/lp/utils/solanaClient.ts
+const DEFAULT_ENDPOINT = clusterApiUrl("mainnet-beta");
+const DEFAULT_COMMITMENT = "confirmed";
+/**
+* Gets a Solana RPC connection configured from runtime settings
+*/
+function getConnection(runtime) {
+	const rpcUrl = runtime.getSetting("SOLANA_RPC_URL") || runtime.getSetting("RPC_URL") || DEFAULT_ENDPOINT;
+	const commitmentRaw = runtime.getSetting("SOLANA_COMMITMENT") || DEFAULT_COMMITMENT;
+	return new Connection(rpcUrl, typeof commitmentRaw === "string" ? commitmentRaw : DEFAULT_COMMITMENT);
+}
+function getWalletPublicKey(runtime) {
+	const pubKey = runtime.getSetting("SOLANA_PUBLIC_KEY");
+	return pubKey && typeof pubKey === "string" ? pubKey : null;
+}
+function getWalletPrivateKey(runtime) {
+	const privKey = runtime.getSetting("SOLANA_PRIVATE_KEY");
+	return privKey && typeof privKey === "string" ? privKey : null;
+}
+/**
+* Loads a Solana wallet from runtime settings
+* @param runtime The agent runtime
+* @param requirePrivateKey Whether to require a full keypair (true) or just public key (false)
+* @returns WalletResult containing either keypair or public key
+*/
+async function loadWallet(runtime, requirePrivateKey = true) {
+	if (requirePrivateKey) {
+		const privateKeyString = getWalletPrivateKey(runtime);
+		if (!privateKeyString) throw new Error("SOLANA_PRIVATE_KEY not found in settings");
+		try {
+			const secretKey = bs58.decode(privateKeyString);
+			const signer = Keypair.fromSecretKey(secretKey);
+			return {
+				signer,
+				address: signer.publicKey
+			};
+		} catch (_e) {
+			logger.debug("Error decoding base58 private key, trying base64...");
+			try {
+				const secretKey = Uint8Array.from(Buffer.from(privateKeyString, "base64"));
+				const signer = Keypair.fromSecretKey(secretKey);
+				return {
+					signer,
+					address: signer.publicKey
+				};
+			} catch (e2) {
+				logger.error("Error decoding private key:", e2);
+				throw new Error("Invalid private key format - must be base58 or base64 encoded");
+			}
+		}
+	} else {
+		const privateKeyString = getWalletPrivateKey(runtime);
+		if (privateKeyString) try {
+			const secretKey = bs58.decode(privateKeyString);
+			return { address: Keypair.fromSecretKey(secretKey).publicKey };
+		} catch {}
+		const publicKeyString = getWalletPublicKey(runtime);
+		if (!publicKeyString) throw new Error("SOLANA_PUBLIC_KEY or SOLANA_PRIVATE_KEY not found in settings");
+		return { address: new PublicKey(publicKeyString) };
+	}
+}
+//#endregion
+//#region src/chains/solana/dex/orca/providers/positionProvider.ts
+const POSITION_LIMIT = 20;
+const positionProvider = {
+	name: "orca-lp-position-provider",
+	description: "Provides Orca LP position status.",
+	descriptionCompressed: "Orca LP positions status.",
+	dynamic: true,
+	contexts: [
+		"finance",
+		"crypto",
+		"wallet"
+	],
+	contextGate: { anyOf: [
+		"finance",
+		"crypto",
+		"wallet"
+	] },
+	cacheStable: false,
+	cacheScope: "turn",
+	roleGate: { minRole: "OWNER" },
+	relevanceKeywords: [
+		"orca",
+		"position",
+		"positionprovider",
+		"plugin",
+		"manager",
+		"status",
+		"state",
+		"context",
+		"info",
+		"details",
+		"chat",
+		"conversation",
+		"agent",
+		"room"
+	],
+	get: async (runtime, message, state) => {
+		const __providerKeywords = [
+			"orca",
+			"position",
+			"positionprovider",
+			"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 { address: ownerAddress } = await loadWallet(runtime, false);
+			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 Orca position provider:", error);
+			return {
+				text: "Orca 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 "Orca LP positions:\npositions:";
+	const lines = ["Orca LP positions:"];
+	positions.forEach((position, index) => {
+		lines.push(`positions[${index}]{whirlpoolAddress,positionMint,inRange,distanceCenterPositionFromPoolPriceBps,positionWidthBps}: ${position.whirlpoolAddress.toString()},${position.positionMint.toString()},${position.inRange},${position.distanceCenterPositionFromPoolPriceBps},${position.positionWidthBps}`);
+	});
+	return lines.join("\n");
+}
+const fetchPositions = async (connection, ownerAddress) => {
+	try {
+		const client = buildWhirlpoolClient(connection);
+		const positions = await client.getUserPositions(ownerAddress);
+		const fetchedWhirlpools = /* @__PURE__ */ new Map();
+		const fetchedMints = /* @__PURE__ */ new Map();
+		return await Promise.all(positions.map(async (position) => {
+			const positionData = position.getData();
+			const positionMint = position.getAddress();
+			const whirlpoolAddress = position.getWhirlpoolAddress();
+			if (!fetchedWhirlpools.has(whirlpoolAddress.toString())) {
+				const whirlpool = await client.getWhirlpool(whirlpoolAddress);
+				if (whirlpool) fetchedWhirlpools.set(whirlpoolAddress.toString(), whirlpool);
+			}
+			const whirlpool = fetchedWhirlpools.get(whirlpoolAddress.toString());
+			const tokenMintA = whirlpool.getTokenAMint();
+			const tokenMintB = whirlpool.getTokenBMint();
+			if (!fetchedMints.has(tokenMintA.toString())) {
+				const mintA = await getMint(connection, tokenMintA);
+				fetchedMints.set(tokenMintA.toString(), mintA);
+			}
+			if (!fetchedMints.has(tokenMintB.toString())) {
+				const mintB = await getMint(connection, tokenMintB);
+				fetchedMints.set(tokenMintB.toString(), mintB);
+			}
+			const mintA = fetchedMints.get(tokenMintA.toString());
+			const mintB = fetchedMints.get(tokenMintB.toString());
+			const currentPrice = PoolUtil.sqrtPriceX64ToPrice(whirlpool.getData().sqrtPrice, mintA.decimals, mintB.decimals);
+			const positionLowerPrice = PoolUtil.tickIndexToPrice(positionData.tickLowerIndex, mintA.decimals, mintB.decimals);
+			const positionUpperPrice = PoolUtil.tickIndexToPrice(positionData.tickUpperIndex, mintA.decimals, mintB.decimals);
+			const currentTick = whirlpool.getData().tickCurrentIndex;
+			const inRange = currentTick >= positionData.tickLowerIndex && currentTick <= positionData.tickUpperIndex;
+			const positionCenterPrice = (positionLowerPrice + positionUpperPrice) / 2;
+			return {
+				whirlpoolAddress,
+				positionMint,
+				inRange,
+				distanceCenterPositionFromPoolPriceBps: Math.abs(currentPrice - positionCenterPrice) / currentPrice * 1e4,
+				positionWidthBps: (positionUpperPrice - positionLowerPrice) / positionCenterPrice * 1e4 / 2
+			};
+		}));
+	} catch (_error) {
+		throw new Error("Error during fetching positions");
+	}
+};
+//#endregion
+//#region src/chains/solana/dex/orca/services/srv_orca.ts
+var OrcaService = class OrcaService extends Service {
+	static serviceType = "ORCA_SERVICE";
+	capabilityDescription = "Provides Orca DEX integration for LP management";
+	constructor(runtime) {
+		super(runtime);
+		console.log("ORCA_SERVICE cstr");
+	}
+	static async start(runtime) {
+		console.log("ORCA_SERVICE trying to start");
+		const service = new OrcaService(runtime);
+		await service.start();
+		return service;
+	}
+	async start() {
+		console.log("ORCA_SERVICE trying to start");
+	}
+	async stop() {
+		console.log("ORCA_SERVICE trying to stop");
+	}
+};
+//#endregion
+//#region src/chains/solana/dex/orca/index.ts
+var orca_exports = /* @__PURE__ */ __exportAll({
+	OrcaService: () => OrcaService,
+	default: () => orcaPlugin,
+	orcaPlugin: () => orcaPlugin
+});
+const orcaPlugin = {
+	name: "@elizaos/plugin-lp-manager/orca",
+	description: "Orca Whirlpool LP management plugin for Solana",
+	providers: [positionProvider],
+	actions: [],
+	services: [OrcaService],
+	init: async (_config, runtime) => {
+		console.info("Orca Plugin initialized");
+		await registerLpProtocolProvider(runtime, createSolanaLpProtocolProvider({
+			dex: "orca",
+			label: "Orca",
+			service: runtime.getService(OrcaService.serviceType) ?? await OrcaService.start(runtime)
+		}));
+	}
+};
+//#endregion
+export { orca_exports as n, getConnection as r, orcaPlugin as t };