@unicitylabs/sphere-sdk 0.15.0 → 0.16.0-dev.1

package/dist/index.d.cts

@@ -861,6 +861,25 @@ interface SphereStatus {
  * All operations are async for platform flexibility
  */
 interface StorageProvider extends BaseProvider {
+    /**
+     * Stable identity of the BACKING STORE this provider addresses — not of this
+     * object, and not of the class (`id` is a class constant like `'file-storage'`,
+     * which is exactly the wrong granularity).
+     *
+     * Two providers that return the SAME value address the same data, so erasing
+     * through one erases through the other: `Sphere.clear({ storage })` tears down
+     * the live Spheres of every provider sharing this value, not merely those built
+     * on this object. Compose it from everything that selects the store (file path,
+     * database name, key prefix) behind a scheme prefix, so two kinds of store can
+     * never collide on one string.
+     *
+     * It must not change over the provider's lifetime — it is read again on teardown,
+     * and a value that moved would strand the entry it was registered under.
+     *
+     * Optional: omit it and liveness falls back to per-object identity, i.e. a
+     * second provider over the same data is treated as unrelated.
+     */
+    readonly backingStoreId?: string;
     /**
      * Set identity for scoped storage
      */
@@ -890,11 +909,44 @@ interface StorageProvider extends BaseProvider {
      */
     clear(prefix?: string): Promise<void>;
     /**
-     * Save tracked addresses (only user state: index, hidden, timestamps)
+     * Save tracked addresses (only user state: index, hidden, timestamps).
+     *
+     * MUST MERGE, NEVER REPLACE (#766 item 5). `entries` is ONE writer's snapshot,
+     * not the whole truth: every Sphere sharing this storage keeps its own copy of
+     * the registry and persists all of it, so writing the argument verbatim is a
+     * lost update — A activates index 1, B (whose snapshot predates that) activates
+     * index 2, and B's write erases index 1 while A still reports it. This happens
+     * on a single network with a single provider; do NOT "fix" it by renaming or
+     * network-scoping the key.
+     *
+     * The contract, implemented by `storage/tracked-addresses.ts` — reuse those
+     * helpers rather than re-deriving this:
+     *  - read the stored registry, union it with `entries` BY `index`;
+     *  - on a conflicting index, the entry with the greater `updatedAt` supplies
+     *    `hidden`, and `createdAt` keeps the earlier value;
+     *  - serialize concurrent calls on the provider instance, so one call's read
+     *    cannot interleave with another's write;
+     *  - a failed write must not brick later writes, and must still reject to its
+     *    own caller.
+     *
+     * An `index` must be a UINT32 — a BIP32 child number. `deriveKeyAtPath` parseInt()s
+     * that path segment, so `1.5` derives index 1's keys and the row aliases a real
+     * address. The ceiling matters too: `deriveChildKey` pads the child number to 8 hex
+     * digits, so anything above `0xffffffff` emits extra bytes and derives off-standard.
+     * An `entries` row that is not one must REJECT the whole call (`mergeTrackedAddresses`
+     * throws `VALIDATION_ERROR`); dropping it silently on a write reports a save that
+     * never happened. Already-stored rows are dropped on READ instead, so one bad row
+     * cannot brick every later write. Validate before opening the write transaction if
+     * your platform would otherwise replace the reason with a generic abort.
+     *
+     * A union is safe because there is no delete path: entries are only ever added,
+     * and wiping the wallet removes the key itself (`Sphere.clear()`). Adding a
+     * per-entry delete would require revisiting this contract.
      */
     saveTrackedAddresses(entries: TrackedAddressEntry[]): Promise<void>;
     /**
-     * Load tracked addresses
+     * Load tracked addresses. Tolerant: unusable/corrupt storage reads as `[]`
+     * (see `parseTrackedAddresses` in `storage/tracked-addresses.ts`).
      */
     loadTrackedAddresses(): Promise<TrackedAddressEntry[]>;
 }
@@ -2002,8 +2054,12 @@ declare function getAddressStorageKey(addressId: string, key: string): string;
  * @returns Sanitized identifier like "DIRECT_abc123_xyz789"
  */
 declare function getAddressId(directAddress: string): string;
-/** Default Nostr relays */
-declare const DEFAULT_NOSTR_RELAYS: readonly ["wss://relay.unicity.network", "wss://relay.damus.io", "wss://nos.lol", "wss://relay.nostr.band"];
+/**
+ * Fallback Nostr relays, used only when no relay list is configured
+ * (NostrTransportProvider / MultiAddressTransportMux). `relay.unicity.network`
+ * was the v1 relay and no longer resolves, so it is not listed here.
+ */
+declare const DEFAULT_NOSTR_RELAYS: readonly ["wss://relay.damus.io", "wss://nos.lol", "wss://relay.nostr.band"];
 /** Nostr event kinds used by SDK - must match @unicitylabs/nostr-js-sdk */
 declare const NOSTR_EVENT_KINDS: {
     /** NIP-04 encrypted direct message */
@@ -2051,7 +2107,12 @@ declare const NIP29_KINDS: {
     /** Relay-signed group roles */
     readonly GROUP_ROLES: 39003;
 };
-/** Default aggregator request timeout (ms) */
+/**
+ * Default aggregator request timeout (ms)
+ * Note: The aggregator is conceptually an oracle - a trusted service that provides
+ * verifiable truth about token state through cryptographic inclusion proofs.
+ * There is no default aggregator URL: every live network names its own gateway.
+ */
 declare const DEFAULT_AGGREGATOR_TIMEOUT = 30000;
 /** Default BIP32 derivation path (full path with chain/index) */
 declare const DEFAULT_DERIVATION_PATH: "m/44'/0'/0'/0/0";
@@ -2068,10 +2129,11 @@ declare const DEFAULT_GROUP_RELAYS: readonly ["wss://sphere-relay.unicity.networ
 declare const NETWORKS: {
     readonly mainnet: {
         readonly name: "Mainnet";
-        readonly aggregatorUrl: "https://aggregator.unicity.network/rpc";
-        readonly nostrRelays: readonly ["wss://relay.unicity.network", "wss://relay.damus.io", "wss://nos.lol", "wss://relay.nostr.band"];
+        readonly networkId: 1;
+        readonly aggregatorUrl: "https://gateway.mainnet.unicity.network";
+        readonly nostrRelays: readonly ["wss://nostr-relay.testnet.unicity.network"];
         readonly groupRelays: readonly ["wss://sphere-relay.unicity.network"];
-        readonly tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
+        readonly tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.mainnet.json";
     };
     readonly testnet: {
         readonly name: "Testnet2";
@@ -2089,13 +2151,6 @@ declare const NETWORKS: {
         readonly groupRelays: readonly ["wss://sphere-relay.unicity.network"];
         readonly tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet2.json";
     };
-    readonly dev: {
-        readonly name: "Development";
-        readonly aggregatorUrl: "https://dev-aggregator.dyndns.org/rpc";
-        readonly nostrRelays: readonly ["wss://nostr-relay.testnet.unicity.network"];
-        readonly groupRelays: readonly ["wss://sphere-relay.unicity.network"];
-        readonly tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
-    };
 };
 type NetworkType = keyof typeof NETWORKS;
 /** Default timeouts (ms) */
@@ -2964,9 +3019,26 @@ interface SphereInitResult {
     generatedMnemonic?: string;
 }
 declare class Sphere {
-    private static instance;
+    private static readonly _liveByStorage;
+    /** Fallback keys for providers that declare no `backingStoreId` — one per object. */
+    private static readonly _objectStoreKeys;
+    /**
+     * How many times each backing store has been cleared. An init is invisible to `clear()`
+     * until it PUBLISHES (#767), so a clear cannot destroy one in flight and would wipe the
+     * store under it. Every init records this number before its first storage work and
+     * publication refuses if it moved (#772). Only cleared stores get an entry, so the
+     * strongly-held keys are bounded by the stores a process actually clears.
+     */
+    private static readonly _clearGenerations;
     private static _orphanCacheCleaned;
     private _initialized;
+    /**
+     * Destroyed latch (#770). Distinct from `_initialized`, which destroy() clears LAST — after
+     * every teardown step — so it cannot mark "teardown has begun". This is set as destroy()'s
+     * very FIRST statement, so the WHOLE teardown window is guarded, not just the instant after
+     * it. Read by ensureAlive() and by the §7 lifecycle mutex.
+     */
+    private _destroyed;
     private _trackedAddressesLoaded;
     private _identity;
     private _masterKey;
@@ -3019,6 +3091,8 @@ declare class Sphere {
      * the rebuild after an api-key change share one pool configuration.
      */
     private _verification;
+    /** This Sphere's OWN token registry. Disposed by destroy(); never the process global. */
+    private _registry;
     private eventHandlers;
     private _disabledProviders;
     private _providerEventCleanups;
@@ -3090,6 +3164,23 @@ declare class Sphere {
      * bundle). This method ensures the main bundle's TokenRegistry is configured.
      */
     private static configureTokenRegistry;
+    /**
+     * Build the registry THIS Sphere owns, so its metadata cannot be repointed by another
+     * Sphere's init. The global is still configured above for consumers that read it
+     * directly; this instance is what the payments facade presents from.
+     */
+    /**
+     * Own a registry for the duration of `bringUp`, disposing it if any of that rejects.
+     *
+     * `bringUp` must cover EVERY fallible step from here until the Sphere is returned to
+     * its caller — until then nobody holds anything they could destroy, so a
+     * registry left behind is unreachable and its hourly fetch runs for the life of the
+     * process. Guarding a named subset of the steps is what failed twice: the guarded region
+     * and the fallible region were separate things, and drifted. Publication is the LAST
+     * guarded step for the same reason: it can refuse, and a refusal must tear down.
+     */
+    private static withOwnedRegistry;
+    private static createOwnedRegistry;
     /**
      * Create new wallet with mnemonic
      */
@@ -3118,6 +3209,7 @@ declare class Sphere {
     static clear(options: {
         storage: StorageProvider;
     }): Promise<void>;
+    private static clearStore;
     /**
      * Raw `indexedDB.deleteDatabase` sweep of `sphere-token-storage-*` databases
      * left by pre-flip versions (tokens are server-custody now). Browser-only,
@@ -3132,13 +3224,27 @@ declare class Sphere {
      */
     private static cleanupOrphanedVestingCache;
     /**
-     * Get current instance
+     * The key a provider registers under: the store it addresses, so every provider
+     * over one dataDir/DB shares an entry. A provider that declares no store keeps a
+     * private key, leaving custom implementations scoped by object identity.
      */
-    static getInstance(): Sphere | null;
+    private static storeKeyOf;
+    /** The clears this store has seen. Absent means none — `clear()` creates the entry. */
+    private static clearGenerationOf;
+    private static bumpClearGeneration;
     /**
-     * Check if initialized
+     * Make a fully-built Sphere reachable — or refuse, if `clear()` emptied the store
+     * under it while it was building. Check and registration are one SYNCHRONOUS step on
+     * purpose: split by an await, a clear could land between them and wipe a store whose
+     * Sphere is already published. The refusal throws inside `withOwnedRegistry`, whose
+     * teardown then destroys the half-built Sphere the caller never received.
      */
-    static isInitialized(): boolean;
+    private static publishLive;
+    /** Record a fully-built Sphere against the storage it owns. See `_liveByStorage`. */
+    private static registerLive;
+    private static unregisterLive;
+    /** Snapshot — callers iterate this while destroy() mutates the underlying Set. */
+    private static liveOn;
     /**
      * Validate mnemonic using BIP39
      */
@@ -3307,7 +3413,8 @@ declare class Sphere {
     /**
      * Import wallet from JSON backup
      *
-     * @returns Object with success status and optionally recovered mnemonic
+     * @returns `{ success, sphere?, mnemonic?, error? }`. `sphere` is the instance built
+     *   on the SUPPLIED storage — hold it, there is no global to look it up from (#766).
      *
      * @example
      * ```ts
@@ -3324,6 +3431,7 @@ declare class Sphere {
         password?: string;
     }): Promise<{
         success: boolean;
+        sphere?: Sphere;
         mnemonic?: string;
         error?: string;
     }>;
@@ -3423,6 +3531,18 @@ declare class Sphere {
      * independently in background. The payments vertical is NOT created here —
      * the caller starts it via stopThenStartPaymentsV2 (§7 single vertical).
      */
+    /** Tear one address's module set down. Each address owns its own engine, so its own pool. */
+    private static destroyModuleSet;
+    /**
+     * Undo a module set built while `destroy()` was running.
+     *
+     * `destroy()`'s teardown loop has already emptied `_addressModules`, so a set
+     * registered after it would stay live and unreachable — its own engine (and worker
+     * pool), and a transport mux `ensureTransportMux` rebuilt because teardown had just
+     * nulled the field. Then re-raise, so the switch fails rather than reporting success
+     * on a destroyed Sphere (#770, #772 review).
+     */
+    private discardModulesBuiltDuringDestroy;
     private initializeAddressModules;
     /**
      * Ensure the transport multiplexer exists and register an address.
@@ -3431,6 +3551,8 @@ declare class Sphere {
      * @returns AddressTransportAdapter or null if transport is not Nostr-based
      */
     private ensureTransportMux;
+    /** A BIP32 child number: an integer in 0…0xffffffff. Anything else aliases an address. */
+    private static assertDerivableIndex;
     /**
      * Derive address at a specific index
      *
@@ -3669,6 +3791,29 @@ declare class Sphere {
      * Strip @ prefix and normalize a nametag (lowercase, phone E.164, strip @unicity suffix).
      */
     private cleanNametag;
+    /**
+     * Disconnect transport, storage and oracle, attempting each even if an earlier one
+     * rejects. They are separate resources, and one failure must not skip the rest — that
+     * is how a partial teardown leaves connections open, which is exactly the state the
+     * failed-initialization path calls destroy() in.
+     */
+    private disconnectProvidersIndependently;
+    /** Run one teardown step, logging rather than propagating so the next one still runs. */
+    private static safeDisconnect;
+    /**
+     * Tear this Sphere down: stop the vertical, destroy the modules, disconnect the providers
+     * and zero the key material. Idempotent by construction (every step is null-guarded) and
+     * deliberately WITHOUT an early return on re-entry, which would change what a double call
+     * means.
+     *
+     * #770: the FIRST statement flips `_destroyed` — before any await, and before this queues
+     * its own stop on the §7 lifecycle mutex. That position is load-bearing. Every guard reads
+     * the flag, so from that instant any switchToAddress step not yet begun refuses; and
+     * because it flips SYNCHRONOUSLY at entry, a stop/start pair the mutex runs after this call
+     * sees `true` and skips its start. Set it beside `_initialized` at the bottom instead and a
+     * concurrent switch re-arms a wallet whose owner already had destroy() return: fresh
+     * sockets, a fresh wallet-api session, a whole fresh vertical nothing will ever stop.
+     */
     destroy(): Promise<void>;
     private storeMnemonic;
     private storeMasterKey;
@@ -3706,7 +3851,17 @@ declare class Sphere {
     private initializeModules;
     /** §7 mutex: run one stop/start lifecycle op after all queued ones settle. */
     private queuePaymentsV2Op;
-    /** Switch/boot: stop whatever runs, then start `index`'s vertical — atomically vs other lifecycle ops. */
+    /**
+     * Switch/boot: stop whatever runs, then start `index`'s vertical — atomically vs other
+     * lifecycle ops.
+     *
+     * #770: the destroyed check between the two halves settles the FACADE vector on its own.
+     * `_destroyed` flips synchronously at destroy() entry, so any closure that BEGINS executing
+     * after destroy() was called sees `true`, and any closure already past the check has
+     * facade.start() in flight — which destroy()'s own queued stop is necessarily ordered
+     * after. The TRANSPORT vector is not on this mutex at all; the ensureAlive() calls in
+     * switchToAddress are what cover it.
+     */
     private stopThenStartPaymentsV2;
     /**
      * Compose + start the payments vertical for ONE address (the §7 rule:
@@ -3717,6 +3872,12 @@ declare class Sphere {
     private startPaymentsV2Inner;
     /** P9 §7: stop the active vertical and await quiescence (in-flight ops settle). */
     private stopPaymentsV2Inner;
+    /**
+     * Refuse once destroy() has STARTED (#770). `_initialized` cannot carry this: destroy()
+     * clears it last, so every teardown step is a window in which a concurrent call still reads
+     * a ready Sphere and re-arms it.
+     */
+    private ensureAlive;
     private ensureReady;
     private emitEvent;
     private encrypt;
@@ -3725,7 +3886,6 @@ declare class Sphere {
 declare const createSphere: typeof Sphere.create;
 declare const loadSphere: typeof Sphere.load;
 declare const initSphere: typeof Sphere.init;
-declare const getSphere: typeof Sphere.getInstance;
 declare const sphereExists: typeof Sphere.exists;
 
 /**
@@ -4241,7 +4401,7 @@ interface TokenDefinition {
 /**
  * Network type for registry lookup
  */
-type RegistryNetwork = 'testnet' | 'mainnet' | 'dev';
+type RegistryNetwork = 'testnet' | 'testnet2' | 'mainnet';
 /**
  * Configuration options for remote registry refresh
  */
@@ -4275,7 +4435,7 @@ interface TokenRegistryConfig {
  *
  * // Usually called automatically by createBrowserProviders / createNodeProviders
  * TokenRegistry.configure({
- *   remoteUrl: 'https://raw.githubusercontent.com/.../unicity-ids.testnet.json',
+ *   remoteUrl: 'https://raw.githubusercontent.com/.../unicity-ids.testnet2.json',
  *   storage: myStorageProvider,
  * });
  *
@@ -4296,6 +4456,12 @@ declare class TokenRegistry {
     private lastRefreshAt;
     private refreshPromise;
     private initialLoadPromise;
+    /** Bumped on every remoteUrl change; loads started in an older generation are discarded. */
+    private generation;
+    /** Set by dispose(). A disposed registry starts no work and applies no late result. */
+    private disposed;
+    /** Cancels the in-flight fetch (and its abort timer) when the registry is disposed. */
+    private inFlight;
     private constructor();
     /**
      * Get singleton instance of TokenRegistry
@@ -4315,6 +4481,29 @@ declare class TokenRegistry {
      * @param options.autoRefresh - Start auto-refresh immediately (default: true)
      */
     static configure(options: TokenRegistryConfig): void;
+    /**
+     * Create an INDEPENDENT registry, not the process-global singleton.
+     *
+     * One Sphere owns one of these, so two Spheres on different networks cannot wipe each
+     * other's definitions — the singleton's `configure()` reaches into whatever instance
+     * exists and repoints it, which is how a mainnet init silently retargeted a live
+     * testnet2 wallet's decimals. Dispose it when the owner is destroyed.
+     */
+    static create(options: TokenRegistryConfig): TokenRegistry;
+    /** The body of configure(), on the instance, so owned registries share it exactly. */
+    private applyConfig;
+    /**
+     * Stop this registry for good: no timer, no late apply, no late cache write.
+     *
+     * Sphere.destroy() calls this on the registry it owns. Without it a discarded Sphere
+     * leaves an hourly fetch running forever — nothing in this file calls unref(), so in
+     * Node it also keeps the event loop alive.
+     */
+    dispose(): void;
+    /** Whether dispose() has been called. Reads still work; they are simply frozen. */
+    get isDisposed(): boolean;
+    /** Per-instance readiness — the same contract as the static, for an owned registry. */
+    waitForReady(timeoutMs?: number): Promise<boolean>;
     /**
      * Reset the singleton instance (useful for testing).
      * Stops auto-refresh if running.
@@ -4369,6 +4558,14 @@ declare class TokenRegistry {
      * Concurrent calls are deduplicated — only one fetch runs at a time.
      */
     refreshFromRemote(): Promise<boolean>;
+    /**
+     * Fetch with a bounded timeout, exposing a cancel hook to dispose().
+     *
+     * Both the request and its abort timer keep Node's event loop alive for the full
+     * FETCH_TIMEOUT_MS, so a registry disposed mid-flight must cancel them rather than
+     * merely ignore the result.
+     */
+    private fetchCancellable;
     private doRefresh;
     /**
      * Start periodic auto-refresh from the remote URL.
@@ -4460,99 +4657,21 @@ declare class TokenRegistry {
      */
     getCoinIdByName(name: string): string | undefined;
 }
+
 /**
- * Get token definition by coin ID
- * @param coinId - 64-character hex string
- * @returns Token definition or undefined
+ * Readers bound to the PROCESS-GLOBAL registry: with two Spheres alive they answer for
+ * whichever network configured it last. Prefer a Sphere-owned registry when it matters.
  */
+
 declare function getTokenDefinition(coinId: string): TokenDefinition | undefined;
-/**
- * Get token symbol by coin ID
- * @param coinId - 64-character hex string
- * @returns Symbol or truncated ID
- */
 declare function getTokenSymbol(coinId: string): string;
-/**
- * Get token name by coin ID
- * @param coinId - 64-character hex string
- * @returns Name or coin ID
- */
 declare function getTokenName(coinId: string): string;
-/**
- * Get token decimals by coin ID
- * @param coinId - 64-character hex string
- * @returns Decimals or 0
- */
 declare function getTokenDecimals(coinId: string): number;
-/**
- * Get token icon URL by coin ID
- * @param coinId - 64-character hex string
- * @param preferPng - Prefer PNG over SVG
- * @returns Icon URL or null
- */
 declare function getTokenIconUrl(coinId: string, preferPng?: boolean): string | null;
-/**
- * Check if coin ID is in registry
- * @param coinId - 64-character hex string
- * @returns true if known
- */
 declare function isKnownToken(coinId: string): boolean;
-/**
- * Get coin ID by symbol
- * @param symbol - Token symbol (e.g., "UCT")
- * @returns Coin ID or undefined
- */
 declare function getCoinIdBySymbol(symbol: string): string | undefined;
-/**
- * Get coin ID by name
- * @param name - Token name (e.g., "bitcoin")
- * @returns Coin ID or undefined
- */
 declare function getCoinIdByName(name: string): string | undefined;
-/**
- * Normalize a coin identifier to its canonical hash coinId.
- *
- * Accepts both symbolic names ("BTC", "ETH") and hash coinIds (64-char hex).
- * If the input is a short symbol, resolves it via the TokenRegistry.
- * Returns the input unchanged if it's already a hash coinId or unknown.
- *
- * @public
- *
- * @remarks
- * Heuristic: inputs matching `length <= 20 && /^[A-Za-z0-9]+$/` are treated
- * as symbolic names and looked up in the registry. Long inputs, hyphenated
- * inputs ("TOKEN-123"), or dotted inputs ("BTC.CASH") pass through unchanged.
- *
- * **Stability:** This function depends on `TokenRegistry` content. Adding a
- * new symbol that shadows a previously-unknown short alphanumeric coinId
- * changes normalization semantics retroactively. Consumers building stable
- * keys against this output should be aware that registry growth is a
- * non-breaking change *for unknown inputs* but a breaking change *for inputs
- * that newly resolve*.
- *
- * @param coinId - A symbolic name or hash coinId.
- * @returns The canonical hash coinId, or the original string if not resolvable.
- */
 declare function normalizeCoinId(coinId: string): string;
-/**
- * Compare two coin identifiers for equality, normalizing both sides.
- *
- * Handles mixed-format comparisons: "BTC" vs hash coinId, or two hash coinIds.
- * Both values are normalized to hash coinIds via the TokenRegistry before comparison.
- *
- * @public
- *
- * @remarks
- * Reflexive byte-equality short-circuit comes first; otherwise both sides
- * are normalized via {@link normalizeCoinId} and compared. Inherits the
- * registry-dependence caveat from `normalizeCoinId`. Two distinct symbols
- * that both fail to resolve will compare unequal even if they're semantic
- * aliases — register them as aliases in `TokenRegistry` for matching.
- *
- * @param a - First coin identifier (symbol or hash coinId).
- * @param b - Second coin identifier (symbol or hash coinId).
- * @returns true if both resolve to the same canonical coinId.
- */
 declare function coinIdsMatch(a: string, b: string): boolean;
 
 /**
@@ -4618,4 +4737,4 @@ declare function normalizeAddress(address: string): string;
  */
 declare function addressesMatch(a: string, b: string): boolean;
 
-export { AUTH_CHALLENGE_PREFIX, type AddressInfo, type AddressType, type AggregatorEvent, type AggregatorEventCallback, type AggregatorEventType, type AggregatorProvider, type Asset, type BaseProvider, type BroadcastHandler, type BroadcastMessage, COIN_TYPES, ChallengeTemplateError, type CheckNetworkHealthOptions, CoinGeckoPriceProvider, CommunicationsModule, type CommunicationsModuleConfig, type CommunicationsModuleDependencies, type ComposingIndicator, type ConversationPage, type CreateGroupOptions, DEFAULT_AGGREGATOR_TIMEOUT, DEFAULT_DERIVATION_PATH, DEFAULT_GROUP_RELAYS, DEFAULT_MARKET_API_URL, DEFAULT_NOSTR_RELAYS, type DecryptionProgressCallback, type DerivationMode, type DirectMessage, type DiscoverAddressProgress, type DiscoverAddressesOptions, type DiscoverAddressesResult, type DiscoveredAddress, type EncryptedData, FIELD_ENCRYPTION_HKDF_INFO, FIELD_ENVELOPE_MAX_BYTES, FIELD_ENVELOPE_NONCE_BYTES, FIELD_ENVELOPE_PREFIX, type FullIdentity, type GetConversationPageOptions, GroupChatModule, type GroupChatModuleConfig, type GroupChatModuleDependencies, type GroupData, type GroupMemberData, type GroupMessageData, GroupRole, GroupVisibility, type HealthCheckFn, type HistoryRecord, type Identity, type IdentityConfig, type IncomingBroadcast, type IncomingMessage, type IncomingTransfer, type InitProgress, type InitProgressCallback, type InitProgressStep, type IntentStatus, type IntentType, LIMITS, type LegacyFileParseResult, type LegacyFileParsedData, type LegacyFileType, type LogHandler, type LogLevel, type LoggerConfig, type MarketIntent, MarketModule, type MarketModuleConfig, type MarketModuleDependencies, type MessageHandler, NETWORKS, NIP29_KINDS, NOSTR_EVENT_KINDS, type NetworkHealthResult, type NetworkType, type OracleEvent, type OracleEventCallback, type OracleEventType, type OracleProvider, type ParsedAddress, PartialSendConflictError, type PeerInfo, type PostIntentRequest, type PostIntentResult, type PricePlatform, type PriceProvider, type PriceProviderConfig, type ProviderMetadata, type ProviderRole, type ProviderStatus, type ProviderStatusInfo, type RegistryNetwork, SIGN_MESSAGE_PREFIX, STORAGE_KEYS_ADDRESS, STORAGE_KEYS_GLOBAL, STORAGE_PREFIX, type SearchFilters, type SearchIntentResult, type SearchOptions, type SearchResult, type ServiceHealthResult, Sphere, type SphereCreateOptions, SphereError, type SphereErrorCode, type SphereEventHandler, type SphereEventMap, type SphereEventType, type SphereImportOptions, type SphereInitOptions, type SphereInitResult, type SphereLoadOptions, type SphereStatus, type StorageProvider, TEST_NOSTR_RELAYS, TIMEOUTS, type Token, type TokenDefinition, type TokenIcon, type TokenPrice, TokenRegistry, type TokenStatus, type TokenTransferDetail, type TrackedAddress, type TrackedAddressEntry, type HistoryRecord as TransactionHistoryEntry, type TransferRequest, type TransferResult, type TransferStatus, type TransportEvent, type TransportEventCallback, type TransportEventType, type TransportProvider, type WalletApiTransportConfig, type WalletInfo, type WalletJSON, type WalletJSONExportOptions, type WalletSource, addressesMatch, assertFieldEnvelopeShape, base58Decode, base58Encode, bytesToHex, checkNetworkHealth, coinIdsMatch, createCommunicationsModule, createGroupChatModule, createKeyPair, createMarketModule, createPriceProvider, createSphere, decrypt, decryptField, decryptFieldBytes, decryptJson, decryptMnemonic, decryptSimple, decryptTextFormatKey, decryptWithSalt, deriveAddressInfo, deriveChildKey, deriveFieldEncryptionKey, deriveKeyAtPath, doubleSha256, encrypt, encryptField, encryptFieldBytes, encryptMnemonic, encryptSimple, extractFromText, findPattern, formatAmount, generateAddressFromMasterKey, generateMasterKey, generateMnemonic, getAddressId, getAddressStorageKey, getCoinIdByName, getCoinIdBySymbol, getPublicKey, getSphere, getTokenDecimals, getTokenDefinition, getTokenIconUrl, getTokenName, getTokenSymbol, hash160, hashSignMessage, hexToBytes, identityFromMnemonicSync, initSphere, isKnownToken, isPossiblyCommittedSendOutcome, isSphereError, isTextWalletEncrypted, isValidAddress, isValidDirectAddress, isValidNametag, isValidPrivateKey, isWalletTextFormat, loadSphere, logger, mnemonicToSeedSync, normalizeAddress, normalizeCoinId, parseAddress, parseAndDecryptWalletText, parseTokenAmount, parseWalletText, randomBytes, randomHex, randomUUID, recoverPubkeyFromSignature, ripemd160, safeParseTokenAmount, sha256, signMessage, sleep, sphereExists, toHumanReadable, validateMnemonic, verifyChallengeTemplate, verifySignedMessage };
+export { AUTH_CHALLENGE_PREFIX, type AddressInfo, type AddressType, type AggregatorEvent, type AggregatorEventCallback, type AggregatorEventType, type AggregatorProvider, type Asset, type BaseProvider, type BroadcastHandler, type BroadcastMessage, COIN_TYPES, ChallengeTemplateError, type CheckNetworkHealthOptions, CoinGeckoPriceProvider, CommunicationsModule, type CommunicationsModuleConfig, type CommunicationsModuleDependencies, type ComposingIndicator, type ConversationPage, type CreateGroupOptions, DEFAULT_AGGREGATOR_TIMEOUT, DEFAULT_DERIVATION_PATH, DEFAULT_GROUP_RELAYS, DEFAULT_MARKET_API_URL, DEFAULT_NOSTR_RELAYS, type DecryptionProgressCallback, type DerivationMode, type DirectMessage, type DiscoverAddressProgress, type DiscoverAddressesOptions, type DiscoverAddressesResult, type DiscoveredAddress, type EncryptedData, FIELD_ENCRYPTION_HKDF_INFO, FIELD_ENVELOPE_MAX_BYTES, FIELD_ENVELOPE_NONCE_BYTES, FIELD_ENVELOPE_PREFIX, type FullIdentity, type GetConversationPageOptions, GroupChatModule, type GroupChatModuleConfig, type GroupChatModuleDependencies, type GroupData, type GroupMemberData, type GroupMessageData, GroupRole, GroupVisibility, type HealthCheckFn, type HistoryRecord, type Identity, type IdentityConfig, type IncomingBroadcast, type IncomingMessage, type IncomingTransfer, type InitProgress, type InitProgressCallback, type InitProgressStep, type IntentStatus, type IntentType, LIMITS, type LegacyFileParseResult, type LegacyFileParsedData, type LegacyFileType, type LogHandler, type LogLevel, type LoggerConfig, type MarketIntent, MarketModule, type MarketModuleConfig, type MarketModuleDependencies, type MessageHandler, NETWORKS, NIP29_KINDS, NOSTR_EVENT_KINDS, type NetworkHealthResult, type NetworkType, type OracleEvent, type OracleEventCallback, type OracleEventType, type OracleProvider, type ParsedAddress, PartialSendConflictError, type PeerInfo, type PostIntentRequest, type PostIntentResult, type PricePlatform, type PriceProvider, type PriceProviderConfig, type ProviderMetadata, type ProviderRole, type ProviderStatus, type ProviderStatusInfo, type RegistryNetwork, SIGN_MESSAGE_PREFIX, STORAGE_KEYS_ADDRESS, STORAGE_KEYS_GLOBAL, STORAGE_PREFIX, type SearchFilters, type SearchIntentResult, type SearchOptions, type SearchResult, type ServiceHealthResult, Sphere, type SphereCreateOptions, SphereError, type SphereErrorCode, type SphereEventHandler, type SphereEventMap, type SphereEventType, type SphereImportOptions, type SphereInitOptions, type SphereInitResult, type SphereLoadOptions, type SphereStatus, type StorageProvider, TEST_NOSTR_RELAYS, TIMEOUTS, type Token, type TokenDefinition, type TokenIcon, type TokenPrice, TokenRegistry, type TokenStatus, type TokenTransferDetail, type TrackedAddress, type TrackedAddressEntry, type HistoryRecord as TransactionHistoryEntry, type TransferRequest, type TransferResult, type TransferStatus, type TransportEvent, type TransportEventCallback, type TransportEventType, type TransportProvider, type WalletApiTransportConfig, type WalletInfo, type WalletJSON, type WalletJSONExportOptions, type WalletSource, addressesMatch, assertFieldEnvelopeShape, base58Decode, base58Encode, bytesToHex, checkNetworkHealth, coinIdsMatch, createCommunicationsModule, createGroupChatModule, createKeyPair, createMarketModule, createPriceProvider, createSphere, decrypt, decryptField, decryptFieldBytes, decryptJson, decryptMnemonic, decryptSimple, decryptTextFormatKey, decryptWithSalt, deriveAddressInfo, deriveChildKey, deriveFieldEncryptionKey, deriveKeyAtPath, doubleSha256, encrypt, encryptField, encryptFieldBytes, encryptMnemonic, encryptSimple, extractFromText, findPattern, formatAmount, generateAddressFromMasterKey, generateMasterKey, generateMnemonic, getAddressId, getAddressStorageKey, getCoinIdByName, getCoinIdBySymbol, getPublicKey, getTokenDecimals, getTokenDefinition, getTokenIconUrl, getTokenName, getTokenSymbol, hash160, hashSignMessage, hexToBytes, identityFromMnemonicSync, initSphere, isKnownToken, isPossiblyCommittedSendOutcome, isSphereError, isTextWalletEncrypted, isValidAddress, isValidDirectAddress, isValidNametag, isValidPrivateKey, isWalletTextFormat, loadSphere, logger, mnemonicToSeedSync, normalizeAddress, normalizeCoinId, parseAddress, parseAndDecryptWalletText, parseTokenAmount, parseWalletText, randomBytes, randomHex, randomUUID, recoverPubkeyFromSignature, ripemd160, safeParseTokenAmount, sha256, signMessage, sleep, sphereExists, toHumanReadable, validateMnemonic, verifyChallengeTemplate, verifySignedMessage };