@elizaos/plugin-wallet 2.0.0-beta.1

package/dist/uniswap-CReXgXVN.mjs

@@ -0,0 +1,573 @@
+import { n as __exportAll } from "./chunk-hT5z_Zn9.mjs";
+import { o as registerLpProtocolProvider, r as createEvmLpProtocolProvider } from "./LpManagementService-BWrQ5-cO.mjs";
+import { a as UNISWAP_V3_POOL_ABI, i as UNISWAP_V3_FEE_TIERS, n as UNISWAP_V3_ADDRESSES, o as UNISWAP_V3_POSITION_MANAGER_ABI, r as UNISWAP_V3_FACTORY_ABI, t as ERC20_ABI } from "./types-D5252NZk.mjs";
+import { Service, logger } from "@elizaos/core";
+import { createPublicClient, createWalletClient, http, maxUint128 } from "viem";
+import * as viemChains from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+//#region src/chains/evm/dex/uniswap/services/UniswapV3LpService.ts
+const SUPPORTED_CHAIN_IDS = [
+	1,
+	8453,
+	42161,
+	137,
+	10
+];
+function getViemChain(chainId) {
+	const chain = {
+		1: viemChains.mainnet,
+		8453: viemChains.base,
+		42161: viemChains.arbitrum,
+		137: viemChains.polygon,
+		10: viemChains.optimism
+	}[chainId];
+	if (!chain) throw new Error(`Unsupported chain ID: ${chainId}`);
+	return chain;
+}
+var UniswapV3LpService = class UniswapV3LpService extends Service {
+	static serviceType = "uniswap-v3-lp";
+	capabilityDescription = "Provides Uniswap V3 liquidity pool management for EVM chains.";
+	publicClients = /* @__PURE__ */ new Map();
+	walletClients = /* @__PURE__ */ new Map();
+	rpcUrls = /* @__PURE__ */ new Map();
+	constructor(runtime) {
+		super(runtime);
+		if (runtime) this.initializeRpcUrls();
+	}
+	initializeRpcUrls() {
+		for (const [chainId, envKeys] of Object.entries({
+			1: [
+				"ETHEREUM_RPC_URL",
+				"ETH_RPC_URL",
+				"EVM_PROVIDER_MAINNET"
+			],
+			8453: ["BASE_RPC_URL", "EVM_PROVIDER_BASE"],
+			42161: ["ARBITRUM_RPC_URL", "EVM_PROVIDER_ARBITRUM"],
+			137: ["POLYGON_RPC_URL", "EVM_PROVIDER_POLYGON"],
+			10: ["OPTIMISM_RPC_URL", "EVM_PROVIDER_OPTIMISM"]
+		})) for (const key of envKeys) {
+			const rpcUrl = this.runtime.getSetting(key);
+			if (rpcUrl && typeof rpcUrl === "string") {
+				this.rpcUrls.set(Number(chainId), rpcUrl);
+				break;
+			}
+		}
+	}
+	getPublicClient(chainId) {
+		let client = this.publicClients.get(chainId);
+		if (client) return client;
+		const rpcUrl = this.rpcUrls.get(chainId);
+		client = createPublicClient({
+			chain: getViemChain(chainId),
+			transport: rpcUrl ? http(rpcUrl) : http()
+		});
+		this.publicClients.set(chainId, client);
+		return client;
+	}
+	getWalletClient(chainId, privateKey) {
+		const cacheKey = chainId;
+		let client = this.walletClients.get(cacheKey);
+		if (client) return client;
+		const rpcUrl = this.rpcUrls.get(chainId);
+		const chain = getViemChain(chainId);
+		const account = privateKeyToAccount(privateKey);
+		client = createWalletClient({
+			chain,
+			transport: rpcUrl ? http(rpcUrl) : http(),
+			account
+		});
+		this.walletClients.set(cacheKey, client);
+		return client;
+	}
+	static async start(runtime) {
+		const service = new UniswapV3LpService(runtime);
+		logger.info("[UniswapV3LpService] started");
+		return service;
+	}
+	async stop() {
+		this.publicClients.clear();
+		this.walletClients.clear();
+		logger.info("[UniswapV3LpService] stopped");
+	}
+	getDexName() {
+		return "uniswap";
+	}
+	getSupportedChainIds() {
+		return SUPPORTED_CHAIN_IDS.filter((chainId) => UNISWAP_V3_ADDRESSES[chainId] !== void 0);
+	}
+	supportsChain(chainId) {
+		return this.getSupportedChainIds().includes(chainId);
+	}
+	async getPools(chainId, tokenA, tokenB, feeTier) {
+		if (!this.supportsChain(chainId)) {
+			logger.warn(`[UniswapV3LpService] Chain ${chainId} not supported`);
+			return [];
+		}
+		const addresses = UNISWAP_V3_ADDRESSES[chainId];
+		if (!addresses) return [];
+		const client = this.getPublicClient(chainId);
+		const pools = [];
+		if (tokenA && tokenB) {
+			const feeTiers = feeTier ? [feeTier] : Object.values(UNISWAP_V3_FEE_TIERS);
+			for (const fee of feeTiers) try {
+				const poolAddress = await client.readContract({
+					address: addresses.factory,
+					abi: UNISWAP_V3_FACTORY_ABI,
+					functionName: "getPool",
+					args: [
+						tokenA,
+						tokenB,
+						fee
+					]
+				});
+				if (poolAddress && poolAddress !== "0x0000000000000000000000000000000000000000") {
+					const poolInfo = await this.getPoolInfo(chainId, poolAddress);
+					if (poolInfo) pools.push(poolInfo);
+				}
+			} catch (_error) {
+				logger.debug(`[UniswapV3LpService] No pool found for ${tokenA}/${tokenB} at fee ${fee}`);
+			}
+		}
+		return pools;
+	}
+	async getPoolInfo(chainId, poolAddress) {
+		const client = this.getPublicClient(chainId);
+		const chain = getViemChain(chainId);
+		try {
+			const [token0, token1, fee, tickSpacing, _liquidity, slot0] = await Promise.all([
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "token0"
+				}),
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "token1"
+				}),
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "fee"
+				}),
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "tickSpacing"
+				}),
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "liquidity"
+				}),
+				client.readContract({
+					address: poolAddress,
+					abi: UNISWAP_V3_POOL_ABI,
+					functionName: "slot0"
+				})
+			]);
+			const [symbol0, decimals0, symbol1, decimals1] = await Promise.all([
+				client.readContract({
+					address: token0,
+					abi: ERC20_ABI,
+					functionName: "symbol"
+				}).catch(() => "UNKNOWN"),
+				client.readContract({
+					address: token0,
+					abi: ERC20_ABI,
+					functionName: "decimals"
+				}).catch(() => 18),
+				client.readContract({
+					address: token1,
+					abi: ERC20_ABI,
+					functionName: "symbol"
+				}).catch(() => "UNKNOWN"),
+				client.readContract({
+					address: token1,
+					abi: ERC20_ABI,
+					functionName: "decimals"
+				}).catch(() => 18)
+			]);
+			return {
+				id: poolAddress,
+				dex: "uniswap",
+				chainId,
+				chainName: chain.name,
+				poolAddress,
+				tokenA: {
+					address: token0,
+					symbol: symbol0,
+					decimals: Number(decimals0)
+				},
+				tokenB: {
+					address: token1,
+					symbol: symbol1,
+					decimals: Number(decimals1)
+				},
+				feeTier: Number(fee),
+				tickSpacing: Number(tickSpacing),
+				currentTick: Number(slot0[1]),
+				sqrtPriceX96: slot0[0],
+				fee: Number(fee) / 1e6,
+				displayName: `${symbol0}/${symbol1} (${Number(fee) / 1e4}%)`
+			};
+		} catch (error) {
+			logger.error(`[UniswapV3LpService] Error fetching pool info for ${poolAddress}:`, error instanceof Error ? error.message : String(error));
+			return null;
+		}
+	}
+	async addLiquidity(params) {
+		if (!this.supportsChain(params.chainId)) return {
+			success: false,
+			error: `Chain ${params.chainId} not supported`
+		};
+		const addresses = UNISWAP_V3_ADDRESSES[params.chainId];
+		if (!addresses) return {
+			success: false,
+			error: "Uniswap V3 not deployed on this chain"
+		};
+		try {
+			const publicClient = this.getPublicClient(params.chainId);
+			const walletClient = this.getWalletClient(params.chainId, params.wallet.privateKey);
+			const poolInfo = await this.getPoolInfo(params.chainId, params.poolAddress);
+			if (!poolInfo) return {
+				success: false,
+				error: "Pool not found"
+			};
+			const slippageMultiplier = BigInt(1e4 - params.slippageBps);
+			const amount0Min = params.tokenAAmount * slippageMultiplier / 10000n;
+			const amount1Min = (params.tokenBAmount ?? 0n) * slippageMultiplier / 10000n;
+			await this.approveToken(params.chainId, params.wallet.privateKey, poolInfo.tokenA.address, addresses.nonfungiblePositionManager, params.tokenAAmount);
+			if (params.tokenBAmount && params.tokenBAmount > 0n) await this.approveToken(params.chainId, params.wallet.privateKey, poolInfo.tokenB.address, addresses.nonfungiblePositionManager, params.tokenBAmount);
+			const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 1800);
+			const tickLower = params.tickLower ?? poolInfo.currentTick - 1e3;
+			const tickUpper = params.tickUpper ?? poolInfo.currentTick + 1e3;
+			const tickSpacing = poolInfo.tickSpacing ?? 60;
+			const alignedTickLower = Math.floor(tickLower / tickSpacing) * tickSpacing;
+			const alignedTickUpper = Math.ceil(tickUpper / tickSpacing) * tickSpacing;
+			const mintParams = {
+				token0: poolInfo.tokenA.address,
+				token1: poolInfo.tokenB.address,
+				fee: poolInfo.feeTier,
+				tickLower: alignedTickLower,
+				tickUpper: alignedTickUpper,
+				amount0Desired: params.tokenAAmount,
+				amount1Desired: params.tokenBAmount ?? 0n,
+				amount0Min,
+				amount1Min,
+				recipient: params.wallet.address,
+				deadline
+			};
+			const { request } = await publicClient.simulateContract({
+				address: addresses.nonfungiblePositionManager,
+				abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+				functionName: "mint",
+				args: [mintParams],
+				account: walletClient.account
+			});
+			const hash = await walletClient.writeContract(request);
+			const receipt = await publicClient.waitForTransactionReceipt({ hash });
+			return {
+				success: receipt.status === "success",
+				transactionId: hash,
+				hash,
+				chainId: params.chainId,
+				blockNumber: receipt.blockNumber,
+				gasUsed: receipt.gasUsed,
+				data: {
+					poolAddress: params.poolAddress,
+					tickLower: alignedTickLower,
+					tickUpper: alignedTickUpper
+				}
+			};
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error("[UniswapV3LpService] Error adding liquidity:", errorMsg);
+			return {
+				success: false,
+				error: errorMsg || "Unknown error adding liquidity"
+			};
+		}
+	}
+	async removeLiquidity(params) {
+		if (!this.supportsChain(params.chainId)) return {
+			success: false,
+			error: `Chain ${params.chainId} not supported`
+		};
+		const addresses = UNISWAP_V3_ADDRESSES[params.chainId];
+		if (!addresses) return {
+			success: false,
+			error: "Uniswap V3 not deployed on this chain"
+		};
+		if (!params.tokenId) return {
+			success: false,
+			error: "Position token ID required for Uniswap V3"
+		};
+		try {
+			const publicClient = this.getPublicClient(params.chainId);
+			const walletClient = this.getWalletClient(params.chainId, params.wallet.privateKey);
+			const position = await this.getPositionFromContract(params.chainId, params.tokenId);
+			if (!position) return {
+				success: false,
+				error: "Position not found"
+			};
+			let liquidityToRemove = position.liquidity;
+			if (params.percentageToRemove && params.percentageToRemove < 100) liquidityToRemove = position.liquidity * BigInt(params.percentageToRemove) / 100n;
+			const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 1800);
+			BigInt(1e4 - params.slippageBps);
+			const decreaseParams = {
+				tokenId: params.tokenId,
+				liquidity: liquidityToRemove,
+				amount0Min: 0n,
+				amount1Min: 0n,
+				deadline
+			};
+			const { request: decreaseRequest } = await publicClient.simulateContract({
+				address: addresses.nonfungiblePositionManager,
+				abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+				functionName: "decreaseLiquidity",
+				args: [decreaseParams],
+				account: walletClient.account
+			});
+			const decreaseHash = await walletClient.writeContract(decreaseRequest);
+			await publicClient.waitForTransactionReceipt({ hash: decreaseHash });
+			const collectParams = {
+				tokenId: params.tokenId,
+				recipient: params.wallet.address,
+				amount0Max: maxUint128,
+				amount1Max: maxUint128
+			};
+			const { request: collectRequest } = await publicClient.simulateContract({
+				address: addresses.nonfungiblePositionManager,
+				abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+				functionName: "collect",
+				args: [collectParams],
+				account: walletClient.account
+			});
+			const collectHash = await walletClient.writeContract(collectRequest);
+			const receipt = await publicClient.waitForTransactionReceipt({ hash: collectHash });
+			if (params.percentageToRemove === 100 || !params.percentageToRemove) try {
+				const { request: burnRequest } = await publicClient.simulateContract({
+					address: addresses.nonfungiblePositionManager,
+					abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+					functionName: "burn",
+					args: [params.tokenId],
+					account: walletClient.account
+				});
+				await walletClient.writeContract(burnRequest);
+			} catch (burnError) {
+				logger.debug("[UniswapV3LpService] Could not burn position NFT:", burnError instanceof Error ? burnError.message : String(burnError));
+			}
+			return {
+				success: receipt.status === "success",
+				transactionId: collectHash,
+				hash: collectHash,
+				chainId: params.chainId,
+				blockNumber: receipt.blockNumber,
+				gasUsed: receipt.gasUsed
+			};
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error("[UniswapV3LpService] Error removing liquidity:", errorMsg);
+			return {
+				success: false,
+				error: errorMsg || "Unknown error removing liquidity"
+			};
+		}
+	}
+	async getPositionFromContract(chainId, tokenId) {
+		const addresses = UNISWAP_V3_ADDRESSES[chainId];
+		if (!addresses) return null;
+		const client = this.getPublicClient(chainId);
+		try {
+			const result = await client.readContract({
+				address: addresses.nonfungiblePositionManager,
+				abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+				functionName: "positions",
+				args: [tokenId]
+			});
+			return {
+				tokenId,
+				nonce: result[0],
+				operator: result[1],
+				token0: result[2],
+				token1: result[3],
+				fee: result[4],
+				tickLower: result[5],
+				tickUpper: result[6],
+				liquidity: result[7],
+				feeGrowthInside0LastX128: result[8],
+				feeGrowthInside1LastX128: result[9],
+				tokensOwed0: result[10],
+				tokensOwed1: result[11]
+			};
+		} catch (error) {
+			logger.error(`[UniswapV3LpService] Error fetching position ${tokenId}:`, error instanceof Error ? error.message : String(error));
+			return null;
+		}
+	}
+	async getPositionDetails(chainId, owner, poolAddress, tokenId) {
+		if (!this.supportsChain(chainId)) return null;
+		if (tokenId) {
+			const position = await this.getPositionFromContract(chainId, tokenId);
+			if (!position) return null;
+			const client = this.getPublicClient(chainId);
+			getViemChain(chainId);
+			const [symbol0, decimals0, symbol1, decimals1] = await Promise.all([
+				client.readContract({
+					address: position.token0,
+					abi: ERC20_ABI,
+					functionName: "symbol"
+				}).catch(() => "UNKNOWN"),
+				client.readContract({
+					address: position.token0,
+					abi: ERC20_ABI,
+					functionName: "decimals"
+				}).catch(() => 18),
+				client.readContract({
+					address: position.token1,
+					abi: ERC20_ABI,
+					functionName: "symbol"
+				}).catch(() => "UNKNOWN"),
+				client.readContract({
+					address: position.token1,
+					abi: ERC20_ABI,
+					functionName: "decimals"
+				}).catch(() => 18)
+			]);
+			return {
+				poolId: poolAddress,
+				dex: "uniswap",
+				chainId,
+				owner,
+				tokenId: position.tokenId,
+				tickLower: position.tickLower,
+				tickUpper: position.tickUpper,
+				liquidity: position.liquidity,
+				lpTokenBalance: {
+					address: poolAddress,
+					balance: position.liquidity.toString(),
+					decimals: 0,
+					symbol: `UNI-V3-${symbol0}/${symbol1}`
+				},
+				underlyingTokens: [{
+					address: position.token0,
+					balance: position.tokensOwed0.toString(),
+					decimals: Number(decimals0),
+					symbol: symbol0
+				}, {
+					address: position.token1,
+					balance: position.tokensOwed1.toString(),
+					decimals: Number(decimals1),
+					symbol: symbol1
+				}]
+			};
+		}
+		return (await this.getAllPositions(chainId, owner)).find((p) => p.poolId.toLowerCase() === poolAddress.toLowerCase()) ?? null;
+	}
+	async getAllPositions(chainId, owner) {
+		if (!this.supportsChain(chainId)) return [];
+		const addresses = UNISWAP_V3_ADDRESSES[chainId];
+		if (!addresses) return [];
+		const client = this.getPublicClient(chainId);
+		const positions = [];
+		try {
+			const balance = await client.readContract({
+				address: addresses.nonfungiblePositionManager,
+				abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+				functionName: "balanceOf",
+				args: [owner]
+			});
+			for (let i = 0; i < Number(balance); i++) {
+				const tokenId = await client.readContract({
+					address: addresses.nonfungiblePositionManager,
+					abi: UNISWAP_V3_POSITION_MANAGER_ABI,
+					functionName: "tokenOfOwnerByIndex",
+					args: [owner, BigInt(i)]
+				});
+				const position = await this.getPositionFromContract(chainId, tokenId);
+				if (position && position.liquidity > 0n) {
+					const poolAddress = await client.readContract({
+						address: addresses.factory,
+						abi: UNISWAP_V3_FACTORY_ABI,
+						functionName: "getPool",
+						args: [
+							position.token0,
+							position.token1,
+							position.fee
+						]
+					});
+					if (poolAddress) {
+						const details = await this.getPositionDetails(chainId, owner, poolAddress, tokenId);
+						if (details) positions.push(details);
+					}
+				}
+			}
+		} catch (error) {
+			logger.error("[UniswapV3LpService] Error fetching all positions:", error instanceof Error ? error.message : String(error));
+		}
+		return positions;
+	}
+	async getMarketData(poolAddresses) {
+		const result = {};
+		for (const address of poolAddresses) for (const chainId of this.getSupportedChainIds()) try {
+			const poolInfo = await this.getPoolInfo(chainId, address);
+			if (poolInfo) {
+				result[address] = poolInfo;
+				break;
+			}
+		} catch {}
+		return result;
+	}
+	async approveToken(chainId, privateKey, tokenAddress, spenderAddress, amount) {
+		const publicClient = this.getPublicClient(chainId);
+		const walletClient = this.getWalletClient(chainId, privateKey);
+		if (await publicClient.readContract({
+			address: tokenAddress,
+			abi: ERC20_ABI,
+			functionName: "allowance",
+			args: [walletClient.account?.address, spenderAddress]
+		}) >= amount) return;
+		logger.info(`[UniswapV3LpService] Approving ${tokenAddress} for ${spenderAddress}`);
+		const { request } = await publicClient.simulateContract({
+			address: tokenAddress,
+			abi: ERC20_ABI,
+			functionName: "approve",
+			args: [spenderAddress, amount],
+			account: walletClient.account
+		});
+		const hash = await walletClient.writeContract(request);
+		await publicClient.waitForTransactionReceipt({ hash });
+		logger.info(`[UniswapV3LpService] Token approved: ${hash}`);
+	}
+};
+//#endregion
+//#region src/chains/evm/dex/uniswap/index.ts
+var uniswap_exports = /* @__PURE__ */ __exportAll({
+	ERC20_ABI: () => ERC20_ABI,
+	UNISWAP_V3_ADDRESSES: () => UNISWAP_V3_ADDRESSES,
+	UNISWAP_V3_FACTORY_ABI: () => UNISWAP_V3_FACTORY_ABI,
+	UNISWAP_V3_FEE_TIERS: () => UNISWAP_V3_FEE_TIERS,
+	UNISWAP_V3_POOL_ABI: () => UNISWAP_V3_POOL_ABI,
+	UNISWAP_V3_POSITION_MANAGER_ABI: () => UNISWAP_V3_POSITION_MANAGER_ABI,
+	UniswapV3LpService: () => UniswapV3LpService,
+	default: () => uniswapPlugin,
+	uniswapPlugin: () => uniswapPlugin
+});
+const uniswapPlugin = {
+	name: "@elizaos/plugin-lp-manager/uniswap",
+	description: "Uniswap V3 liquidity pool management plugin",
+	services: [UniswapV3LpService],
+	actions: [],
+	providers: [],
+	init: async (_config, runtime) => {
+		console.info("Uniswap V3 Plugin initialized");
+		await registerLpProtocolProvider(runtime, createEvmLpProtocolProvider({
+			dex: "uniswap",
+			label: "Uniswap V3",
+			service: runtime.getService(UniswapV3LpService.serviceType) ?? await UniswapV3LpService.start(runtime)
+		}));
+	}
+};
+//#endregion
+export { uniswap_exports as n, UniswapV3LpService as r, uniswapPlugin as t };

package/dist/wallet-action.d.mts

@@ -0,0 +1,6 @@
+import { Action } from "@elizaos/core";
+
+//#region src/chains/wallet-action.d.ts
+declare const walletRouterAction: Action;
+//#endregion
+export { walletRouterAction as default, walletRouterAction };