@permissionless-technologies/upp-sdk 0.1.0

package/dist/index-C-jSNw6j.d.cts

@@ -0,0 +1,757 @@
+import { PublicClient, WalletClient, Address, Hex } from 'viem';
+import { r as ShieldParams, h as Note, O as TransferParams, M as MergeParams, Y as WithdrawParams, E as EncryptedNote } from './transfer-DKZuJnRM.cjs';
+import { M as MasterKeys, O as OneTimeKeys, b as StarkMasterKeys } from './types-CJSbxv4q.cjs';
+import { a as M31Digest } from './keccak-m31-B_AqBbRF.cjs';
+import { P as Point } from './merkle-mteVOlDf.cjs';
+
+/**
+ * Main UPP Client
+ *
+ * Provides high-level API for interacting with the Universal Private Pool.
+ */
+
+/**
+ * UPP Client configuration
+ */
+interface UPPClientConfig {
+    /** Viem public client for reading chain state */
+    publicClient: PublicClient;
+    /** Viem wallet client for sending transactions */
+    walletClient: WalletClient;
+    /** Universal Private Pool contract address */
+    poolAddress: Address;
+    /** ASP Registry Hub contract address */
+    aspHubAddress: Address;
+    /** Chain ID (optional, derived from clients if not provided) */
+    chainId?: number;
+}
+/**
+ * UPP Client interface
+ */
+interface UPPClient {
+    /** Shield tokens into the private pool */
+    shield(params: ShieldParams): Promise<{
+        commitment: `0x${string}`;
+        note: Note;
+    }>;
+    /** Transfer tokens privately */
+    transfer(params: TransferParams): Promise<{
+        nullifier: `0x${string}`;
+        changeNote?: Note;
+    }>;
+    /** Merge multiple notes into one */
+    merge(params: MergeParams): Promise<{
+        commitment: `0x${string}`;
+        note: Note;
+    }>;
+    /** Withdraw tokens from the private pool */
+    withdraw(params: WithdrawParams): Promise<{
+        txHash: `0x${string}`;
+    }>;
+    /** Scan for notes belonging to a viewing key */
+    scanNotes(viewingKey: `0x${string}`): Promise<Note[]>;
+    /** Get the current state root */
+    getStateRoot(): Promise<bigint>;
+    /** Check if a nullifier has been spent */
+    isNullifierSpent(nullifier: `0x${string}`): Promise<boolean>;
+}
+/**
+ * Create a UPP client instance
+ *
+ * @example
+ * ```ts
+ * import { createUPPClient } from '@upp/sdk'
+ * import { createPublicClient, createWalletClient, http } from 'viem'
+ * import { sepolia } from 'viem/chains'
+ *
+ * const publicClient = createPublicClient({
+ *   chain: sepolia,
+ *   transport: http(),
+ * })
+ *
+ * const walletClient = createWalletClient({
+ *   chain: sepolia,
+ *   transport: http(),
+ * })
+ *
+ * const client = createUPPClient({
+ *   publicClient,
+ *   walletClient,
+ *   poolAddress: '0x...',
+ *   aspHubAddress: '0x...',
+ * })
+ * ```
+ */
+declare function createUPPClient(_config: UPPClientConfig): UPPClient;
+
+/**
+ * Note management utilities
+ *
+ * Create, encrypt, and decrypt private notes.
+ */
+
+/**
+ * Parameters for creating a new note
+ */
+interface CreateNoteParams {
+    /** Token amount */
+    amount: bigint;
+    /** ERC20 token address */
+    token: Address;
+    /** Origin address (who is responsible) */
+    origin: Address;
+    /** Sender address */
+    sender: Address;
+    /** Optional memo */
+    memo?: string;
+    /** Optional blinding factor (generated if not provided) */
+    blinding?: bigint;
+}
+/**
+ * Create a new private note
+ *
+ * @example
+ * ```ts
+ * const note = createNote({
+ *   amount: 1000n * 10n ** 18n,
+ *   token: '0x...',
+ *   origin: '0xMyAddress...',
+ *   sender: '0xMyAddress...',
+ *   memo: 'Payment for services',
+ * })
+ * ```
+ */
+declare function createNote(params: CreateNoteParams): Note;
+/**
+ * Encrypt a note for a recipient
+ *
+ * @param note - The note to encrypt
+ * @param sharedSecret - ECDH shared secret with recipient
+ * @returns Encrypted note data
+ */
+declare function encryptNote(_note: Note, _sharedSecret: Uint8Array): EncryptedNote;
+/**
+ * Decrypt a received note
+ *
+ * @param encrypted - The encrypted note data
+ * @param sharedSecret - ECDH shared secret
+ * @returns Decrypted note or null if decryption fails
+ */
+declare function decryptNote(_encrypted: EncryptedNote, _sharedSecret: Uint8Array): Note | null;
+
+/**
+ * Stealth Address Utilities (Post-Quantum, Hash-Based)
+ *
+ * Implements stealth addresses using Poseidon hashes with bech32m encoding.
+ * No BabyJubJub curve operations — ownership is proven via hash preimage.
+ *
+ * Address Format (bech32m):
+ *   0zk1<version><chainId><ownerHash><viewingHash>
+ *
+ * Key Flow (self-shield):
+ *   1. User derives ownerHash = Poseidon(spendingSecret)
+ *   2. Commitment = Poseidon(amount, ownerHash, blinding, origin, token)
+ *   3. Encrypt note with key derived from viewingSecret
+ *
+ * Key Flow (send to others, future):
+ *   1. Decode recipient's stealth address (ownerHash, viewingHash)
+ *   2. Generate per-note secret and derive ownerHash for the note
+ *   3. Encrypt note so recipient's viewingSecret can decrypt
+ */
+
+/**
+ * Stealth address prefix
+ */
+declare const STEALTH_ADDRESS_PREFIX = "0zk";
+/**
+ * Address version (v2 = hash-based, post-quantum)
+ */
+declare const ADDRESS_VERSION = 2;
+/**
+ * Encode a stealth address in bech32m format
+ *
+ * Format: 0zk1<version><chainId><ownerHash><viewingHash>
+ *
+ * @param ownerHash - Owner hash = Poseidon(spendingSecret)
+ * @param viewingHash - Viewing hash = Poseidon(viewingSecret)
+ * @param chainId - Optional chain ID (0 = any chain)
+ * @returns bech32m encoded stealth address
+ */
+declare function encodeStealthAddress(ownerHash: bigint, viewingHash: bigint, chainId?: number): string;
+/**
+ * Decode a bech32m stealth address
+ *
+ * @param address - bech32m encoded stealth address
+ * @returns Decoded hash values
+ */
+declare function decodeStealthAddress(address: string): {
+    version: number;
+    chainId: number;
+    ownerHash: bigint;
+    viewingHash: bigint;
+};
+/**
+ * Validate a stealth address format
+ */
+declare function isValidStealthAddress(address: string): boolean;
+/**
+ * Generate stealth address from master keys
+ */
+declare function generateStealthAddress(keys: MasterKeys, chainId?: number): string;
+/**
+ * Create one-time keys for a transaction (hash-based)
+ *
+ * For self-shield: the user uses their own spendingSecret directly
+ * as the ownerSecret, producing ownerHash = Poseidon(spendingSecret).
+ *
+ * For sending to others (future): generate a random oneTimeSecret
+ * and derive ownerHash = Poseidon(oneTimeSecret).
+ *
+ * @param recipientOwnerHash - Recipient's owner hash (for verification)
+ * @param selfSecret - If self-shield, the user's spending secret
+ * @returns One-time keys for the note
+ */
+declare function createOneTimeKeys(_recipientOwnerHash?: bigint, selfSecret?: bigint): Promise<OneTimeKeys>;
+/**
+ * Verify ownership of a note by checking hash preimage
+ *
+ * @param secret - Claimed spending secret
+ * @param expectedOwnerHash - Owner hash from the note commitment
+ * @returns True if the secret hashes to the expected owner hash
+ */
+declare function verifyOwnership(secret: bigint, expectedOwnerHash: bigint): Promise<boolean>;
+/**
+ * Compute shared secret for note encryption/decryption (hash-based)
+ *
+ * For self-shield: just uses the viewing secret directly.
+ * For sending to others (future): use Poseidon(viewingSecret, recipientViewingHash)
+ *
+ * @param viewingSecret - Sender's or recipient's viewing secret
+ * @param nonce - Optional nonce for key derivation
+ * @returns Encryption key as bigint
+ */
+declare function computeNoteEncryptionKey(viewingSecret: bigint, nonce?: bigint): Promise<bigint>;
+/**
+ * STARK stealth address prefix
+ */
+declare const STARK_STEALTH_ADDRESS_PREFIX = "0zs";
+/**
+ * STARK address version (v1 = M31/Keccak)
+ */
+declare const STARK_ADDRESS_VERSION = 1;
+/**
+ * Encode a STARK stealth address in bech32m format
+ *
+ * Format: 0zs1<version><chainId><ownerHash[0..3]><viewingHash[0..3]>
+ *
+ * Each M31 element is encoded as 4 bytes (little-endian).
+ * Total data: 1 (version) + 4 (chainId) + 16 (ownerHash) + 16 (viewingHash) = 37 bytes.
+ *
+ * @param ownerHash - 4 M31 elements: keccak_m31(starkSecret)
+ * @param viewingHash - 4 M31 elements: keccak_m31(starkViewingSecret)
+ * @param chainId - Optional chain ID (0 = any chain)
+ */
+declare function encodeStarkStealthAddress(ownerHash: M31Digest, viewingHash: M31Digest, chainId?: number): string;
+/**
+ * Decode a STARK stealth address (0zs prefix)
+ */
+declare function decodeStarkStealthAddress(address: string): {
+    version: number;
+    chainId: number;
+    ownerHash: M31Digest;
+    viewingHash: M31Digest;
+};
+/**
+ * Validate a STARK stealth address format
+ */
+declare function isValidStarkStealthAddress(address: string): boolean;
+/**
+ * Generate a STARK stealth address from STARK master keys
+ */
+declare function generateStarkStealthAddress(keys: StarkMasterKeys, chainId?: number): string;
+/**
+ * Detect whether an address is SNARK (0zk) or STARK (0zs)
+ */
+declare function detectAddressType(address: string): 'snark' | 'stark' | 'unknown';
+
+/**
+ * Account Adapter — Pluggable account creation
+ *
+ * Abstracts how master keys are derived/loaded.
+ * The SDK doesn't care if keys come from a wallet signature,
+ * seed phrase, hardware wallet, or external KMS.
+ */
+
+/**
+ * Account adapter interface — pluggable key source.
+ *
+ * Implement this to bring your own key derivation:
+ * - SignatureAccountAdapter: EIP-712 wallet signature (built-in)
+ * - DirectAccountAdapter: pre-derived keys (built-in, for testing/KMS)
+ * - SeedPhraseAccountAdapter: BIP-39 seed phrase (custom)
+ * - HardwareWalletAccountAdapter: Ledger/Trezor (custom)
+ */
+interface IAccountAdapter {
+    /** Derive or load SNARK master keys */
+    getKeys(): Promise<MasterKeys>;
+    /** Derive or load STARK master keys (optional) */
+    getStarkKeys?(): Promise<StarkMasterKeys>;
+    /** Persist keys (adapter decides where/how) */
+    save?(): Promise<void>;
+    /** Clear persisted keys */
+    clear?(): Promise<void>;
+}
+/**
+ * Direct account adapter — accepts pre-derived keys.
+ *
+ * Use for testing, external KMS, or when keys are derived
+ * outside the SDK (e.g., from a seed phrase).
+ *
+ * @example
+ * ```ts
+ * const adapter = new DirectAccountAdapter({
+ *   spendingSecret: 12345n,
+ *   ownerHash: await poseidon([12345n]),
+ *   viewingSecret: 67890n,
+ *   viewingHash: await poseidon([67890n]),
+ * })
+ * const keys = await adapter.getKeys()
+ * ```
+ */
+declare class DirectAccountAdapter implements IAccountAdapter {
+    private keys;
+    private starkKeys?;
+    constructor(keys: MasterKeys, starkKeys?: StarkMasterKeys | undefined);
+    getKeys(): Promise<MasterKeys>;
+    getStarkKeys(): Promise<StarkMasterKeys>;
+}
+
+/**
+ * ASP Provider — Pluggable compliance layer
+ *
+ * Abstracts where ASP membership proofs come from.
+ * The pool protocol doesn't care which ASP you use —
+ * it's the operator who makes the rules.
+ *
+ * Built-in: none (ASP is optional, ragequit always available)
+ * Implementations:
+ * - RestASPProvider: fetch from ASP service API (e.g., asp-whitelist.upd.io)
+ * - LocalASPProvider: generate from local tree (via upc-sdk)
+ * - Custom: any source that can provide Merkle proofs
+ */
+
+interface ASPMembershipProof {
+    /** Merkle root of the ASP tree */
+    root: bigint;
+    /** Path elements (siblings) */
+    pathElements: bigint[];
+    /** Path indices (0 = left, 1 = right) */
+    pathIndices: number[];
+}
+/**
+ * ASP provider interface — pluggable compliance.
+ *
+ * Implement this to bring your own ASP:
+ * - Each operator runs their own ASP service
+ * - Users are whitelisted by the operator's rules
+ * - Proofs are fetched from the operator's service
+ *
+ * If no ASP is configured, users can always ragequit
+ * (withdraw their own deposits without ASP approval).
+ */
+interface IASPProvider {
+    /** ASP ID registered on-chain */
+    getASPId(): bigint;
+    /** Fetch a membership proof for an address */
+    getProof(address: Address): Promise<ASPMembershipProof | null>;
+    /** Check if an address is whitelisted (without fetching full proof) */
+    isWhitelisted(address: Address): Promise<boolean>;
+}
+
+/**
+ * Indexer Types
+ *
+ * Types for the pluggable indexer module that handles note scanning and persistence.
+ */
+
+/**
+ * Status of a shielded note
+ */
+type NoteStatus$1 = 'pending' | 'confirmed' | 'spent';
+/**
+ * A shielded note (UTXO) stored by the indexer
+ */
+interface IndexedNote {
+    /** Amount of tokens */
+    amount: bigint;
+    /** Random blinding factor */
+    blinding: bigint;
+    /** Commitment hash (hex) */
+    commitment: Hex;
+    /** One-time spending secret (hex) */
+    oneTimeSecret: Hex;
+    /** One-time public key X (hex) */
+    oneTimePubkeyX: Hex;
+    /** One-time public key Y (hex) */
+    oneTimePubkeyY: Hex;
+    /** Position in Merkle tree */
+    leafIndex: number;
+    /** Transaction hash */
+    txHash?: Hex;
+    /** Note status */
+    status: NoteStatus$1;
+    /** Block number where note was created */
+    blockNumber: number;
+    /** Timestamp (Unix seconds) */
+    timestamp: number;
+    /** Origin address (original depositor for ASP proofs) */
+    origin?: Address;
+    /** Token address (for multi-token pools) */
+    token?: Address;
+    /** Ephemeral public key X (R.x — used as viewing key nonce) */
+    ephemeralX?: Hex;
+    /** Ephemeral public key Y (R.y) */
+    ephemeralY?: Hex;
+}
+/**
+ * Serialized note for storage (bigints as strings)
+ */
+interface SerializedNote {
+    amount: string;
+    blinding: string;
+    commitment: string;
+    oneTimeSecret: string;
+    oneTimePubkeyX: string;
+    oneTimePubkeyY: string;
+    leafIndex: number;
+    txHash?: string;
+    status: NoteStatus$1;
+    blockNumber: number;
+    timestamp: number;
+    origin?: string;
+    token?: string;
+    ephemeralX?: string;
+    ephemeralY?: string;
+}
+/**
+ * Sync state persisted by the indexer
+ */
+interface SyncState {
+    /** Last processed block number */
+    lastBlock: number;
+    /** Chain ID for validation */
+    chainId: number;
+    /** Pool contract address */
+    contractAddress: Address;
+    /** Timestamp of last sync */
+    lastSyncTimestamp: number;
+}
+/**
+ * Full indexer state for persistence
+ */
+interface IndexerState {
+    /** Sync metadata */
+    sync: SyncState;
+    /** All indexed notes */
+    notes: SerializedNote[];
+    /** Nullifier hashes of spent notes */
+    nullifiers: Hex[];
+}
+/**
+ * Storage adapter interface for pluggable persistence
+ *
+ * Implementations must be async-safe and handle concurrent access.
+ */
+interface StorageAdapter {
+    /**
+     * Get a value by key
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value
+     */
+    set<T>(key: string, value: T): Promise<void>;
+    /**
+     * Delete a value
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear all data
+     */
+    clear(): Promise<void>;
+    /**
+     * Check if storage is available
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Result of a sync operation
+ */
+interface SyncResult {
+    /** Number of new notes discovered */
+    newNotesCount: number;
+    /** Number of notes marked as spent */
+    spentNotesCount: number;
+    /** Last block synced to */
+    lastBlock: number;
+    /** Time taken in milliseconds */
+    durationMs: number;
+    /** Any errors encountered (non-fatal) */
+    errors?: string[];
+}
+/**
+ * Progress information during sync
+ */
+interface SyncProgress {
+    /** Current block being processed */
+    currentBlock: number;
+    /** Target block (latest block) */
+    targetBlock: number;
+    /** Total events processed */
+    eventsProcessed: number;
+    /** Notes found so far */
+    notesFound: number;
+    /** Progress percentage (0-100) */
+    percent: number;
+    /** Events skipped by search tag filtering */
+    eventsSkipped: number;
+}
+/**
+ * Configuration for sync operation
+ */
+interface SyncConfig {
+    /** Callback for progress updates */
+    onProgress?: (progress: SyncProgress) => void;
+    /** Enable search tag filtering (default: true) */
+    useSearchTagFiltering?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Filter options for querying notes
+ */
+interface NoteFilters {
+    /** Filter by status */
+    status?: NoteStatus$1 | NoteStatus$1[];
+    /** Filter by token address */
+    token?: Address;
+    /** Minimum amount */
+    minAmount?: bigint;
+    /** Maximum amount */
+    maxAmount?: bigint;
+}
+/**
+ * Configuration for RPC indexer
+ */
+interface RpcIndexerConfig {
+    /** viem PublicClient instance */
+    client: any;
+    /** Pool contract address */
+    contractAddress: Address;
+    /** Chain ID */
+    chainId: number;
+    /** Initial batch size for getLogs (will adapt on rate limits) */
+    batchSize?: number;
+    /** Minimum batch size (won't go below this) */
+    minBatchSize?: number;
+    /** Delay between batches in ms */
+    batchDelayMs?: number;
+    /** Storage adapter (defaults to IndexedDB) */
+    storage?: StorageAdapter;
+    /** Spending secret for trial decryption */
+    spendingSecret: bigint;
+    /** Spending public key for verification */
+    spendingPubkey: Point;
+    /** Master viewing secret for DVK derivation */
+    masterViewingSecret: bigint;
+    /** Master viewing public key for EVK/DVK derivation */
+    masterViewingPubKey: Point;
+    /** Initial starting block (if no saved state). Useful to skip blocks before account creation. */
+    fromBlock?: number;
+}
+/**
+ * Live sync configuration
+ */
+interface LiveSyncConfig {
+    /** Interval between syncs in ms (default 30000) */
+    intervalMs?: number;
+    /** Callback when new notes are found */
+    onNewNotes?: (notes: IndexedNote[]) => void;
+    /** Callback when notes are spent */
+    onNotesSpent?: (commitments: Hex[]) => void;
+    /** Callback on sync error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Indexer interface
+ *
+ * Provides note scanning, balance calculation, and state management.
+ */
+interface Indexer {
+    /**
+     * Sync notes from blockchain
+     *
+     * Fetches new events since last sync and tries to decrypt them.
+     *
+     * @param config - Optional sync configuration (progress callbacks, etc.)
+     */
+    sync(config?: SyncConfig): Promise<SyncResult>;
+    /**
+     * Get total balance of unspent notes
+     *
+     * @param token - Optional token address filter
+     */
+    getBalance(token?: Address): bigint;
+    /**
+     * Get all notes matching filters
+     */
+    getNotes(filters?: NoteFilters): IndexedNote[];
+    /**
+     * Get unspent notes
+     */
+    getUnspentNotes(): IndexedNote[];
+    /**
+     * Get the last synced block number
+     */
+    getLastBlock(): number;
+    /**
+     * Mark a note as spent (e.g., after a transfer)
+     */
+    markSpent(commitment: Hex): void;
+    /**
+     * Add a note directly (e.g., after shielding)
+     */
+    addNote(note: IndexedNote): void;
+    /**
+     * Start live sync (polls for new blocks)
+     */
+    startLiveSync(config?: LiveSyncConfig): void;
+    /**
+     * Stop live sync
+     */
+    stopLiveSync(): void;
+    /**
+     * Check if live sync is running
+     */
+    isLiveSyncing(): boolean;
+    /**
+     * Clear all indexed data
+     */
+    clear(): Promise<void>;
+    /**
+     * Export current state (for backup/migration)
+     */
+    exportState(): Promise<IndexerState>;
+    /**
+     * Import state (for restore)
+     */
+    importState(state: IndexerState): Promise<void>;
+}
+/**
+ * CommitmentInserted event args
+ */
+interface CommitmentInsertedArgs {
+    commitment: Hex;
+    leafIndex: number;
+    timestamp: bigint;
+}
+/**
+ * StealthTransact event args
+ */
+interface StealthTransactArgs {
+    commitment: Hex;
+    searchTag: bigint;
+    ephemeralPubkeyX: bigint;
+    ephemeralPubkeyY: bigint;
+    encryptedNote: Hex;
+}
+/**
+ * Nullified event args
+ */
+interface NullifiedArgs {
+    nullifier: Hex;
+}
+
+/**
+ * NoteStore — Single source of truth for note state
+ *
+ * Framework-agnostic. Uses StorageAdapter for persistence.
+ * Handles deduplication, status management, balance calculation.
+ *
+ * Usage:
+ *   const store = new NoteStore(createMemoryAdapter())
+ *   await store.load()
+ *   store.addNote(note)  // returns false if duplicate
+ *   store.getBalance()   // sum of unspent notes
+ */
+
+type NoteStatus = 'pending' | 'confirmed' | 'spent';
+type ProofSystem = 'snark' | 'stark';
+interface ShieldedNote {
+    amount: bigint;
+    blinding: bigint;
+    commitment: string;
+    ownerSecret: string;
+    ownerHash: string;
+    leafIndex: number;
+    origin: string;
+    token: string;
+    txHash?: string;
+    status: NoteStatus;
+    timestamp: number;
+    proofSystem?: ProofSystem;
+}
+interface INoteStore {
+    getNotes(): ShieldedNote[];
+    getUnspentNotes(proofSystem?: ProofSystem): ShieldedNote[];
+    getBalance(token?: string, proofSystem?: ProofSystem): bigint;
+    addNote(note: ShieldedNote): boolean;
+    addNotes(notes: ShieldedNote[]): number;
+    markSpent(commitment: string): void;
+    unmarkSpent(commitment: string): void;
+    updateLeafIndex(commitment: string, leafIndex: number): void;
+    load(): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    onChange(callback: () => void): () => void;
+}
+declare class NoteStore implements INoteStore {
+    private storage;
+    private storageKey;
+    private notes;
+    private commitmentSet;
+    private listeners;
+    private dirty;
+    constructor(storage: StorageAdapter, storageKey?: string);
+    getNotes(): ShieldedNote[];
+    getUnspentNotes(proofSystem?: ProofSystem): ShieldedNote[];
+    getBalance(token?: string, proofSystem?: ProofSystem): bigint;
+    /**
+     * Add a note. Returns false if duplicate (by commitment).
+     * Normalizes token and origin addresses.
+     */
+    addNote(note: ShieldedNote): boolean;
+    /**
+     * Add multiple notes. Returns count of actually added (non-duplicate).
+     */
+    addNotes(notes: ShieldedNote[]): number;
+    /**
+     * Mark a note as spent (optimistic — syncNotes reconciles via nullifier check).
+     */
+    markSpent(commitment: string): void;
+    /**
+     * Un-mark a note as spent (reconciliation: nullifier not found on-chain).
+     */
+    unmarkSpent(commitment: string): void;
+    /**
+     * Update the leafIndex for a note (e.g., after confirming on-chain).
+     */
+    updateLeafIndex(commitment: string, leafIndex: number): void;
+    load(): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    onChange(callback: () => void): () => void;
+    private notify;
+}
+
+export { ADDRESS_VERSION as A, decryptNote as B, type CommitmentInsertedArgs as C, DirectAccountAdapter as D, detectAddressType as E, encodeStarkStealthAddress as F, encodeStealthAddress as G, encryptNote as H, type Indexer as I, generateStarkStealthAddress as J, generateStealthAddress as K, type LiveSyncConfig as L, isValidStarkStealthAddress as M, type NoteStatus$1 as N, isValidStealthAddress as O, type ProofSystem as P, verifyOwnership as Q, type RpcIndexerConfig as R, type StorageAdapter as S, type NoteStatus as T, type UPPClient as U, type IndexedNote as a, type NoteFilters as b, type SyncResult as c, type SyncProgress as d, type SyncConfig as e, type IndexerState as f, type SyncState as g, type SerializedNote as h, type StealthTransactArgs as i, type NullifiedArgs as j, type ASPMembershipProof as k, type IASPProvider as l, type IAccountAdapter as m, type INoteStore as n, NoteStore as o, STARK_ADDRESS_VERSION as p, STARK_STEALTH_ADDRESS_PREFIX as q, STEALTH_ADDRESS_PREFIX as r, type ShieldedNote as s, type UPPClientConfig as t, computeNoteEncryptionKey as u, createNote as v, createOneTimeKeys as w, createUPPClient as x, decodeStarkStealthAddress as y, decodeStealthAddress as z };