@elizaos/plugin-wallet 2.0.0-beta.1

package/dist/aerodrome-CfnESC32.mjs

@@ -0,0 +1,890 @@
+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 };