@unicitylabs/sphere-sdk 0.4.7 → 0.4.9

package/dist/index.js

@@ -14,6 +14,228 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// constants.ts
+function getAddressStorageKey(addressId, key) {
+  return `${addressId}_${key}`;
+}
+function getAddressId(directAddress) {
+  let hash = directAddress;
+  if (hash.startsWith("DIRECT://")) {
+    hash = hash.slice(9);
+  } else if (hash.startsWith("DIRECT:")) {
+    hash = hash.slice(7);
+  }
+  const first = hash.slice(0, 6).toLowerCase();
+  const last = hash.slice(-6).toLowerCase();
+  return `DIRECT_${first}_${last}`;
+}
+var STORAGE_PREFIX, DEFAULT_ENCRYPTION_KEY, STORAGE_KEYS_GLOBAL, STORAGE_KEYS_ADDRESS, STORAGE_KEYS, DEFAULT_NOSTR_RELAYS, NOSTR_EVENT_KINDS, NIP29_KINDS, DEFAULT_AGGREGATOR_URL, DEV_AGGREGATOR_URL, TEST_AGGREGATOR_URL, DEFAULT_AGGREGATOR_TIMEOUT, DEFAULT_IPFS_GATEWAYS, DEFAULT_IPFS_BOOTSTRAP_PEERS, DEFAULT_BASE_PATH, DEFAULT_DERIVATION_PATH, COIN_TYPES, DEFAULT_ELECTRUM_URL, TEST_ELECTRUM_URL, TOKEN_REGISTRY_URL, TOKEN_REGISTRY_REFRESH_INTERVAL, TEST_NOSTR_RELAYS, DEFAULT_GROUP_RELAYS, NETWORKS, TIMEOUTS, LIMITS;
+var init_constants = __esm({
+  "constants.ts"() {
+    "use strict";
+    STORAGE_PREFIX = "sphere_";
+    DEFAULT_ENCRYPTION_KEY = "sphere-default-key";
+    STORAGE_KEYS_GLOBAL = {
+      /** Encrypted BIP39 mnemonic */
+      MNEMONIC: "mnemonic",
+      /** Encrypted master private key */
+      MASTER_KEY: "master_key",
+      /** BIP32 chain code */
+      CHAIN_CODE: "chain_code",
+      /** HD derivation path (full path like m/44'/0'/0'/0/0) */
+      DERIVATION_PATH: "derivation_path",
+      /** Base derivation path (like m/44'/0'/0' without chain/index) */
+      BASE_PATH: "base_path",
+      /** Derivation mode: bip32, wif_hmac, legacy_hmac */
+      DERIVATION_MODE: "derivation_mode",
+      /** Wallet source: mnemonic, file, unknown */
+      WALLET_SOURCE: "wallet_source",
+      /** Wallet existence flag */
+      WALLET_EXISTS: "wallet_exists",
+      /** Current active address index */
+      CURRENT_ADDRESS_INDEX: "current_address_index",
+      /** Nametag cache per address (separate from tracked addresses registry) */
+      ADDRESS_NAMETAGS: "address_nametags",
+      /** Active addresses registry (JSON: TrackedAddressesStorage) */
+      TRACKED_ADDRESSES: "tracked_addresses",
+      /** Last processed Nostr wallet event timestamp (unix seconds), keyed per pubkey */
+      LAST_WALLET_EVENT_TS: "last_wallet_event_ts",
+      /** Group chat: last used relay URL (stale data detection) — global, same relay for all addresses */
+      GROUP_CHAT_RELAY_URL: "group_chat_relay_url",
+      /** Cached token registry JSON (fetched from remote) */
+      TOKEN_REGISTRY_CACHE: "token_registry_cache",
+      /** Timestamp of last token registry cache update (ms since epoch) */
+      TOKEN_REGISTRY_CACHE_TS: "token_registry_cache_ts",
+      /** Cached price data JSON (from CoinGecko or other provider) */
+      PRICE_CACHE: "price_cache",
+      /** Timestamp of last price cache update (ms since epoch) */
+      PRICE_CACHE_TS: "price_cache_ts"
+    };
+    STORAGE_KEYS_ADDRESS = {
+      /** Pending transfers for this address */
+      PENDING_TRANSFERS: "pending_transfers",
+      /** Transfer outbox for this address */
+      OUTBOX: "outbox",
+      /** Conversations for this address */
+      CONVERSATIONS: "conversations",
+      /** Messages for this address */
+      MESSAGES: "messages",
+      /** Transaction history for this address */
+      TRANSACTION_HISTORY: "transaction_history",
+      /** Pending V5 finalization tokens (unconfirmed instant split tokens) */
+      PENDING_V5_TOKENS: "pending_v5_tokens",
+      /** Group chat: joined groups for this address */
+      GROUP_CHAT_GROUPS: "group_chat_groups",
+      /** Group chat: messages for this address */
+      GROUP_CHAT_MESSAGES: "group_chat_messages",
+      /** Group chat: members for this address */
+      GROUP_CHAT_MEMBERS: "group_chat_members",
+      /** Group chat: processed event IDs for deduplication */
+      GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events"
+    };
+    STORAGE_KEYS = {
+      ...STORAGE_KEYS_GLOBAL,
+      ...STORAGE_KEYS_ADDRESS
+    };
+    DEFAULT_NOSTR_RELAYS = [
+      "wss://relay.unicity.network",
+      "wss://relay.damus.io",
+      "wss://nos.lol",
+      "wss://relay.nostr.band"
+    ];
+    NOSTR_EVENT_KINDS = {
+      /** NIP-04 encrypted direct message */
+      DIRECT_MESSAGE: 4,
+      /** Token transfer (Unicity custom - 31113) */
+      TOKEN_TRANSFER: 31113,
+      /** Payment request (Unicity custom - 31115) */
+      PAYMENT_REQUEST: 31115,
+      /** Payment request response (Unicity custom - 31116) */
+      PAYMENT_REQUEST_RESPONSE: 31116,
+      /** Nametag binding (NIP-78 app-specific data) */
+      NAMETAG_BINDING: 30078,
+      /** Public broadcast */
+      BROADCAST: 1
+    };
+    NIP29_KINDS = {
+      /** Chat message sent to group */
+      CHAT_MESSAGE: 9,
+      /** Thread root message */
+      THREAD_ROOT: 11,
+      /** Thread reply message */
+      THREAD_REPLY: 12,
+      /** User join request */
+      JOIN_REQUEST: 9021,
+      /** User leave request */
+      LEAVE_REQUEST: 9022,
+      /** Admin: add/update user */
+      PUT_USER: 9e3,
+      /** Admin: remove user */
+      REMOVE_USER: 9001,
+      /** Admin: edit group metadata */
+      EDIT_METADATA: 9002,
+      /** Admin: delete event */
+      DELETE_EVENT: 9005,
+      /** Admin: create group */
+      CREATE_GROUP: 9007,
+      /** Admin: delete group */
+      DELETE_GROUP: 9008,
+      /** Admin: create invite code */
+      CREATE_INVITE: 9009,
+      /** Relay-signed group metadata */
+      GROUP_METADATA: 39e3,
+      /** Relay-signed group admins */
+      GROUP_ADMINS: 39001,
+      /** Relay-signed group members */
+      GROUP_MEMBERS: 39002,
+      /** Relay-signed group roles */
+      GROUP_ROLES: 39003
+    };
+    DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
+    DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
+    TEST_AGGREGATOR_URL = "https://goggregator-test.unicity.network";
+    DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
+    DEFAULT_IPFS_GATEWAYS = [
+      "https://unicity-ipfs1.dyndns.org"
+    ];
+    DEFAULT_IPFS_BOOTSTRAP_PEERS = [
+      "/dns4/unicity-ipfs2.dyndns.org/tcp/4001/p2p/12D3KooWLNi5NDPPHbrfJakAQqwBqymYTTwMQXQKEWuCrJNDdmfh",
+      "/dns4/unicity-ipfs3.dyndns.org/tcp/4001/p2p/12D3KooWQ4aujVE4ShLjdusNZBdffq3TbzrwT2DuWZY9H1Gxhwn6",
+      "/dns4/unicity-ipfs4.dyndns.org/tcp/4001/p2p/12D3KooWJ1ByPfUzUrpYvgxKU8NZrR8i6PU1tUgMEbQX9Hh2DEn1",
+      "/dns4/unicity-ipfs5.dyndns.org/tcp/4001/p2p/12D3KooWB1MdZZGHN5B8TvWXntbycfe7Cjcz7n6eZ9eykZadvmDv"
+    ];
+    DEFAULT_BASE_PATH = "m/44'/0'/0'";
+    DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
+    COIN_TYPES = {
+      /** ALPHA token (L1 blockchain) */
+      ALPHA: "ALPHA",
+      /** Test token */
+      TEST: "TEST"
+    };
+    DEFAULT_ELECTRUM_URL = "wss://fulcrum.unicity.network:50004";
+    TEST_ELECTRUM_URL = "wss://fulcrum.unicity.network:50004";
+    TOKEN_REGISTRY_URL = "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
+    TOKEN_REGISTRY_REFRESH_INTERVAL = 36e5;
+    TEST_NOSTR_RELAYS = [
+      "wss://nostr-relay.testnet.unicity.network"
+    ];
+    DEFAULT_GROUP_RELAYS = [
+      "wss://sphere-relay.unicity.network"
+    ];
+    NETWORKS = {
+      mainnet: {
+        name: "Mainnet",
+        aggregatorUrl: DEFAULT_AGGREGATOR_URL,
+        nostrRelays: DEFAULT_NOSTR_RELAYS,
+        ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+        electrumUrl: DEFAULT_ELECTRUM_URL,
+        groupRelays: DEFAULT_GROUP_RELAYS,
+        tokenRegistryUrl: TOKEN_REGISTRY_URL
+      },
+      testnet: {
+        name: "Testnet",
+        aggregatorUrl: TEST_AGGREGATOR_URL,
+        nostrRelays: TEST_NOSTR_RELAYS,
+        ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+        electrumUrl: TEST_ELECTRUM_URL,
+        groupRelays: DEFAULT_GROUP_RELAYS,
+        tokenRegistryUrl: TOKEN_REGISTRY_URL
+      },
+      dev: {
+        name: "Development",
+        aggregatorUrl: DEV_AGGREGATOR_URL,
+        nostrRelays: TEST_NOSTR_RELAYS,
+        ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+        electrumUrl: TEST_ELECTRUM_URL,
+        groupRelays: DEFAULT_GROUP_RELAYS,
+        tokenRegistryUrl: TOKEN_REGISTRY_URL
+      }
+    };
+    TIMEOUTS = {
+      /** WebSocket connection timeout */
+      WEBSOCKET_CONNECT: 1e4,
+      /** Nostr relay reconnect delay */
+      NOSTR_RECONNECT_DELAY: 3e3,
+      /** Max reconnect attempts */
+      MAX_RECONNECT_ATTEMPTS: 5,
+      /** Proof polling interval */
+      PROOF_POLL_INTERVAL: 1e3,
+      /** Sync interval */
+      SYNC_INTERVAL: 6e4
+    };
+    LIMITS = {
+      /** Min nametag length */
+      NAMETAG_MIN_LENGTH: 3,
+      /** Max nametag length */
+      NAMETAG_MAX_LENGTH: 20,
+      /** Max memo length */
+      MEMO_MAX_LENGTH: 500,
+      /** Max message length */
+      MESSAGE_MAX_LENGTH: 1e4
+    };
+  }
+});
+
 // core/bech32.ts
 function convertBits(data, fromBits, toBits, pad) {
   let acc = 0;
@@ -424,13 +646,16 @@ function disconnect() {
     if (cb.timeoutId) clearTimeout(cb.timeoutId);
   });
   connectionCallbacks.length = 0;
+  blockSubscribers.length = 0;
+  lastBlockHeader = null;
 }
 var DEFAULT_ENDPOINT, ws, isConnected, isConnecting, requestId, intentionalClose, reconnectAttempts, isBlockSubscribed, lastBlockHeader, pending, blockSubscribers, connectionCallbacks, MAX_RECONNECT_ATTEMPTS, BASE_DELAY, MAX_DELAY, RPC_TIMEOUT, CONNECTION_TIMEOUT;
 var init_network = __esm({
   "l1/network.ts"() {
     "use strict";
     init_addressToScriptHash();
-    DEFAULT_ENDPOINT = "wss://fulcrum.unicity.network:50004";
+    init_constants();
+    DEFAULT_ENDPOINT = DEFAULT_ELECTRUM_URL;
     ws = null;
     isConnected = false;
     isConnecting = false;
@@ -450,6 +675,9 @@ var init_network = __esm({
   }
 });
 
+// modules/payments/L1PaymentsModule.ts
+init_constants();
+
 // l1/index.ts
 var l1_exports = {};
 __export(l1_exports, {
@@ -1635,7 +1863,7 @@ var L1PaymentsModule = class {
   _transport;
   constructor(config) {
     this._config = {
-      electrumUrl: config?.electrumUrl ?? "wss://fulcrum.unicity.network:50004",
+      electrumUrl: config?.electrumUrl ?? DEFAULT_ELECTRUM_URL,
       network: config?.network ?? "mainnet",
       defaultFeeRate: config?.defaultFeeRate ?? 10,
       enableVesting: config?.enableVesting ?? true
@@ -2475,221 +2703,8 @@ var NametagMinter = class {
   }
 };
 
-// constants.ts
-var STORAGE_PREFIX = "sphere_";
-var DEFAULT_ENCRYPTION_KEY = "sphere-default-key";
-var STORAGE_KEYS_GLOBAL = {
-  /** Encrypted BIP39 mnemonic */
-  MNEMONIC: "mnemonic",
-  /** Encrypted master private key */
-  MASTER_KEY: "master_key",
-  /** BIP32 chain code */
-  CHAIN_CODE: "chain_code",
-  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
-  DERIVATION_PATH: "derivation_path",
-  /** Base derivation path (like m/44'/0'/0' without chain/index) */
-  BASE_PATH: "base_path",
-  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
-  DERIVATION_MODE: "derivation_mode",
-  /** Wallet source: mnemonic, file, unknown */
-  WALLET_SOURCE: "wallet_source",
-  /** Wallet existence flag */
-  WALLET_EXISTS: "wallet_exists",
-  /** Current active address index */
-  CURRENT_ADDRESS_INDEX: "current_address_index",
-  /** Nametag cache per address (separate from tracked addresses registry) */
-  ADDRESS_NAMETAGS: "address_nametags",
-  /** Active addresses registry (JSON: TrackedAddressesStorage) */
-  TRACKED_ADDRESSES: "tracked_addresses",
-  /** Last processed Nostr wallet event timestamp (unix seconds), keyed per pubkey */
-  LAST_WALLET_EVENT_TS: "last_wallet_event_ts",
-  /** Group chat: last used relay URL (stale data detection) — global, same relay for all addresses */
-  GROUP_CHAT_RELAY_URL: "group_chat_relay_url",
-  /** Cached token registry JSON (fetched from remote) */
-  TOKEN_REGISTRY_CACHE: "token_registry_cache",
-  /** Timestamp of last token registry cache update (ms since epoch) */
-  TOKEN_REGISTRY_CACHE_TS: "token_registry_cache_ts",
-  /** Cached price data JSON (from CoinGecko or other provider) */
-  PRICE_CACHE: "price_cache",
-  /** Timestamp of last price cache update (ms since epoch) */
-  PRICE_CACHE_TS: "price_cache_ts"
-};
-var STORAGE_KEYS_ADDRESS = {
-  /** Pending transfers for this address */
-  PENDING_TRANSFERS: "pending_transfers",
-  /** Transfer outbox for this address */
-  OUTBOX: "outbox",
-  /** Conversations for this address */
-  CONVERSATIONS: "conversations",
-  /** Messages for this address */
-  MESSAGES: "messages",
-  /** Transaction history for this address */
-  TRANSACTION_HISTORY: "transaction_history",
-  /** Pending V5 finalization tokens (unconfirmed instant split tokens) */
-  PENDING_V5_TOKENS: "pending_v5_tokens",
-  /** Group chat: joined groups for this address */
-  GROUP_CHAT_GROUPS: "group_chat_groups",
-  /** Group chat: messages for this address */
-  GROUP_CHAT_MESSAGES: "group_chat_messages",
-  /** Group chat: members for this address */
-  GROUP_CHAT_MEMBERS: "group_chat_members",
-  /** Group chat: processed event IDs for deduplication */
-  GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events"
-};
-var STORAGE_KEYS = {
-  ...STORAGE_KEYS_GLOBAL,
-  ...STORAGE_KEYS_ADDRESS
-};
-function getAddressStorageKey(addressId, key) {
-  return `${addressId}_${key}`;
-}
-function getAddressId(directAddress) {
-  let hash = directAddress;
-  if (hash.startsWith("DIRECT://")) {
-    hash = hash.slice(9);
-  } else if (hash.startsWith("DIRECT:")) {
-    hash = hash.slice(7);
-  }
-  const first = hash.slice(0, 6).toLowerCase();
-  const last = hash.slice(-6).toLowerCase();
-  return `DIRECT_${first}_${last}`;
-}
-var DEFAULT_NOSTR_RELAYS = [
-  "wss://relay.unicity.network",
-  "wss://relay.damus.io",
-  "wss://nos.lol",
-  "wss://relay.nostr.band"
-];
-var NOSTR_EVENT_KINDS = {
-  /** NIP-04 encrypted direct message */
-  DIRECT_MESSAGE: 4,
-  /** Token transfer (Unicity custom - 31113) */
-  TOKEN_TRANSFER: 31113,
-  /** Payment request (Unicity custom - 31115) */
-  PAYMENT_REQUEST: 31115,
-  /** Payment request response (Unicity custom - 31116) */
-  PAYMENT_REQUEST_RESPONSE: 31116,
-  /** Nametag binding (NIP-78 app-specific data) */
-  NAMETAG_BINDING: 30078,
-  /** Public broadcast */
-  BROADCAST: 1
-};
-var NIP29_KINDS = {
-  /** Chat message sent to group */
-  CHAT_MESSAGE: 9,
-  /** Thread root message */
-  THREAD_ROOT: 11,
-  /** Thread reply message */
-  THREAD_REPLY: 12,
-  /** User join request */
-  JOIN_REQUEST: 9021,
-  /** User leave request */
-  LEAVE_REQUEST: 9022,
-  /** Admin: add/update user */
-  PUT_USER: 9e3,
-  /** Admin: remove user */
-  REMOVE_USER: 9001,
-  /** Admin: edit group metadata */
-  EDIT_METADATA: 9002,
-  /** Admin: delete event */
-  DELETE_EVENT: 9005,
-  /** Admin: create group */
-  CREATE_GROUP: 9007,
-  /** Admin: delete group */
-  DELETE_GROUP: 9008,
-  /** Admin: create invite code */
-  CREATE_INVITE: 9009,
-  /** Relay-signed group metadata */
-  GROUP_METADATA: 39e3,
-  /** Relay-signed group admins */
-  GROUP_ADMINS: 39001,
-  /** Relay-signed group members */
-  GROUP_MEMBERS: 39002,
-  /** Relay-signed group roles */
-  GROUP_ROLES: 39003
-};
-var DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
-var DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
-var TEST_AGGREGATOR_URL = "https://goggregator-test.unicity.network";
-var DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
-var DEFAULT_IPFS_GATEWAYS = [
-  "https://unicity-ipfs1.dyndns.org"
-];
-var DEFAULT_IPFS_BOOTSTRAP_PEERS = [
-  "/dns4/unicity-ipfs2.dyndns.org/tcp/4001/p2p/12D3KooWLNi5NDPPHbrfJakAQqwBqymYTTwMQXQKEWuCrJNDdmfh",
-  "/dns4/unicity-ipfs3.dyndns.org/tcp/4001/p2p/12D3KooWQ4aujVE4ShLjdusNZBdffq3TbzrwT2DuWZY9H1Gxhwn6",
-  "/dns4/unicity-ipfs4.dyndns.org/tcp/4001/p2p/12D3KooWJ1ByPfUzUrpYvgxKU8NZrR8i6PU1tUgMEbQX9Hh2DEn1",
-  "/dns4/unicity-ipfs5.dyndns.org/tcp/4001/p2p/12D3KooWB1MdZZGHN5B8TvWXntbycfe7Cjcz7n6eZ9eykZadvmDv"
-];
-var DEFAULT_BASE_PATH = "m/44'/0'/0'";
-var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
-var COIN_TYPES = {
-  /** ALPHA token (L1 blockchain) */
-  ALPHA: "ALPHA",
-  /** Test token */
-  TEST: "TEST"
-};
-var DEFAULT_ELECTRUM_URL = "wss://fulcrum.alpha.unicity.network:50004";
-var TEST_ELECTRUM_URL = "wss://fulcrum.alpha.testnet.unicity.network:50004";
-var TOKEN_REGISTRY_URL = "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
-var TOKEN_REGISTRY_REFRESH_INTERVAL = 36e5;
-var TEST_NOSTR_RELAYS = [
-  "wss://nostr-relay.testnet.unicity.network"
-];
-var DEFAULT_GROUP_RELAYS = [
-  "wss://sphere-relay.unicity.network"
-];
-var NETWORKS = {
-  mainnet: {
-    name: "Mainnet",
-    aggregatorUrl: DEFAULT_AGGREGATOR_URL,
-    nostrRelays: DEFAULT_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: DEFAULT_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS,
-    tokenRegistryUrl: TOKEN_REGISTRY_URL
-  },
-  testnet: {
-    name: "Testnet",
-    aggregatorUrl: TEST_AGGREGATOR_URL,
-    nostrRelays: TEST_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: TEST_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS,
-    tokenRegistryUrl: TOKEN_REGISTRY_URL
-  },
-  dev: {
-    name: "Development",
-    aggregatorUrl: DEV_AGGREGATOR_URL,
-    nostrRelays: TEST_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: TEST_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS,
-    tokenRegistryUrl: TOKEN_REGISTRY_URL
-  }
-};
-var TIMEOUTS = {
-  /** WebSocket connection timeout */
-  WEBSOCKET_CONNECT: 1e4,
-  /** Nostr relay reconnect delay */
-  NOSTR_RECONNECT_DELAY: 3e3,
-  /** Max reconnect attempts */
-  MAX_RECONNECT_ATTEMPTS: 5,
-  /** Proof polling interval */
-  PROOF_POLL_INTERVAL: 1e3,
-  /** Sync interval */
-  SYNC_INTERVAL: 6e4
-};
-var LIMITS = {
-  /** Min nametag length */
-  NAMETAG_MIN_LENGTH: 3,
-  /** Max nametag length */
-  NAMETAG_MAX_LENGTH: 20,
-  /** Max memo length */
-  MEMO_MAX_LENGTH: 500,
-  /** Max message length */
-  MESSAGE_MAX_LENGTH: 1e4
-};
+// modules/payments/PaymentsModule.ts
+init_constants();
 
 // types/txf.ts
 var ARCHIVED_PREFIX = "archived-";
@@ -2734,6 +2749,7 @@ function isValidTokenId(tokenId) {
 }
 
 // registry/TokenRegistry.ts
+init_constants();
 var FETCH_TIMEOUT_MS = 1e4;
 var TokenRegistry = class _TokenRegistry {
   static instance = null;
@@ -7631,6 +7647,7 @@ import { HashAlgorithm as HashAlgorithm6 } from "@unicitylabs/state-transition-s
 import { UnmaskedPredicate as UnmaskedPredicate6 } from "@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate";
 
 // modules/communications/CommunicationsModule.ts
+init_constants();
 var CommunicationsModule = class {
   config;
   deps = null;
@@ -8105,6 +8122,7 @@ function createCommunicationsModule(config) {
 }
 
 // modules/groupchat/GroupChatModule.ts
+init_constants();
 import {
   NostrClient,
   NostrKeyManager,
@@ -11954,6 +11972,9 @@ function createMarketModule(config) {
   return new MarketModule(config);
 }
 
+// core/Sphere.ts
+init_constants();
+
 // core/encryption.ts
 import CryptoJS6 from "crypto-js";
 function encryptSimple(plaintext, password) {
@@ -12057,6 +12078,72 @@ async function scanAddressesImpl(deriveAddress, options = {}) {
   };
 }
 
+// core/discover.ts
+async function discoverAddressesImpl(deriveTransportPubkey, batchResolve, options = {}) {
+  const maxAddresses = options.maxAddresses ?? 50;
+  const gapLimit = options.gapLimit ?? 20;
+  const batchSize = options.batchSize ?? 20;
+  const { onProgress, signal } = options;
+  const discovered = /* @__PURE__ */ new Map();
+  let consecutiveEmpty = 0;
+  let scanned = 0;
+  const totalBatches = Math.ceil(maxAddresses / batchSize);
+  for (let batchStart = 0; batchStart < maxAddresses; batchStart += batchSize) {
+    if (signal?.aborted) break;
+    if (consecutiveEmpty >= gapLimit) break;
+    const batchEnd = Math.min(batchStart + batchSize, maxAddresses);
+    const batchIndices = [];
+    const pubkeyToIndex = /* @__PURE__ */ new Map();
+    const pubkeyToInfo = /* @__PURE__ */ new Map();
+    for (let i = batchStart; i < batchEnd; i++) {
+      const info = deriveTransportPubkey(i);
+      batchIndices.push(i);
+      pubkeyToIndex.set(info.transportPubkey, i);
+      pubkeyToInfo.set(info.transportPubkey, info);
+    }
+    const batchPubkeys = Array.from(pubkeyToIndex.keys());
+    onProgress?.({
+      currentBatch: Math.floor(batchStart / batchSize) + 1,
+      totalBatches,
+      discoveredCount: discovered.size,
+      currentGap: consecutiveEmpty,
+      phase: "transport"
+    });
+    const peerInfos = await batchResolve(batchPubkeys);
+    const foundInBatch = /* @__PURE__ */ new Set();
+    for (const peer of peerInfos) {
+      const index = pubkeyToIndex.get(peer.transportPubkey);
+      if (index !== void 0) {
+        foundInBatch.add(index);
+        const derived = pubkeyToInfo.get(peer.transportPubkey);
+        discovered.set(index, {
+          index,
+          l1Address: peer.l1Address || derived.l1Address,
+          directAddress: peer.directAddress || derived.directAddress,
+          chainPubkey: peer.chainPubkey || derived.chainPubkey,
+          nametag: peer.nametag,
+          l1Balance: 0,
+          source: "transport"
+        });
+      }
+    }
+    for (const idx of batchIndices) {
+      scanned++;
+      if (foundInBatch.has(idx)) {
+        consecutiveEmpty = 0;
+      } else {
+        consecutiveEmpty++;
+        if (consecutiveEmpty >= gapLimit) break;
+      }
+    }
+  }
+  return {
+    addresses: Array.from(discovered.values()).sort((a, b) => a.index - b.index),
+    scannedCount: scanned,
+    aborted: signal?.aborted ?? false
+  };
+}
+
 // core/Sphere.ts
 init_network();
 
@@ -12879,7 +12966,9 @@ var Sphere = class _Sphere {
         price: options.price,
         groupChat,
         market,
-        password: options.password
+        password: options.password,
+        discoverAddresses: options.discoverAddresses,
+        onProgress: options.onProgress
       });
       return { sphere: sphere2, created: false };
     }
@@ -12907,7 +12996,9 @@ var Sphere = class _Sphere {
       price: options.price,
       groupChat,
       market,
-      password: options.password
+      password: options.password,
+      discoverAddresses: options.discoverAddresses,
+      onProgress: options.onProgress
     });
     return { sphere, created: true, generatedMnemonic };
   }
@@ -12968,6 +13059,7 @@ var Sphere = class _Sphere {
     if (await _Sphere.exists(options.storage)) {
       throw new Error("Wallet already exists. Use Sphere.load() or Sphere.clear() first.");
     }
+    const progress = options.onProgress;
     if (!options.storage.isConnected()) {
       await options.storage.connect();
     }
@@ -12985,20 +13077,39 @@ var Sphere = class _Sphere {
       marketConfig
     );
     sphere._password = options.password ?? null;
+    progress?.({ step: "storing_keys", message: "Storing wallet keys..." });
     await sphere.storeMnemonic(options.mnemonic, options.derivationPath);
     await sphere.initializeIdentityFromMnemonic(options.mnemonic, options.derivationPath);
+    progress?.({ step: "initializing", message: "Initializing wallet..." });
     await sphere.initializeProviders();
     await sphere.initializeModules();
+    progress?.({ step: "finalizing", message: "Finalizing wallet..." });
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
     _Sphere.instance = sphere;
     await sphere.ensureAddressTracked(0);
     if (options.nametag) {
+      progress?.({ step: "registering_nametag", message: "Registering nametag..." });
       await sphere.registerNametag(options.nametag);
     } else {
+      progress?.({ step: "recovering_nametag", message: "Recovering nametag..." });
       await sphere.recoverNametagFromTransport();
+      progress?.({ step: "syncing_identity", message: "Publishing identity..." });
       await sphere.syncIdentityWithTransport();
     }
+    if (options.discoverAddresses !== false && sphere._transport.discoverAddresses) {
+      progress?.({ step: "discovering_addresses", message: "Discovering addresses..." });
+      try {
+        const discoverOpts = typeof options.discoverAddresses === "object" ? { ...options.discoverAddresses, autoTrack: options.discoverAddresses.autoTrack ?? true } : { autoTrack: true };
+        const result = await sphere.discoverAddresses(discoverOpts);
+        if (result.addresses.length > 0) {
+          console.log(`[Sphere.create] Address discovery: found ${result.addresses.length} address(es)`);
+        }
+      } catch (err) {
+        console.warn("[Sphere.create] Address discovery failed (non-fatal):", err);
+      }
+    }
+    progress?.({ step: "complete", message: "Wallet created" });
     return sphere;
   }
   /**
@@ -13008,6 +13119,7 @@ var Sphere = class _Sphere {
     if (!await _Sphere.exists(options.storage)) {
       throw new Error("No wallet found. Use Sphere.create() to create a new wallet.");
     }
+    const progress = options.onProgress;
     _Sphere.configureTokenRegistry(options.storage, options.network);
     const groupChatConfig = _Sphere.resolveGroupChatConfig(options.groupChat, options.network);
     const marketConfig = _Sphere.resolveMarketConfig(options.market);
@@ -13025,13 +13137,17 @@ var Sphere = class _Sphere {
     if (!options.storage.isConnected()) {
       await options.storage.connect();
     }
+    progress?.({ step: "storing_keys", message: "Loading wallet keys..." });
     await sphere.loadIdentityFromStorage();
+    progress?.({ step: "initializing", message: "Initializing wallet..." });
     await sphere.initializeProviders();
     await sphere.initializeModules();
+    progress?.({ step: "syncing_identity", message: "Publishing identity..." });
     await sphere.syncIdentityWithTransport();
     sphere._initialized = true;
     _Sphere.instance = sphere;
     if (sphere._identity?.nametag && !sphere._payments.hasNametag()) {
+      progress?.({ step: "registering_nametag", message: "Restoring nametag token..." });
       console.log(`[Sphere] Nametag @${sphere._identity.nametag} has no token, attempting to mint...`);
       try {
         const result = await sphere.mintNametag(sphere._identity.nametag);
@@ -13044,6 +13160,19 @@ var Sphere = class _Sphere {
         console.warn(`[Sphere] Nametag token mint failed:`, err);
       }
     }
+    if (options.discoverAddresses !== false && sphere._transport.discoverAddresses && sphere._masterKey) {
+      progress?.({ step: "discovering_addresses", message: "Discovering addresses..." });
+      try {
+        const discoverOpts = typeof options.discoverAddresses === "object" ? { ...options.discoverAddresses, autoTrack: options.discoverAddresses.autoTrack ?? true } : { autoTrack: true };
+        const result = await sphere.discoverAddresses(discoverOpts);
+        if (result.addresses.length > 0) {
+          console.log(`[Sphere.load] Address discovery: found ${result.addresses.length} address(es)`);
+        }
+      } catch (err) {
+        console.warn("[Sphere.load] Address discovery failed (non-fatal):", err);
+      }
+    }
+    progress?.({ step: "complete", message: "Wallet loaded" });
     return sphere;
   }
   /**
@@ -13053,9 +13182,11 @@ var Sphere = class _Sphere {
     if (!options.mnemonic && !options.masterKey) {
       throw new Error("Either mnemonic or masterKey is required");
     }
+    const progress = options.onProgress;
     console.log("[Sphere.import] Starting import...");
     const needsClear = _Sphere.instance !== null || await _Sphere.exists(options.storage);
     if (needsClear) {
+      progress?.({ step: "clearing", message: "Clearing previous wallet data..." });
       console.log("[Sphere.import] Clearing existing wallet data...");
       await _Sphere.clear({ storage: options.storage, tokenStorage: options.tokenStorage });
       console.log("[Sphere.import] Clear done");
@@ -13080,6 +13211,7 @@ var Sphere = class _Sphere {
       marketConfig
     );
     sphere._password = options.password ?? null;
+    progress?.({ step: "storing_keys", message: "Storing wallet keys..." });
     if (options.mnemonic) {
       if (!_Sphere.validateMnemonic(options.mnemonic)) {
         throw new Error("Invalid mnemonic");
@@ -13104,17 +13236,21 @@ var Sphere = class _Sphere {
         options.derivationPath
       );
     }
+    progress?.({ step: "initializing", message: "Initializing wallet..." });
     console.log("[Sphere.import] Initializing providers...");
     await sphere.initializeProviders();
     console.log("[Sphere.import] Providers initialized. Initializing modules...");
     await sphere.initializeModules();
     console.log("[Sphere.import] Modules initialized");
     if (!options.nametag) {
+      progress?.({ step: "recovering_nametag", message: "Recovering nametag..." });
       console.log("[Sphere.import] Recovering nametag from transport...");
       await sphere.recoverNametagFromTransport();
       console.log("[Sphere.import] Nametag recovery done");
+      progress?.({ step: "syncing_identity", message: "Publishing identity..." });
       await sphere.syncIdentityWithTransport();
     }
+    progress?.({ step: "finalizing", message: "Finalizing wallet..." });
     console.log("[Sphere.import] Finalizing wallet creation...");
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
@@ -13122,10 +13258,12 @@ var Sphere = class _Sphere {
     console.log("[Sphere.import] Tracking address 0...");
     await sphere.ensureAddressTracked(0);
     if (options.nametag) {
+      progress?.({ step: "registering_nametag", message: "Registering nametag..." });
       console.log("[Sphere.import] Registering nametag...");
       await sphere.registerNametag(options.nametag);
     }
     if (sphere._tokenStorageProviders.size > 0) {
+      progress?.({ step: "syncing_tokens", message: "Syncing tokens..." });
       try {
         const syncResult = await sphere._payments.sync();
         console.log(`[Sphere.import] Auto-sync: +${syncResult.added} -${syncResult.removed}`);
@@ -13133,6 +13271,19 @@ var Sphere = class _Sphere {
         console.warn("[Sphere.import] Auto-sync failed (non-fatal):", err);
       }
     }
+    if (options.discoverAddresses !== false && sphere._transport.discoverAddresses) {
+      progress?.({ step: "discovering_addresses", message: "Discovering addresses..." });
+      try {
+        const discoverOpts = typeof options.discoverAddresses === "object" ? { ...options.discoverAddresses, autoTrack: options.discoverAddresses.autoTrack ?? true } : { autoTrack: true };
+        const result = await sphere.discoverAddresses(discoverOpts);
+        if (result.addresses.length > 0) {
+          console.log(`[Sphere.import] Address discovery: found ${result.addresses.length} address(es)`);
+        }
+      } catch (err) {
+        console.warn("[Sphere.import] Address discovery failed (non-fatal):", err);
+      }
+    }
+    progress?.({ step: "complete", message: "Import complete" });
     console.log("[Sphere.import] Import complete");
     return sphere;
   }
@@ -14001,6 +14152,23 @@ var Sphere = class _Sphere {
       await provider.initialize();
     }
     await this.reinitializeModulesForNewAddress();
+    this.emitEvent("identity:changed", {
+      l1Address: this._identity.l1Address,
+      directAddress: this._identity.directAddress,
+      chainPubkey: this._identity.chainPubkey,
+      nametag: this._identity.nametag,
+      addressIndex: index
+    });
+    console.log(`[Sphere] Switched to address ${index}:`, this._identity.l1Address);
+    this.postSwitchSync(index, newNametag).catch((err) => {
+      console.warn(`[Sphere] Post-switch sync failed for address ${index}:`, err);
+    });
+  }
+  /**
+   * Background transport sync and nametag operations after address switch.
+   * Runs after switchToAddress returns so L1/L3 queries can start immediately.
+   */
+  async postSwitchSync(index, newNametag) {
     if (!newNametag) {
       await this.syncIdentityWithTransport();
     }
@@ -14023,7 +14191,7 @@ var Sphere = class _Sphere {
         nametag: newNametag,
         addressIndex: index
       });
-    } else if (this._identity.nametag && !this._payments.hasNametag()) {
+    } else if (this._identity?.nametag && !this._payments.hasNametag()) {
       console.log(`[Sphere] Nametag @${this._identity.nametag} has no token after switch, minting...`);
       try {
         const result = await this.mintNametag(this._identity.nametag);
@@ -14036,14 +14204,6 @@ var Sphere = class _Sphere {
         console.warn(`[Sphere] Nametag token mint failed after switch:`, err);
       }
     }
-    this.emitEvent("identity:changed", {
-      l1Address: this._identity.l1Address,
-      directAddress: this._identity.directAddress,
-      chainPubkey: this._identity.chainPubkey,
-      nametag: this._identity.nametag,
-      addressIndex: index
-    });
-    console.log(`[Sphere] Switched to address ${index}:`, this._identity.l1Address);
   }
   /**
    * Re-initialize modules after address switch
@@ -14250,6 +14410,98 @@ var Sphere = class _Sphere {
     await this.persistTrackedAddresses();
     await this.persistAddressNametags();
   }
+  /**
+   * Discover previously used HD addresses.
+   *
+   * Primary: queries Nostr relay for identity binding events (fast, single batch query).
+   * Secondary: runs L1 balance scan to find legacy addresses with no binding event.
+   *
+   * @example
+   * ```ts
+   * const result = await sphere.discoverAddresses();
+   * console.log(`Found ${result.addresses.length} addresses`);
+   *
+   * // With auto-tracking
+   * await sphere.discoverAddresses({ autoTrack: true });
+   * ```
+   */
+  async discoverAddresses(options = {}) {
+    this.ensureReady();
+    if (!this._masterKey) {
+      throw new Error("Address discovery requires HD master key");
+    }
+    if (!this._transport.discoverAddresses) {
+      throw new Error("Transport provider does not support address discovery");
+    }
+    const includeL1Scan = options.includeL1Scan ?? true;
+    const transportResult = await discoverAddressesImpl(
+      (index) => {
+        const addrInfo = this._deriveAddressInternal(index, false);
+        return {
+          transportPubkey: addrInfo.publicKey.slice(2),
+          // x-only 32 bytes
+          chainPubkey: addrInfo.publicKey,
+          l1Address: addrInfo.address,
+          directAddress: ""
+          // not needed for discovery query
+        };
+      },
+      (pubkeys) => this._transport.discoverAddresses(pubkeys),
+      options
+    );
+    if (includeL1Scan) {
+      try {
+        const l1Result = await this.scanAddresses({
+          maxAddresses: options.maxAddresses,
+          gapLimit: options.gapLimit,
+          signal: options.signal,
+          onProgress: options.onProgress ? (p) => options.onProgress({
+            currentBatch: 0,
+            totalBatches: 0,
+            discoveredCount: p.foundCount,
+            currentGap: p.currentGap,
+            phase: "l1"
+          }) : void 0
+        });
+        for (const l1Addr of l1Result.addresses) {
+          if (l1Addr.isChange) continue;
+          const existing = transportResult.addresses.find((a) => a.index === l1Addr.index);
+          if (existing) {
+            existing.l1Balance = l1Addr.balance;
+            existing.source = "both";
+            if (!existing.nametag && l1Addr.nametag) {
+              existing.nametag = l1Addr.nametag;
+            }
+          } else {
+            const addrInfo = this._deriveAddressInternal(l1Addr.index, false);
+            transportResult.addresses.push({
+              index: l1Addr.index,
+              l1Address: l1Addr.address,
+              directAddress: "",
+              chainPubkey: addrInfo.publicKey,
+              nametag: l1Addr.nametag,
+              l1Balance: l1Addr.balance,
+              source: "l1"
+            });
+          }
+        }
+        transportResult.addresses.sort((a, b) => a.index - b.index);
+      } catch (err) {
+        console.warn("[Sphere] L1 scan failed during discovery (non-fatal):", err);
+      }
+    }
+    if (options.autoTrack && transportResult.addresses.length > 0) {
+      await this.trackScannedAddresses(
+        transportResult.addresses.map((a) => ({
+          index: a.index,
+          // Preserve existing hidden state; default to false for newly discovered
+          hidden: this._trackedAddresses.get(a.index)?.hidden ?? false,
+          nametag: a.nametag
+        }))
+      );
+    }
+    return transportResult;
+  }
   // ===========================================================================
   // Public Methods - Status
   // ===========================================================================
@@ -14821,6 +15073,17 @@ var Sphere = class _Sphere {
                 return;
               }
             }
+            const needsUpdate = !existing.directAddress || !existing.l1Address || !existing.chainPubkey || this._identity?.nametag && !existing.nametag;
+            if (needsUpdate) {
+              console.log("[Sphere] Existing binding incomplete, re-publishing with full data");
+              await this._transport.publishIdentityBinding(
+                this._identity.chainPubkey,
+                this._identity.l1Address,
+                this._identity.directAddress || "",
+                this._identity?.nametag || existing.nametag || void 0
+              );
+              return;
+            }
             console.log("[Sphere] Existing binding found, skipping re-publish");
             return;
           }
@@ -15309,6 +15572,7 @@ function formatAmount(amount, options = {}) {
 init_bech32();
 
 // core/network-health.ts
+init_constants();
 var DEFAULT_TIMEOUT_MS = 5e3;
 async function checkNetworkHealth(network = "testnet", options) {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -15494,6 +15758,9 @@ async function runCustomCheck(name, checkFn, timeoutMs) {
   }
 }
 
+// index.ts
+init_constants();
+
 // types/payment-session.ts
 function createPaymentSession(params) {
   const now = Date.now();
@@ -15565,6 +15832,9 @@ var SphereError = class extends Error {
   }
 };
 
+// index.ts
+init_constants();
+
 // validation/token-validator.ts
 var TokenValidator = class {
   aggregatorClient = null;
@@ -15898,6 +16168,7 @@ import {
 } from "@unicitylabs/nostr-js-sdk";
 
 // price/CoinGeckoPriceProvider.ts
+init_constants();
 var CoinGeckoPriceProvider = class {
   platform = "coingecko";
   cache = /* @__PURE__ */ new Map();