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

package/dist/chains/solana/service.d.ts

@@ -0,0 +1,237 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+export interface WalletAsset {
+    address: string;
+    symbol: string;
+    balance: string;
+    decimals: number;
+    valueUsd: number;
+}
+export interface WalletPortfolioType {
+    totalValueUsd: number;
+    assets: WalletAsset[];
+}
+import { type AccountInfo, Connection, type Context, Keypair, type ParsedAccountData, PublicKey } from "@solana/web3.js";
+import BigNumber from "bignumber.js";
+import type { WalletChainHandler, WalletRouterExecution, WalletRouterParams } from "../../types/wallet-router.js";
+import type { ExchangeProvider, ExtendedJupiterServiceInterface, JupiterQuote, SwapExecutionResponse, SwapWalletEntry, TokenAccountEntry, TradingSignal, WalletPortfolio } from "./types";
+export declare const SOLANA_WALLET_COMPAT_SERVICE_NAME = "chain_solana_wallet";
+export type MintBalance = {
+    amount: string;
+    decimals: number;
+    uiAmount: number;
+};
+export type SolanaWalletSubaction = "transfer" | "swap";
+export type SolanaWalletActionMode = "prepare" | "execute";
+export type SolanaTransferParams = {
+    tokenAddress?: string | null;
+    fromToken?: string | null;
+    recipient: string;
+    amount: string | number;
+    dryRun?: boolean;
+    mode?: SolanaWalletActionMode;
+};
+export type SolanaSwapParams = {
+    inputTokenCA?: string | null;
+    outputTokenCA?: string | null;
+    fromToken?: string | null;
+    toToken?: string | null;
+    inputTokenSymbol?: string | null;
+    outputTokenSymbol?: string | null;
+    amount: string | number;
+    slippageBps?: number;
+    dryRun?: boolean;
+    mode?: SolanaWalletActionMode;
+};
+export type SolanaWalletActionParams = ({
+    subaction: "transfer";
+    chain?: string;
+} & SolanaTransferParams) | ({
+    subaction: "swap";
+    chain?: string;
+} & SolanaSwapParams);
+export type SolanaTransferResult = {
+    success: true;
+    signature: string | null;
+    dryRun: boolean;
+    kind: "sol" | "spl";
+    amount: string;
+    recipient: string;
+    tokenAddress: string | null;
+};
+export type SolanaSwapResult = {
+    success: true;
+    txid: string | null;
+    dryRun: boolean;
+    inputTokenCA: string;
+    outputTokenCA: string;
+    amount: string;
+};
+export type SolanaWalletActionResult = SolanaTransferResult | SolanaSwapResult;
+type KeyedParsedTokenAccount = {
+    pubkey: PublicKey;
+    account: AccountInfo<ParsedAccountData>;
+};
+export interface ISolanaPluginServiceAPI extends Service {
+    executeSwap: (wallets: Array<{
+        keypair: Keypair;
+        amount: number;
+    }>, signal: TradingSignal) => Promise<Record<string, SwapExecutionResponse>>;
+    getPublicKey: () => Promise<PublicKey | null>;
+}
+export declare class SolanaWalletService extends Service {
+    static readonly serviceType: string;
+    readonly capabilityDescription = "Deprecated Solana wallet compatibility adapter. Use chain_solana.";
+    private _solanaService;
+    constructor(runtime?: IAgentRuntime);
+    private get solanaService();
+    getPortfolio(owner?: string): Promise<WalletPortfolioType>;
+    getBalance(assetAddress: string, owner?: string): Promise<number>;
+    transferSol(from: Keypair, to: PublicKey, lamports: number | bigint): Promise<string>;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare class SolanaService extends Service {
+    static readonly serviceType: string;
+    readonly capabilityDescription = "The agent is able to interact with the Solana blockchain, and has access to the wallet data";
+    private lastUpdate;
+    private readonly UPDATE_INTERVAL;
+    private connection;
+    private _publicKey;
+    private _keypair;
+    private _publicKeyPromise;
+    private _keypairPromise;
+    private exchangeRegistry;
+    private subscriptions;
+    jupiterService: ExtendedJupiterServiceInterface | null;
+    static readonly LAMPORTS2SOL: number;
+    static readonly SOL2LAMPORTS = 1000000000;
+    private decimalsCache;
+    constructor(runtime?: IAgentRuntime);
+    private isJupiterService;
+    private ensurePublicKey;
+    private ensureKeypair;
+    /**
+     * Force reload wallet keys from settings (e.g., after wallet creation)
+     * Clears cached values and reloads on next access
+     */
+    reloadKeys(): Promise<void>;
+    getConnection(): Connection;
+    getWalletChainHandler(): WalletChainHandler;
+    handleWalletAction(params: SolanaWalletActionParams): Promise<SolanaWalletActionResult>;
+    executeWalletRouterAction(params: WalletRouterParams): Promise<WalletRouterExecution>;
+    getPortfolio(owner?: string): Promise<WalletPortfolioType>;
+    getBalance(assetAddress: string, owner?: string): Promise<number>;
+    transferSol(from: Keypair, to: PublicKey, lamports: number | bigint): Promise<string>;
+    transfer(params: SolanaTransferParams): Promise<SolanaTransferResult>;
+    swap(params: SolanaSwapParams): Promise<SolanaSwapResult>;
+    private isNativeSol;
+    private normalizeSolanaTokenAddress;
+    private normalizeRequiredTokenAddress;
+    private normalizePositiveAmount;
+    private toAtomicAmount;
+    private getTokenDecimalsForTransfer;
+    private buildJupiterSwapTransaction;
+    registerExchange(provider: ExchangeProvider): Promise<number>;
+    /**
+     * Determine the Birdeye API configuration.
+     *
+     * Priority:
+     * 1. Direct BIRDEYE_API_KEY — user's own key, calls birdeye.so directly
+     * 2. Eliza Cloud proxy — routes through cloud, cloud injects its own key
+     * 3. Error — no Birdeye data source available
+     */
+    private getBirdeyeConfig;
+    /**
+     * Determine the Solana RPC connection URL.
+     *
+     * Priority:
+     * 1. Direct SOLANA_RPC_URL — user's own RPC endpoint
+     * 2. HELIUS_API_KEY — builds Helius RPC URL
+     * 3. Eliza Cloud proxy — routes through cloud RPC proxy
+     * 4. Default public RPC (rate-limited)
+     */
+    private static resolveRpcUrl;
+    private birdeyeFetchWithRetry;
+    batchGetMultipleAccountsInfo(pubkeys: PublicKey[], _label: string): Promise<(AccountInfo<Buffer> | null)[]>;
+    verifySignature({ publicKeyBase58, message, signatureBase64, }: {
+        message: string;
+        signatureBase64: string;
+        publicKeyBase58: string;
+    }): boolean;
+    isValidAddress(address: string, onCurveOnly?: boolean): boolean;
+    validateAddress(address: string | undefined): boolean;
+    private static readonly TOKEN_ACCOUNT_DATA_LENGTH;
+    private static readonly TOKEN_MINT_DATA_LENGTH;
+    getAddressType(address: string): Promise<string>;
+    getAddressesTypes(addresses: string[]): Promise<Record<string, string>>;
+    detectPubkeysFromString(input: string, checkCurve?: boolean): Array<string>;
+    detectPrivateKeysFromString(input: string): Array<{
+        format: "base58" | "hex";
+        match: string;
+        bytes: Uint8Array;
+    }>;
+    getCirculatingSupply(mint: string): Promise<number>;
+    getCirculatingSupplies(mints: string[]): Promise<number[]>;
+    private fetchPrices;
+    getDecimal(mintPublicKey: PublicKey): Promise<number>;
+    getDecimals(mints: string[]): Promise<number[]>;
+    getMetadataAddress(mint: PublicKey): Promise<PublicKey>;
+    getTokenSymbol(mint: PublicKey): Promise<string | null>;
+    private parseToken2022SymbolFromMintOrPtr;
+    getTokensSymbols(mints: string[]): Promise<Record<string, string | null>>;
+    getSupply(CAs: string[]): Promise<{
+        [k: string]: {
+            supply: bigint | undefined;
+            decimals: number | undefined;
+            human: BigNumber | undefined;
+        };
+    }>;
+    parseTokenAccounts(heldTokens: TokenAccountEntry[], options?: {
+        notOlderThan?: number;
+    }): Promise<{
+        [k: string]: {
+            symbol: string | null;
+            supply: string | number | null;
+            tokenProgram: string;
+            decimals: number;
+            balanceUi: number;
+            isMutable: boolean | null;
+        };
+    }>;
+    private getTokenAccounts;
+    getWalletKeypair(): Promise<Keypair>;
+    getPublicKey(): Promise<PublicKey | null>;
+    updateWalletData(force?: boolean): Promise<WalletPortfolio>;
+    getCachedData(): Promise<WalletPortfolio | null>;
+    forceUpdate(): Promise<WalletPortfolio>;
+    createWallet(): Promise<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+    getTokenAccountsByKeypair(walletAddress: PublicKey, options?: {
+        notOlderThan?: number;
+        includeZeroBalances?: boolean;
+    }): Promise<KeyedParsedTokenAccount[]>;
+    getTokenAccountsByKeypairs(walletAddresses: string[], options?: {}): Promise<Record<string, KeyedParsedTokenAccount[]>>;
+    getBalancesByAddrs(walletAddressArr: string[]): Promise<Record<string, number>>;
+    walletAddressToHumanString(pubKey: string): Promise<string>;
+    walletAddressToLLMString(pubKey: string): Promise<string>;
+    getWalletBalances(publicKeyStr: string, mintAddresses: string[]): Promise<Record<string, MintBalance | null>>;
+    getTokenBalanceForWallets(mint: PublicKey, walletAddresses: string[]): Promise<Record<string, number>>;
+    subscribeToAccount(accountAddress: string, handler: (address: string, accountInfo: AccountInfo<Buffer>, context: Context) => void): Promise<number>;
+    unsubscribeFromAccount(accountAddress: string): Promise<boolean>;
+    calculateOptimalBuyAmount(inputMint: string, outputMint: string, availableAmount: number): Promise<{
+        amount: number;
+        slippage: number;
+    }>;
+    calculateOptimalBuyAmount2(quote: JupiterQuote, availableAmount: number): Promise<{
+        amount: number;
+        slippage: number;
+    }>;
+    executeSwap(wallets: SwapWalletEntry[], signal: TradingSignal): Promise<Record<string, SwapExecutionResponse>>;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};

package/dist/chains/solana/types.d.ts

@@ -0,0 +1,377 @@
+import type { Keypair, PublicKey } from "@solana/web3.js";
+export interface Item {
+    name: string;
+    address: string;
+    symbol: string;
+    decimals: number;
+    balance: string;
+    uiAmount: string;
+    priceUsd: string;
+    valueUsd: string;
+    valueSol?: string;
+}
+export interface Prices {
+    solana: {
+        usd: string;
+    };
+    bitcoin: {
+        usd: string;
+    };
+    ethereum: {
+        usd: string;
+    };
+}
+export interface WalletPortfolio {
+    totalUsd: string;
+    totalSol?: string;
+    items: Array<Item>;
+    prices?: Prices;
+    lastUpdated?: number;
+}
+export interface TokenAccountInfo {
+    pubkey: PublicKey;
+    account: {
+        lamports: number;
+        data: {
+            parsed: {
+                info: {
+                    mint: string;
+                    owner: string;
+                    tokenAmount: {
+                        amount: string;
+                        decimals: number;
+                        uiAmount: number;
+                    };
+                };
+                type: string;
+            };
+            program: string;
+            space: number;
+        };
+        owner: string;
+        executable: boolean;
+        rentEpoch: number;
+    };
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}
+export interface ApiError {
+    code: string;
+    message: string;
+    details?: string;
+}
+export interface WalletAddressResponse {
+    publicKey: string;
+}
+export interface WalletBalanceResponse {
+    publicKey: string;
+    balance: number;
+    symbol: string;
+}
+export interface TokenBalanceResponse {
+    publicKey: string;
+    token: string;
+    balance: number;
+    decimals: number;
+}
+export interface WalletPortfolioResponse {
+    publicKey: string;
+    totalUsd: string;
+    totalSol: string;
+    tokens: PortfolioTokenResponse[];
+    prices?: {
+        solana: number;
+        bitcoin: number;
+        ethereum: number;
+    };
+    lastUpdated?: string;
+    hasBirdeyeData: boolean;
+}
+export interface PortfolioTokenResponse {
+    name: string;
+    symbol: string;
+    address: string;
+    balance: string;
+    decimals: number;
+    priceUsd: string;
+    valueUsd: string;
+    valueSol: string;
+}
+export interface WalletTokensResponse {
+    publicKey: string;
+    tokens: TokenAccountResponse[];
+    count: number;
+}
+export interface TokenAccountResponse {
+    mint: string;
+    balance: number;
+    decimals: number;
+    amount: string;
+}
+export interface MintBalance {
+    amount: string;
+    decimals: number;
+    uiAmount: number;
+}
+export interface ParsedTokenAccount {
+    pubkey: PublicKey;
+    account: {
+        lamports: number;
+        data: {
+            parsed: {
+                info: {
+                    mint: string;
+                    owner: string;
+                    tokenAmount: {
+                        amount: string;
+                        decimals: number;
+                        uiAmount: number;
+                        uiAmountString?: string;
+                    };
+                    isNative?: boolean;
+                    state?: string;
+                    extensions?: Array<Record<string, string | number | boolean>>;
+                };
+                type: string;
+            };
+            program: string;
+            space: number;
+        };
+        owner: PublicKey | string;
+        executable: boolean;
+        rentEpoch: number;
+    };
+}
+export interface JupiterQuote {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: null | {
+        amount: string;
+        feeBps: number;
+    };
+    priceImpactPct: string;
+    routePlan: Array<{
+        swapInfo: {
+            ammKey: string;
+            label: string;
+            inputMint: string;
+            outputMint: string;
+            inAmount: string;
+            outAmount: string;
+            feeAmount: string;
+            feeMint: string;
+        };
+        percent: number;
+    }>;
+    contextSlot: number;
+    timeTaken: number;
+}
+export interface JupiterSwapResult {
+    swapTransaction: string;
+    lastValidBlockHeight: number;
+    prioritizationFeeLamports: number;
+    computeUnitLimit: number;
+    error?: string;
+}
+export interface SwapResult {
+    success: boolean;
+    signature?: string;
+    outAmount?: number;
+    fees?: SwapFees;
+    error?: string;
+}
+export interface SwapFees {
+    totalFee: number;
+    platformFee: number;
+    networkFee: number;
+}
+export interface ExchangeProvider {
+    name: string;
+    getQuote(params: SwapQuoteParams): Promise<JupiterQuote>;
+    executeSwap(params: SwapExecuteParams): Promise<SwapResult>;
+}
+export interface SwapQuoteParams {
+    inputMint: string;
+    outputMint: string;
+    amount: string;
+    slippageBps?: number;
+}
+export interface SwapExecuteParams {
+    quote: JupiterQuote;
+    userPublicKey: string;
+    wrapAndUnwrapSol?: boolean;
+}
+export interface JupiterServiceInterface {
+    getQuote(params: SwapQuoteParams): Promise<JupiterQuote>;
+    swap(params: SwapExecuteParams): Promise<SwapResult>;
+}
+export interface ExtendedJupiterServiceInterface extends JupiterServiceInterface {
+    getPriceImpact?(params: {
+        inputMint: string;
+        outputMint: string;
+        amount: number;
+    }): Promise<number>;
+    findBestSlippage?(params: {
+        inputMint: string;
+        outputMint: string;
+        amount: number;
+    }): Promise<number>;
+    estimateLamportsNeeded?(params: {
+        inputMint: string;
+        inAmount: number;
+    }): number;
+    executeSwap?(params: {
+        quoteResponse: JupiterQuote;
+        userPublicKey: string;
+        slippageBps: number;
+    }): Promise<JupiterSwapResult>;
+    estimateGasFees?(params: {
+        inputMint: string;
+        outputMint: string;
+        amount: number;
+    }): Promise<SwapFees>;
+}
+export interface TradingSignal {
+    sourceTokenCA: string;
+    targetTokenCA: string;
+}
+export interface SwapExecutionResponse {
+    success: boolean;
+    outAmount?: string;
+    outDecimal?: number;
+    signature?: string;
+    fees?: {
+        lamports: number;
+        sol: number;
+    };
+    swapResponse?: JupiterSwapResult;
+    error?: string;
+}
+export interface AccountNotification {
+    context: {
+        slot: number;
+    };
+    value: {
+        lamports: number;
+        data: string | Buffer | {
+            parsed: Record<string, string | number | boolean | null>;
+            program: string;
+            space: number;
+        };
+        owner: string;
+        executable: boolean;
+        rentEpoch: number;
+    };
+}
+/**
+ * WebSocket subscription handler.
+ */
+export type SubscriptionHandler = (notification: AccountNotification) => void | Promise<void>;
+export interface CacheWrapper<T> {
+    exp: number;
+    data: T;
+}
+export interface Token2022Metadata {
+    isMutable: boolean;
+    updateAuthority?: string;
+    mint: string;
+    name: string;
+    symbol: string;
+    uri: string;
+    additional?: Array<[string, string]>;
+}
+export interface TokenSupplyInfo {
+    supply: bigint;
+    decimals: number;
+    human: string;
+}
+export interface BirdeyePriceResponse {
+    success: boolean;
+    data: {
+        value: number;
+        updateUnixTime: number;
+        updateHumanTime: string;
+    };
+}
+export interface BirdeyeWalletTokenItem {
+    address: string;
+    symbol?: string;
+    name?: string;
+    decimals?: number;
+    balance?: string;
+    balanceUsd?: number;
+    priceUsd?: string;
+    valueUsd?: string;
+    uiAmount?: string;
+}
+export interface BirdeyeWalletTokenListResponse {
+    success: boolean;
+    data?: {
+        totalUsd: number | string;
+        items: BirdeyeWalletTokenItem[];
+    };
+}
+export interface SwapWalletEntry {
+    keypair: Keypair;
+    amount: number;
+}
+export interface BatchSwapResult {
+    success: boolean;
+    outAmount?: number;
+    fees?: SwapFees;
+    swapResponse?: JupiterSwapResult;
+    error?: string;
+}
+export interface TokenAccountEntry {
+    pubkey: PublicKey;
+    account: {
+        data: {
+            program: string;
+            parsed: {
+                type: string;
+                info: {
+                    mint: string;
+                    owner: string;
+                    state: string;
+                    tokenAmount: {
+                        amount: string;
+                        decimals: number;
+                        uiAmount: number;
+                        uiAmountString: string;
+                    };
+                    isNative?: boolean;
+                    extensions?: Array<Record<string, string | number | boolean>>;
+                };
+            };
+        };
+        owner: PublicKey;
+        lamports: number;
+    };
+}
+export interface TokenMetaCacheEntry {
+    setAt: number;
+    data: {
+        symbol: string | null;
+        supply: string | number | null;
+        tokenProgram: string;
+        decimals: number;
+        isMutable: boolean | null;
+    };
+}
+export interface ParsedTokenResult {
+    mint: string;
+    symbol: string | null;
+    supply: string | number | null;
+    tokenProgram: "Token-2022" | "Token";
+    decimals: number;
+    balanceUi: number;
+    isMutable: boolean | null;
+}

package/dist/chains/solana/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/chains/wallet-action.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from "@elizaos/core";
+export declare const walletRouterAction: Action;
+export default walletRouterAction;

package/dist/contracts.d.ts

@@ -0,0 +1,58 @@
+export interface WalletExportRequestBody {
+    confirm?: boolean;
+    exportToken?: string;
+}
+export interface WalletExportRejection {
+    status: 400 | 401 | 402 | 403 | 429;
+    reason: string;
+}
+export interface WalletMarketPriceSnapshot {
+    id: string;
+    symbol: string;
+    name: string;
+    priceUsd: number;
+    change24hPct: number;
+    imageUrl: string | null;
+}
+export interface WalletMarketMover {
+    id: string;
+    symbol: string;
+    name: string;
+    priceUsd: number;
+    change24hPct: number;
+    marketCapRank: number | null;
+    imageUrl: string | null;
+}
+export interface WalletMarketPrediction {
+    id: string;
+    slug: string | null;
+    question: string;
+    highlightedOutcomeLabel: string;
+    highlightedOutcomeProbability: number | null;
+    volume24hUsd: number;
+    totalVolumeUsd: number | null;
+    endsAt: string | null;
+    imageUrl: string | null;
+}
+export type WalletMarketOverviewProviderId = "coingecko" | "polymarket";
+export interface WalletMarketOverviewSource {
+    providerId: WalletMarketOverviewProviderId;
+    providerName: string;
+    providerUrl: string;
+    available: boolean;
+    stale: boolean;
+    error: string | null;
+}
+export interface WalletMarketOverviewResponse {
+    generatedAt: string;
+    cacheTtlSeconds: number;
+    stale: boolean;
+    sources: {
+        prices: WalletMarketOverviewSource;
+        movers: WalletMarketOverviewSource;
+        predictions: WalletMarketOverviewSource;
+    };
+    prices: WalletMarketPriceSnapshot[];
+    movers: WalletMarketMover[];
+    predictions: WalletMarketPrediction[];
+}

package/dist/core-augmentation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Augment elizaOS service registry so `getService("wallet-backend")` is typed.
+ */
+declare module "@elizaos/core" {
+    interface ServiceTypeRegistry {
+        WALLET_BACKEND: "wallet-backend";
+    }
+}
+export {};