@unicitylabs/sphere-sdk 0.4.9 → 0.5.1

package/dist/impl/nodejs/index.d.cts

@@ -3,420 +3,116 @@ import { AggregatorClient } from '@unicitylabs/state-transition-sdk/lib/api/Aggr
 import { RootTrustBase } from '@unicitylabs/state-transition-sdk/lib/bft/RootTrustBase';
 import { TransferCommitment as TransferCommitment$1 } from '@unicitylabs/state-transition-sdk/lib/transaction/TransferCommitment';
 
-interface GroupChatModuleConfig {
-    /** Override relay URLs (default: from network config) */
-    relays?: string[];
-    /** Default message fetch limit (default: 50) */
-    defaultMessageLimit?: number;
-    /** Max previous message IDs in ordering tags (default: 3) */
-    maxPreviousTags?: number;
-    /** Reconnect delay in ms (default: 3000) */
-    reconnectDelayMs?: number;
-    /** Max reconnect attempts (default: 5) */
-    maxReconnectAttempts?: number;
-}
-
-/**
- * SDK2 Core Types
- * Platform-independent type definitions
- */
-type ProviderStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
-interface ProviderMetadata {
-    readonly id: string;
-    readonly name: string;
-    readonly type: 'local' | 'cloud' | 'p2p' | 'network';
-    readonly description?: string;
-}
-interface BaseProvider extends ProviderMetadata {
-    connect(config?: unknown): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStatus(): ProviderStatus;
-}
-interface Identity {
-    /** 33-byte compressed secp256k1 public key (for L3 chain) */
-    readonly chainPubkey: string;
-    /** L1 address (alpha1...) */
-    readonly l1Address: string;
-    /** L3 DIRECT address (DIRECT://...) */
-    readonly directAddress?: string;
-    readonly ipnsName?: string;
-    readonly nametag?: string;
-}
-interface FullIdentity extends Identity {
-    readonly privateKey: string;
-}
-interface ComposingIndicator {
-    readonly senderPubkey: string;
-    readonly senderNametag?: string;
-    readonly expiresIn: number;
-}
 /**
- * Minimal data stored in persistent storage for a tracked address.
- * Only contains user state — derived fields are computed on load.
- */
-interface TrackedAddressEntry {
-    /** HD derivation index (0, 1, 2, ...) */
-    readonly index: number;
-    /** Whether this address is hidden from UI display */
-    hidden: boolean;
-    /** Timestamp (ms) when this address was first activated */
-    readonly createdAt: number;
-    /** Timestamp (ms) of last modification */
-    updatedAt: number;
-}
-
-/**
- * Storage Provider Interface
- * Platform-independent storage abstraction
+ * Transport Provider Interface
+ * Platform-independent P2P messaging abstraction
  */
 
 /**
- * Basic key-value storage provider
- * All operations are async for platform flexibility
+ * P2P messaging transport provider
  */
-interface StorageProvider extends BaseProvider {
+interface TransportProvider extends BaseProvider {
     /**
-     * Set identity for scoped storage
+     * Set identity for signing/encryption.
+     * If the transport is already connected, reconnects with the new identity.
      */
-    setIdentity(identity: FullIdentity): void;
+    setIdentity(identity: FullIdentity): void | Promise<void>;
     /**
-     * Get value by key
+     * Send encrypted direct message
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
      */
-    get(key: string): Promise<string | null>;
+    sendMessage(recipientTransportPubkey: string, content: string): Promise<string>;
     /**
-     * Set value by key
+     * Subscribe to incoming direct messages
+     * @returns Unsubscribe function
      */
-    set(key: string, value: string): Promise<void>;
+    onMessage(handler: MessageHandler): () => void;
     /**
-     * Remove key
+     * Send token transfer payload
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
      */
-    remove(key: string): Promise<void>;
+    sendTokenTransfer(recipientTransportPubkey: string, payload: TokenTransferPayload): Promise<string>;
     /**
-     * Check if key exists
+     * Subscribe to incoming token transfers
+     * @returns Unsubscribe function
      */
-    has(key: string): Promise<boolean>;
+    onTokenTransfer(handler: TokenTransferHandler): () => void;
     /**
-     * Get all keys with optional prefix filter
+     * Resolve any identifier to full peer information.
+     * Accepts @nametag, bare nametag, DIRECT://, PROXY://, L1 address, chain pubkey, or transport pubkey.
+     * @param identifier - Any supported identifier format
+     * @returns PeerInfo or null if not found
      */
-    keys(prefix?: string): Promise<string[]>;
+    resolve?(identifier: string): Promise<PeerInfo | null>;
     /**
-     * Clear all keys with optional prefix filter
+     * Resolve nametag to public key
      */
-    clear(prefix?: string): Promise<void>;
+    resolveNametag?(nametag: string): Promise<string | null>;
     /**
-     * Save tracked addresses (only user state: index, hidden, timestamps)
+     * Resolve nametag to full peer information
+     * Returns transportPubkey, chainPubkey, l1Address, directAddress, proxyAddress
      */
-    saveTrackedAddresses(entries: TrackedAddressEntry[]): Promise<void>;
+    resolveNametagInfo?(nametag: string): Promise<PeerInfo | null>;
     /**
-     * Load tracked addresses
+     * Resolve a DIRECT://, PROXY://, or L1 address to full peer info.
+     * Performs reverse lookup: address → binding event → PeerInfo.
+     * @param address - L3 address (DIRECT://... or PROXY://...) or L1 address (alpha1...)
+     * @returns PeerInfo or null if no binding found for this address
      */
-    loadTrackedAddresses(): Promise<TrackedAddressEntry[]>;
-}
-/**
- * Storage result types
- */
-interface SaveResult {
-    success: boolean;
-    cid?: string;
-    error?: string;
-    timestamp: number;
-}
-interface LoadResult<T = unknown> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    source: 'local' | 'remote' | 'cache';
-    timestamp: number;
-}
-interface SyncResult<T = unknown> {
-    success: boolean;
-    merged?: T;
-    added: number;
-    removed: number;
-    conflicts: number;
-    error?: string;
-}
-/**
- * Token-specific storage provider
- * Handles token persistence with sync capabilities
- */
-interface TokenStorageProvider<TData = unknown> extends BaseProvider {
+    resolveAddressInfo?(address: string): Promise<PeerInfo | null>;
     /**
-     * Set identity for storage scope
+     * Resolve transport pubkey to full peer info.
+     * Queries binding events authored by the given transport pubkey.
+     * @param transportPubkey - Transport-specific pubkey (e.g. 64-char hex string)
+     * @returns PeerInfo or null if no binding found
      */
-    setIdentity(identity: FullIdentity): void;
+    resolveTransportPubkeyInfo?(transportPubkey: string): Promise<PeerInfo | null>;
     /**
-     * Initialize provider (called once after identity is set)
+     * Batch-resolve multiple transport pubkeys to peer info.
+     * Used for HD address discovery: derives transport pubkeys for indices 0..N
+     * and queries binding events in a single batch.
+     * @param transportPubkeys - Array of transport-specific pubkeys to look up
+     * @returns Array of PeerInfo for pubkeys that have binding events (may be shorter than input)
      */
-    initialize(): Promise<boolean>;
+    discoverAddresses?(transportPubkeys: string[]): Promise<PeerInfo[]>;
     /**
-     * Shutdown provider
+     * Recover nametag for current identity by decrypting stored encrypted nametag
+     * Used after wallet import to recover associated nametag
+     * @returns Decrypted nametag or null if none found
      */
-    shutdown(): Promise<void>;
+    recoverNametag?(): Promise<string | null>;
     /**
-     * Save token data
+     * Publish identity binding event.
+     * Without nametag: publishes base binding (chainPubkey, l1Address, directAddress).
+     * With nametag: adds nametag hash, proxy address, encrypted nametag for recovery.
+     * Uses parameterized replaceable event (kind 30078, d=hash(nostrPubkey)).
+     * @returns true if successful, false if nametag is taken by another pubkey
      */
-    save(data: TData): Promise<SaveResult>;
+    publishIdentityBinding?(chainPubkey: string, l1Address: string, directAddress: string, nametag?: string): Promise<boolean>;
     /**
-     * Load token data
+     * @deprecated Use publishIdentityBinding instead
+     * Register a nametag for this identity
      */
-    load(identifier?: string): Promise<LoadResult<TData>>;
+    registerNametag?(nametag: string, chainPubkey: string, directAddress: string): Promise<boolean>;
     /**
-     * Sync local data with remote
+     * @deprecated Use publishIdentityBinding instead
+     * Publish nametag binding
      */
-    sync(localData: TData): Promise<SyncResult<TData>>;
+    publishNametag?(nametag: string, address: string): Promise<void>;
     /**
-     * Check if data exists
+     * Subscribe to broadcast messages (global/channel)
      */
-    exists?(identifier?: string): Promise<boolean>;
+    subscribeToBroadcast?(tags: string[], handler: BroadcastHandler): () => void;
     /**
-     * Clear all data
+     * Publish broadcast message
      */
-    clear?(): Promise<boolean>;
+    publishBroadcast?(content: string, tags?: string[]): Promise<string>;
     /**
-     * Subscribe to storage events
-     */
-    onEvent?(callback: StorageEventCallback): () => void;
-}
-type StorageEventType = 'storage:saving' | 'storage:saved' | 'storage:loading' | 'storage:loaded' | 'storage:error' | 'storage:remote-updated' | 'sync:started' | 'sync:completed' | 'sync:conflict' | 'sync:error';
-interface StorageEvent {
-    type: StorageEventType;
-    timestamp: number;
-    data?: unknown;
-    error?: string;
-}
-type StorageEventCallback = (event: StorageEvent) => void;
-interface TxfStorageDataBase {
-    _meta: TxfMeta;
-    _tombstones?: TxfTombstone[];
-    _outbox?: TxfOutboxEntry[];
-    _sent?: TxfSentEntry[];
-    _invalid?: TxfInvalidEntry[];
-    [key: `_${string}`]: unknown;
-}
-interface TxfMeta {
-    version: number;
-    address: string;
-    ipnsName?: string;
-    formatVersion: string;
-    updatedAt: number;
-}
-interface TxfTombstone {
-    tokenId: string;
-    stateHash: string;
-    timestamp: number;
-}
-interface TxfOutboxEntry {
-    id: string;
-    status: string;
-    tokenId: string;
-    recipient: string;
-    createdAt: number;
-    data: unknown;
-}
-interface TxfSentEntry {
-    tokenId: string;
-    recipient: string;
-    txHash: string;
-    sentAt: number;
-}
-interface TxfInvalidEntry {
-    tokenId: string;
-    reason: string;
-    detectedAt: number;
-}
-
-/**
- * File Storage Provider for Node.js
- * Stores wallet data in JSON files
- */
-
-interface FileStorageProviderConfig {
-    /** Directory to store wallet data */
-    dataDir: string;
-    /** File name for key-value data (default: 'wallet.json') */
-    fileName?: string;
-}
-declare class FileStorageProvider implements StorageProvider {
-    readonly id = "file-storage";
-    readonly name = "File Storage";
-    readonly type: "local";
-    private dataDir;
-    private filePath;
-    private isTxtMode;
-    private data;
-    private status;
-    private _identity;
-    constructor(config: FileStorageProviderConfig | string);
-    setIdentity(identity: FullIdentity): void;
-    getIdentity(): FullIdentity | null;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStatus(): ProviderStatus;
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
-    remove(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-    keys(prefix?: string): Promise<string[]>;
-    clear(prefix?: string): Promise<void>;
-    saveTrackedAddresses(entries: TrackedAddressEntry[]): Promise<void>;
-    loadTrackedAddresses(): Promise<TrackedAddressEntry[]>;
-    /**
-     * Get full storage key with address prefix for per-address keys
-     */
-    private getFullKey;
-    private save;
-}
-declare function createFileStorageProvider(config: FileStorageProviderConfig | string): FileStorageProvider;
-
-/**
- * File Token Storage Provider for Node.js
- * Stores tokens as individual JSON files in per-address subdirectories
- */
-
-interface FileTokenStorageConfig {
-    /** Directory to store token files */
-    tokensDir: string;
-}
-declare class FileTokenStorageProvider implements TokenStorageProvider<TxfStorageDataBase> {
-    readonly id = "file-token-storage";
-    readonly name = "File Token Storage";
-    readonly type: "local";
-    private baseTokensDir;
-    private status;
-    private identity;
-    constructor(config: FileTokenStorageConfig | string);
-    setIdentity(identity: FullIdentity): void;
-    /**
-     * Get tokens directory for current address
-     * Format: {baseTokensDir}/{addressId}/
-     */
-    private get tokensDir();
-    initialize(): Promise<boolean>;
-    shutdown(): Promise<void>;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStatus(): ProviderStatus;
-    load(): Promise<LoadResult<TxfStorageDataBase>>;
-    save(data: TxfStorageDataBase): Promise<SaveResult>;
-    sync(localData: TxfStorageDataBase): Promise<SyncResult<TxfStorageDataBase>>;
-    clear(): Promise<boolean>;
-}
-declare function createFileTokenStorageProvider(config: FileTokenStorageConfig | string): FileTokenStorageProvider;
-
-/**
- * Transport Provider Interface
- * Platform-independent P2P messaging abstraction
- */
-
-/**
- * P2P messaging transport provider
- */
-interface TransportProvider extends BaseProvider {
-    /**
-     * Set identity for signing/encryption.
-     * If the transport is already connected, reconnects with the new identity.
-     */
-    setIdentity(identity: FullIdentity): void | Promise<void>;
-    /**
-     * Send encrypted direct message
-     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
-     * @returns Event ID
-     */
-    sendMessage(recipientTransportPubkey: string, content: string): Promise<string>;
-    /**
-     * Subscribe to incoming direct messages
-     * @returns Unsubscribe function
-     */
-    onMessage(handler: MessageHandler): () => void;
-    /**
-     * Send token transfer payload
-     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
-     * @returns Event ID
-     */
-    sendTokenTransfer(recipientTransportPubkey: string, payload: TokenTransferPayload): Promise<string>;
-    /**
-     * Subscribe to incoming token transfers
-     * @returns Unsubscribe function
-     */
-    onTokenTransfer(handler: TokenTransferHandler): () => void;
-    /**
-     * Resolve any identifier to full peer information.
-     * Accepts @nametag, bare nametag, DIRECT://, PROXY://, L1 address, chain pubkey, or transport pubkey.
-     * @param identifier - Any supported identifier format
-     * @returns PeerInfo or null if not found
-     */
-    resolve?(identifier: string): Promise<PeerInfo | null>;
-    /**
-     * Resolve nametag to public key
-     */
-    resolveNametag?(nametag: string): Promise<string | null>;
-    /**
-     * Resolve nametag to full peer information
-     * Returns transportPubkey, chainPubkey, l1Address, directAddress, proxyAddress
-     */
-    resolveNametagInfo?(nametag: string): Promise<PeerInfo | null>;
-    /**
-     * Resolve a DIRECT://, PROXY://, or L1 address to full peer info.
-     * Performs reverse lookup: address → binding event → PeerInfo.
-     * @param address - L3 address (DIRECT://... or PROXY://...) or L1 address (alpha1...)
-     * @returns PeerInfo or null if no binding found for this address
-     */
-    resolveAddressInfo?(address: string): Promise<PeerInfo | null>;
-    /**
-     * Resolve transport pubkey to full peer info.
-     * Queries binding events authored by the given transport pubkey.
-     * @param transportPubkey - Transport-specific pubkey (e.g. 64-char hex string)
-     * @returns PeerInfo or null if no binding found
-     */
-    resolveTransportPubkeyInfo?(transportPubkey: string): Promise<PeerInfo | null>;
-    /**
-     * Batch-resolve multiple transport pubkeys to peer info.
-     * Used for HD address discovery: derives transport pubkeys for indices 0..N
-     * and queries binding events in a single batch.
-     * @param transportPubkeys - Array of transport-specific pubkeys to look up
-     * @returns Array of PeerInfo for pubkeys that have binding events (may be shorter than input)
-     */
-    discoverAddresses?(transportPubkeys: string[]): Promise<PeerInfo[]>;
-    /**
-     * Recover nametag for current identity by decrypting stored encrypted nametag
-     * Used after wallet import to recover associated nametag
-     * @returns Decrypted nametag or null if none found
-     */
-    recoverNametag?(): Promise<string | null>;
-    /**
-     * Publish identity binding event.
-     * Without nametag: publishes base binding (chainPubkey, l1Address, directAddress).
-     * With nametag: adds nametag hash, proxy address, encrypted nametag for recovery.
-     * Uses parameterized replaceable event (kind 30078, d=hash(nostrPubkey)).
-     * @returns true if successful, false if nametag is taken by another pubkey
-     */
-    publishIdentityBinding?(chainPubkey: string, l1Address: string, directAddress: string, nametag?: string): Promise<boolean>;
-    /**
-     * @deprecated Use publishIdentityBinding instead
-     * Register a nametag for this identity
-     */
-    registerNametag?(nametag: string, chainPubkey: string, directAddress: string): Promise<boolean>;
-    /**
-     * @deprecated Use publishIdentityBinding instead
-     * Publish nametag binding
-     */
-    publishNametag?(nametag: string, address: string): Promise<void>;
-    /**
-     * Subscribe to broadcast messages (global/channel)
-     */
-    subscribeToBroadcast?(tags: string[], handler: BroadcastHandler): () => void;
-    /**
-     * Publish broadcast message
-     */
-    publishBroadcast?(content: string, tags?: string[]): Promise<string>;
-    /**
-     * Send payment request to a recipient
-     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
-     * @returns Event ID
+     * Send payment request to a recipient
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
      */
     sendPaymentRequest?(recipientTransportPubkey: string, request: PaymentRequestPayload): Promise<string>;
     /**
@@ -939,258 +635,662 @@ declare class NostrTransportProvider implements TransportProvider {
 }
 
 /**
- * Node.js Transport Exports
- * Re-exports shared transport with Node.js WebSocket
- */
-
-/**
- * Create WebSocket factory for Node.js using 'ws' package
+ * Oracle Provider Interface
+ * Platform-independent Unicity oracle abstraction
+ *
+ * The oracle is a trusted third-party service that provides verifiable truth
+ * about the state of tokens in the Unicity network. It aggregates state
+ * transitions into rounds and provides inclusion proofs that cryptographically
+ * verify token ownership and transfers.
+ */
+
+/**
+ * Unicity state transition oracle provider
+ *
+ * The oracle serves as the source of truth for:
+ * - Token state validation (spent/unspent)
+ * - State transition inclusion proofs
+ * - Round-based commitment aggregation
+ */
+interface OracleProvider extends BaseProvider {
+    /**
+     * Initialize with trust base
+     */
+    initialize(trustBase?: unknown): Promise<void>;
+    /**
+     * Submit transfer commitment
+     */
+    submitCommitment(commitment: TransferCommitment): Promise<SubmitResult>;
+    /**
+     * Get inclusion proof for a request
+     */
+    getProof(requestId: string): Promise<InclusionProof | null>;
+    /**
+     * Wait for inclusion proof with polling
+     */
+    waitForProof(requestId: string, options?: WaitOptions): Promise<InclusionProof>;
+    /**
+     * Validate token against aggregator
+     */
+    validateToken(tokenData: unknown): Promise<ValidationResult>;
+    /**
+     * Check if token state is spent
+     */
+    isSpent(stateHash: string): Promise<boolean>;
+    /**
+     * Get token state
+     */
+    getTokenState(tokenId: string): Promise<TokenState | null>;
+    /**
+     * Get current round number
+     */
+    getCurrentRound(): Promise<number>;
+    /**
+     * Mint new tokens (for faucet/testing)
+     */
+    mint?(params: MintParams): Promise<MintResult>;
+    /**
+     * Get underlying StateTransitionClient (if available)
+     * Used for advanced SDK operations like commitment creation
+     */
+    getStateTransitionClient?(): unknown;
+    /**
+     * Get underlying AggregatorClient (if available)
+     * Used for direct aggregator API access
+     */
+    getAggregatorClient?(): unknown;
+    /**
+     * Wait for inclusion proof using SDK commitment (if available)
+     * Used for transfer flows with SDK TransferCommitment
+     */
+    waitForProofSdk?(commitment: unknown, signal?: AbortSignal): Promise<unknown>;
+}
+interface TransferCommitment {
+    /** Source token (SDK format) */
+    sourceToken: unknown;
+    /** Recipient address/predicate */
+    recipient: string;
+    /** Random salt (non-reproducible) */
+    salt: Uint8Array;
+    /** Optional additional data */
+    data?: unknown;
+}
+interface SubmitResult {
+    success: boolean;
+    requestId?: string;
+    error?: string;
+    timestamp: number;
+}
+interface InclusionProof {
+    requestId: string;
+    roundNumber: number;
+    proof: unknown;
+    timestamp: number;
+}
+interface WaitOptions {
+    /** Timeout in ms (default: 30000) */
+    timeout?: number;
+    /** Poll interval in ms (default: 1000) */
+    pollInterval?: number;
+    /** Callback on each poll attempt */
+    onPoll?: (attempt: number) => void;
+}
+interface ValidationResult {
+    valid: boolean;
+    spent: boolean;
+    error?: string;
+    stateHash?: string;
+}
+interface TokenState {
+    tokenId: string;
+    stateHash: string;
+    spent: boolean;
+    roundNumber?: number;
+    lastUpdated: number;
+}
+interface MintParams {
+    coinId: string;
+    amount: string;
+    recipientAddress: string;
+    recipientPubkey?: string;
+}
+interface MintResult {
+    success: boolean;
+    requestId?: string;
+    tokenId?: string;
+    error?: string;
+}
+type OracleEventType = 'oracle:connected' | 'oracle:disconnected' | 'oracle:error' | 'commitment:submitted' | 'proof:received' | 'validation:completed';
+interface OracleEvent {
+    type: OracleEventType;
+    timestamp: number;
+    data?: unknown;
+    error?: string;
+}
+type OracleEventCallback = (event: OracleEvent) => void;
+/**
+ * Trust base loader interface for platform-specific loading
+ * Browser: fetch from URL
+ * Node.js: read from file
+ */
+interface TrustBaseLoader$1 {
+    /**
+     * Load trust base JSON data
+     * @returns Trust base data or null if not available
+     */
+    load(): Promise<unknown | null>;
+}
+
+/**
+ * Unicity Aggregator Provider
+ * Platform-independent implementation using @unicitylabs/state-transition-sdk
+ *
+ * The oracle is a trusted service that provides verifiable truth
+ * about token state through cryptographic inclusion proofs.
+ *
+ * TrustBaseLoader is injected for platform-specific loading:
+ * - Browser: fetch from URL
+ * - Node.js: read from file
+ */
+
+interface SdkMintCommitment {
+    requestId?: {
+        toString(): string;
+    };
+    [key: string]: unknown;
+}
+interface UnicityAggregatorProviderConfig {
+    /** Aggregator URL */
+    url: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Request timeout (ms) */
+    timeout?: number;
+    /** Skip trust base verification (dev only) */
+    skipVerification?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Trust base loader (platform-specific) */
+    trustBaseLoader?: TrustBaseLoader$1;
+}
+/**
+ * Unicity Aggregator Provider
+ * Concrete implementation of OracleProvider using Unicity's aggregator service
+ */
+declare class UnicityAggregatorProvider implements OracleProvider {
+    readonly id = "unicity-aggregator";
+    readonly name = "Unicity Aggregator";
+    readonly type: "network";
+    readonly description = "Unicity state transition aggregator (oracle implementation)";
+    private config;
+    private status;
+    private eventCallbacks;
+    private aggregatorClient;
+    private stateTransitionClient;
+    private trustBase;
+    /** Get the current trust base */
+    getTrustBase(): RootTrustBase | null;
+    /** Get the state transition client */
+    getStateTransitionClient(): StateTransitionClient | null;
+    /** Get the aggregator client */
+    getAggregatorClient(): AggregatorClient | null;
+    private spentCache;
+    constructor(config: UnicityAggregatorProviderConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStatus(): ProviderStatus;
+    initialize(trustBase?: RootTrustBase): Promise<void>;
+    /**
+     * Submit a transfer commitment to the aggregator.
+     * Accepts either an SDK TransferCommitment or a simple commitment object.
+     */
+    submitCommitment(commitment: TransferCommitment | TransferCommitment$1): Promise<SubmitResult>;
+    /**
+     * Submit a mint commitment to the aggregator (SDK only)
+     * @param commitment - SDK MintCommitment instance
+     */
+    submitMintCommitment(commitment: SdkMintCommitment): Promise<SubmitResult>;
+    private isSdkTransferCommitment;
+    getProof(requestId: string): Promise<InclusionProof | null>;
+    waitForProof(requestId: string, options?: WaitOptions): Promise<InclusionProof>;
+    validateToken(tokenData: unknown): Promise<ValidationResult>;
+    /**
+     * Wait for inclusion proof using SDK (for SDK commitments)
+     */
+    waitForProofSdk(commitment: TransferCommitment$1 | SdkMintCommitment, signal?: AbortSignal): Promise<unknown>;
+    isSpent(stateHash: string): Promise<boolean>;
+    getTokenState(tokenId: string): Promise<TokenState | null>;
+    getCurrentRound(): Promise<number>;
+    mint(params: MintParams): Promise<MintResult>;
+    onEvent(callback: OracleEventCallback): () => void;
+    private rpcCall;
+    private ensureConnected;
+    private emitEvent;
+    private log;
+}
+/** @deprecated Use UnicityAggregatorProvider instead */
+declare const UnicityOracleProvider: typeof UnicityAggregatorProvider;
+/** @deprecated Use UnicityAggregatorProviderConfig instead */
+type UnicityOracleProviderConfig = UnicityAggregatorProviderConfig;
+
+/**
+ * Price Provider Interface
+ *
+ * Platform-independent abstraction for fetching token market prices.
+ * Does not extend BaseProvider — stateless HTTP client with internal caching.
+ */
+
+/**
+ * Supported price provider platforms
+ */
+type PricePlatform = 'coingecko';
+/**
+ * Price data for a single token
+ */
+interface TokenPrice {
+    /** Token name used by the price platform (e.g., "bitcoin") */
+    readonly tokenName: string;
+    /** Price in USD */
+    readonly priceUsd: number;
+    /** Price in EUR (if available) */
+    readonly priceEur?: number;
+    /** 24h price change percentage (if available) */
+    readonly change24h?: number;
+    /** Timestamp when this price was fetched */
+    readonly timestamp: number;
+}
+/**
+ * Price data provider
+ *
+ * Fetches current market prices for tokens. Implementations handle
+ * caching internally to avoid excessive API calls.
+ *
+ * @example
+ * ```ts
+ * const provider = new CoinGeckoPriceProvider({ apiKey: 'CG-xxx' });
+ * const prices = await provider.getPrices(['bitcoin', 'ethereum']);
+ * console.log(prices.get('bitcoin')?.priceUsd); // 97500
+ * ```
+ */
+interface PriceProvider {
+    /** Platform identifier (e.g., 'coingecko') */
+    readonly platform: PricePlatform;
+    /**
+     * Get prices for multiple tokens by their platform-compatible names
+     * @param tokenNames - Array of token names (e.g., ['bitcoin', 'ethereum'])
+     * @returns Map of token name to price data
+     */
+    getPrices(tokenNames: string[]): Promise<Map<string, TokenPrice>>;
+    /**
+     * Get price for a single token
+     * @param tokenName - Token name (e.g., 'bitcoin')
+     * @returns Token price (zero-price entry for tokens not listed on the platform), or null on network error with no cache
+     */
+    getPrice(tokenName: string): Promise<TokenPrice | null>;
+    /**
+     * Clear cached prices
+     */
+    clearCache(): void;
+}
+
+interface GroupChatModuleConfig {
+    /** Override relay URLs (default: from network config) */
+    relays?: string[];
+    /** Default message fetch limit (default: 50) */
+    defaultMessageLimit?: number;
+    /** Max previous message IDs in ordering tags (default: 3) */
+    maxPreviousTags?: number;
+    /** Reconnect delay in ms (default: 3000) */
+    reconnectDelayMs?: number;
+    /** Max reconnect attempts (default: 5) */
+    maxReconnectAttempts?: number;
+}
+
+/**
+ * SDK2 Core Types
+ * Platform-independent type definitions
  */
-declare function createNodeWebSocketFactory(): WebSocketFactory;
+type ProviderStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface ProviderMetadata {
+    readonly id: string;
+    readonly name: string;
+    readonly type: 'local' | 'cloud' | 'p2p' | 'network';
+    readonly description?: string;
+}
+interface BaseProvider extends ProviderMetadata {
+    connect(config?: unknown): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStatus(): ProviderStatus;
+}
+interface Identity {
+    /** 33-byte compressed secp256k1 public key (for L3 chain) */
+    readonly chainPubkey: string;
+    /** L1 address (alpha1...) */
+    readonly l1Address: string;
+    /** L3 DIRECT address (DIRECT://...) */
+    readonly directAddress?: string;
+    readonly ipnsName?: string;
+    readonly nametag?: string;
+}
+interface FullIdentity extends Identity {
+    readonly privateKey: string;
+}
+interface ComposingIndicator {
+    readonly senderPubkey: string;
+    readonly senderNametag?: string;
+    readonly expiresIn: number;
+}
 /**
- * Create NostrTransportProvider with Node.js WebSocket
+ * Minimal data stored in persistent storage for a tracked address.
+ * Only contains user state — derived fields are computed on load.
  */
-declare function createNostrTransportProvider(config: Omit<NostrTransportProviderConfig, 'createWebSocket'>): NostrTransportProvider;
+interface TrackedAddressEntry {
+    /** HD derivation index (0, 1, 2, ...) */
+    readonly index: number;
+    /** Whether this address is hidden from UI display */
+    hidden: boolean;
+    /** Timestamp (ms) when this address was first activated */
+    readonly createdAt: number;
+    /** Timestamp (ms) of last modification */
+    updatedAt: number;
+}
 
 /**
- * Oracle Provider Interface
- * Platform-independent Unicity oracle abstraction
- *
- * The oracle is a trusted third-party service that provides verifiable truth
- * about the state of tokens in the Unicity network. It aggregates state
- * transitions into rounds and provides inclusion proofs that cryptographically
- * verify token ownership and transfers.
+ * Storage Provider Interface
+ * Platform-independent storage abstraction
  */
 
 /**
- * Unicity state transition oracle provider
- *
- * The oracle serves as the source of truth for:
- * - Token state validation (spent/unspent)
- * - State transition inclusion proofs
- * - Round-based commitment aggregation
+ * Basic key-value storage provider
+ * All operations are async for platform flexibility
  */
-interface OracleProvider extends BaseProvider {
-    /**
-     * Initialize with trust base
-     */
-    initialize(trustBase?: unknown): Promise<void>;
-    /**
-     * Submit transfer commitment
-     */
-    submitCommitment(commitment: TransferCommitment): Promise<SubmitResult>;
-    /**
-     * Get inclusion proof for a request
-     */
-    getProof(requestId: string): Promise<InclusionProof | null>;
+interface StorageProvider extends BaseProvider {
     /**
-     * Wait for inclusion proof with polling
+     * Set identity for scoped storage
      */
-    waitForProof(requestId: string, options?: WaitOptions): Promise<InclusionProof>;
+    setIdentity(identity: FullIdentity): void;
     /**
-     * Validate token against aggregator
+     * Get value by key
      */
-    validateToken(tokenData: unknown): Promise<ValidationResult>;
+    get(key: string): Promise<string | null>;
     /**
-     * Check if token state is spent
+     * Set value by key
      */
-    isSpent(stateHash: string): Promise<boolean>;
+    set(key: string, value: string): Promise<void>;
     /**
-     * Get token state
+     * Remove key
      */
-    getTokenState(tokenId: string): Promise<TokenState | null>;
+    remove(key: string): Promise<void>;
     /**
-     * Get current round number
+     * Check if key exists
      */
-    getCurrentRound(): Promise<number>;
+    has(key: string): Promise<boolean>;
     /**
-     * Mint new tokens (for faucet/testing)
+     * Get all keys with optional prefix filter
      */
-    mint?(params: MintParams): Promise<MintResult>;
+    keys(prefix?: string): Promise<string[]>;
     /**
-     * Get underlying StateTransitionClient (if available)
-     * Used for advanced SDK operations like commitment creation
+     * Clear all keys with optional prefix filter
      */
-    getStateTransitionClient?(): unknown;
+    clear(prefix?: string): Promise<void>;
     /**
-     * Get underlying AggregatorClient (if available)
-     * Used for direct aggregator API access
+     * Save tracked addresses (only user state: index, hidden, timestamps)
      */
-    getAggregatorClient?(): unknown;
+    saveTrackedAddresses(entries: TrackedAddressEntry[]): Promise<void>;
     /**
-     * Wait for inclusion proof using SDK commitment (if available)
-     * Used for transfer flows with SDK TransferCommitment
+     * Load tracked addresses
      */
-    waitForProofSdk?(commitment: unknown, signal?: AbortSignal): Promise<unknown>;
+    loadTrackedAddresses(): Promise<TrackedAddressEntry[]>;
 }
-interface TransferCommitment {
-    /** Source token (SDK format) */
-    sourceToken: unknown;
-    /** Recipient address/predicate */
-    recipient: string;
-    /** Random salt (non-reproducible) */
-    salt: Uint8Array;
-    /** Optional additional data */
-    data?: unknown;
+interface HistoryRecord {
+    /** Composite dedup key (primary key) — e.g. "RECEIVED_v5split_abc123" */
+    dedupKey: string;
+    /** UUID for public API consumption */
+    id: string;
+    type: 'SENT' | 'RECEIVED' | 'SPLIT' | 'MINT';
+    amount: string;
+    coinId: string;
+    symbol: string;
+    timestamp: number;
+    transferId?: string;
+    /** Genesis tokenId this entry relates to (used for dedup) */
+    tokenId?: string;
+    senderPubkey?: string;
+    senderAddress?: string;
+    senderNametag?: string;
+    recipientPubkey?: string;
+    recipientAddress?: string;
+    recipientNametag?: string;
+    /** Optional memo/message attached to the transfer */
+    memo?: string;
 }
-interface SubmitResult {
+/**
+ * Storage result types
+ */
+interface SaveResult {
     success: boolean;
-    requestId?: string;
+    cid?: string;
     error?: string;
     timestamp: number;
 }
-interface InclusionProof {
-    requestId: string;
-    roundNumber: number;
-    proof: unknown;
+interface LoadResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    source: 'local' | 'remote' | 'cache';
     timestamp: number;
 }
-interface WaitOptions {
-    /** Timeout in ms (default: 30000) */
-    timeout?: number;
-    /** Poll interval in ms (default: 1000) */
-    pollInterval?: number;
-    /** Callback on each poll attempt */
-    onPoll?: (attempt: number) => void;
-}
-interface ValidationResult {
-    valid: boolean;
-    spent: boolean;
+interface SyncResult<T = unknown> {
+    success: boolean;
+    merged?: T;
+    added: number;
+    removed: number;
+    conflicts: number;
     error?: string;
-    stateHash?: string;
-}
-interface TokenState {
-    tokenId: string;
-    stateHash: string;
-    spent: boolean;
-    roundNumber?: number;
-    lastUpdated: number;
 }
-interface MintParams {
-    coinId: string;
-    amount: string;
-    recipientAddress: string;
-    recipientPubkey?: string;
+/**
+ * Token-specific storage provider
+ * Handles token persistence with sync capabilities
+ */
+interface TokenStorageProvider<TData = unknown> extends BaseProvider {
+    /**
+     * Set identity for storage scope
+     */
+    setIdentity(identity: FullIdentity): void;
+    /**
+     * Initialize provider (called once after identity is set)
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Shutdown provider
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Save token data
+     */
+    save(data: TData): Promise<SaveResult>;
+    /**
+     * Load token data
+     */
+    load(identifier?: string): Promise<LoadResult<TData>>;
+    /**
+     * Sync local data with remote
+     */
+    sync(localData: TData): Promise<SyncResult<TData>>;
+    /**
+     * Check if data exists
+     */
+    exists?(identifier?: string): Promise<boolean>;
+    /**
+     * Clear all data
+     */
+    clear?(): Promise<boolean>;
+    /**
+     * Subscribe to storage events
+     */
+    onEvent?(callback: StorageEventCallback): () => void;
+    /** Store a history entry (upsert by dedupKey) */
+    addHistoryEntry?(entry: HistoryRecord): Promise<void>;
+    /** Get all history entries sorted by timestamp descending */
+    getHistoryEntries?(): Promise<HistoryRecord[]>;
+    /** Check if a history entry exists by dedupKey */
+    hasHistoryEntry?(dedupKey: string): Promise<boolean>;
+    /** Clear all history entries */
+    clearHistory?(): Promise<void>;
+    /** Bulk import history entries (skip existing dedupKeys). Returns count of newly imported. */
+    importHistoryEntries?(entries: HistoryRecord[]): Promise<number>;
 }
-interface MintResult {
-    success: boolean;
-    requestId?: string;
-    tokenId?: string;
+type StorageEventType = 'storage:saving' | 'storage:saved' | 'storage:loading' | 'storage:loaded' | 'storage:error' | 'storage:remote-updated' | 'sync:started' | 'sync:completed' | 'sync:conflict' | 'sync:error';
+interface StorageEvent {
+    type: StorageEventType;
+    timestamp: number;
+    data?: unknown;
     error?: string;
 }
-type OracleEventType = 'oracle:connected' | 'oracle:disconnected' | 'oracle:error' | 'commitment:submitted' | 'proof:received' | 'validation:completed';
-interface OracleEvent {
-    type: OracleEventType;
+type StorageEventCallback = (event: StorageEvent) => void;
+interface TxfStorageDataBase {
+    _meta: TxfMeta;
+    _tombstones?: TxfTombstone[];
+    _outbox?: TxfOutboxEntry[];
+    _sent?: TxfSentEntry[];
+    _invalid?: TxfInvalidEntry[];
+    [key: `_${string}`]: unknown;
+}
+interface TxfMeta {
+    version: number;
+    address: string;
+    ipnsName?: string;
+    formatVersion: string;
+    updatedAt: number;
+}
+interface TxfTombstone {
+    tokenId: string;
+    stateHash: string;
     timestamp: number;
-    data?: unknown;
-    error?: string;
 }
-type OracleEventCallback = (event: OracleEvent) => void;
-/**
- * Trust base loader interface for platform-specific loading
- * Browser: fetch from URL
- * Node.js: read from file
- */
-interface TrustBaseLoader$1 {
-    /**
-     * Load trust base JSON data
-     * @returns Trust base data or null if not available
-     */
-    load(): Promise<unknown | null>;
+interface TxfOutboxEntry {
+    id: string;
+    status: string;
+    tokenId: string;
+    recipient: string;
+    createdAt: number;
+    data: unknown;
+}
+interface TxfSentEntry {
+    tokenId: string;
+    recipient: string;
+    txHash: string;
+    sentAt: number;
+}
+interface TxfInvalidEntry {
+    tokenId: string;
+    reason: string;
+    detectedAt: number;
 }
 
 /**
- * Unicity Aggregator Provider
- * Platform-independent implementation using @unicitylabs/state-transition-sdk
- *
- * The oracle is a trusted service that provides verifiable truth
- * about token state through cryptographic inclusion proofs.
- *
- * TrustBaseLoader is injected for platform-specific loading:
- * - Browser: fetch from URL
- * - Node.js: read from file
+ * File Storage Provider for Node.js
+ * Stores wallet data in JSON files
  */
 
-interface SdkMintCommitment {
-    requestId?: {
-        toString(): string;
-    };
-    [key: string]: unknown;
-}
-interface UnicityAggregatorProviderConfig {
-    /** Aggregator URL */
-    url: string;
-    /** API key for authentication */
-    apiKey?: string;
-    /** Request timeout (ms) */
-    timeout?: number;
-    /** Skip trust base verification (dev only) */
-    skipVerification?: boolean;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Trust base loader (platform-specific) */
-    trustBaseLoader?: TrustBaseLoader$1;
+interface FileStorageProviderConfig {
+    /** Directory to store wallet data */
+    dataDir: string;
+    /** File name for key-value data (default: 'wallet.json') */
+    fileName?: string;
 }
-/**
- * Unicity Aggregator Provider
- * Concrete implementation of OracleProvider using Unicity's aggregator service
- */
-declare class UnicityAggregatorProvider implements OracleProvider {
-    readonly id = "unicity-aggregator";
-    readonly name = "Unicity Aggregator";
-    readonly type: "network";
-    readonly description = "Unicity state transition aggregator (oracle implementation)";
-    private config;
+declare class FileStorageProvider implements StorageProvider {
+    readonly id = "file-storage";
+    readonly name = "File Storage";
+    readonly type: "local";
+    private dataDir;
+    private filePath;
+    private isTxtMode;
+    private data;
     private status;
-    private eventCallbacks;
-    private aggregatorClient;
-    private stateTransitionClient;
-    private trustBase;
-    /** Get the current trust base */
-    getTrustBase(): RootTrustBase | null;
-    /** Get the state transition client */
-    getStateTransitionClient(): StateTransitionClient | null;
-    /** Get the aggregator client */
-    getAggregatorClient(): AggregatorClient | null;
-    private spentCache;
-    constructor(config: UnicityAggregatorProviderConfig);
+    private _identity;
+    constructor(config: FileStorageProviderConfig | string);
+    setIdentity(identity: FullIdentity): void;
+    getIdentity(): FullIdentity | null;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
     getStatus(): ProviderStatus;
-    initialize(trustBase?: RootTrustBase): Promise<void>;
-    /**
-     * Submit a transfer commitment to the aggregator.
-     * Accepts either an SDK TransferCommitment or a simple commitment object.
-     */
-    submitCommitment(commitment: TransferCommitment | TransferCommitment$1): Promise<SubmitResult>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(prefix?: string): Promise<string[]>;
+    clear(prefix?: string): Promise<void>;
+    saveTrackedAddresses(entries: TrackedAddressEntry[]): Promise<void>;
+    loadTrackedAddresses(): Promise<TrackedAddressEntry[]>;
     /**
-     * Submit a mint commitment to the aggregator (SDK only)
-     * @param commitment - SDK MintCommitment instance
+     * Get full storage key with address prefix for per-address keys
      */
-    submitMintCommitment(commitment: SdkMintCommitment): Promise<SubmitResult>;
-    private isSdkTransferCommitment;
-    getProof(requestId: string): Promise<InclusionProof | null>;
-    waitForProof(requestId: string, options?: WaitOptions): Promise<InclusionProof>;
-    validateToken(tokenData: unknown): Promise<ValidationResult>;
+    private getFullKey;
+    private save;
+}
+declare function createFileStorageProvider(config: FileStorageProviderConfig | string): FileStorageProvider;
+
+/**
+ * File Token Storage Provider for Node.js
+ * Stores tokens as individual JSON files in per-address subdirectories
+ */
+
+interface FileTokenStorageConfig {
+    /** Directory to store token files */
+    tokensDir: string;
+}
+declare class FileTokenStorageProvider implements TokenStorageProvider<TxfStorageDataBase> {
+    readonly id = "file-token-storage";
+    readonly name = "File Token Storage";
+    readonly type: "local";
+    private baseTokensDir;
+    private status;
+    private identity;
+    constructor(config: FileTokenStorageConfig | string);
+    setIdentity(identity: FullIdentity): void;
     /**
-     * Wait for inclusion proof using SDK (for SDK commitments)
+     * Get tokens directory for current address
+     * Format: {baseTokensDir}/{addressId}/
      */
-    waitForProofSdk(commitment: TransferCommitment$1 | SdkMintCommitment, signal?: AbortSignal): Promise<unknown>;
-    isSpent(stateHash: string): Promise<boolean>;
-    getTokenState(tokenId: string): Promise<TokenState | null>;
-    getCurrentRound(): Promise<number>;
-    mint(params: MintParams): Promise<MintResult>;
-    onEvent(callback: OracleEventCallback): () => void;
-    private rpcCall;
-    private ensureConnected;
-    private emitEvent;
-    private log;
+    private get tokensDir();
+    initialize(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStatus(): ProviderStatus;
+    load(): Promise<LoadResult<TxfStorageDataBase>>;
+    save(data: TxfStorageDataBase): Promise<SaveResult>;
+    sync(localData: TxfStorageDataBase): Promise<SyncResult<TxfStorageDataBase>>;
+    clear(): Promise<boolean>;
+    private get historyPath();
+    private readHistoryFile;
+    private writeHistoryFile;
+    addHistoryEntry(entry: HistoryRecord): Promise<void>;
+    getHistoryEntries(): Promise<HistoryRecord[]>;
+    hasHistoryEntry(dedupKey: string): Promise<boolean>;
+    clearHistory(): Promise<void>;
+    importHistoryEntries(entries: HistoryRecord[]): Promise<number>;
 }
-/** @deprecated Use UnicityAggregatorProvider instead */
-declare const UnicityOracleProvider: typeof UnicityAggregatorProvider;
-/** @deprecated Use UnicityAggregatorProviderConfig instead */
-type UnicityOracleProviderConfig = UnicityAggregatorProviderConfig;
+declare function createFileTokenStorageProvider(config: FileTokenStorageConfig | string): FileTokenStorageProvider;
+
+/**
+ * Node.js Transport Exports
+ * Re-exports shared transport with Node.js WebSocket
+ */
+
+/**
+ * Create WebSocket factory for Node.js using 'ws' package
+ */
+declare function createNodeWebSocketFactory(): WebSocketFactory;
+/**
+ * Create NostrTransportProvider with Node.js WebSocket
+ */
+declare function createNostrTransportProvider(config: Omit<NostrTransportProviderConfig, 'createWebSocket'>): NostrTransportProvider;
 
 /** Network configurations */
 declare const NETWORKS: {
@@ -1273,66 +1373,6 @@ declare function createUnicityAggregatorProvider(config: Omit<UnicityAggregatorP
 /** @deprecated Use createUnicityAggregatorProvider instead */
 declare const createUnicityOracleProvider: typeof createUnicityAggregatorProvider;
 
-/**
- * Price Provider Interface
- *
- * Platform-independent abstraction for fetching token market prices.
- * Does not extend BaseProvider — stateless HTTP client with internal caching.
- */
-
-/**
- * Supported price provider platforms
- */
-type PricePlatform = 'coingecko';
-/**
- * Price data for a single token
- */
-interface TokenPrice {
-    /** Token name used by the price platform (e.g., "bitcoin") */
-    readonly tokenName: string;
-    /** Price in USD */
-    readonly priceUsd: number;
-    /** Price in EUR (if available) */
-    readonly priceEur?: number;
-    /** 24h price change percentage (if available) */
-    readonly change24h?: number;
-    /** Timestamp when this price was fetched */
-    readonly timestamp: number;
-}
-/**
- * Price data provider
- *
- * Fetches current market prices for tokens. Implementations handle
- * caching internally to avoid excessive API calls.
- *
- * @example
- * ```ts
- * const provider = new CoinGeckoPriceProvider({ apiKey: 'CG-xxx' });
- * const prices = await provider.getPrices(['bitcoin', 'ethereum']);
- * console.log(prices.get('bitcoin')?.priceUsd); // 97500
- * ```
- */
-interface PriceProvider {
-    /** Platform identifier (e.g., 'coingecko') */
-    readonly platform: PricePlatform;
-    /**
-     * Get prices for multiple tokens by their platform-compatible names
-     * @param tokenNames - Array of token names (e.g., ['bitcoin', 'ethereum'])
-     * @returns Map of token name to price data
-     */
-    getPrices(tokenNames: string[]): Promise<Map<string, TokenPrice>>;
-    /**
-     * Get price for a single token
-     * @param tokenName - Token name (e.g., 'bitcoin')
-     * @returns Token price (zero-price entry for tokens not listed on the platform), or null on network error with no cache
-     */
-    getPrice(tokenName: string): Promise<TokenPrice | null>;
-    /**
-     * Clear cached prices
-     */
-    clearCache(): void;
-}
-
 /**
  * Shared Configuration Interfaces
  * Base types extended by platform-specific implementations