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

package/dist/uniswap-CReXgXVN.mjs

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

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