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

package/dist/aerodrome-CfnESC32.mjs

@@ -1,890 +0,0 @@
-import { n as __exportAll } from "./chunk-hT5z_Zn9.mjs";
-import { o as registerLpProtocolProvider, r as createEvmLpProtocolProvider } from "./LpManagementService-BWrQ5-cO.mjs";
-import { Service, logger } from "@elizaos/core";
-import { createPublicClient, createWalletClient, http } from "viem";
-import { base } from "viem/chains";
-import { privateKeyToAccount } from "viem/accounts";
-//#region src/chains/evm/dex/aerodrome/types.ts
-const AERODROME_ADDRESSES = { 8453: {
-	router: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
-	factory: "0x420DD381b31aEf6683db6B902084cB0FFECe40Da",
-	voter: "0x16613524e02ad97eDfeF371bC883F2F5d6C480A5",
-	aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
-} };
-const AERODROME_ROUTER_ABI = [
-	{
-		inputs: [
-			{
-				name: "tokenA",
-				type: "address"
-			},
-			{
-				name: "tokenB",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			},
-			{
-				name: "amountADesired",
-				type: "uint256"
-			},
-			{
-				name: "amountBDesired",
-				type: "uint256"
-			},
-			{
-				name: "amountAMin",
-				type: "uint256"
-			},
-			{
-				name: "amountBMin",
-				type: "uint256"
-			},
-			{
-				name: "to",
-				type: "address"
-			},
-			{
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "addLiquidity",
-		outputs: [
-			{
-				name: "amountA",
-				type: "uint256"
-			},
-			{
-				name: "amountB",
-				type: "uint256"
-			},
-			{
-				name: "liquidity",
-				type: "uint256"
-			}
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				name: "token",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			},
-			{
-				name: "amountTokenDesired",
-				type: "uint256"
-			},
-			{
-				name: "amountTokenMin",
-				type: "uint256"
-			},
-			{
-				name: "amountETHMin",
-				type: "uint256"
-			},
-			{
-				name: "to",
-				type: "address"
-			},
-			{
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "addLiquidityETH",
-		outputs: [
-			{
-				name: "amountToken",
-				type: "uint256"
-			},
-			{
-				name: "amountETH",
-				type: "uint256"
-			},
-			{
-				name: "liquidity",
-				type: "uint256"
-			}
-		],
-		stateMutability: "payable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				name: "tokenA",
-				type: "address"
-			},
-			{
-				name: "tokenB",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			},
-			{
-				name: "liquidity",
-				type: "uint256"
-			},
-			{
-				name: "amountAMin",
-				type: "uint256"
-			},
-			{
-				name: "amountBMin",
-				type: "uint256"
-			},
-			{
-				name: "to",
-				type: "address"
-			},
-			{
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "removeLiquidity",
-		outputs: [{
-			name: "amountA",
-			type: "uint256"
-		}, {
-			name: "amountB",
-			type: "uint256"
-		}],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				name: "token",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			},
-			{
-				name: "liquidity",
-				type: "uint256"
-			},
-			{
-				name: "amountTokenMin",
-				type: "uint256"
-			},
-			{
-				name: "amountETHMin",
-				type: "uint256"
-			},
-			{
-				name: "to",
-				type: "address"
-			},
-			{
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "removeLiquidityETH",
-		outputs: [{
-			name: "amountToken",
-			type: "uint256"
-		}, {
-			name: "amountETH",
-			type: "uint256"
-		}],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				name: "tokenA",
-				type: "address"
-			},
-			{
-				name: "tokenB",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			}
-		],
-		name: "getReserves",
-		outputs: [{
-			name: "reserveA",
-			type: "uint256"
-		}, {
-			name: "reserveB",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				name: "amountIn",
-				type: "uint256"
-			},
-			{
-				name: "tokenIn",
-				type: "address"
-			},
-			{
-				name: "tokenOut",
-				type: "address"
-			}
-		],
-		name: "getAmountOut",
-		outputs: [{
-			name: "amount",
-			type: "uint256"
-		}, {
-			name: "stable",
-			type: "bool"
-		}],
-		stateMutability: "view",
-		type: "function"
-	}
-];
-const AERODROME_FACTORY_ABI = [
-	{
-		inputs: [
-			{
-				name: "tokenA",
-				type: "address"
-			},
-			{
-				name: "tokenB",
-				type: "address"
-			},
-			{
-				name: "stable",
-				type: "bool"
-			}
-		],
-		name: "getPool",
-		outputs: [{
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "allPools",
-		outputs: [{
-			name: "",
-			type: "address[]"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "allPoolsLength",
-		outputs: [{
-			name: "",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "index",
-			type: "uint256"
-		}],
-		name: "allPools",
-		outputs: [{
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	}
-];
-const AERODROME_POOL_ABI = [
-	{
-		inputs: [],
-		name: "token0",
-		outputs: [{ type: "address" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "token1",
-		outputs: [{ type: "address" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "stable",
-		outputs: [{ type: "bool" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "reserve0",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "reserve1",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "totalSupply",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "account",
-			type: "address"
-		}],
-		name: "balanceOf",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "getReserves",
-		outputs: [
-			{
-				name: "_reserve0",
-				type: "uint256"
-			},
-			{
-				name: "_reserve1",
-				type: "uint256"
-			},
-			{
-				name: "_blockTimestampLast",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "spender",
-			type: "address"
-		}, {
-			name: "amount",
-			type: "uint256"
-		}],
-		name: "approve",
-		outputs: [{ type: "bool" }],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "owner",
-			type: "address"
-		}, {
-			name: "spender",
-			type: "address"
-		}],
-		name: "allowance",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	}
-];
-const ERC20_ABI = [
-	{
-		inputs: [],
-		name: "symbol",
-		outputs: [{ type: "string" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "decimals",
-		outputs: [{ type: "uint8" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "name",
-		outputs: [{ type: "string" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "account",
-			type: "address"
-		}],
-		name: "balanceOf",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "spender",
-			type: "address"
-		}, {
-			name: "amount",
-			type: "uint256"
-		}],
-		name: "approve",
-		outputs: [{ type: "bool" }],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [{
-			name: "owner",
-			type: "address"
-		}, {
-			name: "spender",
-			type: "address"
-		}],
-		name: "allowance",
-		outputs: [{ type: "uint256" }],
-		stateMutability: "view",
-		type: "function"
-	}
-];
-//#endregion
-//#region src/chains/evm/dex/aerodrome/services/AerodromeLpService.ts
-const SUPPORTED_CHAIN_IDS = [8453];
-var AerodromeLpService = class AerodromeLpService extends Service {
-	static serviceType = "aerodrome-lp";
-	capabilityDescription = "Provides Aerodrome DEX liquidity pool management on Base chain.";
-	publicClient = null;
-	walletClients = /* @__PURE__ */ new Map();
-	rpcUrl = null;
-	constructor(runtime) {
-		super(runtime);
-		if (runtime) this.initializeRpcUrl();
-	}
-	initializeRpcUrl() {
-		for (const key of ["BASE_RPC_URL", "EVM_PROVIDER_BASE"]) {
-			const rpcUrl = this.runtime.getSetting(key);
-			if (rpcUrl && typeof rpcUrl === "string") {
-				this.rpcUrl = rpcUrl;
-				break;
-			}
-		}
-	}
-	getPublicClient() {
-		if (this.publicClient) return this.publicClient;
-		this.publicClient = createPublicClient({
-			chain: base,
-			transport: this.rpcUrl ? http(this.rpcUrl) : http()
-		});
-		return this.publicClient;
-	}
-	getWalletClient(privateKey) {
-		const cacheKey = privateKey.slice(0, 10);
-		let client = this.walletClients.get(cacheKey);
-		if (client) return client;
-		const account = privateKeyToAccount(privateKey);
-		client = createWalletClient({
-			chain: base,
-			transport: this.rpcUrl ? http(this.rpcUrl) : http(),
-			account
-		});
-		this.walletClients.set(cacheKey, client);
-		return client;
-	}
-	static async start(runtime) {
-		const service = new AerodromeLpService(runtime);
-		logger.info("[AerodromeLpService] started");
-		return service;
-	}
-	async stop() {
-		this.publicClient = null;
-		this.walletClients.clear();
-		logger.info("[AerodromeLpService] stopped");
-	}
-	getDexName() {
-		return "aerodrome";
-	}
-	getSupportedChainIds() {
-		return SUPPORTED_CHAIN_IDS;
-	}
-	supportsChain(chainId) {
-		return chainId === 8453;
-	}
-	async getPools(chainId, tokenA, tokenB, _feeTier) {
-		if (!this.supportsChain(chainId)) {
-			logger.warn(`[AerodromeLpService] Chain ${chainId} not supported`);
-			return [];
-		}
-		const addresses = AERODROME_ADDRESSES[8453];
-		const client = this.getPublicClient();
-		const pools = [];
-		if (tokenA && tokenB) for (const stable of [false, true]) try {
-			const poolAddress = await client.readContract({
-				address: addresses.factory,
-				abi: AERODROME_FACTORY_ABI,
-				functionName: "getPool",
-				args: [
-					tokenA,
-					tokenB,
-					stable
-				]
-			});
-			if (poolAddress && poolAddress !== "0x0000000000000000000000000000000000000000") {
-				const poolInfo = await this.getPoolInfo(poolAddress);
-				if (poolInfo) pools.push(poolInfo);
-			}
-		} catch (_error) {
-			logger.debug(`[AerodromeLpService] No ${stable ? "stable" : "volatile"} pool found for ${tokenA}/${tokenB}`);
-		}
-		return pools;
-	}
-	async getPoolInfo(poolAddress) {
-		const client = this.getPublicClient();
-		try {
-			const [token0, token1, stable, reserves] = await Promise.all([
-				client.readContract({
-					address: poolAddress,
-					abi: AERODROME_POOL_ABI,
-					functionName: "token0"
-				}),
-				client.readContract({
-					address: poolAddress,
-					abi: AERODROME_POOL_ABI,
-					functionName: "token1"
-				}),
-				client.readContract({
-					address: poolAddress,
-					abi: AERODROME_POOL_ABI,
-					functionName: "stable"
-				}),
-				client.readContract({
-					address: poolAddress,
-					abi: AERODROME_POOL_ABI,
-					functionName: "getReserves"
-				})
-			]);
-			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)
-			]);
-			const poolType = stable ? "stable" : "volatile";
-			return {
-				id: poolAddress,
-				dex: "aerodrome",
-				chainId: 8453,
-				chainName: "Base",
-				poolAddress,
-				tokenA: {
-					address: token0,
-					symbol: symbol0,
-					decimals: Number(decimals0),
-					reserve: reserves[0].toString()
-				},
-				tokenB: {
-					address: token1,
-					symbol: symbol1,
-					decimals: Number(decimals1),
-					reserve: reserves[1].toString()
-				},
-				fee: stable ? 4e-4 : .003,
-				displayName: `${symbol0}/${symbol1} (${poolType})`,
-				metadata: {
-					poolType,
-					stable
-				}
-			};
-		} catch (error) {
-			logger.error(`[AerodromeLpService] Error fetching pool info for ${poolAddress}:`, error);
-			return null;
-		}
-	}
-	async addLiquidity(params) {
-		if (!this.supportsChain(params.chainId)) return {
-			success: false,
-			error: `Chain ${params.chainId} not supported. Aerodrome is only on Base (8453).`
-		};
-		const addresses = AERODROME_ADDRESSES[8453];
-		try {
-			const publicClient = this.getPublicClient();
-			const walletClient = this.getWalletClient(params.wallet.privateKey);
-			const poolInfo = await this.getPoolInfo(params.poolAddress);
-			if (!poolInfo) return {
-				success: false,
-				error: "Pool not found"
-			};
-			const stable = poolInfo.metadata?.stable === true;
-			const slippageMultiplier = BigInt(1e4 - params.slippageBps);
-			const amountAMin = params.tokenAAmount * slippageMultiplier / 10000n;
-			const amountBMin = (params.tokenBAmount ?? 0n) * slippageMultiplier / 10000n;
-			await this.approveToken(params.wallet.privateKey, poolInfo.tokenA.address, addresses.router, params.tokenAAmount);
-			if (params.tokenBAmount && params.tokenBAmount > 0n) await this.approveToken(params.wallet.privateKey, poolInfo.tokenB.address, addresses.router, params.tokenBAmount);
-			const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 1800);
-			const { request } = await publicClient.simulateContract({
-				address: addresses.router,
-				abi: AERODROME_ROUTER_ABI,
-				functionName: "addLiquidity",
-				args: [
-					poolInfo.tokenA.address,
-					poolInfo.tokenB.address,
-					stable,
-					params.tokenAAmount,
-					params.tokenBAmount ?? 0n,
-					amountAMin,
-					amountBMin,
-					params.wallet.address,
-					deadline
-				],
-				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,
-					stable
-				}
-			};
-		} catch (error) {
-			logger.error("[AerodromeLpService] Error adding liquidity:", error);
-			return {
-				success: false,
-				error: error instanceof Error ? error.message : "Unknown error adding liquidity"
-			};
-		}
-	}
-	async removeLiquidity(params) {
-		if (!this.supportsChain(params.chainId)) return {
-			success: false,
-			error: `Chain ${params.chainId} not supported. Aerodrome is only on Base (8453).`
-		};
-		const addresses = AERODROME_ADDRESSES[8453];
-		try {
-			const publicClient = this.getPublicClient();
-			const walletClient = this.getWalletClient(params.wallet.privateKey);
-			const poolInfo = await this.getPoolInfo(params.poolAddress);
-			if (!poolInfo) return {
-				success: false,
-				error: "Pool not found"
-			};
-			const stable = poolInfo.metadata?.stable === true;
-			let lpTokenAmount = params.lpTokenAmount;
-			if (!lpTokenAmount) {
-				const balance = await publicClient.readContract({
-					address: params.poolAddress,
-					abi: AERODROME_POOL_ABI,
-					functionName: "balanceOf",
-					args: [params.wallet.address]
-				});
-				if (params.percentageToRemove && params.percentageToRemove < 100) lpTokenAmount = balance * BigInt(params.percentageToRemove) / 100n;
-				else lpTokenAmount = balance;
-			}
-			if (!lpTokenAmount || lpTokenAmount === 0n) return {
-				success: false,
-				error: "No LP tokens to remove"
-			};
-			await this.approveToken(params.wallet.privateKey, params.poolAddress, addresses.router, lpTokenAmount);
-			BigInt(1e4 - params.slippageBps);
-			const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 1800);
-			const { request } = await publicClient.simulateContract({
-				address: addresses.router,
-				abi: AERODROME_ROUTER_ABI,
-				functionName: "removeLiquidity",
-				args: [
-					poolInfo.tokenA.address,
-					poolInfo.tokenB.address,
-					stable,
-					lpTokenAmount,
-					0n,
-					0n,
-					params.wallet.address,
-					deadline
-				],
-				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
-			};
-		} catch (error) {
-			logger.error("[AerodromeLpService] Error removing liquidity:", error);
-			return {
-				success: false,
-				error: error instanceof Error ? error.message : "Unknown error removing liquidity"
-			};
-		}
-	}
-	async getPositionDetails(chainId, owner, poolAddress, _tokenId) {
-		if (!this.supportsChain(chainId)) return null;
-		const client = this.getPublicClient();
-		try {
-			const poolInfo = await this.getPoolInfo(poolAddress);
-			if (!poolInfo) return null;
-			const lpBalance = await client.readContract({
-				address: poolAddress,
-				abi: AERODROME_POOL_ABI,
-				functionName: "balanceOf",
-				args: [owner]
-			});
-			if (lpBalance === 0n) return null;
-			const totalSupply = await client.readContract({
-				address: poolAddress,
-				abi: AERODROME_POOL_ABI,
-				functionName: "totalSupply"
-			});
-			const lpBalanceBigInt = lpBalance;
-			const totalSupplyBigInt = totalSupply;
-			const reserve0 = BigInt(poolInfo.tokenA.reserve ?? "0");
-			const reserve1 = BigInt(poolInfo.tokenB.reserve ?? "0");
-			const amount0 = totalSupplyBigInt > 0n ? reserve0 * lpBalanceBigInt / totalSupplyBigInt : 0n;
-			const amount1 = totalSupplyBigInt > 0n ? reserve1 * lpBalanceBigInt / totalSupplyBigInt : 0n;
-			return {
-				poolId: poolAddress,
-				dex: "aerodrome",
-				chainId: 8453,
-				owner,
-				lpTokenBalance: {
-					address: poolAddress,
-					balance: lpBalanceBigInt.toString(),
-					decimals: 18,
-					symbol: `AERO-LP-${poolInfo.tokenA.symbol}/${poolInfo.tokenB.symbol}`
-				},
-				underlyingTokens: [{
-					address: poolInfo.tokenA.address,
-					balance: amount0.toString(),
-					decimals: poolInfo.tokenA.decimals,
-					symbol: poolInfo.tokenA.symbol
-				}, {
-					address: poolInfo.tokenB.address,
-					balance: amount1.toString(),
-					decimals: poolInfo.tokenB.decimals,
-					symbol: poolInfo.tokenB.symbol
-				}],
-				metadata: poolInfo.metadata
-			};
-		} catch (error) {
-			logger.error(`[AerodromeLpService] Error getting position details for ${owner}:`, error);
-			return null;
-		}
-	}
-	async getAllPositions(chainId, _owner) {
-		if (!this.supportsChain(chainId)) return [];
-		logger.info(`[AerodromeLpService] getAllPositions not fully implemented - need pool tracking`);
-		return [];
-	}
-	async getMarketData(poolAddresses) {
-		const result = {};
-		for (const address of poolAddresses) try {
-			const poolInfo = await this.getPoolInfo(address);
-			if (poolInfo) result[address] = poolInfo;
-		} catch {}
-		return result;
-	}
-	async approveToken(privateKey, tokenAddress, spenderAddress, amount) {
-		const publicClient = this.getPublicClient();
-		const walletClient = this.getWalletClient(privateKey);
-		if (await publicClient.readContract({
-			address: tokenAddress,
-			abi: ERC20_ABI,
-			functionName: "allowance",
-			args: [walletClient.account?.address, spenderAddress]
-		}) >= amount) return;
-		logger.info(`[AerodromeLpService] 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(`[AerodromeLpService] Token approved: ${hash}`);
-	}
-};
-//#endregion
-//#region src/chains/evm/dex/aerodrome/index.ts
-var aerodrome_exports = /* @__PURE__ */ __exportAll({
-	AERODROME_ADDRESSES: () => AERODROME_ADDRESSES,
-	AERODROME_FACTORY_ABI: () => AERODROME_FACTORY_ABI,
-	AERODROME_POOL_ABI: () => AERODROME_POOL_ABI,
-	AERODROME_ROUTER_ABI: () => AERODROME_ROUTER_ABI,
-	AerodromeLpService: () => AerodromeLpService,
-	ERC20_ABI: () => ERC20_ABI,
-	aerodromePlugin: () => aerodromePlugin,
-	default: () => aerodromePlugin
-});
-const aerodromePlugin = {
-	name: "@elizaos/plugin-lp-manager/aerodrome",
-	description: "Aerodrome DEX liquidity pool management plugin for Base chain",
-	services: [AerodromeLpService],
-	actions: [],
-	providers: [],
-	init: async (_config, runtime) => {
-		console.info("Aerodrome Plugin initialized");
-		await registerLpProtocolProvider(runtime, createEvmLpProtocolProvider({
-			dex: "aerodrome",
-			label: "Aerodrome",
-			service: runtime.getService(AerodromeLpService.serviceType) ?? await AerodromeLpService.start(runtime)
-		}));
-	}
-};
-//#endregion
-export { aerodrome_exports as n, AerodromeLpService as r, aerodromePlugin as t };