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

package/dist/browser-shim/build-shim.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Build a self-contained JS string that, when evaluated in a page's MAIN
+ * world, registers the agent as a Wallet-Standard Solana wallet and an
+ * EIP-1193 EVM provider. All signing requests are forwarded to the wallet
+ * plugin's HTTP sign endpoints (gated by the bearer token).
+ *
+ * Consumers:
+ *   - browser-bridge extension content script (MAIN world, document_start)
+ *   - Playwright `page.addInitScript(buildWalletShim({...}))`
+ *   - plugin-browser `BROWSER eval` (post-load fallback)
+ */
+export interface WalletShimConfig {
+    /** Base URL of the wallet HTTP API (e.g. `http://127.0.0.1:31337`). */
+    apiBase: string;
+    /** Shared bearer token (matches `WALLET_BROWSER_SIGN_TOKEN`). */
+    signToken: string;
+    /** Display name shown to dApps. */
+    walletName?: string;
+    /** Optional data URL icon. */
+    walletIcon?: string;
+    /** Active Solana public key (base58). Pass null to disable Solana surface. */
+    solanaPublicKey: string | null;
+    /** Active EVM address (0x…). Pass null to disable EVM surface. */
+    evmAddress: string | null;
+    /** Default EVM chain id the provider reports until a switch is requested. */
+    evmChainId?: number;
+    /** Public RPC URLs the shim uses for read-only EVM calls, keyed by chainId. */
+    evmRpcByChainId?: Record<string, string>;
+}
+export declare function buildWalletShim(config: WalletShimConfig): string;
+export declare function buildWalletShimFromTemplate(template: string, config: WalletShimConfig): string;

package/dist/browser-shim/index.d.ts

@@ -0,0 +1 @@
+export { buildWalletShim, buildWalletShimFromTemplate, type WalletShimConfig, } from "./build-shim";

package/dist/chains/evm/actions/helpers.d.ts

@@ -0,0 +1,31 @@
+import type { Action, ActionResult, HandlerCallback, IAgentRuntime } from "@elizaos/core";
+import type { Address, Chain, Hex, SendTransactionParameters } from "viem";
+import type { Account } from "viem/accounts";
+type ActionValidate = NonNullable<Action["validate"]>;
+interface EvmActionValidatorConfig {
+    readonly keywords: readonly string[];
+    readonly regex: RegExp;
+}
+export declare function hasEvmPrivateKey(runtime: IAgentRuntime): boolean;
+/**
+ * LLM-supplied `confirmed` / TOON flags are never trusted (GHSA-rqm7-f4jc-84x3).
+ * Use {@link gateWalletFinancialExecution} from `security/wallet-financial-confirmation.ts`.
+ */
+export declare function isConfirmed(_options?: Record<string, unknown>): boolean;
+export declare function confirmationRequired(params: {
+    actionName: string;
+    preview: string;
+    parameters: object;
+    callback?: HandlerCallback;
+}): Promise<ActionResult>;
+export declare function createEvmActionValidator(_config: EvmActionValidatorConfig): ActionValidate;
+export declare function buildSendTxParams(params: {
+    account: Account;
+    to: Address;
+    value?: bigint;
+    data?: Hex;
+    chain?: Chain;
+    gas?: bigint;
+    gasPrice?: bigint;
+}): SendTransactionParameters;
+export {};

package/dist/chains/evm/actions/swap.d.ts

@@ -0,0 +1,53 @@
+import type { ActionResult, HandlerCallback, IAgentRuntime, Memory, State } from "@elizaos/core";
+import { type WalletProvider } from "../providers/wallet";
+import { swapTemplate } from "../templates";
+import { type SwapParams, type Transaction } from "../types";
+export { swapTemplate };
+export declare class SwapAction {
+    private readonly walletProvider;
+    constructor(walletProvider: WalletProvider);
+    private resolveTokenAddress;
+    swap(params: SwapParams): Promise<Transaction>;
+    private isRecoverableError;
+    private getSortedQuotes;
+    private getLifiQuote;
+    private getBebopQuote;
+    private getKyberSwapQuote;
+    private executeLifiQuote;
+    private executeBebopQuote;
+    private executeKyberSwapQuote;
+    private handleTokenApproval;
+}
+export declare function buildSwapDetails(state: State, message: Memory, runtime: IAgentRuntime, wp: WalletProvider): Promise<SwapParams>;
+export declare const swapAction: {
+    name: string;
+    description: string;
+    descriptionCompressed: string | undefined;
+    contexts: string[];
+    contextGate: {
+        anyOf: string[];
+    };
+    roleGate: {
+        minRole: string;
+    };
+    parameters: {
+        name: string;
+        description: string;
+        required: boolean;
+        schema: {
+            type: string;
+        };
+    }[];
+    handler: (runtime: IAgentRuntime, message: Memory, state?: State, _options?: Record<string, unknown>, callback?: HandlerCallback) => Promise<ActionResult>;
+    template: string;
+    validate: import("@elizaos/core").Validator;
+    examples: {
+        name: string;
+        user: string;
+        content: {
+            text: string;
+            action: string;
+        };
+    }[][];
+    similes: string[];
+};

package/dist/chains/evm/actions/transfer.d.ts

@@ -0,0 +1,10 @@
+import { type Action, type IAgentRuntime, type Memory, type State } from "@elizaos/core";
+import { type WalletProvider } from "../providers/wallet";
+import { type Transaction, type TransferParams } from "../types";
+export declare class TransferAction {
+    private readonly walletProvider;
+    constructor(walletProvider: WalletProvider);
+    transfer(params: TransferParams): Promise<Transaction>;
+}
+export declare function buildTransferDetails(state: State, message: Memory, runtime: IAgentRuntime, wp: WalletProvider): Promise<TransferParams>;
+export declare const transferAction: Action;

package/dist/chains/evm/bridge-router.d.ts

@@ -0,0 +1,44 @@
+import { type RouteExtended } from "@lifi/sdk";
+import { type Chain } from "viem";
+import { type WalletProvider } from "./providers/wallet";
+import { type BridgeParams } from "./types";
+import type { WalletRouterContext, WalletRouterExecution, WalletRouterParams } from "../../types/wallet-router.js";
+export declare class BridgeAction {
+    private readonly walletProvider;
+    private readonly activeRoutes;
+    constructor(walletProvider: WalletProvider);
+    private getChainNameById;
+    private resolveTokenAddress;
+    private getTokenDecimals;
+    private createExecutionOptions;
+    private updateRouteStatus;
+    private pollBridgeStatus;
+    getQuote(params: BridgeParams): Promise<{
+        routes: import("@lifi/sdk").Route[];
+        fromChainId: number;
+        toChainId: number;
+        resolvedFromToken: string;
+        resolvedToToken: string;
+        fromAmountParsed: bigint;
+        fromAddress: `0x${string}`;
+    }>;
+    bridge(params: BridgeParams): Promise<{
+        hash: `0x${string}`;
+        from: `0x${string}`;
+        to: `0x${string}`;
+        value: bigint;
+        chainId: number;
+        route: import("@lifi/sdk").Route;
+    }>;
+    resumeBridge(route: RouteExtended): Promise<RouteExtended>;
+}
+export declare function checkBridgeStatus(txHash: string, fromChainId: number, toChainId: number, tool?: string): Promise<{
+    status: "PENDING" | "DONE" | "FAILED" | "NOT_FOUND" | "INVALID";
+    substatus: import("@lifi/sdk").Substatus | undefined;
+    isComplete: boolean;
+    isFailed: boolean;
+    isPending: boolean;
+    error: import("@lifi/sdk").Substatus | undefined;
+}>;
+export declare function validateWalletBridgeParams(params: WalletRouterParams): string | null;
+export declare function routeEvmBridge(params: WalletRouterParams, context: WalletRouterContext, fromChainKey: string, fromChain: Chain): Promise<WalletRouterExecution>;

package/dist/chains/evm/build.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/chains/evm/chain-handler.d.ts

@@ -0,0 +1,37 @@
+import { type Chain } from "viem";
+import { type WalletProvider } from "./providers/wallet";
+import type { WalletChainHandler, WalletRouterContext, WalletRouterExecution, WalletRouterParams } from "../../types/wallet-router.js";
+import type { SupportedChain } from "./types";
+export type EvmWalletSubaction = "transfer" | "swap" | "gov";
+export type EvmWalletMode = "prepare" | "execute";
+export interface EvmWalletChainHandlerOptions {
+    readonly walletProvider?: WalletProvider;
+}
+export interface EvmPreparedResult extends WalletRouterExecution {
+    readonly status: "prepared";
+}
+export interface EvmExecutedTransaction extends WalletRouterExecution {
+    readonly status: "submitted";
+}
+export type EvmRouterResult = EvmPreparedResult | EvmExecutedTransaction;
+export declare class EvmWalletChainHandler implements WalletChainHandler {
+    private readonly chainKey;
+    private readonly chainConfig;
+    private readonly options;
+    readonly chainId: string;
+    readonly chain: string;
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly supportedActions: readonly ["transfer", "swap", "gov"];
+    readonly tokens: WalletChainHandler["tokens"];
+    readonly signer: WalletChainHandler["signer"];
+    readonly dryRun: WalletChainHandler["dryRun"];
+    constructor(chainKey: SupportedChain, chainConfig: Chain, options?: EvmWalletChainHandlerOptions);
+    execute(params: WalletRouterParams, context: WalletRouterContext): Promise<EvmRouterResult>;
+    prepareTransfer(params: WalletRouterParams): EvmPreparedResult;
+    prepareSwap(params: WalletRouterParams): EvmPreparedResult;
+    executeTransfer(params: WalletRouterParams, context: WalletRouterContext): Promise<EvmExecutedTransaction>;
+    executeSwap(params: WalletRouterParams, context: WalletRouterContext): Promise<EvmExecutedTransaction>;
+    private getWalletProvider;
+}
+export declare function createEvmWalletChainHandler(chainKey: string, chain: Chain, options?: EvmWalletChainHandlerOptions): EvmWalletChainHandler;

package/dist/chains/evm/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const EVM_SERVICE_NAME: "evmService";
+export declare const EVM_WALLET_DATA_CACHE_KEY: "evm_wallet_data";
+export declare const CACHE_REFRESH_INTERVAL_MS = 60000;
+export declare const GAS_BUFFER_MULTIPLIER: 1.2;
+export declare const GAS_PRICE_MULTIPLIER: 1.1;
+export declare const MAX_SLIPPAGE_PERCENT: 0.05;
+export declare const DEFAULT_SLIPPAGE_PERCENT: 0.01;
+export declare const MAX_PRICE_IMPACT: 0.4;
+export declare const TX_CONFIRMATION_TIMEOUT_MS = 60000;
+export declare const BRIDGE_POLL_INTERVAL_MS = 5000;
+export declare const MAX_BRIDGE_POLL_ATTEMPTS: 60;
+export declare const NATIVE_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const KYBERSWAP_NATIVE_SENTINEL: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const BEBOP_CHAIN_MAP: Readonly<Record<string, string>>;
+export declare const KYBERSWAP_CHAIN_MAP: Readonly<Record<string, string>>;
+export declare const DEFAULT_CHAINS: readonly ["mainnet", "base", "bsc"];

package/dist/chains/evm/dex/aerodrome/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "@elizaos/core";
+import { AerodromeLpService } from "./services/AerodromeLpService.ts";
+export declare const aerodromePlugin: Plugin;
+export * from "./types.ts";
+export { AerodromeLpService };
+export default aerodromePlugin;

package/dist/chains/evm/dex/aerodrome/services/AerodromeLpService.d.ts

@@ -0,0 +1,27 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import { type Address } from "viem";
+import type { EvmAddLiquidityParams, EvmDex, EvmPoolInfo, EvmPositionDetails, EvmRemoveLiquidityParams, EvmTransactionResult, IEvmLpService } from "../../../../../lp/types.ts";
+export declare class AerodromeLpService extends Service implements IEvmLpService {
+    static readonly serviceType = "aerodrome-lp";
+    readonly capabilityDescription = "Provides Aerodrome DEX liquidity pool management on Base chain.";
+    private publicClient;
+    private walletClients;
+    private rpcUrl;
+    constructor(runtime?: IAgentRuntime);
+    private initializeRpcUrl;
+    private getPublicClient;
+    private getWalletClient;
+    static start(runtime: IAgentRuntime): Promise<AerodromeLpService>;
+    stop(): Promise<void>;
+    getDexName(): EvmDex;
+    getSupportedChainIds(): number[];
+    supportsChain(chainId: number): boolean;
+    getPools(chainId: number, tokenA?: Address, tokenB?: Address, _feeTier?: number): Promise<EvmPoolInfo[]>;
+    private getPoolInfo;
+    addLiquidity(params: EvmAddLiquidityParams): Promise<EvmTransactionResult>;
+    removeLiquidity(params: EvmRemoveLiquidityParams): Promise<EvmTransactionResult>;
+    getPositionDetails(chainId: number, owner: Address, poolAddress: Address, _tokenId?: bigint): Promise<EvmPositionDetails | null>;
+    getAllPositions(chainId: number, _owner: Address): Promise<EvmPositionDetails[]>;
+    getMarketData(poolAddresses: Address[]): Promise<Record<string, Partial<EvmPoolInfo>>>;
+    private approveToken;
+}