@unicitylabs/sphere-sdk 0.2.1 → 0.2.2

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,218 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  COIN_TYPES: () => COIN_TYPES,
-  CoinGeckoPriceProvider: () => CoinGeckoPriceProvider,
-  CommunicationsModule: () => CommunicationsModule,
-  DEFAULT_AGGREGATOR_TIMEOUT: () => DEFAULT_AGGREGATOR_TIMEOUT,
-  DEFAULT_AGGREGATOR_URL: () => DEFAULT_AGGREGATOR_URL,
-  DEFAULT_DERIVATION_PATH: () => DEFAULT_DERIVATION_PATH,
-  DEFAULT_ELECTRUM_URL: () => DEFAULT_ELECTRUM_URL,
-  DEFAULT_IPFS_BOOTSTRAP_PEERS: () => DEFAULT_IPFS_BOOTSTRAP_PEERS,
-  DEFAULT_IPFS_GATEWAYS: () => DEFAULT_IPFS_GATEWAYS,
-  DEFAULT_NOSTR_RELAYS: () => DEFAULT_NOSTR_RELAYS,
-  DEV_AGGREGATOR_URL: () => DEV_AGGREGATOR_URL,
-  L1: () => l1_exports,
-  L1PaymentsModule: () => L1PaymentsModule,
-  LIMITS: () => LIMITS,
-  NETWORKS: () => NETWORKS,
-  NOSTR_EVENT_KINDS: () => NOSTR_EVENT_KINDS,
-  PaymentsModule: () => PaymentsModule,
-  STORAGE_KEYS: () => STORAGE_KEYS,
-  STORAGE_PREFIX: () => STORAGE_PREFIX,
-  Sphere: () => Sphere,
-  SphereError: () => SphereError,
-  TEST_AGGREGATOR_URL: () => TEST_AGGREGATOR_URL,
-  TEST_ELECTRUM_URL: () => TEST_ELECTRUM_URL,
-  TEST_NOSTR_RELAYS: () => TEST_NOSTR_RELAYS,
-  TIMEOUTS: () => TIMEOUTS,
-  TokenRegistry: () => TokenRegistry,
-  TokenValidator: () => TokenValidator,
-  archivedKeyFromTokenId: () => archivedKeyFromTokenId,
-  base58Decode: () => base58Decode,
-  base58Encode: () => base58Encode2,
-  buildTxfStorageData: () => buildTxfStorageData,
-  bytesToHex: () => bytesToHex2,
-  countCommittedTransactions: () => countCommittedTransactions,
-  createAddress: () => createAddress,
-  createCommunicationsModule: () => createCommunicationsModule,
-  createKeyPair: () => createKeyPair,
-  createL1PaymentsModule: () => createL1PaymentsModule,
-  createPaymentSession: () => createPaymentSession,
-  createPaymentSessionError: () => createPaymentSessionError,
-  createPaymentsModule: () => createPaymentsModule,
-  createPriceProvider: () => createPriceProvider,
-  createSphere: () => createSphere,
-  createSplitPaymentSession: () => createSplitPaymentSession,
-  createTokenValidator: () => createTokenValidator,
-  decodeBech32: () => decodeBech32,
-  decryptCMasterKey: () => decryptCMasterKey,
-  decryptPrivateKey: () => decryptPrivateKey,
-  decryptTextFormatKey: () => decryptTextFormatKey,
-  deriveAddressInfo: () => deriveAddressInfo,
-  deriveChildKey: () => deriveChildKey,
-  deriveKeyAtPath: () => deriveKeyAtPath,
-  doubleSha256: () => doubleSha256,
-  encodeBech32: () => encodeBech32,
-  extractFromText: () => extractFromText,
-  findPattern: () => findPattern,
-  forkedKeyFromTokenIdAndState: () => forkedKeyFromTokenIdAndState,
-  formatAmount: () => formatAmount,
-  generateMasterKey: () => generateMasterKey,
-  generateMnemonic: () => generateMnemonic2,
-  getAddressHrp: () => getAddressHrp,
-  getCoinIdByName: () => getCoinIdByName,
-  getCoinIdBySymbol: () => getCoinIdBySymbol,
-  getCurrentStateHash: () => getCurrentStateHash,
-  getPublicKey: () => getPublicKey,
-  getSphere: () => getSphere,
-  getTokenDecimals: () => getTokenDecimals,
-  getTokenDefinition: () => getTokenDefinition,
-  getTokenIconUrl: () => getTokenIconUrl,
-  getTokenId: () => getTokenId,
-  getTokenName: () => getTokenName,
-  getTokenSymbol: () => getTokenSymbol,
-  hasMissingNewStateHash: () => hasMissingNewStateHash,
-  hasUncommittedTransactions: () => hasUncommittedTransactions,
-  hasValidTxfData: () => hasValidTxfData,
-  hash160: () => hash160,
-  hexToBytes: () => hexToBytes,
-  identityFromMnemonicSync: () => identityFromMnemonicSync,
-  initSphere: () => initSphere,
-  isArchivedKey: () => isArchivedKey,
-  isForkedKey: () => isForkedKey,
-  isInstantSplitBundle: () => isInstantSplitBundle,
-  isInstantSplitBundleV4: () => isInstantSplitBundleV4,
-  isInstantSplitBundleV5: () => isInstantSplitBundleV5,
-  isKnownToken: () => isKnownToken,
-  isPaymentSessionTerminal: () => isPaymentSessionTerminal,
-  isPaymentSessionTimedOut: () => isPaymentSessionTimedOut,
-  isSQLiteDatabase: () => isSQLiteDatabase,
-  isTextWalletEncrypted: () => isTextWalletEncrypted,
-  isTokenKey: () => isTokenKey,
-  isValidBech32: () => isValidBech32,
-  isValidPrivateKey: () => isValidPrivateKey,
-  isValidTokenId: () => isValidTokenId,
-  isWalletDatEncrypted: () => isWalletDatEncrypted,
-  isWalletTextFormat: () => isWalletTextFormat,
-  keyFromTokenId: () => keyFromTokenId,
-  loadSphere: () => loadSphere,
-  mnemonicToSeedSync: () => mnemonicToSeedSync2,
-  normalizeSdkTokenToStorage: () => normalizeSdkTokenToStorage,
-  objectToTxf: () => objectToTxf,
-  parseAndDecryptWalletDat: () => parseAndDecryptWalletDat,
-  parseAndDecryptWalletText: () => parseAndDecryptWalletText,
-  parseForkedKey: () => parseForkedKey,
-  parseTxfStorageData: () => parseTxfStorageData,
-  parseWalletDat: () => parseWalletDat,
-  parseWalletText: () => parseWalletText,
-  randomBytes: () => randomBytes,
-  randomHex: () => randomHex,
-  randomUUID: () => randomUUID,
-  ripemd160: () => ripemd160,
-  sha256: () => sha256,
-  sleep: () => sleep,
-  sphereExists: () => sphereExists,
-  toHumanReadable: () => toHumanReadable,
-  toSmallestUnit: () => toSmallestUnit,
-  tokenIdFromArchivedKey: () => tokenIdFromArchivedKey,
-  tokenIdFromKey: () => tokenIdFromKey,
-  tokenToTxf: () => tokenToTxf,
-  txfToToken: () => txfToToken,
-  validateMnemonic: () => validateMnemonic2
-});
-module.exports = __toCommonJS(index_exports);
-
-// l1/index.ts
-var l1_exports = {};
-__export(l1_exports, {
-  CHARSET: () => CHARSET,
-  VESTING_THRESHOLD: () => VESTING_THRESHOLD,
-  WalletAddressHelper: () => WalletAddressHelper,
-  addressToScriptHash: () => addressToScriptHash,
-  broadcast: () => broadcast,
-  buildSegWitTransaction: () => buildSegWitTransaction,
-  collectUtxosForAmount: () => collectUtxosForAmount,
-  computeHash160: () => computeHash160,
-  connect: () => connect,
-  convertBits: () => convertBits,
-  createAndSignTransaction: () => createAndSignTransaction,
-  createBech32: () => createBech32,
-  createScriptPubKey: () => createScriptPubKey,
-  createTransactionPlan: () => createTransactionPlan,
-  decodeBech32: () => decodeBech32,
-  decrypt: () => decrypt,
-  decryptWallet: () => decryptWallet,
-  deriveChildKey: () => deriveChildKey2,
-  deriveChildKeyBIP32: () => deriveChildKeyBIP32,
-  deriveKeyAtPath: () => deriveKeyAtPath2,
-  disconnect: () => disconnect,
-  domIdToPath: () => domIdToPath,
-  ec: () => ec,
-  encodeBech32: () => encodeBech32,
-  encrypt: () => encrypt,
-  encryptWallet: () => encryptWallet,
-  generateAddressFromMasterKey: () => generateAddressFromMasterKey,
-  generateAddressInfo: () => generateAddressInfo,
-  generateHDAddress: () => generateHDAddress,
-  generateHDAddressBIP32: () => generateHDAddressBIP32,
-  generateMasterKeyFromSeed: () => generateMasterKeyFromSeed,
-  generatePrivateKey: () => generatePrivateKey,
-  getBalance: () => getBalance,
-  getBlockHeader: () => getBlockHeader,
-  getCurrentBlockHeight: () => getCurrentBlockHeight,
-  getIndexFromPath: () => getIndexFromPath,
-  getTransaction: () => getTransaction,
-  getTransactionHistory: () => getTransactionHistory,
-  getUtxo: () => getUtxo,
-  hash160: () => hash160,
-  hash160ToBytes: () => hash160ToBytes,
-  hexToWIF: () => hexToWIF,
-  isChangePath: () => isChangePath,
-  isWebSocketConnected: () => isWebSocketConnected,
-  parsePathComponents: () => parsePathComponents,
-  pathToDOMId: () => pathToDOMId,
-  privateKeyToAddressInfo: () => privateKeyToAddressInfo,
-  publicKeyToAddress: () => publicKeyToAddress,
-  rpc: () => rpc,
-  sendAlpha: () => sendAlpha,
-  subscribeBlocks: () => subscribeBlocks,
-  vestingClassifier: () => vestingClassifier,
-  vestingState: () => vestingState,
-  waitForConnection: () => waitForConnection
-});
-
-// l1/types.ts
-function parsePathComponents(path) {
-  const match = path.match(/m\/\d+'\/\d+'\/\d+'\/(\d+)\/(\d+)/);
-  if (!match) return null;
-  return { chain: parseInt(match[1], 10), index: parseInt(match[2], 10) };
-}
-function isChangePath(path) {
-  const parsed = parsePathComponents(path);
-  return parsed?.chain === 1;
-}
-function getIndexFromPath(path) {
-  const parsed = parsePathComponents(path);
-  return parsed?.index ?? 0;
-}
-function pathToDOMId(path) {
-  return path.replace(/'/g, "h").replace(/\//g, "-");
-}
-function domIdToPath(encoded) {
-  const parts = encoded.split("-");
-  return parts.map((part, idx) => {
-    if (idx === 0) return part;
-    return part.endsWith("h") ? `${part.slice(0, -1)}'` : part;
-  }).join("/");
-}
-
 // core/bech32.ts
-var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-var GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
 function convertBits(data, fromBits, toBits, pad) {
   let acc = 0;
   let bits = 0;
@@ -345,10 +137,17 @@ function getAddressHrp(addr) {
   const result = decodeBech32(addr);
   return result?.hrp ?? null;
 }
-var createBech32 = encodeBech32;
+var CHARSET, GENERATOR, createBech32;
+var init_bech32 = __esm({
+  "core/bech32.ts"() {
+    "use strict";
+    CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+    GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+    createBech32 = encodeBech32;
+  }
+});
 
 // l1/addressToScriptHash.ts
-var import_crypto_js = __toESM(require("crypto-js"), 1);
 function bytesToHex(buf) {
   return Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -359,301 +158,34 @@ function addressToScriptHash(address) {
   const sha = import_crypto_js.default.SHA256(import_crypto_js.default.enc.Hex.parse(scriptHex)).toString();
   return sha.match(/../g).reverse().join("");
 }
+var import_crypto_js;
+var init_addressToScriptHash = __esm({
+  "l1/addressToScriptHash.ts"() {
+    "use strict";
+    init_bech32();
+    import_crypto_js = __toESM(require("crypto-js"), 1);
+  }
+});
 
-// core/crypto.ts
-var bip39 = __toESM(require("bip39"), 1);
-var import_crypto_js2 = __toESM(require("crypto-js"), 1);
-var import_elliptic = __toESM(require("elliptic"), 1);
-var ec = new import_elliptic.default.ec("secp256k1");
-var CURVE_ORDER = BigInt(
-  "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
-);
-function generateMnemonic2(strength = 128) {
-  return bip39.generateMnemonic(strength);
-}
-function validateMnemonic2(mnemonic) {
-  return bip39.validateMnemonic(mnemonic);
-}
-function mnemonicToSeedSync2(mnemonic, passphrase = "") {
-  const seedBuffer = bip39.mnemonicToSeedSync(mnemonic, passphrase);
-  return Buffer.from(seedBuffer).toString("hex");
-}
-function generateMasterKey(seedHex) {
-  const I = import_crypto_js2.default.HmacSHA512(
-    import_crypto_js2.default.enc.Hex.parse(seedHex),
-    import_crypto_js2.default.enc.Utf8.parse("Bitcoin seed")
-  ).toString();
-  const IL = I.substring(0, 64);
-  const IR = I.substring(64);
-  const masterKeyBigInt = BigInt("0x" + IL);
-  if (masterKeyBigInt === 0n || masterKeyBigInt >= CURVE_ORDER) {
-    throw new Error("Invalid master key generated");
-  }
-  return {
-    privateKey: IL,
-    chainCode: IR
-  };
-}
-function deriveChildKey(parentPrivKey, parentChainCode, index) {
-  const isHardened = index >= 2147483648;
-  let data;
-  if (isHardened) {
-    const indexHex = index.toString(16).padStart(8, "0");
-    data = "00" + parentPrivKey + indexHex;
-  } else {
-    const keyPair = ec.keyFromPrivate(parentPrivKey, "hex");
-    const compressedPubKey = keyPair.getPublic(true, "hex");
-    const indexHex = index.toString(16).padStart(8, "0");
-    data = compressedPubKey + indexHex;
-  }
-  const I = import_crypto_js2.default.HmacSHA512(
-    import_crypto_js2.default.enc.Hex.parse(data),
-    import_crypto_js2.default.enc.Hex.parse(parentChainCode)
-  ).toString();
-  const IL = I.substring(0, 64);
-  const IR = I.substring(64);
-  const ilBigInt = BigInt("0x" + IL);
-  const parentKeyBigInt = BigInt("0x" + parentPrivKey);
-  if (ilBigInt >= CURVE_ORDER) {
-    throw new Error("Invalid key: IL >= curve order");
-  }
-  const childKeyBigInt = (ilBigInt + parentKeyBigInt) % CURVE_ORDER;
-  if (childKeyBigInt === 0n) {
-    throw new Error("Invalid key: child key is zero");
-  }
-  const childPrivKey = childKeyBigInt.toString(16).padStart(64, "0");
-  return {
-    privateKey: childPrivKey,
-    chainCode: IR
-  };
-}
-function deriveKeyAtPath(masterPrivKey, masterChainCode, path) {
-  const pathParts = path.replace("m/", "").split("/");
-  let currentKey = masterPrivKey;
-  let currentChainCode = masterChainCode;
-  for (const part of pathParts) {
-    const isHardened = part.endsWith("'") || part.endsWith("h");
-    const indexStr = part.replace(/['h]$/, "");
-    let index = parseInt(indexStr, 10);
-    if (isHardened) {
-      index += 2147483648;
-    }
-    const derived = deriveChildKey(currentKey, currentChainCode, index);
-    currentKey = derived.privateKey;
-    currentChainCode = derived.chainCode;
-  }
-  return {
-    privateKey: currentKey,
-    chainCode: currentChainCode
-  };
-}
-function getPublicKey(privateKey, compressed = true) {
-  const keyPair = ec.keyFromPrivate(privateKey, "hex");
-  return keyPair.getPublic(compressed, "hex");
-}
-function createKeyPair(privateKey) {
-  return {
-    privateKey,
-    publicKey: getPublicKey(privateKey)
-  };
-}
-function sha256(data, inputEncoding = "hex") {
-  const parsed = inputEncoding === "hex" ? import_crypto_js2.default.enc.Hex.parse(data) : import_crypto_js2.default.enc.Utf8.parse(data);
-  return import_crypto_js2.default.SHA256(parsed).toString();
-}
-function ripemd160(data, inputEncoding = "hex") {
-  const parsed = inputEncoding === "hex" ? import_crypto_js2.default.enc.Hex.parse(data) : import_crypto_js2.default.enc.Utf8.parse(data);
-  return import_crypto_js2.default.RIPEMD160(parsed).toString();
-}
-function hash160(data) {
-  const sha = sha256(data, "hex");
-  return ripemd160(sha, "hex");
-}
-function doubleSha256(data, inputEncoding = "hex") {
-  const first = sha256(data, inputEncoding);
-  return sha256(first, "hex");
-}
-var computeHash160 = hash160;
-function hash160ToBytes(hash160Hex) {
-  const matches = hash160Hex.match(/../g);
-  if (!matches) return new Uint8Array(0);
-  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
-}
-function publicKeyToAddress(publicKey, prefix = "alpha", witnessVersion = 0) {
-  const pubKeyHash = hash160(publicKey);
-  const programBytes = hash160ToBytes(pubKeyHash);
-  return encodeBech32(prefix, witnessVersion, programBytes);
-}
-function privateKeyToAddressInfo(privateKey, prefix = "alpha") {
-  const publicKey = getPublicKey(privateKey);
-  const address = publicKeyToAddress(publicKey, prefix);
-  return { address, publicKey };
-}
-function hexToBytes(hex) {
-  const matches = hex.match(/../g);
-  if (!matches) {
-    return new Uint8Array(0);
-  }
-  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
-}
-function bytesToHex2(bytes) {
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function randomBytes(length) {
-  const words = import_crypto_js2.default.lib.WordArray.random(length);
-  return words.toString(import_crypto_js2.default.enc.Hex);
-}
-function identityFromMnemonicSync(mnemonic, passphrase = "") {
-  if (!validateMnemonic2(mnemonic)) {
-    throw new Error("Invalid mnemonic phrase");
-  }
-  const seedHex = mnemonicToSeedSync2(mnemonic, passphrase);
-  return generateMasterKey(seedHex);
-}
-function deriveAddressInfo(masterKey, basePath, index, isChange = false, prefix = "alpha") {
-  const chain = isChange ? 1 : 0;
-  const fullPath = `${basePath}/${chain}/${index}`;
-  const derived = deriveKeyAtPath(masterKey.privateKey, masterKey.chainCode, fullPath);
-  const publicKey = getPublicKey(derived.privateKey);
-  const address = publicKeyToAddress(publicKey, prefix);
-  return {
-    privateKey: derived.privateKey,
-    publicKey,
-    address,
-    path: fullPath,
-    index
-  };
-}
-function generateAddressInfo(privateKey, index, path, prefix = "alpha") {
-  const { address, publicKey } = privateKeyToAddressInfo(privateKey, prefix);
-  return {
-    privateKey,
-    publicKey,
-    address,
-    path,
-    index
-  };
-}
-
-// l1/crypto.ts
-var import_crypto_js3 = __toESM(require("crypto-js"), 1);
-var SALT = "alpha_wallet_salt";
-var PBKDF2_ITERATIONS = 1e5;
-function encrypt(text, password) {
-  return import_crypto_js3.default.AES.encrypt(text, password).toString();
-}
-function decrypt(encrypted, password) {
-  const bytes = import_crypto_js3.default.AES.decrypt(encrypted, password);
-  return bytes.toString(import_crypto_js3.default.enc.Utf8);
-}
-function generatePrivateKey() {
-  return import_crypto_js3.default.lib.WordArray.random(32).toString();
-}
-function encryptWallet(masterPrivateKey, password) {
-  const passwordKey = import_crypto_js3.default.PBKDF2(password, SALT, {
-    keySize: 256 / 32,
-    iterations: PBKDF2_ITERATIONS
-  }).toString();
-  const encrypted = import_crypto_js3.default.AES.encrypt(
-    masterPrivateKey,
-    passwordKey
-  ).toString();
-  return encrypted;
-}
-function decryptWallet(encryptedData, password) {
-  const passwordKey = import_crypto_js3.default.PBKDF2(password, SALT, {
-    keySize: 256 / 32,
-    iterations: PBKDF2_ITERATIONS
-  }).toString();
-  const decrypted = import_crypto_js3.default.AES.decrypt(encryptedData, passwordKey);
-  return decrypted.toString(import_crypto_js3.default.enc.Utf8);
-}
-function hexToWIF(hexKey) {
-  const versionByte = "80";
-  const extendedKey = versionByte + hexKey;
-  const hash1 = import_crypto_js3.default.SHA256(import_crypto_js3.default.enc.Hex.parse(extendedKey)).toString();
-  const hash2 = import_crypto_js3.default.SHA256(import_crypto_js3.default.enc.Hex.parse(hash1)).toString();
-  const checksum = hash2.substring(0, 8);
-  const finalHex = extendedKey + checksum;
-  return base58Encode(finalHex);
-}
-function base58Encode(hex) {
-  const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  let num = BigInt("0x" + hex);
-  let encoded = "";
-  while (num > 0n) {
-    const remainder = Number(num % 58n);
-    num = num / 58n;
-    encoded = ALPHABET[remainder] + encoded;
-  }
-  for (let i = 0; i < hex.length && hex.substring(i, i + 2) === "00"; i += 2) {
-    encoded = "1" + encoded;
-  }
-  return encoded;
-}
-
-// l1/address.ts
-var import_crypto_js4 = __toESM(require("crypto-js"), 1);
-var deriveChildKeyBIP32 = deriveChildKey;
-var deriveKeyAtPath2 = deriveKeyAtPath;
-function generateMasterKeyFromSeed(seedHex) {
-  const result = generateMasterKey(seedHex);
-  return {
-    masterPrivateKey: result.privateKey,
-    masterChainCode: result.chainCode
-  };
-}
-function generateHDAddressBIP32(masterPriv, chainCode, index, basePath = "m/44'/0'/0'", isChange = false) {
-  const chain = isChange ? 1 : 0;
-  const fullPath = `${basePath}/${chain}/${index}`;
-  const derived = deriveKeyAtPath(masterPriv, chainCode, fullPath);
-  return generateAddressInfo(derived.privateKey, index, fullPath);
-}
-function generateAddressFromMasterKey(masterPrivateKey, index) {
-  const derivationPath = `m/44'/0'/${index}'`;
-  const hmacInput = import_crypto_js4.default.enc.Hex.parse(masterPrivateKey);
-  const hmacKey = import_crypto_js4.default.enc.Utf8.parse(derivationPath);
-  const hmacOutput = import_crypto_js4.default.HmacSHA512(hmacInput, hmacKey).toString();
-  const childPrivateKey = hmacOutput.substring(0, 64);
-  return generateAddressInfo(childPrivateKey, index, derivationPath);
-}
-function deriveChildKey2(masterPriv, chainCode, index) {
-  const data = masterPriv + index.toString(16).padStart(8, "0");
-  const I = import_crypto_js4.default.HmacSHA512(
-    import_crypto_js4.default.enc.Hex.parse(data),
-    import_crypto_js4.default.enc.Hex.parse(chainCode)
-  ).toString();
-  return {
-    privateKey: I.substring(0, 64),
-    nextChainCode: I.substring(64)
-  };
-}
-function generateHDAddress(masterPriv, chainCode, index) {
-  const child = deriveChildKey2(masterPriv, chainCode, index);
-  const path = `m/44'/0'/0'/${index}`;
-  return generateAddressInfo(child.privateKey, index, path);
-}
-
-// l1/network.ts
-var DEFAULT_ENDPOINT = "wss://fulcrum.unicity.network:50004";
-var ws = null;
-var isConnected = false;
-var isConnecting = false;
-var requestId = 0;
-var intentionalClose = false;
-var reconnectAttempts = 0;
-var isBlockSubscribed = false;
-var lastBlockHeader = null;
-var pending = {};
-var blockSubscribers = [];
-var connectionCallbacks = [];
-var MAX_RECONNECT_ATTEMPTS = 10;
-var BASE_DELAY = 2e3;
-var MAX_DELAY = 6e4;
-var RPC_TIMEOUT = 3e4;
-var CONNECTION_TIMEOUT = 3e4;
-function isWebSocketConnected() {
-  return isConnected && ws !== null && ws.readyState === WebSocket.OPEN;
+// l1/network.ts
+var network_exports = {};
+__export(network_exports, {
+  broadcast: () => broadcast,
+  connect: () => connect,
+  disconnect: () => disconnect,
+  getBalance: () => getBalance,
+  getBlockHeader: () => getBlockHeader,
+  getCurrentBlockHeight: () => getCurrentBlockHeight,
+  getTransaction: () => getTransaction,
+  getTransactionHistory: () => getTransactionHistory,
+  getUtxo: () => getUtxo,
+  isWebSocketConnected: () => isWebSocketConnected,
+  rpc: () => rpc,
+  subscribeBlocks: () => subscribeBlocks,
+  waitForConnection: () => waitForConnection
+});
+function isWebSocketConnected() {
+  return isConnected && ws !== null && ws.readyState === WebSocket.OPEN;
 }
 function waitForConnection() {
   if (isWebSocketConnected()) {
@@ -839,83 +371,601 @@ async function getBalance(address) {
   const alpha = totalSats / 1e8;
   return alpha;
 }
-async function broadcast(rawHex) {
-  return await rpc("blockchain.transaction.broadcast", [rawHex]);
+async function broadcast(rawHex) {
+  return await rpc("blockchain.transaction.broadcast", [rawHex]);
+}
+async function subscribeBlocks(cb) {
+  if (!isConnected && !isConnecting) {
+    await connect();
+  }
+  if (!isWebSocketConnected()) {
+    await waitForConnection();
+  }
+  blockSubscribers.push(cb);
+  if (!isBlockSubscribed) {
+    isBlockSubscribed = true;
+    const header = await rpc("blockchain.headers.subscribe", []);
+    if (header) {
+      lastBlockHeader = header;
+      blockSubscribers.forEach((subscriber) => subscriber(header));
+    }
+  } else if (lastBlockHeader) {
+    cb(lastBlockHeader);
+  }
+  return () => {
+    const index = blockSubscribers.indexOf(cb);
+    if (index > -1) {
+      blockSubscribers.splice(index, 1);
+    }
+  };
+}
+async function getTransactionHistory(address) {
+  const scriptHash = addressToScriptHash(address);
+  const result = await rpc("blockchain.scripthash.get_history", [scriptHash]);
+  if (!Array.isArray(result)) {
+    console.warn("get_history returned non-array:", result);
+    return [];
+  }
+  return result;
+}
+async function getTransaction(txid) {
+  return await rpc("blockchain.transaction.get", [txid, true]);
+}
+async function getBlockHeader(height) {
+  return await rpc("blockchain.block.header", [height, height]);
+}
+async function getCurrentBlockHeight() {
+  try {
+    const header = await rpc("blockchain.headers.subscribe", []);
+    return header?.height || 0;
+  } catch (err) {
+    console.error("Error getting current block height:", err);
+    return 0;
+  }
+}
+function disconnect() {
+  if (ws) {
+    intentionalClose = true;
+    ws.close();
+    ws = null;
+  }
+  isConnected = false;
+  isConnecting = false;
+  reconnectAttempts = 0;
+  isBlockSubscribed = false;
+  Object.values(pending).forEach((req) => {
+    if (req.timeoutId) clearTimeout(req.timeoutId);
+  });
+  Object.keys(pending).forEach((key) => delete pending[Number(key)]);
+  connectionCallbacks.forEach((cb) => {
+    if (cb.timeoutId) clearTimeout(cb.timeoutId);
+  });
+  connectionCallbacks.length = 0;
+}
+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";
+    ws = null;
+    isConnected = false;
+    isConnecting = false;
+    requestId = 0;
+    intentionalClose = false;
+    reconnectAttempts = 0;
+    isBlockSubscribed = false;
+    lastBlockHeader = null;
+    pending = {};
+    blockSubscribers = [];
+    connectionCallbacks = [];
+    MAX_RECONNECT_ATTEMPTS = 10;
+    BASE_DELAY = 2e3;
+    MAX_DELAY = 6e4;
+    RPC_TIMEOUT = 3e4;
+    CONNECTION_TIMEOUT = 3e4;
+  }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  COIN_TYPES: () => COIN_TYPES,
+  CoinGeckoPriceProvider: () => CoinGeckoPriceProvider,
+  CommunicationsModule: () => CommunicationsModule,
+  DEFAULT_AGGREGATOR_TIMEOUT: () => DEFAULT_AGGREGATOR_TIMEOUT,
+  DEFAULT_AGGREGATOR_URL: () => DEFAULT_AGGREGATOR_URL,
+  DEFAULT_DERIVATION_PATH: () => DEFAULT_DERIVATION_PATH,
+  DEFAULT_ELECTRUM_URL: () => DEFAULT_ELECTRUM_URL,
+  DEFAULT_IPFS_BOOTSTRAP_PEERS: () => DEFAULT_IPFS_BOOTSTRAP_PEERS,
+  DEFAULT_IPFS_GATEWAYS: () => DEFAULT_IPFS_GATEWAYS,
+  DEFAULT_NOSTR_RELAYS: () => DEFAULT_NOSTR_RELAYS,
+  DEV_AGGREGATOR_URL: () => DEV_AGGREGATOR_URL,
+  L1: () => l1_exports,
+  L1PaymentsModule: () => L1PaymentsModule,
+  LIMITS: () => LIMITS,
+  NETWORKS: () => NETWORKS,
+  NOSTR_EVENT_KINDS: () => NOSTR_EVENT_KINDS,
+  PaymentsModule: () => PaymentsModule,
+  STORAGE_KEYS: () => STORAGE_KEYS,
+  STORAGE_PREFIX: () => STORAGE_PREFIX,
+  Sphere: () => Sphere,
+  SphereError: () => SphereError,
+  TEST_AGGREGATOR_URL: () => TEST_AGGREGATOR_URL,
+  TEST_ELECTRUM_URL: () => TEST_ELECTRUM_URL,
+  TEST_NOSTR_RELAYS: () => TEST_NOSTR_RELAYS,
+  TIMEOUTS: () => TIMEOUTS,
+  TokenRegistry: () => TokenRegistry,
+  TokenValidator: () => TokenValidator,
+  archivedKeyFromTokenId: () => archivedKeyFromTokenId,
+  base58Decode: () => base58Decode,
+  base58Encode: () => base58Encode2,
+  buildTxfStorageData: () => buildTxfStorageData,
+  bytesToHex: () => bytesToHex2,
+  countCommittedTransactions: () => countCommittedTransactions,
+  createAddress: () => createAddress,
+  createCommunicationsModule: () => createCommunicationsModule,
+  createKeyPair: () => createKeyPair,
+  createL1PaymentsModule: () => createL1PaymentsModule,
+  createPaymentSession: () => createPaymentSession,
+  createPaymentSessionError: () => createPaymentSessionError,
+  createPaymentsModule: () => createPaymentsModule,
+  createPriceProvider: () => createPriceProvider,
+  createSphere: () => createSphere,
+  createSplitPaymentSession: () => createSplitPaymentSession,
+  createTokenValidator: () => createTokenValidator,
+  decodeBech32: () => decodeBech32,
+  decryptCMasterKey: () => decryptCMasterKey,
+  decryptPrivateKey: () => decryptPrivateKey,
+  decryptTextFormatKey: () => decryptTextFormatKey,
+  deriveAddressInfo: () => deriveAddressInfo,
+  deriveChildKey: () => deriveChildKey,
+  deriveKeyAtPath: () => deriveKeyAtPath,
+  doubleSha256: () => doubleSha256,
+  encodeBech32: () => encodeBech32,
+  extractFromText: () => extractFromText,
+  findPattern: () => findPattern,
+  forkedKeyFromTokenIdAndState: () => forkedKeyFromTokenIdAndState,
+  formatAmount: () => formatAmount,
+  generateMasterKey: () => generateMasterKey,
+  generateMnemonic: () => generateMnemonic2,
+  getAddressHrp: () => getAddressHrp,
+  getCoinIdByName: () => getCoinIdByName,
+  getCoinIdBySymbol: () => getCoinIdBySymbol,
+  getCurrentStateHash: () => getCurrentStateHash,
+  getPublicKey: () => getPublicKey,
+  getSphere: () => getSphere,
+  getTokenDecimals: () => getTokenDecimals,
+  getTokenDefinition: () => getTokenDefinition,
+  getTokenIconUrl: () => getTokenIconUrl,
+  getTokenId: () => getTokenId,
+  getTokenName: () => getTokenName,
+  getTokenSymbol: () => getTokenSymbol,
+  hasMissingNewStateHash: () => hasMissingNewStateHash,
+  hasUncommittedTransactions: () => hasUncommittedTransactions,
+  hasValidTxfData: () => hasValidTxfData,
+  hash160: () => hash160,
+  hexToBytes: () => hexToBytes,
+  identityFromMnemonicSync: () => identityFromMnemonicSync,
+  initSphere: () => initSphere,
+  isArchivedKey: () => isArchivedKey,
+  isForkedKey: () => isForkedKey,
+  isInstantSplitBundle: () => isInstantSplitBundle,
+  isInstantSplitBundleV4: () => isInstantSplitBundleV4,
+  isInstantSplitBundleV5: () => isInstantSplitBundleV5,
+  isKnownToken: () => isKnownToken,
+  isPaymentSessionTerminal: () => isPaymentSessionTerminal,
+  isPaymentSessionTimedOut: () => isPaymentSessionTimedOut,
+  isSQLiteDatabase: () => isSQLiteDatabase,
+  isTextWalletEncrypted: () => isTextWalletEncrypted,
+  isTokenKey: () => isTokenKey,
+  isValidBech32: () => isValidBech32,
+  isValidPrivateKey: () => isValidPrivateKey,
+  isValidTokenId: () => isValidTokenId,
+  isWalletDatEncrypted: () => isWalletDatEncrypted,
+  isWalletTextFormat: () => isWalletTextFormat,
+  keyFromTokenId: () => keyFromTokenId,
+  loadSphere: () => loadSphere,
+  mnemonicToSeedSync: () => mnemonicToSeedSync2,
+  normalizeSdkTokenToStorage: () => normalizeSdkTokenToStorage,
+  objectToTxf: () => objectToTxf,
+  parseAndDecryptWalletDat: () => parseAndDecryptWalletDat,
+  parseAndDecryptWalletText: () => parseAndDecryptWalletText,
+  parseForkedKey: () => parseForkedKey,
+  parseTxfStorageData: () => parseTxfStorageData,
+  parseWalletDat: () => parseWalletDat,
+  parseWalletText: () => parseWalletText,
+  randomBytes: () => randomBytes,
+  randomHex: () => randomHex,
+  randomUUID: () => randomUUID,
+  ripemd160: () => ripemd160,
+  sha256: () => sha256,
+  sleep: () => sleep,
+  sphereExists: () => sphereExists,
+  toHumanReadable: () => toHumanReadable,
+  toSmallestUnit: () => toSmallestUnit,
+  tokenIdFromArchivedKey: () => tokenIdFromArchivedKey,
+  tokenIdFromKey: () => tokenIdFromKey,
+  tokenToTxf: () => tokenToTxf,
+  txfToToken: () => txfToToken,
+  validateMnemonic: () => validateMnemonic2
+});
+module.exports = __toCommonJS(index_exports);
+
+// l1/index.ts
+var l1_exports = {};
+__export(l1_exports, {
+  CHARSET: () => CHARSET,
+  VESTING_THRESHOLD: () => VESTING_THRESHOLD,
+  WalletAddressHelper: () => WalletAddressHelper,
+  addressToScriptHash: () => addressToScriptHash,
+  broadcast: () => broadcast,
+  buildSegWitTransaction: () => buildSegWitTransaction,
+  collectUtxosForAmount: () => collectUtxosForAmount,
+  computeHash160: () => computeHash160,
+  connect: () => connect,
+  convertBits: () => convertBits,
+  createAndSignTransaction: () => createAndSignTransaction,
+  createBech32: () => createBech32,
+  createScriptPubKey: () => createScriptPubKey,
+  createTransactionPlan: () => createTransactionPlan,
+  decodeBech32: () => decodeBech32,
+  decrypt: () => decrypt,
+  decryptWallet: () => decryptWallet,
+  deriveChildKey: () => deriveChildKey2,
+  deriveChildKeyBIP32: () => deriveChildKeyBIP32,
+  deriveKeyAtPath: () => deriveKeyAtPath2,
+  disconnect: () => disconnect,
+  domIdToPath: () => domIdToPath,
+  ec: () => ec,
+  encodeBech32: () => encodeBech32,
+  encrypt: () => encrypt,
+  encryptWallet: () => encryptWallet,
+  generateAddressFromMasterKey: () => generateAddressFromMasterKey,
+  generateAddressInfo: () => generateAddressInfo,
+  generateHDAddress: () => generateHDAddress,
+  generateHDAddressBIP32: () => generateHDAddressBIP32,
+  generateMasterKeyFromSeed: () => generateMasterKeyFromSeed,
+  generatePrivateKey: () => generatePrivateKey,
+  getBalance: () => getBalance,
+  getBlockHeader: () => getBlockHeader,
+  getCurrentBlockHeight: () => getCurrentBlockHeight,
+  getIndexFromPath: () => getIndexFromPath,
+  getTransaction: () => getTransaction,
+  getTransactionHistory: () => getTransactionHistory,
+  getUtxo: () => getUtxo,
+  hash160: () => hash160,
+  hash160ToBytes: () => hash160ToBytes,
+  hexToWIF: () => hexToWIF,
+  isChangePath: () => isChangePath,
+  isWebSocketConnected: () => isWebSocketConnected,
+  parsePathComponents: () => parsePathComponents,
+  pathToDOMId: () => pathToDOMId,
+  privateKeyToAddressInfo: () => privateKeyToAddressInfo,
+  publicKeyToAddress: () => publicKeyToAddress,
+  rpc: () => rpc,
+  sendAlpha: () => sendAlpha,
+  subscribeBlocks: () => subscribeBlocks,
+  vestingClassifier: () => vestingClassifier,
+  vestingState: () => vestingState,
+  waitForConnection: () => waitForConnection
+});
+
+// l1/types.ts
+function parsePathComponents(path) {
+  const match = path.match(/m\/\d+'\/\d+'\/\d+'\/(\d+)\/(\d+)/);
+  if (!match) return null;
+  return { chain: parseInt(match[1], 10), index: parseInt(match[2], 10) };
+}
+function isChangePath(path) {
+  const parsed = parsePathComponents(path);
+  return parsed?.chain === 1;
+}
+function getIndexFromPath(path) {
+  const parsed = parsePathComponents(path);
+  return parsed?.index ?? 0;
+}
+function pathToDOMId(path) {
+  return path.replace(/'/g, "h").replace(/\//g, "-");
+}
+function domIdToPath(encoded) {
+  const parts = encoded.split("-");
+  return parts.map((part, idx) => {
+    if (idx === 0) return part;
+    return part.endsWith("h") ? `${part.slice(0, -1)}'` : part;
+  }).join("/");
+}
+
+// l1/index.ts
+init_bech32();
+init_addressToScriptHash();
+
+// core/crypto.ts
+var bip39 = __toESM(require("bip39"), 1);
+var import_crypto_js2 = __toESM(require("crypto-js"), 1);
+var import_elliptic = __toESM(require("elliptic"), 1);
+init_bech32();
+var ec = new import_elliptic.default.ec("secp256k1");
+var CURVE_ORDER = BigInt(
+  "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
+);
+function generateMnemonic2(strength = 128) {
+  return bip39.generateMnemonic(strength);
+}
+function validateMnemonic2(mnemonic) {
+  return bip39.validateMnemonic(mnemonic);
+}
+function mnemonicToSeedSync2(mnemonic, passphrase = "") {
+  const seedBuffer = bip39.mnemonicToSeedSync(mnemonic, passphrase);
+  return Buffer.from(seedBuffer).toString("hex");
+}
+function generateMasterKey(seedHex) {
+  const I = import_crypto_js2.default.HmacSHA512(
+    import_crypto_js2.default.enc.Hex.parse(seedHex),
+    import_crypto_js2.default.enc.Utf8.parse("Bitcoin seed")
+  ).toString();
+  const IL = I.substring(0, 64);
+  const IR = I.substring(64);
+  const masterKeyBigInt = BigInt("0x" + IL);
+  if (masterKeyBigInt === 0n || masterKeyBigInt >= CURVE_ORDER) {
+    throw new Error("Invalid master key generated");
+  }
+  return {
+    privateKey: IL,
+    chainCode: IR
+  };
+}
+function deriveChildKey(parentPrivKey, parentChainCode, index) {
+  const isHardened = index >= 2147483648;
+  let data;
+  if (isHardened) {
+    const indexHex = index.toString(16).padStart(8, "0");
+    data = "00" + parentPrivKey + indexHex;
+  } else {
+    const keyPair = ec.keyFromPrivate(parentPrivKey, "hex");
+    const compressedPubKey = keyPair.getPublic(true, "hex");
+    const indexHex = index.toString(16).padStart(8, "0");
+    data = compressedPubKey + indexHex;
+  }
+  const I = import_crypto_js2.default.HmacSHA512(
+    import_crypto_js2.default.enc.Hex.parse(data),
+    import_crypto_js2.default.enc.Hex.parse(parentChainCode)
+  ).toString();
+  const IL = I.substring(0, 64);
+  const IR = I.substring(64);
+  const ilBigInt = BigInt("0x" + IL);
+  const parentKeyBigInt = BigInt("0x" + parentPrivKey);
+  if (ilBigInt >= CURVE_ORDER) {
+    throw new Error("Invalid key: IL >= curve order");
+  }
+  const childKeyBigInt = (ilBigInt + parentKeyBigInt) % CURVE_ORDER;
+  if (childKeyBigInt === 0n) {
+    throw new Error("Invalid key: child key is zero");
+  }
+  const childPrivKey = childKeyBigInt.toString(16).padStart(64, "0");
+  return {
+    privateKey: childPrivKey,
+    chainCode: IR
+  };
+}
+function deriveKeyAtPath(masterPrivKey, masterChainCode, path) {
+  const pathParts = path.replace("m/", "").split("/");
+  let currentKey = masterPrivKey;
+  let currentChainCode = masterChainCode;
+  for (const part of pathParts) {
+    const isHardened = part.endsWith("'") || part.endsWith("h");
+    const indexStr = part.replace(/['h]$/, "");
+    let index = parseInt(indexStr, 10);
+    if (isHardened) {
+      index += 2147483648;
+    }
+    const derived = deriveChildKey(currentKey, currentChainCode, index);
+    currentKey = derived.privateKey;
+    currentChainCode = derived.chainCode;
+  }
+  return {
+    privateKey: currentKey,
+    chainCode: currentChainCode
+  };
+}
+function getPublicKey(privateKey, compressed = true) {
+  const keyPair = ec.keyFromPrivate(privateKey, "hex");
+  return keyPair.getPublic(compressed, "hex");
+}
+function createKeyPair(privateKey) {
+  return {
+    privateKey,
+    publicKey: getPublicKey(privateKey)
+  };
+}
+function sha256(data, inputEncoding = "hex") {
+  const parsed = inputEncoding === "hex" ? import_crypto_js2.default.enc.Hex.parse(data) : import_crypto_js2.default.enc.Utf8.parse(data);
+  return import_crypto_js2.default.SHA256(parsed).toString();
+}
+function ripemd160(data, inputEncoding = "hex") {
+  const parsed = inputEncoding === "hex" ? import_crypto_js2.default.enc.Hex.parse(data) : import_crypto_js2.default.enc.Utf8.parse(data);
+  return import_crypto_js2.default.RIPEMD160(parsed).toString();
+}
+function hash160(data) {
+  const sha = sha256(data, "hex");
+  return ripemd160(sha, "hex");
+}
+function doubleSha256(data, inputEncoding = "hex") {
+  const first = sha256(data, inputEncoding);
+  return sha256(first, "hex");
+}
+var computeHash160 = hash160;
+function hash160ToBytes(hash160Hex) {
+  const matches = hash160Hex.match(/../g);
+  if (!matches) return new Uint8Array(0);
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
+}
+function publicKeyToAddress(publicKey, prefix = "alpha", witnessVersion = 0) {
+  const pubKeyHash = hash160(publicKey);
+  const programBytes = hash160ToBytes(pubKeyHash);
+  return encodeBech32(prefix, witnessVersion, programBytes);
+}
+function privateKeyToAddressInfo(privateKey, prefix = "alpha") {
+  const publicKey = getPublicKey(privateKey);
+  const address = publicKeyToAddress(publicKey, prefix);
+  return { address, publicKey };
+}
+function hexToBytes(hex) {
+  const matches = hex.match(/../g);
+  if (!matches) {
+    return new Uint8Array(0);
+  }
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
+}
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function randomBytes(length) {
+  const words = import_crypto_js2.default.lib.WordArray.random(length);
+  return words.toString(import_crypto_js2.default.enc.Hex);
+}
+function identityFromMnemonicSync(mnemonic, passphrase = "") {
+  if (!validateMnemonic2(mnemonic)) {
+    throw new Error("Invalid mnemonic phrase");
+  }
+  const seedHex = mnemonicToSeedSync2(mnemonic, passphrase);
+  return generateMasterKey(seedHex);
+}
+function deriveAddressInfo(masterKey, basePath, index, isChange = false, prefix = "alpha") {
+  const chain = isChange ? 1 : 0;
+  const fullPath = `${basePath}/${chain}/${index}`;
+  const derived = deriveKeyAtPath(masterKey.privateKey, masterKey.chainCode, fullPath);
+  const publicKey = getPublicKey(derived.privateKey);
+  const address = publicKeyToAddress(publicKey, prefix);
+  return {
+    privateKey: derived.privateKey,
+    publicKey,
+    address,
+    path: fullPath,
+    index
+  };
+}
+function generateAddressInfo(privateKey, index, path, prefix = "alpha") {
+  const { address, publicKey } = privateKeyToAddressInfo(privateKey, prefix);
+  return {
+    privateKey,
+    publicKey,
+    address,
+    path,
+    index
+  };
+}
+
+// l1/crypto.ts
+var import_crypto_js3 = __toESM(require("crypto-js"), 1);
+var SALT = "alpha_wallet_salt";
+var PBKDF2_ITERATIONS = 1e5;
+function encrypt(text, password) {
+  return import_crypto_js3.default.AES.encrypt(text, password).toString();
+}
+function decrypt(encrypted, password) {
+  const bytes = import_crypto_js3.default.AES.decrypt(encrypted, password);
+  return bytes.toString(import_crypto_js3.default.enc.Utf8);
+}
+function generatePrivateKey() {
+  return import_crypto_js3.default.lib.WordArray.random(32).toString();
+}
+function encryptWallet(masterPrivateKey, password) {
+  const passwordKey = import_crypto_js3.default.PBKDF2(password, SALT, {
+    keySize: 256 / 32,
+    iterations: PBKDF2_ITERATIONS
+  }).toString();
+  const encrypted = import_crypto_js3.default.AES.encrypt(
+    masterPrivateKey,
+    passwordKey
+  ).toString();
+  return encrypted;
+}
+function decryptWallet(encryptedData, password) {
+  const passwordKey = import_crypto_js3.default.PBKDF2(password, SALT, {
+    keySize: 256 / 32,
+    iterations: PBKDF2_ITERATIONS
+  }).toString();
+  const decrypted = import_crypto_js3.default.AES.decrypt(encryptedData, passwordKey);
+  return decrypted.toString(import_crypto_js3.default.enc.Utf8);
+}
+function hexToWIF(hexKey) {
+  const versionByte = "80";
+  const extendedKey = versionByte + hexKey;
+  const hash1 = import_crypto_js3.default.SHA256(import_crypto_js3.default.enc.Hex.parse(extendedKey)).toString();
+  const hash2 = import_crypto_js3.default.SHA256(import_crypto_js3.default.enc.Hex.parse(hash1)).toString();
+  const checksum = hash2.substring(0, 8);
+  const finalHex = extendedKey + checksum;
+  return base58Encode(finalHex);
 }
-async function subscribeBlocks(cb) {
-  if (!isConnected && !isConnecting) {
-    await connect();
-  }
-  if (!isWebSocketConnected()) {
-    await waitForConnection();
+function base58Encode(hex) {
+  const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  let num = BigInt("0x" + hex);
+  let encoded = "";
+  while (num > 0n) {
+    const remainder = Number(num % 58n);
+    num = num / 58n;
+    encoded = ALPHABET[remainder] + encoded;
   }
-  blockSubscribers.push(cb);
-  if (!isBlockSubscribed) {
-    isBlockSubscribed = true;
-    const header = await rpc("blockchain.headers.subscribe", []);
-    if (header) {
-      lastBlockHeader = header;
-      blockSubscribers.forEach((subscriber) => subscriber(header));
-    }
-  } else if (lastBlockHeader) {
-    cb(lastBlockHeader);
+  for (let i = 0; i < hex.length && hex.substring(i, i + 2) === "00"; i += 2) {
+    encoded = "1" + encoded;
   }
-  return () => {
-    const index = blockSubscribers.indexOf(cb);
-    if (index > -1) {
-      blockSubscribers.splice(index, 1);
-    }
-  };
+  return encoded;
 }
-async function getTransactionHistory(address) {
-  const scriptHash = addressToScriptHash(address);
-  const result = await rpc("blockchain.scripthash.get_history", [scriptHash]);
-  if (!Array.isArray(result)) {
-    console.warn("get_history returned non-array:", result);
-    return [];
-  }
-  return result;
+
+// l1/address.ts
+var import_crypto_js4 = __toESM(require("crypto-js"), 1);
+var deriveChildKeyBIP32 = deriveChildKey;
+var deriveKeyAtPath2 = deriveKeyAtPath;
+function generateMasterKeyFromSeed(seedHex) {
+  const result = generateMasterKey(seedHex);
+  return {
+    masterPrivateKey: result.privateKey,
+    masterChainCode: result.chainCode
+  };
 }
-async function getTransaction(txid) {
-  return await rpc("blockchain.transaction.get", [txid, true]);
+function generateHDAddressBIP32(masterPriv, chainCode, index, basePath = "m/44'/0'/0'", isChange = false) {
+  const chain = isChange ? 1 : 0;
+  const fullPath = `${basePath}/${chain}/${index}`;
+  const derived = deriveKeyAtPath(masterPriv, chainCode, fullPath);
+  return generateAddressInfo(derived.privateKey, index, fullPath);
 }
-async function getBlockHeader(height) {
-  return await rpc("blockchain.block.header", [height, height]);
+function generateAddressFromMasterKey(masterPrivateKey, index) {
+  const derivationPath = `m/44'/0'/${index}'`;
+  const hmacInput = import_crypto_js4.default.enc.Hex.parse(masterPrivateKey);
+  const hmacKey = import_crypto_js4.default.enc.Utf8.parse(derivationPath);
+  const hmacOutput = import_crypto_js4.default.HmacSHA512(hmacInput, hmacKey).toString();
+  const childPrivateKey = hmacOutput.substring(0, 64);
+  return generateAddressInfo(childPrivateKey, index, derivationPath);
 }
-async function getCurrentBlockHeight() {
-  try {
-    const header = await rpc("blockchain.headers.subscribe", []);
-    return header?.height || 0;
-  } catch (err) {
-    console.error("Error getting current block height:", err);
-    return 0;
-  }
+function deriveChildKey2(masterPriv, chainCode, index) {
+  const data = masterPriv + index.toString(16).padStart(8, "0");
+  const I = import_crypto_js4.default.HmacSHA512(
+    import_crypto_js4.default.enc.Hex.parse(data),
+    import_crypto_js4.default.enc.Hex.parse(chainCode)
+  ).toString();
+  return {
+    privateKey: I.substring(0, 64),
+    nextChainCode: I.substring(64)
+  };
 }
-function disconnect() {
-  if (ws) {
-    intentionalClose = true;
-    ws.close();
-    ws = null;
-  }
-  isConnected = false;
-  isConnecting = false;
-  reconnectAttempts = 0;
-  isBlockSubscribed = false;
-  Object.values(pending).forEach((req) => {
-    if (req.timeoutId) clearTimeout(req.timeoutId);
-  });
-  Object.keys(pending).forEach((key) => delete pending[Number(key)]);
-  connectionCallbacks.forEach((cb) => {
-    if (cb.timeoutId) clearTimeout(cb.timeoutId);
-  });
-  connectionCallbacks.length = 0;
+function generateHDAddress(masterPriv, chainCode, index) {
+  const child = deriveChildKey2(masterPriv, chainCode, index);
+  const path = `m/44'/0'/0'/${index}`;
+  return generateAddressInfo(child.privateKey, index, path);
 }
 
+// l1/index.ts
+init_network();
+
 // l1/tx.ts
+init_network();
+init_bech32();
 var import_crypto_js5 = __toESM(require("crypto-js"), 1);
 var import_elliptic2 = __toESM(require("elliptic"), 1);
 
 // l1/vesting.ts
+init_network();
 var VESTING_THRESHOLD = 28e4;
 var currentBlockHeight = null;
 var VestingClassifier = class {
@@ -1134,6 +1184,24 @@ var VestingClassifier = class {
       tx.objectStore(this.storeName).clear();
     }
   }
+  /**
+   * Destroy caches and delete the IndexedDB database entirely.
+   */
+  async destroy() {
+    this.memoryCache.clear();
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    if (typeof indexedDB !== "undefined") {
+      await new Promise((resolve) => {
+        const req = indexedDB.deleteDatabase(this.dbName);
+        req.onsuccess = () => resolve();
+        req.onerror = () => resolve();
+        req.onblocked = () => resolve();
+      });
+    }
+  }
 };
 var vestingClassifier = new VestingClassifier();
 
@@ -4551,7 +4619,7 @@ var PaymentsModule = class _PaymentsModule {
           memo: request.memo
         });
         console.log(`[Payments] Split token sent successfully`);
-        await this.removeToken(splitPlan.tokenToSplit.uiToken.id, recipientNametag);
+        await this.removeToken(splitPlan.tokenToSplit.uiToken.id, recipientNametag, true);
         result.txHash = "split-" + Date.now().toString(16);
         this.log(`Split transfer completed`);
       }
@@ -4577,7 +4645,7 @@ var PaymentsModule = class _PaymentsModule {
         });
         console.log(`[Payments] Direct token sent successfully`);
         this.log(`Token ${token.id} transferred, txHash: ${result.txHash}`);
-        await this.removeToken(token.id, recipientNametag);
+        await this.removeToken(token.id, recipientNametag, true);
       }
       result.status = "delivered";
       await this.save();
@@ -4726,7 +4794,7 @@ var PaymentsModule = class _PaymentsModule {
       );
       if (result.success) {
         const recipientNametag = request.recipient.startsWith("@") ? request.recipient.slice(1) : void 0;
-        await this.removeToken(tokenToSplit.id, recipientNametag);
+        await this.removeToken(tokenToSplit.id, recipientNametag, true);
         await this.addToHistory({
           type: "SENT",
           amount: request.amount,
@@ -5232,35 +5300,39 @@ var PaymentsModule = class _PaymentsModule {
     const rawAssets = Array.from(assetsMap.values());
     let priceMap = null;
     if (this.priceProvider && rawAssets.length > 0) {
-      const registry = TokenRegistry.getInstance();
-      const nameToCoins = /* @__PURE__ */ new Map();
-      for (const asset of rawAssets) {
-        const def = registry.getDefinition(asset.coinId);
-        if (def?.name) {
-          const existing = nameToCoins.get(def.name);
-          if (existing) {
-            existing.push(asset.coinId);
-          } else {
-            nameToCoins.set(def.name, [asset.coinId]);
+      try {
+        const registry = TokenRegistry.getInstance();
+        const nameToCoins = /* @__PURE__ */ new Map();
+        for (const asset of rawAssets) {
+          const def = registry.getDefinition(asset.coinId);
+          if (def?.name) {
+            const existing = nameToCoins.get(def.name);
+            if (existing) {
+              existing.push(asset.coinId);
+            } else {
+              nameToCoins.set(def.name, [asset.coinId]);
+            }
           }
         }
-      }
-      if (nameToCoins.size > 0) {
-        const tokenNames = Array.from(nameToCoins.keys());
-        const prices = await this.priceProvider.getPrices(tokenNames);
-        priceMap = /* @__PURE__ */ new Map();
-        for (const [name, coinIds] of nameToCoins) {
-          const price = prices.get(name);
-          if (price) {
-            for (const cid of coinIds) {
-              priceMap.set(cid, {
-                priceUsd: price.priceUsd,
-                priceEur: price.priceEur,
-                change24h: price.change24h
-              });
+        if (nameToCoins.size > 0) {
+          const tokenNames = Array.from(nameToCoins.keys());
+          const prices = await this.priceProvider.getPrices(tokenNames);
+          priceMap = /* @__PURE__ */ new Map();
+          for (const [name, coinIds] of nameToCoins) {
+            const price = prices.get(name);
+            if (price) {
+              for (const cid of coinIds) {
+                priceMap.set(cid, {
+                  priceUsd: price.priceUsd,
+                  priceEur: price.priceEur,
+                  change24h: price.change24h
+                });
+              }
             }
           }
         }
+      } catch (error) {
+        console.warn("[Payments] Failed to fetch prices, returning assets without price data:", error);
       }
     }
     return rawAssets.map((raw) => {
@@ -5463,6 +5535,12 @@ var PaymentsModule = class _PaymentsModule {
               updatedAt: Date.now(),
               sdkData: typeof tokenJson === "string" ? tokenJson : JSON.stringify(tokenJson)
             };
+            const loadedTokenId = extractTokenIdFromSdkData(token.sdkData);
+            const loadedStateHash = extractStateHashFromSdkData(token.sdkData);
+            if (loadedTokenId && loadedStateHash && this.isStateTombstoned(loadedTokenId, loadedStateHash)) {
+              this.log(`Skipping tombstoned token file ${tokenId} (${loadedTokenId.slice(0, 8)}...)`);
+              continue;
+            }
             this.tokens.set(token.id, token);
             this.log(`Loaded token from file: ${tokenId}`);
           } catch (tokenError) {
@@ -5520,6 +5598,7 @@ var PaymentsModule = class _PaymentsModule {
       this.log(`Warning: Could not create tombstone for token ${tokenId.slice(0, 8)}... (missing tokenId or stateHash)`);
     }
     this.tokens.delete(tokenId);
+    await this.deleteTokenFiles(token);
     if (!skipHistory && token.coinId && token.amount) {
       await this.addToHistory({
         type: "SENT",
@@ -5532,6 +5611,31 @@ var PaymentsModule = class _PaymentsModule {
     }
     await this.save();
   }
+  /**
+   * Delete physical token file(s) from all storage providers.
+   * Finds files by matching the SDK token ID prefix in the filename.
+   */
+  async deleteTokenFiles(token) {
+    const sdkTokenId = extractTokenIdFromSdkData(token.sdkData);
+    if (!sdkTokenId) return;
+    const tokenIdPrefix = sdkTokenId.slice(0, 16);
+    const providers = this.getTokenStorageProviders();
+    for (const [providerId, provider] of providers) {
+      if (!provider.listTokenIds || !provider.deleteToken) continue;
+      try {
+        const allIds = await provider.listTokenIds();
+        const matchingFiles = allIds.filter(
+          (id) => id.startsWith(`token-${tokenIdPrefix}`)
+        );
+        for (const fileId of matchingFiles) {
+          await provider.deleteToken(fileId);
+          this.log(`Deleted token file ${fileId} from ${providerId}`);
+        }
+      } catch (error) {
+        console.warn(`[Payments] Failed to delete token files from ${providerId}:`, error);
+      }
+    }
+  }
   // ===========================================================================
   // Public API - Tombstones
   // ===========================================================================
@@ -6977,6 +7081,95 @@ function decryptSimple(ciphertext, password) {
   }
   return result;
 }
+function decryptWithSalt(ciphertext, password, salt) {
+  try {
+    const key = import_crypto_js6.default.PBKDF2(password, salt, {
+      keySize: 256 / 32,
+      iterations: 1e5,
+      hasher: import_crypto_js6.default.algo.SHA256
+    }).toString();
+    const decrypted = import_crypto_js6.default.AES.decrypt(ciphertext, key);
+    const result = decrypted.toString(import_crypto_js6.default.enc.Utf8);
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+
+// core/scan.ts
+async function scanAddressesImpl(deriveAddress, options = {}) {
+  const maxAddresses = options.maxAddresses ?? 50;
+  const gapLimit = options.gapLimit ?? 20;
+  const includeChange = options.includeChange ?? true;
+  const { onProgress, signal, resolveNametag } = options;
+  const { connect: connect2, getBalance: getBalance2 } = await Promise.resolve().then(() => (init_network(), network_exports));
+  await connect2();
+  const foundAddresses = [];
+  let totalBalance = 0;
+  let totalScanned = 0;
+  let nametagsFoundCount = 0;
+  const chains = includeChange ? [false, true] : [false];
+  const totalToScan = maxAddresses * chains.length;
+  for (const isChange of chains) {
+    let consecutiveEmpty = 0;
+    for (let index = 0; index < maxAddresses; index++) {
+      if (signal?.aborted) break;
+      const addrInfo = deriveAddress(index, isChange);
+      totalScanned++;
+      onProgress?.({
+        scanned: totalScanned,
+        total: totalToScan,
+        currentAddress: addrInfo.address,
+        foundCount: foundAddresses.length,
+        currentGap: consecutiveEmpty,
+        nametagsFoundCount
+      });
+      try {
+        const balance = await getBalance2(addrInfo.address);
+        if (balance > 0) {
+          let nametag;
+          if (resolveNametag) {
+            try {
+              const tag = await resolveNametag(addrInfo.address);
+              if (tag) {
+                nametag = tag;
+                nametagsFoundCount++;
+              }
+            } catch {
+            }
+          }
+          foundAddresses.push({
+            index,
+            address: addrInfo.address,
+            path: addrInfo.path,
+            balance,
+            isChange,
+            nametag
+          });
+          totalBalance += balance;
+          consecutiveEmpty = 0;
+        } else {
+          consecutiveEmpty++;
+        }
+      } catch (err) {
+        console.warn(`[scanAddresses] Error checking ${addrInfo.address}:`, err);
+        consecutiveEmpty++;
+      }
+      if (consecutiveEmpty >= gapLimit) {
+        break;
+      }
+      if (totalScanned % 5 === 0) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+    }
+    if (signal?.aborted) break;
+  }
+  return {
+    addresses: foundAddresses,
+    totalBalance,
+    scannedCount: totalScanned
+  };
+}
 
 // serialization/wallet-text.ts
 var import_crypto_js7 = __toESM(require("crypto-js"), 1);
@@ -7234,10 +7427,11 @@ function parseWalletText(content) {
     );
     const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
     const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
+    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
     const data = {
       masterKey,
       chainCode: chainCode ?? void 0,
-      descriptorPath: descriptorPath ?? void 0,
+      descriptorPath: effectiveDescriptorPath,
       derivationMode: isBIP32 ? "bip32" : "wif_hmac"
     };
     return {
@@ -7280,10 +7474,11 @@ function parseAndDecryptWalletText(content, password) {
     );
     const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
     const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
+    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
     const data = {
       masterKey,
       chainCode: chainCode ?? void 0,
-      descriptorPath: descriptorPath ?? void 0,
+      descriptorPath: effectiveDescriptorPath,
       derivationMode: isBIP32 ? "bip32" : "wif_hmac"
     };
     return {
@@ -7873,6 +8068,9 @@ var Sphere = class _Sphere {
       throw new Error("Either mnemonic or masterKey is required");
     }
     await _Sphere.clear({ storage: options.storage, tokenStorage: options.tokenStorage });
+    if (!options.storage.isConnected()) {
+      await options.storage.connect();
+    }
     const sphere = new _Sphere(
       options.storage,
       options.transport,
@@ -7952,6 +8150,7 @@ var Sphere = class _Sphere {
     if (tokenStorage?.clear) {
       await tokenStorage.clear();
     }
+    await vestingClassifier.destroy();
     if (_Sphere.instance) {
       await _Sphere.instance.destroy();
     }
@@ -8134,7 +8333,7 @@ var Sphere = class _Sphere {
     return {
       source: this._source,
       hasMnemonic: this._mnemonic !== null,
-      hasChainCode: this._masterKey?.chainCode !== void 0,
+      hasChainCode: !!this._masterKey?.chainCode,
       derivationMode: this._derivationMode,
       basePath: this._basePath,
       address0
@@ -8187,7 +8386,7 @@ var Sphere = class _Sphere {
     let chainCode;
     if (this._masterKey) {
       masterPrivateKey = this._masterKey.privateKey;
-      chainCode = this._masterKey.chainCode;
+      chainCode = this._masterKey.chainCode || void 0;
     }
     let mnemonic;
     let encrypted = false;
@@ -8264,7 +8463,7 @@ var Sphere = class _Sphere {
       }
     }
     const masterPrivateKey = this._masterKey?.privateKey || "";
-    const chainCode = this._masterKey?.chainCode;
+    const chainCode = this._masterKey?.chainCode || void 0;
     const isBIP32 = this._derivationMode === "bip32";
     const descriptorPath = this._basePath.replace(/^m\//, "");
     if (options.password) {
@@ -8472,19 +8671,84 @@ var Sphere = class _Sphere {
     }
     if (fileType === "json") {
       const content = typeof fileContent === "string" ? fileContent : new TextDecoder().decode(fileContent);
-      const result = await _Sphere.importFromJSON({
-        jsonContent: content,
-        password,
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        return { success: false, error: "Invalid JSON file" };
+      }
+      if (parsed.type === "sphere-wallet") {
+        const result = await _Sphere.importFromJSON({
+          jsonContent: content,
+          password,
+          storage: options.storage,
+          transport: options.transport,
+          oracle: options.oracle,
+          tokenStorage: options.tokenStorage
+        });
+        if (result.success) {
+          const sphere2 = _Sphere.getInstance();
+          return { success: true, sphere: sphere2, mnemonic: result.mnemonic };
+        }
+        if (!password && result.error?.includes("Password required")) {
+          return { success: false, needsPassword: true, error: result.error };
+        }
+        return { success: false, error: result.error };
+      }
+      let masterKey;
+      let mnemonic;
+      if (parsed.encrypted && typeof parsed.encrypted === "object") {
+        if (!password) {
+          return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
+        }
+        const enc = parsed.encrypted;
+        if (!enc.salt || !enc.masterPrivateKey) {
+          return { success: false, error: "Invalid encrypted wallet format" };
+        }
+        const decryptedKey = decryptWithSalt(enc.masterPrivateKey, password, enc.salt);
+        if (!decryptedKey) {
+          return { success: false, error: "Failed to decrypt - incorrect password?" };
+        }
+        masterKey = decryptedKey;
+        if (enc.mnemonic) {
+          mnemonic = decryptWithSalt(enc.mnemonic, password, enc.salt) ?? void 0;
+        }
+      } else {
+        masterKey = parsed.masterPrivateKey;
+        mnemonic = parsed.mnemonic;
+      }
+      if (!masterKey) {
+        return { success: false, error: "No master key found in wallet JSON" };
+      }
+      const chainCode = parsed.chainCode;
+      const descriptorPath = parsed.descriptorPath;
+      const derivationMode = parsed.derivationMode;
+      const isBIP32 = derivationMode === "bip32" || !!chainCode;
+      const basePath = descriptorPath ? `m/${descriptorPath}` : isBIP32 ? "m/84'/1'/0'" : DEFAULT_BASE_PATH;
+      if (mnemonic) {
+        const sphere2 = await _Sphere.import({
+          mnemonic,
+          basePath,
+          storage: options.storage,
+          transport: options.transport,
+          oracle: options.oracle,
+          tokenStorage: options.tokenStorage,
+          nametag: options.nametag
+        });
+        return { success: true, sphere: sphere2, mnemonic };
+      }
+      const sphere = await _Sphere.import({
+        masterKey,
+        chainCode,
+        basePath,
+        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac"),
         storage: options.storage,
         transport: options.transport,
         oracle: options.oracle,
-        tokenStorage: options.tokenStorage
+        tokenStorage: options.tokenStorage,
+        nametag: options.nametag
       });
-      if (result.success) {
-        const sphere = _Sphere.getInstance();
-        return { success: true, sphere, mnemonic: result.mnemonic };
-      }
-      return result;
+      return { success: true, sphere };
     }
     return { success: false, error: "Unsupported file type" };
   }
@@ -8782,7 +9046,7 @@ var Sphere = class _Sphere {
       transport: this._transport,
       oracle: this._oracle,
       emitEvent,
-      chainCode: this._masterKey?.chainCode,
+      chainCode: this._masterKey?.chainCode || void 0,
       price: this._priceProvider ?? void 0
     });
     this._communications.initialize({
@@ -8827,6 +9091,9 @@ var Sphere = class _Sphere {
     if (!this._masterKey) {
       throw new Error("HD derivation requires master key with chain code");
     }
+    if (this._derivationMode === "wif_hmac") {
+      return generateAddressFromMasterKey(this._masterKey.privateKey, index);
+    }
     const info = deriveAddressInfo(
       this._masterKey,
       this._basePath,
@@ -8898,6 +9165,66 @@ var Sphere = class _Sphere {
     }
     return addresses;
   }
+  /**
+   * Scan blockchain addresses to discover used addresses with balances.
+   * Derives addresses sequentially and checks L1 balance via Fulcrum.
+   * Uses gap limit to stop after N consecutive empty addresses.
+   *
+   * @param options - Scanning options
+   * @returns Scan results with found addresses and total balance
+   *
+   * @example
+   * ```ts
+   * const result = await sphere.scanAddresses({
+   *   maxAddresses: 100,
+   *   gapLimit: 20,
+   *   onProgress: (p) => console.log(`Scanned ${p.scanned}/${p.total}, found ${p.foundCount}`),
+   * });
+   * console.log(`Found ${result.addresses.length} addresses, total: ${result.totalBalance} ALPHA`);
+   * ```
+   */
+  async scanAddresses(options = {}) {
+    this.ensureReady();
+    if (!this._masterKey) {
+      throw new Error("Address scanning requires HD master key");
+    }
+    const resolveNametag = options.resolveNametag ?? (this._transport.resolveAddressInfo ? async (l1Address) => {
+      try {
+        const info = await this._transport.resolveAddressInfo(l1Address);
+        return info?.nametag ?? null;
+      } catch {
+        return null;
+      }
+    } : void 0);
+    return scanAddressesImpl(
+      (index, isChange) => this._deriveAddressInternal(index, isChange),
+      { ...options, resolveNametag }
+    );
+  }
+  /**
+   * Bulk-track scanned addresses with visibility and nametag data.
+   * Selected addresses get `hidden: false`, unselected get `hidden: true`.
+   * Performs only 2 storage writes total (tracked addresses + nametags).
+   */
+  async trackScannedAddresses(entries) {
+    this.ensureReady();
+    for (const { index, hidden, nametag } of entries) {
+      const tracked = await this.ensureAddressTracked(index);
+      if (nametag) {
+        let nametags = this._addressNametags.get(tracked.addressId);
+        if (!nametags) {
+          nametags = /* @__PURE__ */ new Map();
+          this._addressNametags.set(tracked.addressId, nametags);
+        }
+        if (!nametags.has(0)) nametags.set(0, nametag);
+      }
+      if (tracked.hidden !== hidden) {
+        tracked.hidden = hidden;
+      }
+    }
+    await this.persistTrackedAddresses();
+    await this.persistAddressNametags();
+  }
   // ===========================================================================
   // Public Methods - Status
   // ===========================================================================
@@ -9479,8 +9806,8 @@ var Sphere = class _Sphere {
     };
     this._masterKey = masterKey;
   }
-  async initializeIdentityFromMasterKey(masterKey, chainCode, derivationPath) {
-    const basePath = derivationPath ?? DEFAULT_BASE_PATH;
+  async initializeIdentityFromMasterKey(masterKey, chainCode, _derivationPath) {
+    const basePath = this._basePath;
     const fullPath = `${basePath}/0/0`;
     let privateKey;
     if (chainCode) {
@@ -9491,8 +9818,12 @@ var Sphere = class _Sphere {
         chainCode
       };
     } else {
-      privateKey = masterKey;
-      this._masterKey = null;
+      const addr0 = generateAddressFromMasterKey(masterKey, 0);
+      privateKey = addr0.privateKey;
+      this._masterKey = {
+        privateKey: masterKey,
+        chainCode: ""
+      };
     }
     const publicKey = getPublicKey(privateKey);
     const address = publicKeyToAddress(publicKey, "alpha");
@@ -9532,7 +9863,7 @@ var Sphere = class _Sphere {
       oracle: this._oracle,
       emitEvent,
       // Pass chain code for L1 HD derivation
-      chainCode: this._masterKey?.chainCode,
+      chainCode: this._masterKey?.chainCode || void 0,
       price: this._priceProvider ?? void 0
     });
     this._communications.initialize({
@@ -9615,6 +9946,9 @@ function formatAmount(amount, options = {}) {
   return symbol ? `${readable} ${symbol}` : readable;
 }
 
+// core/index.ts
+init_bech32();
+
 // types/payment-session.ts
 function createPaymentSession(params) {
   const now = Date.now();