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

package/dist/analytics/news/index.d.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from "@elizaos/core";
+/**
+ * DeFi News Plugin
+ *
+ * A comprehensive plugin that automatically provides DeFi and crypto market context to conversations through providers.
+ *
+ * Features:
+ * - Global DeFi market statistics (market cap, volume, dominance) - requires CoinGecko service
+ * - Global crypto market data (active cryptocurrencies, total market cap, dominance) - requires CoinGecko service
+ * - Latest crypto news from Brave New Coin RSS feed (always available)
+ * - Token information (price, market cap, community stats, developer activity) - requires CoinGecko service
+ *
+ * Optional Dependencies:
+ * - COINGECKO_SERVICE: Provided by analytics plugin or similar for market data
+ * - birdeye: For Solana token lookups
+ * - chain_solana: For Solana blockchain interactions
+ *
+ * Required Services:
+ * - NEWS_DATA_SERVICE: Provided by this plugin for news data
+ *
+ * Note: This plugin works standalone with news data only. For full functionality,
+ * ensure the analytics plugin (or similar) is loaded to provide the COINGECKO_SERVICE.
+ *
+ * @author ElizaOS
+ * @version 2.0.0
+ */
+export declare const defiNewsPlugin: Plugin;
+export default defiNewsPlugin;
+export * from "./interfaces/types";
+export { defiNewsProvider } from "./providers/defiNewsProvider";
+export { NewsDataService } from "./services/newsDataService";
+export * from "./utils/formatters";

package/dist/analytics/news/interfaces/types.d.ts

@@ -0,0 +1,177 @@
+import type { IAgentRuntime, Memory, State } from "@elizaos/core";
+/**
+ * DeFi News data types
+ */
+export interface GlobalDefiData {
+    defi_market_cap: string;
+    eth_market_cap: string;
+    defi_to_eth_ratio: string;
+    trading_volume_24h: string;
+    defi_dominance: string;
+    top_coin_name: string;
+    top_coin_defi_dominance: number;
+}
+export interface GlobalCryptoData {
+    active_cryptocurrencies: number;
+    upcoming_icos: number;
+    ongoing_icos: number;
+    ended_icos: number;
+    markets: number;
+    total_market_cap: Record<string, number>;
+    total_volume: Record<string, number>;
+    market_cap_percentage: Record<string, number>;
+    market_cap_change_percentage_24h_usd: number;
+    updated_at: number;
+}
+export interface TokenNewsData {
+    tokenId: string;
+    tokenName: string;
+    symbol: string;
+    description?: string;
+    market_data?: {
+        current_price?: Record<string, number>;
+        market_cap?: Record<string, number>;
+        total_volume?: Record<string, number>;
+        price_change_percentage_24h?: number;
+        price_change_percentage_7d?: number;
+        price_change_percentage_30d?: number;
+    };
+    community_data?: {
+        twitter_followers?: number;
+        reddit_subscribers?: number;
+        telegram_channel_user_count?: number;
+    };
+    developer_data?: {
+        forks?: number;
+        stars?: number;
+        subscribers?: number;
+        total_issues?: number;
+        closed_issues?: number;
+        pull_requests_merged?: number;
+        pull_request_contributors?: number;
+    };
+    last_updated?: string;
+}
+export interface DexPairData {
+    base: string;
+    target: string;
+    market: {
+        name: string;
+        identifier: string;
+        has_trading_incentive: boolean;
+    };
+    last: number;
+    volume: number;
+    converted_last: Record<string, number>;
+    converted_volume: Record<string, number>;
+    trust_score: string;
+    bid_ask_spread_percentage: number;
+    timestamp: string;
+    last_traded_at: string;
+    last_fetch_at: string;
+    is_anomaly: boolean;
+    is_stale: boolean;
+    trade_url: string;
+    token_info_url: string | null;
+    coin_id: string;
+    target_coin_id?: string;
+}
+export interface OHLCVData {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+export interface RealWorldNewsArticle {
+    article_id: string;
+    title: string;
+    link: string;
+    keywords?: string[];
+    creator?: string[];
+    video_url?: string | null;
+    description?: string;
+    content?: string;
+    pubDate: string;
+    image_url?: string;
+    source_id: string;
+    source_priority: number;
+    source_url?: string;
+    source_icon?: string;
+    language: string;
+    country?: string[];
+    category?: string[];
+    ai_tag?: string;
+    sentiment?: string;
+    sentiment_stats?: string;
+    ai_region?: string;
+}
+export interface RealWorldNewsResponse {
+    status: string;
+    totalResults: number;
+    results: RealWorldNewsArticle[];
+    nextPage?: string;
+}
+export interface DefiNewsRequest {
+    tokenId?: string;
+    tokenAddress?: string;
+    chain?: string;
+    includeMarketData?: boolean;
+    includeCommunityData?: boolean;
+    includeDeveloperData?: boolean;
+    includeRealWorldNews?: boolean;
+    newsQuery?: string;
+    newsLanguage?: string;
+    newsCategory?: string;
+}
+export interface DexLiquidityRequest {
+    tokenId: string;
+    includePairs?: boolean;
+    includeOHLCV?: boolean;
+    ohlcvDays?: number;
+    timeframe?: "1h" | "4h" | "1d" | "1w";
+}
+export interface GlobalDefiRequest {
+    includeCryptoData?: boolean;
+}
+export interface DefiNewsResponse {
+    success: boolean;
+    data: {
+        tokenNews?: TokenNewsData;
+        globalDefi?: GlobalDefiData;
+        globalCrypto?: GlobalCryptoData;
+        dexPairs?: DexPairData[];
+        ohlcvData?: OHLCVData[];
+        realWorldNews?: RealWorldNewsArticle[];
+    };
+    timestamp: number;
+    error?: string;
+}
+export interface DefiNewsService {
+    getGlobalDefiData(): Promise<GlobalDefiData>;
+    getGlobalCryptoData(): Promise<GlobalCryptoData>;
+    getTokenData(tokenId: string, options?: {
+        includeMarketData?: boolean;
+        includeCommunityData?: boolean;
+        includeDeveloperData?: boolean;
+    }): Promise<TokenNewsData>;
+    getDexPairs(tokenId: string): Promise<DexPairData[]>;
+    getOHLCVData(tokenId: string, days: number): Promise<OHLCVData[]>;
+    getRealWorldNews(query: string, options?: {
+        language?: string;
+        category?: string;
+        limit?: number;
+    }): Promise<RealWorldNewsArticle[]>;
+}
+export interface ActionRequest {
+    runtime: IAgentRuntime;
+    message: Memory;
+    state?: State;
+}
+export interface ActionResponse {
+    success: boolean;
+    text: string;
+    data?: Record<string, unknown>;
+    error?: string;
+}

package/dist/analytics/news/providers/defiNewsProvider.d.ts

@@ -0,0 +1,106 @@
+import type { Provider } from "@elizaos/core";
+interface CoinGeckoDefiData {
+    defi_market_cap: string;
+    eth_market_cap: string;
+    defi_to_eth_ratio: string;
+    trading_volume_24h: string;
+    defi_dominance: string;
+    top_coin_name: string;
+    top_coin_defi_dominance: number;
+}
+interface CoinGeckoGlobalCryptoData {
+    active_cryptocurrencies: number;
+    markets: number;
+    total_market_cap: {
+        usd: number;
+    };
+    total_volume: {
+        usd: number;
+    };
+    market_cap_change_percentage_24h_usd: number;
+    market_cap_percentage?: Record<string, number>;
+}
+interface CoinGeckoSearchResult {
+    id: string;
+    platforms?: {
+        solana?: string;
+    };
+}
+interface CoinGeckoCoinData {
+    name: string;
+    symbol: string;
+    market_cap_rank?: number;
+    market_data?: {
+        current_price?: {
+            usd?: number;
+        };
+        market_cap?: {
+            usd?: number;
+        };
+        total_volume?: {
+            usd?: number;
+        };
+        high_24h?: {
+            usd?: number;
+        };
+        low_24h?: {
+            usd?: number;
+        };
+        price_change_percentage_24h?: number;
+        price_change_percentage_7d?: number;
+        price_change_percentage_30d?: number;
+    };
+    community_data?: {
+        twitter_followers?: number;
+        reddit_subscribers?: number;
+        telegram_channel_user_count?: number;
+    };
+    developer_data?: {
+        forks?: number;
+        stars?: number;
+    };
+}
+interface CoinGeckoService {
+    getGlobalDefiData(): Promise<CoinGeckoDefiData>;
+    getGlobalCryptoData(): Promise<CoinGeckoGlobalCryptoData>;
+    searchCoin(symbol: string): Promise<CoinGeckoSearchResult[]>;
+    getCoinData(tokenId: string): Promise<CoinGeckoCoinData>;
+}
+/**
+ * DeFi News Provider
+ *
+ * Automatically provides comprehensive DeFi and crypto market context to conversations.
+ * This provider is dynamic and fetches fresh data on each request.
+ *
+ * The provider aggregates data from:
+ * - Global DeFi market statistics (market cap, volume, dominance) - requires CoinGecko service
+ * - Global crypto market data (total market cap, active cryptocurrencies, dominance) - requires CoinGecko service
+ * - Latest crypto news from Brave New Coin RSS feed (top 5 articles) - always available
+ * - Token-specific data when mentioned - requires CoinGecko and optional Birdeye services
+ *
+ * The data is formatted as a comprehensive market report that can be used
+ * by the agent to provide informed responses about DeFi and crypto markets.
+ *
+ * Note: The CoinGecko service should be provided by the analytics plugin or similar.
+ * If not available, the provider will still work with news data only.
+ *
+ * @example
+ * // The provider is automatically called by the framework
+ * // No manual invocation needed - just add to plugin.providers array
+ */
+export declare const defiNewsProvider: Provider;
+/**
+ * Extract symbols from text
+ * Dynamically extracts token symbols from natural language
+ *
+ * @param text - The text to extract symbols from
+ * @param mode - "strict" only matches $SYMBOL format, "loose" matches various patterns
+ * @returns Array of detected symbols
+ */
+export declare const extractSymbols: (text: string, mode?: "strict" | "loose") => string[];
+/**
+ * Get token information
+ * This is a helper function that can be used for specific token queries
+ */
+export declare function getTokenInfo(coinGeckoService: CoinGeckoService, tokenId: string): Promise<string>;
+export {};

package/dist/analytics/news/services/newsDataService.d.ts

@@ -0,0 +1,72 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { Service } from "@elizaos/core";
+import type { RealWorldNewsArticle } from "../interfaces/types";
+/**
+ * Brave New Coin RSS Service for Real-World Crypto Events
+ *
+ * This service fetches real-world news and events related to cryptocurrency
+ * from Brave New Coin RSS feed.
+ */
+export declare class NewsDataService extends Service {
+    static serviceType: string;
+    private rssUrl;
+    get capabilityDescription(): string;
+    /**
+     * Start the NewsData service (static method for framework)
+     */
+    static start(runtime: IAgentRuntime): Promise<NewsDataService>;
+    /**
+     * Stop the NewsData service (static method for framework)
+     */
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Stop the service instance
+     */
+    stop(): Promise<void>;
+    /**
+     * Parse RSS XML to extract news items
+     */
+    private parseRSS;
+    /**
+     * Extract content from XML tag
+     */
+    private extractTag;
+    /**
+     * Strip HTML tags from text
+     */
+    private stripHtml;
+    /**
+     * Decode HTML entities (e.g., &#8217; to ')
+     */
+    private decodeHtmlEntities;
+    /**
+     * Fetch latest crypto news from Brave New Coin RSS feed
+     */
+    getLatestNews(options?: {
+        query?: string;
+        language?: string;
+        category?: string;
+        limit?: number;
+    }): Promise<RealWorldNewsArticle[]>;
+    /**
+     * Fetch news about a specific token
+     */
+    getTokenNews(tokenSymbol: string, options?: {
+        language?: string;
+        limit?: number;
+    }): Promise<RealWorldNewsArticle[]>;
+    /**
+     * Fetch DeFi-specific news
+     */
+    getDefiNews(options?: {
+        language?: string;
+        limit?: number;
+    }): Promise<RealWorldNewsArticle[]>;
+    /**
+     * Fetch blockchain and crypto market news
+     */
+    getCryptoMarketNews(options?: {
+        language?: string;
+        limit?: number;
+    }): Promise<RealWorldNewsArticle[]>;
+}

package/dist/analytics/news/utils/formatters.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Utility functions for formatting DeFi news data
+ */
+/**
+ * Format a number as currency (USD)
+ */
+export declare function formatCurrency(value: number, decimals?: number): string;
+/**
+ * Format a percentage with appropriate emoji
+ */
+export declare function formatPercentage(value: number, decimals?: number): string;
+/**
+ * Format a timestamp as a human-readable date
+ */
+export declare function formatDate(timestamp: number | string): string;
+/**
+ * Format a relative time (e.g., "2 hours ago")
+ */
+export declare function formatRelativeTime(timestamp: number | string): string;
+/**
+ * Truncate text to a maximum length
+ */
+export declare function truncateText(text: string, maxLength?: number): string;
+/**
+ * Get sentiment emoji
+ */
+export declare function getSentimentEmoji(sentiment?: string): string;
+/**
+ * Format large numbers with commas
+ */
+export declare function formatNumber(value: number, decimals?: number): string;
+/**
+ * Extract token symbol from text
+ */
+export declare function extractTokenSymbol(text: string): string | null;
+/**
+ * Format OHLCV data for display
+ */
+export declare function formatOHLCV(candle: {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}): string;
+/**
+ * Clean HTML tags from text
+ */
+export declare function stripHtml(html: string): string;
+/**
+ * Validate if a string is a valid token address
+ */
+export declare function isValidTokenAddress(address: string): boolean;

package/dist/analytics/token-info/action.d.ts

@@ -0,0 +1,6 @@
+import type { ActionResult, HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State } from "@elizaos/core";
+/**
+ * Folded into WALLET as `action=token_info`. Routes token-info queries through
+ * the registered TokenInfoService providers (DexScreener, Birdeye, CoinGecko).
+ */
+export declare function tokenInfoHandler(runtime: IAgentRuntime, message: Memory, state?: State, options?: HandlerOptions | Record<string, unknown>, callback?: HandlerCallback): Promise<ActionResult>;

package/dist/analytics/token-info/index.d.ts

@@ -0,0 +1,3 @@
+export { tokenInfoHandler } from "./action";
+export { TOKEN_INFO_SERVICE_TYPE, TokenInfoService } from "./service";
+export * from "./types";

package/dist/analytics/token-info/params.d.ts

@@ -0,0 +1,10 @@
+import type { HandlerOptions, Memory, State } from "@elizaos/core";
+import { type TokenInfoParams, type TokenInfoSubaction } from "./types";
+export declare function readParams(options?: unknown): Record<string, unknown>;
+export declare function readStringParam(options: unknown, ...keys: string[]): string | undefined;
+export declare function readNumberParam(options: unknown, key: string, fallback?: number): number | undefined;
+export declare function readBooleanParam(options: unknown, key: string): boolean | undefined;
+export declare function normalizeTokenInfoSubaction(value: unknown): TokenInfoSubaction | undefined;
+export declare function inferTokenInfoSubaction(message: Memory, state?: State): TokenInfoSubaction;
+export declare function parseTokenInfoParams(message: Memory, state?: State, options?: HandlerOptions | Record<string, unknown>): TokenInfoParams;
+export declare function selectedContextMatches(state: State | undefined, contexts: readonly string[]): boolean;

package/dist/analytics/token-info/providers.d.ts

@@ -0,0 +1,4 @@
+import type { TokenInfoProvider } from "./types";
+export declare function createDexScreenerTokenInfoProvider(): TokenInfoProvider;
+export declare function createBirdeyeTokenInfoProvider(): TokenInfoProvider;
+export declare function createCoinGeckoTokenInfoProvider(): TokenInfoProvider;

package/dist/analytics/token-info/service.d.ts

@@ -0,0 +1,19 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { TokenInfoDispatchContext, TokenInfoProvider, TokenInfoProviderMetadata, TokenInfoRouteResult } from "./types";
+export declare const TOKEN_INFO_SERVICE_TYPE: "token-info";
+export declare class TokenInfoService extends Service {
+    static serviceType: "token-info";
+    capabilityDescription: string;
+    private readonly providers;
+    private readonly aliases;
+    static start(runtime: IAgentRuntime): Promise<TokenInfoService>;
+    registerProvider(provider: TokenInfoProvider): void;
+    listProviders(): TokenInfoProviderMetadata[];
+    getCapabilities(): {
+        readonly providers: readonly TokenInfoProviderMetadata[];
+    };
+    route(context: TokenInfoDispatchContext): Promise<TokenInfoRouteResult>;
+    stop(): Promise<void>;
+    private resolveProvider;
+    private toMetadata;
+}

package/dist/analytics/token-info/types.d.ts

@@ -0,0 +1,45 @@
+import type { ActionResult, HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State } from "@elizaos/core";
+export declare const TOKEN_INFO_SUBACTIONS: readonly ["search", "token", "trending", "new_pairs", "chain_pairs", "boosted", "profiles", "wallet"];
+export type TokenInfoSubaction = (typeof TOKEN_INFO_SUBACTIONS)[number];
+export interface TokenInfoParams {
+    readonly target?: string;
+    readonly subaction: TokenInfoSubaction;
+    readonly query?: string;
+    readonly address?: string;
+    readonly tokenAddress?: string;
+    readonly chain?: string;
+    readonly timeframe?: "1h" | "6h" | "24h";
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly sortBy?: "volume" | "liquidity" | "priceChange" | "txns";
+    readonly top?: boolean;
+    readonly kind?: "wallet-address" | "token-address" | "token-symbol";
+    readonly id?: string;
+}
+export interface TokenInfoProviderMetadata {
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly supportedSubactions: readonly TokenInfoSubaction[];
+    readonly description?: string;
+}
+export interface TokenInfoProvider extends TokenInfoProviderMetadata {
+    execute(context: TokenInfoDispatchContext): Promise<ActionResult>;
+}
+export interface TokenInfoDispatchContext {
+    readonly runtime: IAgentRuntime;
+    readonly message: Memory;
+    readonly state?: State;
+    readonly options?: HandlerOptions | Record<string, unknown>;
+    readonly params: TokenInfoParams;
+    readonly callback?: HandlerCallback;
+}
+export type TokenInfoRouteResult = {
+    readonly ok: true;
+    readonly provider: TokenInfoProviderMetadata;
+    readonly result: ActionResult;
+} | {
+    readonly ok: false;
+    readonly error: "UNSUPPORTED_PROVIDER" | "UNSUPPORTED_SUBACTION" | "INVALID_PARAMS" | "EXECUTION_FAILED";
+    readonly detail: string;
+    readonly providers?: readonly TokenInfoProviderMetadata[];
+};

package/dist/api/wallet-routes.d.ts

@@ -0,0 +1,100 @@
+import type http from "node:http";
+import type { AgentRuntime, RouteRequestMeta } from "@elizaos/core";
+import type { ElizaConfig, RouteHelpers, WalletBalancesResponse, WalletChain, WalletConfigStatus, WalletExportRejection as WalletExportRejectionLike, WalletExportRequestBody, WalletRpcChain } from "@elizaos/shared";
+export interface WalletRpcReadinessSnapshot {
+    walletNetwork: "mainnet" | "testnet";
+    cloudManagedAccess: boolean;
+    managedBscRpcReady: boolean;
+    evmBalanceReady: boolean;
+    solanaBalanceReady: boolean;
+    selectedRpcProviders: WalletRpcSelections;
+    legacyCustomChains: WalletRpcChain[];
+    bscRpcUrls: string[];
+    ethereumRpcUrls: string[];
+    baseRpcUrls: string[];
+    avalancheRpcUrls: string[];
+    solanaRpcUrls: string[];
+}
+import { type WalletConfigUpdateRequest, type WalletRpcSelections } from "@elizaos/shared";
+export interface WalletAddressesSnapshot {
+    evmAddress: string | null;
+    solanaAddress: string | null;
+}
+export interface FetchEvmBalancesOptions {
+    alchemyKey?: string | null;
+    ankrKey?: string | null;
+    cloudManagedAccess?: boolean;
+    bscRpcUrls?: string[];
+    ethereumRpcUrls?: string[];
+    baseRpcUrls?: string[];
+    avaxRpcUrls?: string[];
+    nodeRealBscRpcUrl?: string;
+    quickNodeBscRpcUrl?: string;
+    bscRpcUrl?: string;
+    ethereumRpcUrl?: string;
+    baseRpcUrl?: string;
+    avaxRpcUrl?: string;
+}
+export interface IntegrationTelemetrySpan {
+    success: (attributes?: Record<string, unknown>) => void;
+    failure: (attributes: {
+        error: unknown;
+    } & Record<string, unknown>) => void;
+}
+export interface CreateIntegrationTelemetrySpanArgs {
+    boundary: string;
+    operation: string;
+}
+export interface WalletRouteDependencies {
+    getWalletAddresses: () => WalletAddressesSnapshot;
+    fetchEvmBalances: (address: string, options: FetchEvmBalancesOptions) => Promise<NonNullable<WalletBalancesResponse["evm"]>["chains"]>;
+    fetchSolanaBalances: (address: string, heliusKey: string) => Promise<Omit<NonNullable<WalletBalancesResponse["solana"]>, "address">>;
+    fetchSolanaNativeBalanceViaRpc: (address: string, rpcUrls: string[]) => Promise<Omit<NonNullable<WalletBalancesResponse["solana"]>, "address">>;
+    validatePrivateKey: (privateKey: string) => {
+        chain: WalletChain;
+    };
+    importWallet: (chain: WalletChain, privateKey: string) => {
+        success: boolean;
+        chain: WalletChain;
+        address: string | null;
+        error: string | null;
+    };
+    generateWalletForChain: (chain: WalletChain) => {
+        privateKey: string;
+        address: string;
+    };
+    deriveSolanaAddress: (privateKey: string) => string;
+    setSolanaWalletEnv: (privateKey: string) => void;
+    resolveWalletRpcReadiness: (config: ElizaConfig) => WalletRpcReadinessSnapshot;
+    resolveWalletNetworkMode: (config: ElizaConfig) => "mainnet" | "testnet";
+    getStoredWalletRpcSelections: (config: ElizaConfig) => WalletRpcSelections;
+    applyWalletRpcConfigUpdate: (config: ElizaConfig, update: WalletConfigUpdateRequest) => void;
+    resolveWalletCapabilityStatus: (args: {
+        config: ElizaConfig;
+        runtime: AgentRuntime | null;
+        getWalletAddresses: () => WalletAddressesSnapshot;
+    }) => {
+        walletSource: WalletConfigStatus["walletSource"];
+        automationMode: WalletConfigStatus["automationMode"];
+        pluginEvmLoaded: WalletConfigStatus["pluginEvmLoaded"];
+        pluginEvmRequired: WalletConfigStatus["pluginEvmRequired"];
+        executionReady: WalletConfigStatus["executionReady"];
+        executionBlockedReason: WalletConfigStatus["executionBlockedReason"];
+        evmSigningCapability: WalletConfigStatus["evmSigningCapability"];
+        evmSigningReason: WalletConfigStatus["evmSigningReason"];
+    };
+    isCloudWalletEnabled: () => boolean;
+    persistConfigEnv: (key: string, value: string) => Promise<void>;
+    createIntegrationTelemetrySpan: (args: CreateIntegrationTelemetrySpanArgs) => IntegrationTelemetrySpan;
+}
+export interface WalletRouteContext extends RouteRequestMeta, Pick<RouteHelpers, "readJsonBody" | "json" | "error"> {
+    config: ElizaConfig;
+    saveConfig: (config: ElizaConfig) => void;
+    ensureWalletKeysInEnvAndConfig: (config: ElizaConfig) => boolean;
+    resolveWalletExportRejection: (req: http.IncomingMessage, body: WalletExportRequestBody) => WalletExportRejectionLike | null;
+    restartRuntime?: (reason: string) => Promise<boolean>;
+    scheduleRuntimeRestart?: (reason: string) => void;
+    deps: WalletRouteDependencies;
+    runtime?: AgentRuntime | null;
+}
+export declare function handleWalletRoutes(ctx: WalletRouteContext): Promise<boolean>;

package/dist/audit/audit-log.d.ts

@@ -0,0 +1,29 @@
+import type { ActionFailureCode, ValidateFailureCode } from "../actions/failure-codes.js";
+import type { SignScope } from "../wallet/pending.js";
+export type AuditKind = "action_validate_start" | "action_validate_end" | "action_handler_start" | "action_handler_end" | "wallet_sign_request" | "wallet_sign_result" | "approval_requested" | "approval_resolved" | "automation_trigger_fired" | "automation_trigger_skipped";
+export type AuditOutcome = "ok" | "validate_fail" | "handler_fail" | "pending_approval" | "approved" | "rejected";
+/**
+ * Row shape for the append-only audit log.
+ */
+export interface AuditLogRow {
+    readonly id: bigint;
+    readonly ts: number;
+    readonly actor: "agent" | "user" | "automation";
+    readonly kind: AuditKind;
+    readonly scope: SignScope | null;
+    readonly actionName: string | null;
+    readonly paramsHash: string;
+    readonly approvalId: string | null;
+    readonly outcome: AuditOutcome;
+    readonly failureCode: ValidateFailureCode | ActionFailureCode | null;
+    readonly detail: string | null;
+    readonly prevHash: string;
+    readonly rowHash: string;
+}
+export type AuditLogRowInput = Omit<AuditLogRow, "id" | "ts" | "prevHash" | "rowHash"> & {
+    readonly id?: bigint;
+    readonly ts?: number;
+    readonly prevHash?: string | null;
+};
+export declare function createAuditLogRow(input: AuditLogRowInput): AuditLogRow;
+export declare function verifyAuditLogRow(row: AuditLogRow): boolean;