@elizaos/plugin-wallet 2.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 up2itnow0822
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @elizaos/plugin-wallet
+
+Unified non-custodial wallet for elizaOS agents. Replaces the legacy fan-out across `plugin-evm`, `plugin-solana`, `plugin-raydium`, `plugin-orca`, `plugin-meteora`, `plugin-jupiter`, `plugin-lp-manager`, `plugin-clanker`, and the former `elizaos-plugin-agentwallet` stub with one canonical action+provider surface governed by [`docs/architecture/wallet-and-trading.md`](../../../docs/architecture/wallet-and-trading.md).
+
+## Surface
+
+The plugin exposes **10 canonical planner-visible actions**:
+
+| Action | Purpose |
+|--------|---------|
+| `TRADE` | Open positions, swap, bridge. Discriminated by `kind`: `perp` (Hyperliquid), `prediction` (Polymarket), `spot` / `swap` (Li.Fi on EVM, Jupiter on Solana), `bridge` (Li.Fi / CCTP). |
+| `MANAGE_POSITION` | Close, modify, cancel orders. |
+| `QUERY_MARKET` | Read-only price / depth / funding / chart / news / sentiment. No wallet required. |
+| `QUERY_PORTFOLIO` | Balances, positions, P&L, history. |
+| `LEND` | Supply / borrow / repay / withdraw on Aave or Morpho. |
+| `MANAGE_LP` | Open / close / collect / rebalance LP positions. EVM (Uniswap V3, Aerodrome) + Solana (Raydium, Orca Whirlpools, Meteora DLMM) behind one surface. |
+| `TRANSFER` | Move value to an arbitrary external address. EVM + Solana. Always policy-checked. |
+| `SET_AUTOMATION` | DCA, threshold triggers, P&L exits. |
+| `MANAGE_AUTOMATION` | List / pause / resume / delete automations. |
+| `MINT` | Token launches via Clanker on Base. |
+
+These dispatch into **typed providers** (one per venue / data source). Adding a new venue means adding a provider, **not** a new planner verb.
+
+## Wallet abstraction
+
+Two backends behind `WalletBackend`:
+
+- **`LocalEoaBackend`** — desktop default. EOA private keys hydrated from the OS keychain. Optional ERC-6551 token-bound account mode (via the bundled SDK at `./sdk`) for on-chain spend policy enforcement.
+- **`StewardBackend`** — cloud + mobile default. Multi-tenant Steward service is the only custody primitive in cloud. No fallback to local.
+
+See `src/wallet/` for interface and impls. `ELIZA_WALLET_BACKEND=local|steward|auto` selects at runtime.
+
+## Layout
+
+```
+src/
+  index.ts                  # Plugin export
+  plugin.ts                 # Plugin object: actions + providers + services
+  sdk/                      # Lifted from agent-wallet-sdk (ERC-6551, x402, CCTP, swap, escrow, identity, multi-token, payment router)
+  wallet/                   # WalletBackend interface + LocalEoa + Steward
+  policy/                   # PolicyModule (local + steward bridge)
+  providers/                # Canonical providers (one per venue / data source)
+  actions/                  # Canonical actions (TRADE, MANAGE_POSITION, ...)
+  audit/                    # Append-only hash-chained audit log
+```
+
+The `sdk/` subtree carries forward primitives from [agent-wallet-sdk](https://github.com/up2itnow0822/agent-wallet-sdk) (MIT). See `SDK-LICENSE`. The wallet/policy/providers/actions/audit subtrees implement the canonical architecture in the spec.
+
+## Migration status
+
+This plugin is being built incrementally. Tracked phases:
+
+- **Phase 0** — interfaces (`WalletBackend`, `CanonicalProvider`, `CanonicalAction`, `PolicyModule`, audit log schema, failure-code unions).
+- **Phase 1** — backend impls + `@elizaos/plugin-wallet` composes legacy `plugin-evm` + `plugin-solana`; migrate call sites to consume `WalletBackend` only.
+- **Phase 2** — provider lifts (13+ providers).
+- **Phase 3** — canonical action implementations.
+- **Phase 4** — approval-queue surface (SSE + decision endpoint + tray + Capacitor bridge).
+- **Phase 5** — EVM + Solana chain implementations live under `src/chains/`; migrate remaining callsites to `WalletBackend` only; expand test coverage.
+
+See `docs/architecture/wallet-and-trading.md` §I for the dependency graph.
+
+## License
+
+MIT. Source code under `src/sdk/` originates from [agent-wallet-sdk](https://github.com/up2itnow0822/agent-wallet-sdk) (MIT, attribution preserved in `SDK-LICENSE`).

package/auto-enable.ts

@@ -0,0 +1,76 @@
+// Auto-enable check for @elizaos/plugin-wallet.
+//
+// Plugin manifest entry-point — referenced by package.json's
+// `elizaos.plugin.autoEnableModule`. Keep this module light: env reads only,
+// no service init, no transitive imports of the full plugin runtime. The
+// auto-enable engine loads dozens of these per boot.
+//
+// EVM detection mirrors `evmAutoEnableReasonFromCapability` in
+// packages/agent/src/services/evm-signing-capability.ts — kept inline so this
+// module has no cross-package import that would pull in agent/runtime code.
+import type { PluginAutoEnableContext } from "@elizaos/core";
+
+const PLACEHOLDER_RE =
+  /^\[?\s*(REDACTED|PLACEHOLDER|T(?:O)D(?:O)|CHANGEME|EMPTY)\s*]?$/i;
+
+function isConcreteValue(value: string | undefined): boolean {
+  const trimmed = value?.trim();
+  return Boolean(trimmed) && !PLACEHOLDER_RE.test(trimmed as string);
+}
+
+/** True when any EVM signing path is available (local key or Steward). */
+function hasEvmSigningPath(env: NodeJS.ProcessEnv): boolean {
+  if (isConcreteValue(env.EVM_PRIVATE_KEY)) return true;
+  const stewardUrl = env.STEWARD_API_URL?.trim();
+  const stewardToken = env.STEWARD_AGENT_TOKEN?.trim();
+  return Boolean(stewardUrl && stewardToken);
+}
+
+/** True when a Solana private key is set. */
+function hasSolanaSigningPath(env: NodeJS.ProcessEnv): boolean {
+  return (
+    typeof env.SOLANA_PRIVATE_KEY === "string" &&
+    env.SOLANA_PRIVATE_KEY.trim().length > 0
+  );
+}
+
+/** True when cloud-provisioned Steward credentials are present. */
+function hasCloudStewardWallet(env: NodeJS.ProcessEnv): boolean {
+  return (
+    env.ELIZA_CLOUD_PROVISIONED === "1" &&
+    Boolean(env.STEWARD_API_URL?.trim()) &&
+    Boolean(env.STEWARD_AGENT_TOKEN?.trim())
+  );
+}
+
+/**
+ * Enable plugin-wallet when ANY signing path is available:
+ *   - EVM (local key or self-hosted/cloud Steward)
+ *   - Solana local key
+ *   - cloud-provisioned Steward
+ *
+ * Honors `ELIZA_AGENT_WALLET_AUTO_ENABLE === "0"` opt-out, and respects an
+ * explicit `enabled: false` on any of plugin-wallet's legacy entry names
+ * (`wallet`, `agent-wallet`, `evm`, `solana`). The central engine only
+ * checks the canonical short id (`wallet`); the legacy aliases need to be
+ * honored here.
+ */
+export function shouldEnable(ctx: PluginAutoEnableContext): boolean {
+  const { env, config } = ctx;
+
+  if (env.ELIZA_AGENT_WALLET_AUTO_ENABLE === "0") return false;
+
+  const entries = (config?.plugins as Record<string, unknown> | undefined)
+    ?.entries as Record<string, { enabled?: boolean } | undefined> | undefined;
+  if (entries) {
+    for (const id of ["wallet", "agent-wallet", "evm", "solana"] as const) {
+      if (entries[id]?.enabled === false) return false;
+    }
+  }
+
+  return (
+    hasEvmSigningPath(env) ||
+    hasSolanaSigningPath(env) ||
+    hasCloudStewardWallet(env)
+  );
+}

package/dist/LpManagementService-BWrQ5-cO.mjs

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

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