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

package/dist/utils/intent-trajectory.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Intent-extraction trajectory helper for plugin-wallet.
+ *
+ * Wraps `runtime.useModel` calls used for financial-parameter extraction
+ * (transfer/swap/bridge/balance intent prompts) with the canonical
+ * `recordLlmCall` trajectory recorder so every intent LLM hop lands in
+ * the trajectories table for training and audit.
+ *
+ * Falls back to `logActiveTrajectoryLlmCall` if `recordLlmCall` is not
+ * exported by the linked `@elizaos/core` build.
+ */
+import { type IAgentRuntime, ModelType } from "@elizaos/core";
+export type IntentModelType = typeof ModelType.TEXT_LARGE | typeof ModelType.TEXT_SMALL;
+export interface RunIntentModelParams {
+    runtime: IAgentRuntime;
+    /** Trajectory `actionType` label. Use a dotted call-site identifier. */
+    taskName: string;
+    /** Logical purpose; financial intent extraction is "action" by default. */
+    purpose?: string;
+    /** Composed prompt text passed to the model. */
+    template: string;
+    /** Defaults to TEXT_LARGE. */
+    modelType?: IntentModelType;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Run an intent-extraction LLM call and record it on the active trajectory.
+ *
+ * Returns the raw model text so callers can continue parsing with their
+ * existing JSON pipeline. Uses `recordLlmCall` when available; otherwise
+ * runs the model and emits a `logActiveTrajectoryLlmCall` entry directly.
+ */
+export declare function runIntentModel(params: RunIntentModelParams): Promise<string>;

package/dist/wallet/backend.d.ts

@@ -0,0 +1,41 @@
+import type { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+import type { Account, Hex, TypedDataDefinition } from "viem";
+import type { SignResult, SignScope } from "./pending.js";
+/**
+ * Narrow signing surface for Solana venues (swap, LP, transfers).
+ */
+export interface SolanaSigner {
+    readonly publicKey: PublicKey;
+    signTransaction(tx: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    signAllTransactions(txs: ReadonlyArray<Transaction | VersionedTransaction>): Promise<Array<Transaction | VersionedTransaction>>;
+    /**
+     * Detached Ed25519 signature of an opaque message. Returned bytes are 64
+     * bytes (raw signature). Used by Wallet-Standard `signMessage` and any
+     * non-transaction sign-in flows.
+     */
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+export interface WalletAddresses {
+    readonly evm: `0x${string}` | null;
+    readonly solana: PublicKey | null;
+}
+export type WalletBackendKind = "local" | "steward";
+/**
+ * Canonical wallet abstraction. Providers and canonical actions reach signing
+ * only through this interface — never via raw env reads inside venue code.
+ *
+ * See docs/architecture/wallet-and-trading.md §A.
+ */
+export interface WalletBackend {
+    readonly kind: WalletBackendKind;
+    getAddresses(): WalletAddresses;
+    /**
+     * Returns true when this backend can satisfy signing for the given hint.
+     * Read-only QUERY_* flows may skip wallet checks per spec.
+     */
+    canSign(chainHint: "evm" | "solana" | "off-chain"): boolean;
+    getEvmAccount(chainId: number): Account;
+    getSolanaSigner(): SolanaSigner;
+    signMessage(scope: SignScope, message: Hex): Promise<SignResult>;
+    signTypedData(scope: SignScope, typedData: TypedDataDefinition): Promise<SignResult>;
+}

package/dist/wallet/errors.d.ts

@@ -0,0 +1,17 @@
+import type { PendingApproval } from "./pending.js";
+export type WalletBackendNotConfiguredCode = "EVM_PRIVATE_KEY_MISSING" | "SOLANA_PRIVATE_KEY_MISSING" | "NO_WALLET_CONFIGURED";
+export declare class WalletBackendNotConfiguredError extends Error {
+    readonly code: WalletBackendNotConfiguredCode;
+    constructor(code: WalletBackendNotConfiguredCode, message?: string);
+}
+export declare class StewardUnavailableError extends Error {
+    constructor(message: string);
+}
+export declare class PendingApprovalError extends Error {
+    readonly pending: PendingApproval;
+    readonly kind: "pending_approval";
+    constructor(pending: PendingApproval);
+}
+export declare class SolanaPrivateKeyInvalidError extends Error {
+    constructor(message: string);
+}

package/dist/wallet/index.d.ts

@@ -0,0 +1,6 @@
+export type { SolanaSigner, WalletAddresses, WalletBackend, WalletBackendKind, } from "./backend.js";
+export { PendingApprovalError, SolanaPrivateKeyInvalidError, StewardUnavailableError, WalletBackendNotConfiguredError, } from "./errors.js";
+export { LocalEoaBackend } from "./local-eoa-backend.js";
+export type { ApprovalSummary, CanonicalHandlerResult, PendingApproval, SignaturePayload, SignResult, SignScope, ValidateOutcome, } from "./pending.js";
+export { resolveWalletBackend, type WalletBackendMode, } from "./select-backend.js";
+export { StewardBackend } from "./steward-backend.js";

package/dist/wallet/local-eoa-backend.d.ts

@@ -0,0 +1,37 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { Hex, TypedDataDefinition } from "viem";
+import type { SolanaSigner, WalletAddresses, WalletBackend } from "./backend.js";
+import type { SignResult, SignScope } from "./pending.js";
+/**
+ * Desktop default: local EOA / keypair signing. **Does not** autogenerate keys.
+ */
+export declare class LocalEoaBackend implements WalletBackend {
+    readonly kind: "local";
+    private readonly evmAccount;
+    private readonly solanaSigner;
+    private constructor();
+    static create(runtime: IAgentRuntime): Promise<LocalEoaBackend>;
+    getAddresses(): WalletAddresses;
+    canSign(chainHint: "evm" | "solana" | "off-chain"): boolean;
+    getEvmAccount(_chainId: number): {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign: (parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<Hex>;
+        signAuthorization: (parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+        publicKey: Hex;
+        source: "privateKey";
+        type: "local";
+    };
+    getSolanaSigner(): SolanaSigner;
+    signMessage(scope: SignScope, message: Hex): Promise<SignResult>;
+    signTypedData(scope: SignScope, typedData: TypedDataDefinition): Promise<SignResult>;
+}

package/dist/wallet/pending.d.ts

@@ -0,0 +1,47 @@
+import type { ActionFailureCode, ValidateFailureCode } from "../actions/failure-codes.js";
+/**
+ * Stable identity for a signing operation. Used by the audit log and the
+ * policy module. Format: "<domain>.<operation>".
+ */
+export type SignScope = `hyperliquid.${string}` | `polymarket.${string}` | `lifi.${string}` | `jupiter.${string}` | `raydium.${string}` | `orca.${string}` | `meteora.${string}` | `aave.${string}` | `morpho.${string}` | `lp.${string}` | `lp-solana.${string}` | `lp-evm.${string}` | `clanker.${string}` | `mint.${string}` | `transfer.${string}` | `automation.${string}` | `x402.${string}` | `cctp.${string}`;
+export interface ApprovalSummary {
+    readonly title: string;
+    readonly venue: string;
+    readonly chainHint: "evm" | "solana" | "off-chain";
+    readonly fields: ReadonlyArray<{
+        label: string;
+        value: string;
+    }>;
+}
+export interface PendingApproval {
+    readonly kind: "pending_approval";
+    readonly approvalId: string;
+    readonly scope: SignScope;
+    readonly expiresAt: number;
+    readonly summary: ApprovalSummary;
+}
+export interface SignaturePayload {
+    readonly kind: "signature";
+    readonly signature: `0x${string}`;
+    readonly raw?: `0x${string}`;
+}
+export type SignResult = SignaturePayload | PendingApproval;
+export type ValidateOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    reason: ValidateFailureCode;
+    detail: string;
+};
+export type CanonicalHandlerResult<TData> = {
+    ok: true;
+    data: TData;
+} | {
+    ok: false;
+    error: ActionFailureCode;
+    detail: string;
+} | {
+    ok: false;
+    error: "PENDING_APPROVAL";
+    pending: PendingApproval;
+};

package/dist/wallet/select-backend.d.ts

@@ -0,0 +1,11 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { WalletBackend } from "./backend.js";
+export type WalletBackendMode = "local" | "steward" | "auto";
+/**
+ * Resolves the active wallet backend.
+ *
+ * - `local` — env keys only ({@link LocalEoaBackend}).
+ * - `steward` — Steward API signing ({@link StewardBackend}).
+ * - `auto` — Steward when cloud-provisioned or `ELIZA_WALLET_STEWARD_AUTO=1`, otherwise local.
+ */
+export declare function resolveWalletBackend(runtime: IAgentRuntime): Promise<WalletBackend>;

package/dist/wallet/steward-backend.d.ts

@@ -0,0 +1,22 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { Account, Hex, TypedDataDefinition } from "viem";
+import type { WalletAddresses, WalletBackend } from "./backend.js";
+import type { SignResult, SignScope } from "./pending.js";
+/**
+ * Cloud / mobile signing via Steward for EVM. Solana addresses may be exposed from
+ * Steward when `/vault/.../addresses` returns them; Solana **transaction** signing is
+ * unavailable here — callers must treat Solana writes as unavailable until wired.
+ */
+export declare class StewardBackend implements WalletBackend {
+    readonly kind: "steward";
+    private readonly account;
+    private readonly solanaPubkey;
+    private constructor();
+    static create(_runtime: IAgentRuntime): Promise<StewardBackend>;
+    getAddresses(): WalletAddresses;
+    canSign(chainHint: "evm" | "solana" | "off-chain"): boolean;
+    getEvmAccount(_chainId: number): Account;
+    getSolanaSigner(): never;
+    signMessage(scope: SignScope, message: Hex): Promise<SignResult>;
+    signTypedData(scope: SignScope, typedData: TypedDataDefinition): Promise<SignResult>;
+}

package/dist/wallet-action.d.ts

@@ -0,0 +1 @@
+export { default, walletRouterAction } from "./chains/wallet-action.js";