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

package/dist/sdk/identity/uaid.d.ts

@@ -0,0 +1,192 @@
+/**
+ * uaid.ts — Universal Agent Identifier (UAID) Resolution Layer
+ *
+ * Provides cross-chain agent identity resolution via the HOL Registry Broker.
+ * UAIDs are chain-agnostic identifiers that bridge ERC-8004 tokens on EVM chains
+ * to agents on Solana, Hedera, off-chain frameworks, and any other protocol.
+ *
+ * This module is an optional extension — agents that only operate on EVM chains
+ * can continue using ERC8004Client directly.
+ *
+ * Registry: https://hol.org
+ * SDK: @hol-org/rb-client (peer dependency — install only if needed)
+ *
+ * @module identity/uaid
+ */
+import type { Address } from "viem";
+import type { AgentIdentity, AgentRegistrationFile, SupportedChain } from "./erc8004.js";
+/** Supported protocol types in the UAID ecosystem */
+export type UAIDProtocol = "erc8004" | "a2a" | "openconvai" | "virtuals" | "x402" | "hedera" | "solana" | string;
+/** A parsed UAID with its component parts */
+export interface ParsedUAID {
+    /** Raw UAID string */
+    raw: string;
+    /** Agent identifier portion */
+    aid: string;
+    /** Unique identifier portion */
+    uid: string;
+    /** Protocol used for resolution */
+    protocol: UAIDProtocol;
+    /** Native identifier on the protocol's own chain/system */
+    nativeId?: string;
+}
+/** Result of resolving a UAID to a known identity */
+export interface UAIDResolution {
+    /** Whether resolution succeeded */
+    resolved: boolean;
+    /** The UAID that was resolved */
+    uaid: string;
+    /** Resolved agent identity (if ERC-8004 backed) */
+    identity: UniversalAgentIdentity | null;
+    /** Protocol the agent was resolved through */
+    protocol: UAIDProtocol;
+    /** Chain the identity lives on (if applicable) */
+    chain?: string;
+    /** Trust score from the registry (0-100) */
+    trustScore?: number;
+    /** Whether the agent is verified in the HOL registry */
+    registryVerified: boolean;
+    /** Error message if resolution failed */
+    error?: string;
+}
+/**
+ * Universal agent identity — superset of ERC-8004 AgentIdentity that works
+ * across chains. For EVM agents, this mirrors AgentIdentity. For non-EVM
+ * agents, it provides equivalent fields using native identifiers.
+ */
+export interface UniversalAgentIdentity {
+    /** Identifier — ERC-8004 tokenId for EVM, native ID for others */
+    agentId: string;
+    /** Owner — EVM address, Hedera account, Solana pubkey, etc. */
+    owner: string;
+    /** Agent URI / metadata endpoint */
+    agentURI: string;
+    /** Payment address (chain-native format) */
+    paymentAddress: string;
+    /** Registration metadata (if available) */
+    registrationFile: AgentRegistrationFile | null;
+    /** Source protocol */
+    protocol: UAIDProtocol;
+    /** Source chain */
+    chain: string;
+    /** UAID for cross-chain reference */
+    uaid: string;
+}
+/** Configuration for the UAID resolver */
+export interface UAIDResolverConfig {
+    /** HOL Registry Broker API key (optional for read-only resolution) */
+    apiKey?: string;
+    /** Custom broker base URL (defaults to production) */
+    brokerUrl?: string;
+    /** Request timeout in ms (default: 10000) */
+    timeoutMs?: number;
+    /** Cache resolved identities for this many ms (default: 300000 = 5 min) */
+    cacheTtlMs?: number;
+}
+/** Parameters for registering an ERC-8004 identity as a UAID */
+export interface RegisterUAIDParams {
+    /** ERC-8004 agent ID (tokenId) */
+    agentId: bigint;
+    /** Chain the identity is registered on */
+    chain: SupportedChain;
+    /** Registry contract address (uses known defaults if omitted) */
+    registryAddress?: Address;
+    /** Agent name for the registry */
+    name: string;
+    /** Agent description */
+    description: string;
+    /** Optional: additional capabilities to advertise */
+    capabilities?: string[];
+}
+export declare class UAIDResolver {
+    private readonly brokerUrl;
+    private readonly apiKey?;
+    private readonly timeoutMs;
+    private readonly cacheTtlMs;
+    private readonly cache;
+    constructor(config?: UAIDResolverConfig);
+    /**
+     * Resolve a UAID to an agent identity.
+     *
+     * Works across chains — the resolver contacts the HOL Registry Broker to
+     * find the agent's identity regardless of whether it lives on EVM, Hedera,
+     * Solana, or off-chain.
+     *
+     * @param uaid - Universal Agent Identifier string
+     * @returns Resolution result with identity details
+     *
+     * @example
+     * ```ts
+     * const resolver = new UAIDResolver();
+     * const result = await resolver.resolve('uaid:aid:0x8004...;uid=42;proto=erc8004');
+     * if (result.resolved) {
+     *   console.log(result.identity?.paymentAddress);
+     * }
+     * ```
+     */
+    resolve(uaid: string): Promise<UAIDResolution>;
+    /**
+     * Search the HOL registry for agents matching criteria.
+     *
+     * @param query - Search terms (name, capability, protocol)
+     * @param options - Optional filters
+     * @returns Array of matching UAIDResolution results
+     */
+    search(query: string, options?: {
+        protocol?: UAIDProtocol;
+        limit?: number;
+        minTrustScore?: number;
+    }): Promise<UAIDResolution[]>;
+    /**
+     * Convert an ERC-8004 AgentIdentity to a UniversalAgentIdentity.
+     *
+     * Useful when you already have an on-chain identity and want to work
+     * with the universal format (e.g., for cross-chain discovery).
+     */
+    erc8004ToUniversal(identity: AgentIdentity, chain: SupportedChain): UniversalAgentIdentity;
+    /**
+     * Build a UAID string for an ERC-8004 agent.
+     *
+     * This creates the identifier — it does NOT register with the HOL registry.
+     * Use registerERC8004Agent() to make the agent discoverable cross-chain.
+     */
+    buildERC8004UAID(agentId: bigint, chain: SupportedChain, ownerAddress: Address): string;
+    /**
+     * Register an ERC-8004 agent in the HOL registry for cross-chain discovery.
+     *
+     * After registration, agents on Solana, Hedera, or any protocol can
+     * discover and verify this agent's identity via its UAID.
+     *
+     * Requires an API key with write permissions.
+     *
+     * @param params - Registration parameters
+     * @returns The assigned UAID
+     */
+    registerERC8004Agent(params: RegisterUAIDParams): Promise<string>;
+    /**
+     * Verify an agent's identity via UAID — works across any chain.
+     *
+     * This is the cross-chain equivalent of ERC8004Client.lookupAgentIdentity().
+     * For EVM agents, it verifies the UAID maps to a valid on-chain ERC-8004 token.
+     * For non-EVM agents, it verifies through the registry's native trust mechanism.
+     *
+     * @param uaid - Universal Agent Identifier to verify
+     * @returns Verification result
+     */
+    verify(uaid: string): Promise<{
+        verified: boolean;
+        identity: UniversalAgentIdentity | null;
+        trustScore: number;
+        protocol: UAIDProtocol;
+        error?: string;
+    }>;
+    /**
+     * Parse a UAID string into its components.
+     *
+     * Format: `uaid:aid:<identifier>;uid=<unique-id>;proto=<protocol>[;nativeId=<id>]`
+     */
+    static parseUAID(uaid: string): ParsedUAID | null;
+    /** Clear the resolution cache */
+    clearCache(): void;
+    private brokerRequest;
+}

package/dist/sdk/identity/validation.d.ts

@@ -0,0 +1,282 @@
+/**
+ * ERC-8004: Trustless Agents — Validation Registry Client
+ *
+ * On-chain validation system for AI agents. Validators can be requested to
+ * validate an agent's capabilities, and their responses are recorded on-chain.
+ *
+ * Note: The ValidationRegistry is part of the ERC-8004 spec. Official registry
+ * addresses are absent from erc-8004-contracts, so deployments must supply the
+ * ValidationRegistry address alongside Identity and Reputation registries.
+ *
+ * Spec: https://eips.ethereum.org/EIPS/eip-8004
+ */
+import { type Address, type Hash, type Hex, type WalletClient } from "viem";
+import { type SupportedChain } from "./erc8004.js";
+export declare const ValidationRegistryAbi: readonly [{
+    readonly name: "validationRequest";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "validator";
+        readonly type: "address";
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "requestURI";
+        readonly type: "string";
+    }, {
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "validationResponse";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "response";
+        readonly type: "uint8";
+    }, {
+        readonly name: "responseURI";
+        readonly type: "string";
+    }, {
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "tag";
+        readonly type: "string";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "getValidationStatus";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "validator";
+        readonly type: "address";
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "requestURI";
+        readonly type: "string";
+    }, {
+        readonly name: "response";
+        readonly type: "uint8";
+    }, {
+        readonly name: "responseURI";
+        readonly type: "string";
+    }, {
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "tag";
+        readonly type: "string";
+    }, {
+        readonly name: "responded";
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "getAgentValidations";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "requestHashes";
+        readonly type: "bytes32[]";
+    }];
+}, {
+    readonly name: "getValidatorRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "validator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "requestHashes";
+        readonly type: "bytes32[]";
+    }];
+}, {
+    readonly name: "getSummary";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validators";
+        readonly type: "address[]";
+    }, {
+        readonly name: "category";
+        readonly type: "string";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "totalRequests";
+        readonly type: "uint256";
+    }, {
+        readonly name: "totalResponses";
+        readonly type: "uint256";
+    }, {
+        readonly name: "passCount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "failCount";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "getIdentityRegistry";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "getVersion";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "ValidationRequest";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly name: "validator";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "requestURI";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }];
+}, {
+    readonly name: "ValidationResponse";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly name: "validator";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }, {
+        readonly name: "response";
+        readonly type: "uint8";
+        readonly indexed: false;
+    }, {
+        readonly name: "responseURI";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }, {
+        readonly name: "tag";
+        readonly type: "string";
+        readonly indexed: false;
+    }];
+}];
+export interface ValidationClientConfig {
+    validationAddress?: Address;
+    chain: SupportedChain;
+    rpcUrl?: string;
+}
+export interface RequestValidationParams {
+    validator: Address;
+    agentId: bigint;
+    requestURI: string;
+    requestHash: Hex;
+}
+export interface RespondToValidationParams {
+    requestHash: Hex;
+    response: number;
+    responseURI: string;
+    responseHash: Hex;
+    tag: string;
+}
+export interface ValidationStatus {
+    validator: Address;
+    agentId: bigint;
+    requestURI: string;
+    response: number;
+    responseURI: string;
+    responseHash: Hex;
+    tag: string;
+    responded: boolean;
+}
+export interface ValidationSummary {
+    totalRequests: bigint;
+    totalResponses: bigint;
+    passCount: bigint;
+    failCount: bigint;
+}
+export declare class ValidationClient {
+    private readonly publicClient;
+    private readonly validationAddress;
+    private readonly chain;
+    constructor(config: ValidationClientConfig);
+    private getReadContract;
+    private getWriteContract;
+    /**
+     * Submit a validation request. Must be called by the owner/operator of the agentId.
+     */
+    requestValidation(walletClient: WalletClient, params: RequestValidationParams): Promise<Hash>;
+    /**
+     * Respond to a validation request. Must be called by the requested validator.
+     */
+    respondToValidation(walletClient: WalletClient, params: RespondToValidationParams): Promise<Hash>;
+    /**
+     * Check the status of a validation request by its hash.
+     */
+    getValidationStatus(requestHash: Hex): Promise<ValidationStatus>;
+    /**
+     * Get all validation request hashes for an agent.
+     */
+    getAgentValidations(agentId: bigint): Promise<Hex[]>;
+    /**
+     * Get all validation request hashes assigned to a validator.
+     */
+    getValidatorRequests(validatorAddress: Address): Promise<Hex[]>;
+    /**
+     * Get a summary of validations for an agent, optionally filtered by validators and category.
+     */
+    getSummary(agentId: bigint, validators?: Address[], category?: string): Promise<ValidationSummary>;
+    /**
+     * Get the linked identity registry address.
+     */
+    getIdentityRegistry(): Promise<Address>;
+    /**
+     * Get the registry contract version.
+     */
+    getVersion(): Promise<string>;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,133 @@
+import { type Address, type Chain, type Hash, type Hex, type WalletClient } from "viem";
+import type { ActivityEntry, BatchTransfer, BudgetForecast, ExecuteResult, PendingTx, QueuedEvent, WalletHealth } from "./types.js";
+import { type AgentWallet as Wallet } from "./wallet-core.js";
+export { AgentAccountFactoryV2Abi, AgentAccountV2Abi } from "./abi.js";
+export type { ActivityEntry, AgentWalletConfig, BatchTransfer, BudgetForecast, BudgetStatus, ExecuteResult, PendingTx, QueuedEvent, SpendPolicy, WalletHealth, } from "./types.js";
+export { agentTransferToken, checkBudget, createWallet, NATIVE_TOKEN, requireWalletAccount, setSpendPolicy, } from "./wallet-core.js";
+export type { X402ClientConfig, X402PaymentPayload, X402PaymentRequired, X402PaymentRequirements, X402ResourceInfo, X402ServiceBudget, X402SettlementResponse, X402TransactionLog, } from "./x402/index.js";
+export { createX402Client, createX402Fetch, DEFAULT_SUPPORTED_NETWORKS, USDC_ADDRESSES, wrapWithX402, X402BudgetExceededError, X402BudgetTracker, X402Client, X402PaymentError, } from "./x402/index.js";
+declare const CHAINS: Record<string, Chain>;
+/**
+ * Execute a transaction as the agent. If within limits, executes immediately.
+ * If over limits, queues for owner approval and returns the pending tx ID.
+ */
+export declare function agentExecute(wallet: Wallet, params: {
+    to: Address;
+    value?: bigint;
+    data?: Hex;
+}): Promise<ExecuteResult>;
+/**
+ * Get a pending transaction by ID.
+ */
+export declare function getPendingApprovals(wallet: Wallet, fromId?: bigint, toId?: bigint): Promise<PendingTx[]>;
+/**
+ * Approve a pending transaction. Only callable by the NFT owner.
+ */
+export declare function approveTransaction(wallet: Wallet, txId: bigint): Promise<Hash>;
+/**
+ * Cancel a pending transaction. Only callable by the NFT owner.
+ */
+export declare function cancelTransaction(wallet: Wallet, txId: bigint): Promise<Hash>;
+/**
+ * Add or remove an operator (agent hot wallet).
+ */
+export declare function setOperator(wallet: Wallet, operator: Address, authorized: boolean): Promise<Hash>;
+/**
+ * Deploy a new AgentAccountV2 wallet via the factory (CREATE2).
+ * Returns the deterministic wallet address.
+ */
+export declare function deployWallet(config: {
+    factoryAddress: Address;
+    tokenContract: Address;
+    tokenId: bigint;
+    chain: keyof typeof CHAINS;
+    rpcUrl?: string;
+    walletClient: WalletClient;
+}): Promise<{
+    walletAddress: Address;
+    txHash: Hash;
+}>;
+/**
+ * Compute the deterministic wallet address without deploying.
+ */
+export declare function getWalletAddress(config: {
+    factoryAddress: Address;
+    tokenContract: Address;
+    tokenId: bigint;
+    chain: string;
+    rpcUrl?: string;
+}): Promise<Address>;
+/**
+ * [MAX-ADDED] Budget forecast with period-aware remaining capacity.
+ * Why: Agents need to know not just "how much is left" but "when does budget reset"
+ * so they can plan spending across time windows and avoid unnecessary queuing.
+ */
+export declare function getBudgetForecast(wallet: Wallet, token?: Address, now?: number): Promise<BudgetForecast>;
+/**
+ * [MAX-ADDED] Wallet health check — diagnostic snapshot for agent self-monitoring.
+ * Why: Agents need a single-call way to verify their wallet is properly configured,
+ * check operator status, and monitor queue depth before executing transactions.
+ */
+export declare function getWalletHealth(wallet: Wallet, operatorsToCheck?: Address[], tokensToCheck?: Address[], now?: number): Promise<WalletHealth>;
+/**
+ * [MAX-ADDED] Batch agent token transfers — multiple transfers in sequential calls.
+ * Why: Agents often need to pay multiple recipients (tips, fees, splits). This helper
+ * reduces boilerplate and returns all tx hashes. Each is a separate on-chain tx
+ * (true batching would need a multicall contract, but this is the safe SDK-level helper).
+ */
+export declare function batchAgentTransfer(wallet: Wallet, transfers: BatchTransfer[]): Promise<Hash[]>;
+/**
+ * [MAX-ADDED] Activity history — query past wallet events for self-auditing.
+ * Why: Agents need to verify what happened on-chain (transfers, operator changes,
+ * policy updates) without relying on external indexers. This queries event logs directly.
+ */
+export declare function getActivityHistory(wallet: Wallet, options?: {
+    fromBlock?: bigint;
+    toBlock?: bigint | "latest";
+}): Promise<ActivityEntry[]>;
+/**
+ * Watch for TransactionQueued events (over-limit transactions needing approval).
+ * Returns an unwatch function.
+ */
+export declare function onTransactionQueued(wallet: Wallet, callback: (event: QueuedEvent) => void): () => void;
+/**
+ * Watch for TransactionExecuted events.
+ */
+export declare function onTransactionExecuted(wallet: Wallet, callback: (event: {
+    target: Address;
+    value: bigint;
+    executor: Address;
+    transactionHash: Hash;
+}) => void): () => void;
+export type { BridgeChain, BridgeOptions, BridgeResult, BurnResult, } from "./bridge/index.js";
+export { BRIDGE_CHAIN_IDS, BridgeError, BridgeModule, CCTP_DOMAIN_IDS, createBridge, ERC20BridgeAbi, FINALITY_THRESHOLD, MESSAGE_TRANSMITTER_V2, MessageTransmitterV2Abi, TOKEN_MESSENGER_V2, TokenMessengerV2Abi, USDC_CONTRACT, } from "./bridge/index.js";
+export type { AgentIdentity, AgentModelMetadata, AgentRegistrationFile, AgentRegistrationRef, AgentServiceEndpoint, ERC8004ClientConfig, MetadataEntry, RegistrationResult, SupportedChain, SupportedTrustMechanism, } from "./identity/erc8004.js";
+export { buildDataURI, ERC8004Client, ERC8004IdentityRegistryAbi, formatAgentRegistry, KNOWN_REGISTRY_ADDRESSES, METADATA_KEYS, parseDataURI, REGISTRATION_FILE_TYPE, resolveAgentURI, validateRegistrationFile, } from "./identity/erc8004.js";
+export type { AgentReputationSummary, FeedbackEntry, FeedbackFilters, GiveFeedbackParams, ReputationClientConfig, RespondToFeedbackParams, } from "./identity/reputation.js";
+export { ReputationClient, ReputationRegistryAbi, } from "./identity/reputation.js";
+export type { ParsedUAID, RegisterUAIDParams, UAIDProtocol, UAIDResolution, UAIDResolverConfig, UniversalAgentIdentity, } from "./identity/uaid.js";
+export { UAIDResolver } from "./identity/uaid.js";
+export type { RequestValidationParams, RespondToValidationParams, ValidationClientConfig, ValidationStatus, ValidationSummary, } from "./identity/validation.js";
+export { ValidationClient, ValidationRegistryAbi, } from "./identity/validation.js";
+export type { SwapModuleConfig, SwapOptions, SwapQuote, SwapResult, UniswapFeeTier, } from "./swap/index.js";
+export { applySlippage, attachSwap, BASE_TOKENS, calcDeadline, calcProtocolFee, DEFAULT_SLIPPAGE_BPS, ERC20Abi, PROTOCOL_FEE_BPS, PROTOCOL_FEE_COLLECTOR, SwapModule, UniswapV3QuoterV2Abi, UniswapV3RouterAbi, } from "./swap/index.js";
+export { setPolicyFromEnv, walletFromEnv, x402FromEnv, } from "./convenience.js";
+export { MutualStakeEscrow } from "./escrow/MutualStakeEscrow.js";
+export type { CreateEscrowParams, EscrowCreated, EscrowDetails, TxResult as EscrowTxResult, } from "./escrow/types.js";
+export { TaskStatus } from "./escrow/types.js";
+export { encodeHashVerifierData, encodeOptimisticVerifierData, resolveVerifierAddress, VERIFIER_ADDRESSES, } from "./escrow/verifiers.js";
+export type { AuditEntry, DraftEntry, PaymentIntent, PolicyResult, PolicyStatus, SpendingPolicyConfig, } from "./policy/SpendingPolicy.js";
+export { SpendingPolicy } from "./policy/SpendingPolicy.js";
+export type { UptoAuthorizationRecord, UptoAuthorizationRequest, UptoAuthorizationStatus, UptoBillingSnapshot, UptoSettlementOptions, UptoSettlementRecord, WalletLedgerDelta, } from "./policy/UptoBillingPolicy.js";
+export { UptoBillingPolicy } from "./policy/UptoBillingPolicy.js";
+export type { PaymentContext, PaymentRail, RailConfig, RailStatus, RoutingDecision, } from "./router/index.js";
+export { PaymentRouter } from "./router/index.js";
+export type { TokenInfo } from "./tokens/decimals.js";
+export { formatBalance, parseAmount, toHuman, toRaw, } from "./tokens/decimals.js";
+export type { AddTokenParams, TokenEntry } from "./tokens/registry.js";
+export { ARBITRUM_REGISTRY, AVALANCHE_REGISTRY, BASE_REGISTRY, BASE_SEPOLIA_REGISTRY, ETHEREUM_REGISTRY, getGlobalRegistry, getNativeToken, LINEA_REGISTRY, OPTIMISM_REGISTRY, POLYGON_REGISTRY, SONIC_REGISTRY, TokenRegistry, UNICHAIN_REGISTRY, WORLDCHAIN_REGISTRY, } from "./tokens/registry.js";
+export type { SolanaTokenInfo, SolanaTokenSymbol, SolanaTxResult, SolanaWalletConfig, SolBalanceResult, SplBalanceResult, } from "./tokens/solana.js";
+export { createSolanaWallet, SOLANA_TOKEN_DECIMALS, SOLANA_TOKENS, SolanaWallet, } from "./tokens/solana.js";
+export type { NativeBalanceResult, TokenBalanceResult, TransferContext, TransferOptions, } from "./tokens/transfers.js";
+export { encodeERC20Transfer, getBalances, getNativeBalance, getTokenBalance, sendNative, sendToken, } from "./tokens/transfers.js";
+export { buildSupportedAssets, isStablecoin, parseNetworkChainId, resolveAssetAddress, resolveAssetDecimals, } from "./x402/multi-asset.js";