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

package/dist/LpManagementService-BWrQ5-cO.mjs

@@ -1,353 +0,0 @@
-import { ILpService, logger } from "@elizaos/core";
-//#region src/lp/services/LpManagementService.ts
-const LP_MANAGEMENT_SERVICE_TYPE = "lp-management";
-var NoMatchingLpProtocolError = class extends Error {
-	code = "NO_MATCHING_LP_PROTOCOL";
-	constructor(request) {
-		const details = [
-			request.chain ? `chain=${request.chain}` : void 0,
-			request.dex ? `dex=${request.dex}` : void 0,
-			request.chainId ? `chainId=${request.chainId}` : void 0
-		].filter(Boolean).join(", ");
-		super(`No registered LP protocol matches ${details || "the request"}`);
-		this.name = "NoMatchingLpProtocolError";
-	}
-};
-function normalizeDex(dex) {
-	return dex?.trim().toLowerCase();
-}
-function normalizeChain(chain) {
-	return chain?.trim().toLowerCase();
-}
-function protocolKey(chain, dex) {
-	return `${normalizeChain(chain)}:${normalizeDex(dex)}`;
-}
-function poolId(pool) {
-	if (!pool) return void 0;
-	if (typeof pool === "string") return pool;
-	return pool.poolAddress || pool.id || pool.address;
-}
-function amountValue(params, key, fallback = "0") {
-	const amount = params.amount;
-	if (key === "value" && [
-		"string",
-		"number",
-		"bigint"
-	].includes(typeof amount)) return String(amount);
-	if (amount && typeof amount === "object" && key in amount) {
-		const value = amount[key];
-		if (value !== void 0 && value !== null) return String(value);
-	}
-	const nested = params.amounts?.[key];
-	if (nested !== void 0 && nested !== null) return String(nested);
-	return fallback;
-}
-function bigintAmount(value, fallback = 0n) {
-	if (typeof value === "bigint") return value;
-	if (typeof value === "number" && Number.isFinite(value)) return BigInt(Math.trunc(value));
-	if (typeof value === "string" && value.trim()) return BigInt(value.trim());
-	return fallback;
-}
-function unsupported(protocol, operation) {
-	return {
-		success: false,
-		error: `${operation} is not implemented for ${protocol.dex} on ${protocol.chain}`
-	};
-}
-var LpManagementService = class LpManagementService extends ILpService {
-	static serviceType = LP_MANAGEMENT_SERVICE_TYPE;
-	capabilityDescription = "Aggregates registered DEX liquidity pool protocol providers across chains.";
-	protocols = /* @__PURE__ */ new Map();
-	static async start(runtime) {
-		const service = new LpManagementService(runtime);
-		logger.info("[LpManagementService] started");
-		return service;
-	}
-	async stop() {
-		this.protocols.clear();
-		logger.info("[LpManagementService] stopped");
-	}
-	getDexName() {
-		return "lp-management";
-	}
-	registerProtocol(provider) {
-		const key = protocolKey(provider.chain, provider.dex);
-		const normalizedProvider = {
-			...provider,
-			id: provider.id || key,
-			chain: normalizeChain(provider.chain),
-			dex: normalizeDex(provider.dex)
-		};
-		if (this.protocols.has(key)) logger.warn(`[LpManagementService] Replacing LP protocol provider ${key}`);
-		this.protocols.set(key, normalizedProvider);
-	}
-	unregisterProtocol(request) {
-		if (!request.chain || !request.dex) return false;
-		return this.protocols.delete(protocolKey(request.chain, request.dex));
-	}
-	listProtocols(request = {}) {
-		return this.matchingProtocols(request);
-	}
-	async listPools(params = {}) {
-		const requireMatch = Boolean(params.chain || params.dex || params.chainId);
-		const protocols = this.matchingProtocols(params);
-		if (protocols.length === 0) {
-			if (requireMatch) throw new NoMatchingLpProtocolError(params);
-			return [];
-		}
-		return (await Promise.all(protocols.map(async (protocol) => {
-			try {
-				return await protocol.listPools(params);
-			} catch (error) {
-				logger.warn(`[LpManagementService] Failed to list pools for ${protocol.chain}:${protocol.dex}`, error instanceof Error ? error.message : String(error));
-				return [];
-			}
-		}))).flat();
-	}
-	async openPosition(params) {
-		return this.resolveProtocol(params).openPosition(params);
-	}
-	async closePosition(params) {
-		return this.resolveProtocol(params).closePosition(params);
-	}
-	async repositionPosition(params) {
-		const protocol = this.resolveProtocol(params);
-		if (!protocol.repositionPosition) return unsupported(protocol, "reposition");
-		return protocol.repositionPosition(params);
-	}
-	async getPosition(params) {
-		return this.resolveProtocol(params).getPosition?.(params) ?? null;
-	}
-	async listPositions(params = {}) {
-		const protocols = this.matchingProtocols(params);
-		return (await Promise.all(protocols.map((protocol) => protocol.listPositions?.(params) ?? []))).flat();
-	}
-	async getPools(tokenAMint, tokenBMint) {
-		return this.listPools({
-			tokenA: tokenAMint,
-			tokenB: tokenBMint
-		});
-	}
-	async addLiquidity(params) {
-		return this.openPosition({
-			chain: params.chain || "solana",
-			dex: params.dexName,
-			userVault: params.userVault,
-			pool: params.poolId,
-			amount: {
-				tokenA: params.tokenAAmountLamports,
-				tokenB: params.tokenBAmountLamports
-			},
-			range: {
-				tickLowerIndex: params.tickLowerIndex,
-				tickUpperIndex: params.tickUpperIndex
-			},
-			slippageBps: params.slippageBps
-		});
-	}
-	async removeLiquidity(params) {
-		return this.closePosition({
-			chain: params.chain || "solana",
-			dex: params.dexName,
-			userVault: params.userVault,
-			pool: params.poolId,
-			amount: { lpToken: params.lpTokenAmountLamports },
-			slippageBps: params.slippageBps
-		});
-	}
-	async getLpPositionDetails(userAccountPublicKey, poolOrPositionIdentifier) {
-		for (const protocol of this.protocols.values()) {
-			if (!protocol.getPosition) continue;
-			const position = await protocol.getPosition({
-				owner: userAccountPublicKey,
-				pool: poolOrPositionIdentifier,
-				position: poolOrPositionIdentifier
-			});
-			if (position) return position;
-		}
-		return null;
-	}
-	async getMarketDataForPools(poolIds) {
-		const marketData = await Promise.all(Array.from(this.protocols.values()).map((protocol) => protocol.getMarketData?.(poolIds) ?? {}));
-		return Object.assign({}, ...marketData);
-	}
-	matchingProtocols(request) {
-		const requestedChain = normalizeChain(request.chain);
-		const requestedDex = normalizeDex(request.dex);
-		return Array.from(this.protocols.values()).filter((protocol) => {
-			if (requestedChain && protocol.chain !== requestedChain) return false;
-			if (requestedDex && protocol.dex !== requestedDex) return false;
-			if (request.chainId !== void 0 && protocol.supportedChainIds?.length && !protocol.supportedChainIds.includes(request.chainId)) return false;
-			return protocol.supportsRequest?.(request) ?? true;
-		});
-	}
-	resolveProtocol(request) {
-		const matches = this.matchingProtocols(request);
-		if (matches.length === 0) throw new NoMatchingLpProtocolError(request);
-		if (matches.length > 1) throw new Error(`Multiple LP protocols match this request (${matches.map((protocol) => `${protocol.chain}:${protocol.dex}`).join(", ")}). Specify chain and dex.`);
-		return matches[0];
-	}
-};
-async function getLpManagementService(runtime) {
-	const existing = runtime.getService(LP_MANAGEMENT_SERVICE_TYPE);
-	if (existing) return existing;
-	if (typeof runtime.getServiceLoadPromise === "function") return await runtime.getServiceLoadPromise("lp-management") ?? null;
-	return null;
-}
-async function registerLpProtocolProvider(runtime, provider) {
-	const registry = await getLpManagementService(runtime);
-	if (!registry) {
-		logger.warn(`[LpManagementService] Cannot register ${provider.chain}:${provider.dex}; registry service is unavailable`);
-		return;
-	}
-	registry.registerProtocol(provider);
-}
-function createSolanaLpProtocolProvider({ dex, label, service }) {
-	const provider = {
-		id: `solana:${normalizeDex(dex)}`,
-		chain: "solana",
-		dex: normalizeDex(dex),
-		label,
-		service,
-		supportsRequest: (request) => (!request.chain || normalizeChain(request.chain) === "solana") && (!request.dex || normalizeDex(request.dex) === normalizeDex(dex)),
-		listPools: async (params) => {
-			if (typeof service.getPools !== "function") return [];
-			return service.getPools(params.tokenA, params.tokenB);
-		},
-		openPosition: async (params) => {
-			if (typeof service.addLiquidity !== "function") return unsupported(provider, "open");
-			const id = poolId(params.pool);
-			if (!id) return {
-				success: false,
-				error: "Pool is required"
-			};
-			return service.addLiquidity({
-				userVault: params.userVault,
-				poolId: id,
-				tokenAAmountLamports: amountValue(params, "tokenA", amountValue(params, "value")),
-				tokenBAmountLamports: amountValue(params, "tokenB", void 0),
-				slippageBps: params.slippageBps ?? 50,
-				tickLowerIndex: params.range?.tickLowerIndex ?? params.range?.tickLower,
-				tickUpperIndex: params.range?.tickUpperIndex ?? params.range?.tickUpper
-			});
-		},
-		closePosition: async (params) => {
-			if (typeof service.removeLiquidity !== "function") return unsupported(provider, "close");
-			const id = poolId(params.pool) || params.position;
-			if (!id) return {
-				success: false,
-				error: "Pool or position is required"
-			};
-			return service.removeLiquidity({
-				userVault: params.userVault,
-				poolId: id,
-				lpTokenAmountLamports: amountValue(params, "lpToken", amountValue(params, "value")),
-				slippageBps: params.slippageBps ?? 50
-			});
-		},
-		getPosition: async (params) => {
-			if (typeof service.getLpPositionDetails !== "function") return null;
-			const identifier = params.position || poolId(params.pool);
-			if (!params.owner || !identifier) return null;
-			return service.getLpPositionDetails(params.owner, identifier);
-		},
-		getMarketData: async (poolIds) => {
-			if (typeof service.getMarketDataForPools !== "function") return {};
-			return service.getMarketDataForPools(poolIds);
-		}
-	};
-	if (typeof service.repositionPosition === "function") provider.repositionPosition = (params) => service.repositionPosition(params);
-	return provider;
-}
-function createEvmLpProtocolProvider({ dex, label, service }) {
-	const supportedChainIds = typeof service.getSupportedChainIds === "function" ? service.getSupportedChainIds() : [];
-	const provider = {
-		id: `evm:${normalizeDex(dex)}`,
-		chain: "evm",
-		dex: normalizeDex(dex),
-		label,
-		service,
-		supportedChainIds,
-		supportsRequest: (request) => {
-			if (request.chain && normalizeChain(request.chain) !== "evm") return false;
-			if (request.dex && normalizeDex(request.dex) !== normalizeDex(dex)) return false;
-			if (request.chainId !== void 0 && supportedChainIds.length > 0) return supportedChainIds.includes(request.chainId);
-			return true;
-		},
-		listPools: async (params) => {
-			const chainIds = params.chainId ? [params.chainId] : supportedChainIds;
-			return (await Promise.all(chainIds.map((chainId) => service.getPools(chainId, params.tokenA, params.tokenB, params.feeTier)))).flat();
-		},
-		openPosition: async (params) => {
-			if (!params.wallet) return {
-				success: false,
-				error: "EVM wallet is required"
-			};
-			if (!params.chainId) return {
-				success: false,
-				error: "EVM chainId is required"
-			};
-			const id = poolId(params.pool);
-			if (!id) return {
-				success: false,
-				error: "Pool address is required"
-			};
-			const evmParams = {
-				wallet: params.wallet,
-				chainId: params.chainId,
-				poolAddress: id,
-				tokenAAmount: bigintAmount(amountValue(params, "tokenA", amountValue(params, "value"))),
-				tokenBAmount: bigintAmount(amountValue(params, "tokenB", void 0), void 0),
-				slippageBps: params.slippageBps ?? 50,
-				tickLower: params.range?.tickLower ?? params.range?.tickLowerIndex,
-				tickUpper: params.range?.tickUpper ?? params.range?.tickUpperIndex,
-				deadline: params.deadline
-			};
-			return service.addLiquidity(evmParams);
-		},
-		closePosition: async (params) => {
-			if (!params.wallet) return {
-				success: false,
-				error: "EVM wallet is required"
-			};
-			if (!params.chainId) return {
-				success: false,
-				error: "EVM chainId is required"
-			};
-			const id = poolId(params.pool);
-			if (!id) return {
-				success: false,
-				error: "Pool address is required"
-			};
-			const evmParams = {
-				wallet: params.wallet,
-				chainId: params.chainId,
-				poolAddress: id,
-				tokenId: params.tokenId !== void 0 ? bigintAmount(params.tokenId) : params.position ? bigintAmount(params.position) : void 0,
-				lpTokenAmount: bigintAmount(amountValue(params, "lpToken", amountValue(params, "value")), void 0),
-				percentageToRemove: typeof params.amount === "object" ? params.amount?.percentage : void 0,
-				slippageBps: params.slippageBps ?? 50,
-				deadline: params.deadline
-			};
-			return service.removeLiquidity(evmParams);
-		},
-		getPosition: async (params) => {
-			if (!params.owner || !params.chainId) return null;
-			const id = poolId(params.pool);
-			if (!id) return null;
-			return service.getPositionDetails(params.chainId, params.owner, id, params.tokenId !== void 0 ? bigintAmount(params.tokenId) : params.position ? bigintAmount(params.position) : void 0);
-		},
-		listPositions: async (params) => {
-			if (!params.owner || !params.chainId) return [];
-			return service.getAllPositions(params.chainId, params.owner);
-		},
-		getMarketData: async (poolIds) => {
-			if (typeof service.getMarketData !== "function") return {};
-			return service.getMarketData(poolIds);
-		}
-	};
-	if (typeof service.repositionPosition === "function") provider.repositionPosition = (params) => service.repositionPosition(params);
-	return provider;
-}
-//#endregion
-export { getLpManagementService as a, createSolanaLpProtocolProvider as i, NoMatchingLpProtocolError as n, registerLpProtocolProvider as o, createEvmLpProtocolProvider as r, LpManagementService as t };

package/dist/MockLpService-D_Apn4Fd.mjs

@@ -1,99 +0,0 @@
-import { a as getLpManagementService, i as createSolanaLpProtocolProvider } from "./LpManagementService-BWrQ5-cO.mjs";
-import { Service } from "@elizaos/core";
-//#region src/lp/services/__tests__/MockLpService.ts
-var MockLpService = class extends Service {
-	capabilityDescription = "Test-only LP service for registry scenarios.";
-	positions = /* @__PURE__ */ new Map();
-	constructor(runtime, dexName = "mock-dex") {
-		super(runtime);
-		this.dexName = dexName;
-	}
-	getDexName() {
-		return this.dexName;
-	}
-	async getPools(tokenAMint, tokenBMint) {
-		const pools = [{
-			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: 1e6
-		}];
-		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) {
-		const owner = config.userVault?.publicKey?.toBase58?.() || "test-owner";
-		const position = {
-			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) {
-		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, poolOrPositionIdentifier) {
-		return (this.positions.get(owner) || []).find((position) => position.poolId === poolOrPositionIdentifier) || null;
-	}
-	async getMarketDataForPools(poolIds) {
-		return Object.fromEntries(poolIds.map((poolId) => [poolId, {
-			apr: 12,
-			tvl: 1e6
-		}]));
-	}
-	async start() {}
-	async stop() {}
-};
-async function registerMockDexServices(runtime) {
-	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
-		}));
-	}
-}
-//#endregion
-export { registerMockDexServices };