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

package/src/lp/services/LpManagementService.ts

@@ -1,10 +1,10 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import {
   type IAgentRuntime,
-  ILpService,
+  type ILpService,
   type LpPositionDetails,
   logger,
   type PoolInfo,
+  Service,
   type TokenBalance,
   type TransactionResult,
 } from "@elizaos/core";
@@ -14,7 +14,6 @@ import type {
   EvmAddLiquidityParams,
   EvmPoolInfo,
   EvmRemoveLiquidityParams,
-  EvmTransactionResult,
   IEvmLpService,
   RemoveLiquidityConfig,
 } from "../types.ts";
@@ -93,6 +92,12 @@ export interface LpProtocolProvider {
   getMarketData?(poolIds: string[]): Promise<Record<string, Partial<PoolInfo>>>;
 }
 
+type SolanaLpServiceAdapter = Partial<ILpService> & {
+  repositionPosition?(
+    params: LpPositionOperationParams,
+  ): Promise<TransactionResult>;
+};
+
 export class NoMatchingLpProtocolError extends Error {
   public readonly code = "NO_MATCHING_LP_PROTOCOL";
 
@@ -113,6 +118,10 @@ function normalizeDex(dex?: string): string | undefined {
   return dex?.trim().toLowerCase();
 }
 
+function normalizeRequiredDex(dex: string): string {
+  return dex.trim().toLowerCase();
+}
+
 function normalizeChain(chain?: string): string | undefined {
   return chain?.trim().toLowerCase();
 }
@@ -134,7 +143,7 @@ function poolId(pool?: string | PoolInfo | EvmPoolInfo): string | undefined {
 function amountValue(
   params: LpPositionOperationParams,
   key: "tokenA" | "tokenB" | "lpToken" | "value",
-  fallback = "0",
+  fallback: string,
 ): string {
   const amount = params.amount;
   if (
@@ -152,6 +161,27 @@ function amountValue(
   return fallback;
 }
 
+function optionalAmountValue(
+  params: LpPositionOperationParams,
+  key: "tokenA" | "tokenB" | "lpToken" | "value",
+  fallback?: string,
+): string | undefined {
+  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 !== undefined && value !== null) return String(value);
+  }
+  const nested = params.amounts?.[key as keyof typeof params.amounts];
+  if (nested !== undefined && nested !== null) return String(nested);
+  return fallback;
+}
+
 function bigintAmount(value: unknown, fallback = 0n): bigint {
   if (typeof value === "bigint") return value;
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -163,20 +193,25 @@ function bigintAmount(value: unknown, fallback = 0n): bigint {
   return fallback;
 }
 
+function optionalBigintAmount(value: unknown): bigint | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  return bigintAmount(value);
+}
+
 function unsupported(
   protocol: LpProtocolProvider,
   operation: string,
 ): TransactionResult {
   return {
     success: false,
-    error: `${operation} is not implemented for ${protocol.dex} on ${protocol.chain}`,
+    error: `${operation} is unavailable for ${protocol.dex} on ${protocol.chain}`,
   };
 }
 
-export class LpManagementService extends ILpService {
+export class LpManagementService extends Service implements ILpService {
   public static override readonly serviceType = LP_MANAGEMENT_SERVICE_TYPE;
   public readonly capabilityDescription =
-    "Aggregates registered DEX liquidity pool protocol providers across chains.";
+    "Provides standardized access to DEX liquidity pools.";
 
   private protocols = new Map<string, LpProtocolProvider>();
 
@@ -197,11 +232,11 @@ export class LpManagementService extends ILpService {
 
   registerProtocol(provider: LpProtocolProvider): void {
     const key = protocolKey(provider.chain, provider.dex);
-    const normalizedProvider = {
+    const normalizedProvider: LpProtocolProvider = {
       ...provider,
       id: provider.id || key,
       chain: normalizeChain(provider.chain) as LpProtocolChain,
-      dex: normalizeDex(provider.dex),
+      dex: normalizeRequiredDex(provider.dex),
     };
     if (this.protocols.has(key)) {
       logger.warn(
@@ -425,17 +460,18 @@ export function createSolanaLpProtocolProvider({
 }: {
   dex: string;
   label?: string;
-  service: Partial<ILpService> & Record<string, unknown>;
+  service: SolanaLpServiceAdapter;
 }): LpProtocolProvider {
+  const normalizedDex = normalizeRequiredDex(dex);
   const provider: LpProtocolProvider = {
-    id: `solana:${normalizeDex(dex)}`,
+    id: `solana:${normalizedDex}`,
     chain: "solana",
-    dex: normalizeDex(dex),
+    dex: normalizedDex,
     label,
     service,
     supportsRequest: (request) =>
       (!request.chain || normalizeChain(request.chain) === "solana") &&
-      (!request.dex || normalizeDex(request.dex) === normalizeDex(dex)),
+      (!request.dex || normalizeDex(request.dex) === normalizedDex),
     listPools: async (params) => {
       if (typeof service.getPools !== "function") return [];
       return service.getPools(params.tokenA, params.tokenB);
@@ -444,6 +480,9 @@ export function createSolanaLpProtocolProvider({
       if (typeof service.addLiquidity !== "function") {
         return unsupported(provider, "open");
       }
+      if (!params.userVault) {
+        return { success: false, error: "User vault is required" };
+      }
       const id = poolId(params.pool);
       if (!id) return { success: false, error: "Pool is required" };
       return service.addLiquidity({
@@ -452,9 +491,9 @@ export function createSolanaLpProtocolProvider({
         tokenAAmountLamports: amountValue(
           params,
           "tokenA",
-          amountValue(params, "value"),
+          amountValue(params, "value", "0"),
         ),
-        tokenBAmountLamports: amountValue(params, "tokenB", undefined),
+        tokenBAmountLamports: optionalAmountValue(params, "tokenB"),
         slippageBps: params.slippageBps ?? 50,
         tickLowerIndex: params.range?.tickLowerIndex ?? params.range?.tickLower,
         tickUpperIndex: params.range?.tickUpperIndex ?? params.range?.tickUpper,
@@ -464,6 +503,9 @@ export function createSolanaLpProtocolProvider({
       if (typeof service.removeLiquidity !== "function") {
         return unsupported(provider, "close");
       }
+      if (!params.userVault) {
+        return { success: false, error: "User vault is required" };
+      }
       const id = poolId(params.pool) || params.position;
       if (!id) return { success: false, error: "Pool or position is required" };
       return service.removeLiquidity({
@@ -472,7 +514,7 @@ export function createSolanaLpProtocolProvider({
         lpTokenAmountLamports: amountValue(
           params,
           "lpToken",
-          amountValue(params, "value"),
+          amountValue(params, "value", "0"),
         ),
         slippageBps: params.slippageBps ?? 50,
       });
@@ -489,9 +531,9 @@ export function createSolanaLpProtocolProvider({
     },
   };
 
-  if (typeof service.repositionPosition === "function") {
-    provider.repositionPosition = (params) =>
-      service.repositionPosition(params);
+  const repositionPosition = service.repositionPosition;
+  if (typeof repositionPosition === "function") {
+    provider.repositionPosition = (params) => repositionPosition(params);
   }
 
   return provider;
@@ -510,10 +552,11 @@ export function createEvmLpProtocolProvider({
     typeof service.getSupportedChainIds === "function"
       ? service.getSupportedChainIds()
       : [];
+  const normalizedDex = normalizeRequiredDex(dex);
   const provider: LpProtocolProvider = {
-    id: `evm:${normalizeDex(dex)}`,
+    id: `evm:${normalizedDex}`,
     chain: "evm",
-    dex: normalizeDex(dex),
+    dex: normalizedDex,
     label,
     service,
     supportedChainIds,
@@ -521,7 +564,7 @@ export function createEvmLpProtocolProvider({
       if (request.chain && normalizeChain(request.chain) !== "evm") {
         return false;
       }
-      if (request.dex && normalizeDex(request.dex) !== normalizeDex(dex)) {
+      if (request.dex && normalizeDex(request.dex) !== normalizedDex) {
         return false;
       }
       if (request.chainId !== undefined && supportedChainIds.length > 0) {
@@ -555,11 +598,10 @@ export function createEvmLpProtocolProvider({
         chainId: params.chainId,
         poolAddress: id as Address,
         tokenAAmount: bigintAmount(
-          amountValue(params, "tokenA", amountValue(params, "value")),
+          amountValue(params, "tokenA", amountValue(params, "value", "0")),
         ),
-        tokenBAmount: bigintAmount(
-          amountValue(params, "tokenB", undefined),
-          undefined,
+        tokenBAmount: optionalBigintAmount(
+          optionalAmountValue(params, "tokenB"),
         ),
         slippageBps: params.slippageBps ?? 50,
         tickLower: params.range?.tickLower ?? params.range?.tickLowerIndex,
@@ -585,13 +627,16 @@ export function createEvmLpProtocolProvider({
             : params.position
               ? bigintAmount(params.position)
               : undefined,
-        lpTokenAmount: bigintAmount(
-          amountValue(params, "lpToken", amountValue(params, "value")),
-          undefined,
+        lpTokenAmount: optionalBigintAmount(
+          optionalAmountValue(
+            params,
+            "lpToken",
+            optionalAmountValue(params, "value"),
+          ),
         ),
         percentageToRemove:
           typeof params.amount === "object"
-            ? params.amount?.percentage
+            ? params.amount.percentage
             : undefined,
         slippageBps: params.slippageBps ?? 50,
         deadline: params.deadline,
@@ -623,10 +668,5 @@ export function createEvmLpProtocolProvider({
     },
   };
 
-  if (typeof service.repositionPosition === "function") {
-    provider.repositionPosition = (params) =>
-      service.repositionPosition(params) as Promise<EvmTransactionResult>;
-  }
-
   return provider;
 }

package/src/lp/services/UserLpProfileService.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import { type IAgentRuntime, Service } from "@elizaos/core";
 import type {
   IUserLpProfileService,
@@ -17,11 +16,11 @@ export class UserLpProfileService
   private profiles: Map<string, UserLpProfile> = new Map();
 
   async start(_runtime?: IAgentRuntime): Promise<void> {
-    // No-op
+    // In-memory profiles are ready immediately.
   }
 
   async stop(_runtime?: IAgentRuntime): Promise<void> {
-    // No-op
+    // No external resources to release.
   }
 
   // Static methods required by ElizaOS Service architecture

package/src/lp/services/VaultService.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import { type IAgentRuntime, Service } from "@elizaos/core";
 import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import {
@@ -35,7 +34,7 @@ export class VaultService extends Service implements IVaultService {
   }
 
   async stop(): Promise<void> {
-    // No-op
+    // Connection lifecycle is managed by the Solana client helper.
   }
 
   public async createVault(
@@ -136,8 +135,15 @@ export class VaultService extends Service implements IVaultService {
   ): Promise<string> {
     // In a real implementation, you would verify the confirmationToken
     // For now, we'll do a simple check
-    if (!confirmationToken || confirmationToken.length < 6) {
-      throw new Error("Invalid confirmation token");
+    if (
+      !confirmationToken ||
+      confirmationToken.length < 32 ||
+      confirmationToken.length > 256 ||
+      !/^[A-Za-z0-9_-]+$/.test(confirmationToken)
+    ) {
+      throw new Error(
+        "Invalid confirmation token — use a cryptographically random token (32+ chars)",
+      );
     }
 
     try {

package/src/lp/services/YieldOptimizationService.ts

@@ -1,6 +1,5 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import { type IAgentRuntime, Service } from "@elizaos/core";
-import { LAMPORTS_PER_SOL } from "@solana/web3.js"; // For SOL price placeholder
+import { LAMPORTS_PER_SOL } from "@solana/web3.js";
 import type {
   IDexInteractionService,
   IUserLpProfileService,
@@ -12,12 +11,10 @@ import type {
 import type { DexInteractionService } from "./DexInteractionService.ts";
 import type { UserLpProfileService } from "./UserLpProfileService.ts";
 
-// Placeholder constants - should be configurable or dynamically fetched
 const _AVG_SOL_TX_FEE_LAMPORTS = BigInt(5000); // Average fee for a simple Solana transaction
 const AVG_SWAP_TX_FEE_LAMPORTS = BigInt(10000); // Potentially higher for swaps involving more accounts/CUs
 const AVG_LP_ADD_REMOVE_TX_FEE_LAMPORTS = BigInt(15000); // LP operations can be more complex
-const PLACEHOLDER_SOL_PRICE_USD = 150; // Placeholder for SOL price in USD
-const _PLACEHOLDER_SWAP_FEE_BPS = 30; // Placeholder for swap fee in basis points (0.3%)
+const DEFAULT_SOL_PRICE_USD = 150;
 
 /**
  * Interface for the YieldOptimizationService.
@@ -74,6 +71,22 @@ export interface IYieldOptimizationService extends Service {
   ): Promise<OptimizationOpportunity[]>;
 }
 
+function readPositiveNumberSetting(
+  runtime: IAgentRuntime,
+  key: string,
+  fallback: number,
+): number {
+  const fromSetting =
+    typeof runtime.getSetting === "function"
+      ? runtime.getSetting(key)
+      : undefined;
+  const raw =
+    (typeof fromSetting === "string" && fromSetting) ||
+    (typeof process !== "undefined" ? process.env?.[key] : undefined);
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 export class YieldOptimizationService
   extends Service
   implements IYieldOptimizationService
@@ -84,6 +97,7 @@ export class YieldOptimizationService
 
   private dexInteractionService!: IDexInteractionService;
   private userLpProfileService!: IUserLpProfileService;
+  private solPriceUsdForCosting = DEFAULT_SOL_PRICE_USD;
 
   // Static methods required by ElizaOS Service architecture
   static async start(
@@ -111,10 +125,15 @@ export class YieldOptimizationService
     }
     this.dexInteractionService = dexInteractionService;
     this.userLpProfileService = userLpProfileService;
+    this.solPriceUsdForCosting = readPositiveNumberSetting(
+      runtime,
+      "LP_SOL_PRICE_USD",
+      DEFAULT_SOL_PRICE_USD,
+    );
   }
 
   async stop(): Promise<void> {
-    // No-op
+    // Collaborating services own their own lifecycles.
   }
 
   async fetchAllPoolData(): Promise<PoolInfo[]> {
@@ -205,7 +224,7 @@ export class YieldOptimizationService
     }
     const allAvailablePools = await this.fetchAllPoolData();
     const opportunities: OptimizationOpportunity[] = [];
-    const solPriceUsdForCosting = PLACEHOLDER_SOL_PRICE_USD;
+    const solPriceUsdForCosting = this.solPriceUsdForCosting;
 
     for (const position of currentPositions) {
       const { underlyingTokens } = position;
@@ -332,13 +351,10 @@ export class YieldOptimizationService
   }
 
   public async findBestYield(
-    userId: string,
-    currentTokenA: string,
-    currentTokenB: string,
+    _userId: string,
+    _currentTokenA: string,
+    _currentTokenB: string,
   ): Promise<OptimizationOpportunity[]> {
-    console.log(
-      `Finding best yield for user ${userId} with tokens ${currentTokenA} and ${currentTokenB}`,
-    );
     return [];
   }
 }

package/src/lp/services/__tests__/MockLpService.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — test-only mock for LP registry and E2E setup
 import { type IAgentRuntime, Service } from "@elizaos/core";
 import type {
   AddLiquidityConfig,
@@ -15,7 +14,7 @@ import {
 
 export class MockLpService extends Service implements ILpService {
   public readonly capabilityDescription =
-    "Test-only LP service for registry scenarios.";
+    "Provides standardized access to DEX liquidity pools.";
   private positions = new Map<string, LpPositionDetails[]>();
 
   constructor(

package/src/lp/types.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import type {
   IAgentRuntime,
   ILpService,
@@ -92,6 +91,13 @@ export interface EvmWallet {
   privateKey: `0x${string}`;
 }
 
+export type EvmPoolTokenInfo = PoolInfo["tokenA"] & {
+  /** EVM token contract address. Also mirrored to mint for core PoolInfo compatibility. */
+  address: Address;
+  mint: Address;
+  decimals: number;
+};
+
 export interface EvmPoolInfo extends Omit<PoolInfo, "tokenA" | "tokenB"> {
   /** Chain ID where the pool exists */
   chainId: number;
@@ -100,19 +106,9 @@ export interface EvmPoolInfo extends Omit<PoolInfo, "tokenA" | "tokenB"> {
   /** Pool contract address */
   poolAddress: Address;
   /** Token A info with EVM address */
-  tokenA: {
-    address: Address;
-    symbol?: string;
-    decimals: number;
-    reserve?: string;
-  };
+  tokenA: EvmPoolTokenInfo;
   /** Token B info with EVM address */
-  tokenB: {
-    address: Address;
-    symbol?: string;
-    decimals: number;
-    reserve?: string;
-  };
+  tokenB: EvmPoolTokenInfo;
   /** Fee tier (for Uniswap V3 style pools) */
   feeTier?: number;
   /** Tick spacing (for concentrated liquidity) */

package/src/lp/utils/solanaClient.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import { type IAgentRuntime, logger } from "@elizaos/core";
 import { Connection, clusterApiUrl, Keypair, PublicKey } from "@solana/web3.js";
 import bs58 from "bs58";
@@ -75,7 +74,10 @@ export async function loadWallet(
         const signer = Keypair.fromSecretKey(secretKey);
         return { signer, address: signer.publicKey };
       } catch (e2) {
-        logger.error("Error decoding private key:", e2);
+        logger.error(
+          "Error decoding private key:",
+          e2 instanceof Error ? e2.message : String(e2),
+        );
         throw new Error(
           "Invalid private key format - must be base58 or base64 encoded",
         );

package/src/plugin.routes.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { walletPlugin } from "./plugin";
+
+describe("walletPlugin route contract", () => {
+  it("exposes both EVM and Solana browser signing routes through the aggregate plugin", () => {
+    const routeNames =
+      walletPlugin.routes?.map((route) => route.name).filter(Boolean) ?? [];
+
+    expect(routeNames).toEqual(
+      expect.arrayContaining([
+        "wallet-evm-address",
+        "wallet-evm-personal-sign",
+        "wallet-evm-sign-typed-data",
+        "wallet-evm-sign-transaction",
+        "wallet-evm-send-transaction",
+        "wallet-solana-pubkey",
+        "wallet-solana-sign-message",
+        "wallet-solana-sign-transaction",
+        "wallet-solana-sign-all-transactions",
+        "wallet-solana-sign-and-send-transaction",
+      ]),
+    );
+  });
+});

package/src/plugin.ts

@@ -5,7 +5,6 @@ import {
   parseBooleanFromText,
   type ServiceClass,
 } from "@elizaos/core";
-import { walletSearchAddressAction } from "./analytics/birdeye/actions/wallet-search-address.js";
 import { agentPortfolioProvider } from "./analytics/birdeye/providers/agent-portfolio-provider.js";
 import { marketProvider } from "./analytics/birdeye/providers/market.js";
 import { trendingProvider } from "./analytics/birdeye/providers/trending.js";
@@ -16,19 +15,20 @@ import {
 } from "./analytics/birdeye/service.js";
 import { registerDexScreenerSearchCategory } from "./analytics/dexscreener/search-category.js";
 import { DexScreenerService } from "./analytics/dexscreener/service.js";
-import { tokenInfoAction } from "./analytics/token-info/action.js";
 import { TokenInfoService } from "./analytics/token-info/service.js";
 import evmPlugin from "./chains/evm/index.js";
 import solanaPlugin from "./chains/solana/index.js";
-import { unifiedWalletProvider } from "./providers/unified-wallet-provider.js";
-import { WalletBackendService } from "./services/wallet-backend-service.js";
+import { walletProvider } from "./providers/wallet-provider.js";
+import {
+  WALLET_BACKEND_SERVICE_TYPE,
+  WalletBackendService,
+} from "./services/wallet-backend-service.js";
 
 const coreWalletPlugin: Plugin = {
   name: "wallet-backend",
-  description:
-    "Wallet backend service + unified wallet provider (Steward / local).",
+  description: "Wallet backend service + wallet provider (Steward / local).",
   services: [WalletBackendService],
-  providers: [unifiedWalletProvider],
+  providers: [walletProvider],
   actions: [],
 };
 
@@ -100,7 +100,7 @@ const analyticsServices: ServiceClass[] = [
 export const walletPlugin: Plugin = {
   name: "wallet",
   description:
-    "Unified non-custodial wallet for elizaOS — EVM + Solana, Steward/local backends, x402, CCTP, and venue routing.",
+    "Non-custodial wallet for elizaOS — EVM + Solana, Steward/local backends, x402, CCTP, and venue routing.",
   services: concatServices(
     coreWalletPlugin.services,
     evmPlugin.services as ServiceClass[] | undefined,
@@ -108,11 +108,8 @@ export const walletPlugin: Plugin = {
     analyticsServices,
   ),
   providers: concatPlugins(coreWalletPlugin.providers, evmPlugin.providers),
-  actions: concatPlugins(coreWalletPlugin.actions, evmPlugin.actions, [
-    tokenInfoAction,
-    walletSearchAddressAction,
-  ]),
-  routes: concatPlugins(solanaPlugin.routes),
+  actions: concatPlugins(coreWalletPlugin.actions, evmPlugin.actions),
+  routes: concatPlugins(evmPlugin.routes, solanaPlugin.routes),
   init: async (config, runtime) => {
     await coreWalletPlugin.init?.(config, runtime);
     await evmPlugin.init?.(config, runtime);
@@ -120,6 +117,26 @@ export const walletPlugin: Plugin = {
     registerDexScreenerSearchCategory(runtime);
     await initBirdeyeAnalytics(runtime);
   },
+  async dispose(runtime: IAgentRuntime) {
+    await evmPlugin.dispose?.(runtime);
+    await solanaPlugin.dispose?.(runtime);
+    const birdeye = runtime.getService<BirdeyeService>(
+      BirdeyeService.serviceType,
+    );
+    await birdeye?.stop();
+    const dexscreener = runtime.getService<DexScreenerService>(
+      DexScreenerService.serviceType,
+    );
+    await dexscreener?.stop();
+    const tokenInfo = runtime.getService<TokenInfoService>(
+      TokenInfoService.serviceType,
+    );
+    await tokenInfo?.stop();
+    const walletBackend = runtime.getService<WalletBackendService>(
+      WALLET_BACKEND_SERVICE_TYPE,
+    );
+    await walletBackend?.stop();
+  },
 };
 
 export default walletPlugin;

package/src/providers/canonical-provider.ts

@@ -9,7 +9,7 @@ export type HealthStatus = { ok: true } | { ok: false; reason: string };
 
 /**
  * Typed venue / data-source adapter. Canonical actions dispatch into concrete
- * provider classes registered on the runtime provider registry (Phase 2 wiring).
+ * provider classes registered on the runtime provider registry.
  *
  * See docs/architecture/wallet-and-trading.md §B.3.
  */

package/src/providers/{unified-wallet-provider.ts → wallet-provider.ts}

@@ -10,12 +10,12 @@ const MAX_WALLET_TEXT_CHARS = 1000;
 /**
  * Injects live addresses into planner context. Always-on (200-token budget in spec).
  */
-export const unifiedWalletProvider: Provider = {
+export const walletProvider: Provider = {
   name: "wallet",
   description:
-    "Unified non-custodial wallet — EVM + Solana addresses (@elizaos/plugin-wallet).",
+    "Non-custodial wallet — EVM + Solana addresses (@elizaos/plugin-wallet).",
   descriptionCompressed:
-    "unifi non-custodial wallet EVM + Solana address (elizaos/plugin-wallet)",
+    "non-custodial wallet EVM + Solana address (elizaos/plugin-wallet)",
   contexts: ["finance", "crypto", "wallet"],
   contextGate: { anyOf: ["finance", "crypto", "wallet"] },
   cacheStable: false,