@unicitylabs/sphere-sdk 0.2.1 → 0.2.2

package/dist/core/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,82 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// core/index.ts
-var core_exports = {};
-__export(core_exports, {
-  CHARSET: () => CHARSET,
-  CurrencyUtils: () => CurrencyUtils,
-  DEFAULT_DERIVATION_PATH: () => DEFAULT_DERIVATION_PATH,
-  DEFAULT_TOKEN_DECIMALS: () => DEFAULT_TOKEN_DECIMALS,
-  Sphere: () => Sphere,
-  base58Decode: () => base58Decode,
-  base58Encode: () => base58Encode,
-  bytesToHex: () => bytesToHex2,
-  computeHash160: () => computeHash160,
-  convertBits: () => convertBits,
-  createAddress: () => createAddress,
-  createBech32: () => createBech32,
-  createKeyPair: () => createKeyPair,
-  createSphere: () => createSphere,
-  decodeBech32: () => decodeBech32,
-  decrypt: () => decrypt2,
-  decryptJson: () => decryptJson,
-  decryptMnemonic: () => decryptMnemonic,
-  decryptSimple: () => decryptSimple,
-  deriveAddressInfo: () => deriveAddressInfo,
-  deriveChildKey: () => deriveChildKey,
-  deriveKeyAtPath: () => deriveKeyAtPath,
-  deserializeEncrypted: () => deserializeEncrypted,
-  doubleSha256: () => doubleSha256,
-  ec: () => ec,
-  encodeBech32: () => encodeBech32,
-  encrypt: () => encrypt2,
-  encryptMnemonic: () => encryptMnemonic,
-  encryptSimple: () => encryptSimple,
-  entropyToMnemonic: () => entropyToMnemonic2,
-  extractFromText: () => extractFromText,
-  findPattern: () => findPattern,
-  formatAmount: () => formatAmount,
-  generateAddressInfo: () => generateAddressInfo,
-  generateMasterKey: () => generateMasterKey,
-  generateMnemonic: () => generateMnemonic2,
-  generateRandomKey: () => generateRandomKey,
-  getAddressHrp: () => getAddressHrp,
-  getPublicKey: () => getPublicKey,
-  getSphere: () => getSphere,
-  hash160: () => hash160,
-  hash160ToBytes: () => hash160ToBytes,
-  hexToBytes: () => hexToBytes,
-  identityFromMnemonic: () => identityFromMnemonic,
-  identityFromMnemonicSync: () => identityFromMnemonicSync,
-  importSphere: () => importSphere,
-  initSphere: () => initSphere,
-  isEncryptedData: () => isEncryptedData,
-  isValidBech32: () => isValidBech32,
-  isValidPrivateKey: () => isValidPrivateKey,
-  loadSphere: () => loadSphere,
-  mnemonicToEntropy: () => mnemonicToEntropy2,
-  mnemonicToSeed: () => mnemonicToSeed2,
-  mnemonicToSeedSync: () => mnemonicToSeedSync2,
-  privateKeyToAddressInfo: () => privateKeyToAddressInfo,
-  publicKeyToAddress: () => publicKeyToAddress,
-  randomBytes: () => randomBytes,
-  randomHex: () => randomHex,
-  randomUUID: () => randomUUID,
-  ripemd160: () => ripemd160,
-  serializeEncrypted: () => serializeEncrypted,
-  sha256: () => sha256,
-  sleep: () => sleep,
-  sphereExists: () => sphereExists,
-  toHumanReadable: () => toHumanReadable,
-  toSmallestUnit: () => toSmallestUnit,
-  validateMnemonic: () => validateMnemonic2
-});
-module.exports = __toCommonJS(core_exports);
-
 // 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;
@@ -209,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("");
 }
@@ -223,267 +158,75 @@ 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"
-);
-var DEFAULT_DERIVATION_PATH = "m/44'/0'/0'";
-function generateMnemonic2(strength = 128) {
-  return bip39.generateMnemonic(strength);
-}
-function validateMnemonic2(mnemonic) {
-  return bip39.validateMnemonic(mnemonic);
-}
-async function mnemonicToSeed2(mnemonic, passphrase = "") {
-  const seedBuffer = await bip39.mnemonicToSeed(mnemonic, passphrase);
-  return Buffer.from(seedBuffer).toString("hex");
-}
-function mnemonicToSeedSync2(mnemonic, passphrase = "") {
-  const seedBuffer = bip39.mnemonicToSeedSync(mnemonic, passphrase);
-  return Buffer.from(seedBuffer).toString("hex");
-}
-function mnemonicToEntropy2(mnemonic) {
-  return bip39.mnemonicToEntropy(mnemonic);
-}
-function entropyToMnemonic2(entropy) {
-  return bip39.entropyToMnemonic(entropy);
+// 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 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");
+function waitForConnection() {
+  if (isWebSocketConnected()) {
+    return Promise.resolve();
   }
-  return {
-    privateKey: IL,
-    chainCode: IR
-  };
+  return new Promise((resolve, reject) => {
+    const callback = {
+      resolve: () => {
+        if (callback.timeoutId) clearTimeout(callback.timeoutId);
+        resolve();
+      },
+      reject: (err) => {
+        if (callback.timeoutId) clearTimeout(callback.timeoutId);
+        reject(err);
+      }
+    };
+    callback.timeoutId = setTimeout(() => {
+      const idx = connectionCallbacks.indexOf(callback);
+      if (idx > -1) connectionCallbacks.splice(idx, 1);
+      reject(new Error("Connection timeout"));
+    }, CONNECTION_TIMEOUT);
+    connectionCallbacks.push(callback);
+  });
 }
-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");
+function connect(endpoint = DEFAULT_ENDPOINT) {
+  if (isConnected) {
+    return Promise.resolve();
   }
-  const childKeyBigInt = (ilBigInt + parentKeyBigInt) % CURVE_ORDER;
-  if (childKeyBigInt === 0n) {
-    throw new Error("Invalid key: child key is zero");
+  if (isConnecting) {
+    return waitForConnection();
   }
-  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);
-}
-async function identityFromMnemonic(mnemonic, passphrase = "") {
-  if (!validateMnemonic2(mnemonic)) {
-    throw new Error("Invalid mnemonic phrase");
-  }
-  const seedHex = await mnemonicToSeed2(mnemonic, passphrase);
-  return generateMasterKey(seedHex);
-}
-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);
-
-// l1/address.ts
-var import_crypto_js4 = __toESM(require("crypto-js"), 1);
-
-// 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;
-}
-function waitForConnection() {
-  if (isWebSocketConnected()) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    const callback = {
-      resolve: () => {
-        if (callback.timeoutId) clearTimeout(callback.timeoutId);
-        resolve();
-      },
-      reject: (err) => {
-        if (callback.timeoutId) clearTimeout(callback.timeoutId);
-        reject(err);
-      }
-    };
-    callback.timeoutId = setTimeout(() => {
-      const idx = connectionCallbacks.indexOf(callback);
-      if (idx > -1) connectionCallbacks.splice(idx, 1);
-      reject(new Error("Connection timeout"));
-    }, CONNECTION_TIMEOUT);
-    connectionCallbacks.push(callback);
-  });
-}
-function connect(endpoint = DEFAULT_ENDPOINT) {
-  if (isConnected) {
-    return Promise.resolve();
-  }
-  if (isConnecting) {
-    return waitForConnection();
-  }
-  isConnecting = true;
-  return new Promise((resolve, reject) => {
-    let hasResolved = false;
-    try {
-      ws = new WebSocket(endpoint);
-    } catch (err) {
-      console.error("[L1] WebSocket constructor threw exception:", err);
-      isConnecting = false;
-      reject(err);
-      return;
+  isConnecting = true;
+  return new Promise((resolve, reject) => {
+    let hasResolved = false;
+    try {
+      ws = new WebSocket(endpoint);
+    } catch (err) {
+      console.error("[L1] WebSocket constructor threw exception:", err);
+      isConnecting = false;
+      reject(err);
+      return;
     }
     ws.onopen = () => {
       isConnected = true;
@@ -604,79 +347,424 @@ async function rpc(method, params = []) {
     ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
   });
 }
-async function getUtxo(address) {
-  const scripthash = addressToScriptHash(address);
-  const result = await rpc("blockchain.scripthash.listunspent", [scripthash]);
-  if (!Array.isArray(result)) {
-    console.warn("listunspent returned non-array:", result);
-    return [];
-  }
-  return result.map((u) => ({
-    tx_hash: u.tx_hash,
-    tx_pos: u.tx_pos,
-    value: u.value,
-    height: u.height,
-    address
-  }));
+async function getUtxo(address) {
+  const scripthash = addressToScriptHash(address);
+  const result = await rpc("blockchain.scripthash.listunspent", [scripthash]);
+  if (!Array.isArray(result)) {
+    console.warn("listunspent returned non-array:", result);
+    return [];
+  }
+  return result.map((u) => ({
+    tx_hash: u.tx_hash,
+    tx_pos: u.tx_pos,
+    value: u.value,
+    height: u.height,
+    address
+  }));
+}
+async function getBalance(address) {
+  const scriptHash = addressToScriptHash(address);
+  const result = await rpc("blockchain.scripthash.get_balance", [scriptHash]);
+  const confirmed = result.confirmed || 0;
+  const unconfirmed = result.unconfirmed || 0;
+  const totalSats = confirmed + unconfirmed;
+  const alpha = totalSats / 1e8;
+  return alpha;
+}
+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;
+  }
+});
+
+// core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  CHARSET: () => CHARSET,
+  CurrencyUtils: () => CurrencyUtils,
+  DEFAULT_DERIVATION_PATH: () => DEFAULT_DERIVATION_PATH,
+  DEFAULT_TOKEN_DECIMALS: () => DEFAULT_TOKEN_DECIMALS,
+  Sphere: () => Sphere,
+  base58Decode: () => base58Decode,
+  base58Encode: () => base58Encode,
+  bytesToHex: () => bytesToHex2,
+  computeHash160: () => computeHash160,
+  convertBits: () => convertBits,
+  createAddress: () => createAddress,
+  createBech32: () => createBech32,
+  createKeyPair: () => createKeyPair,
+  createSphere: () => createSphere,
+  decodeBech32: () => decodeBech32,
+  decrypt: () => decrypt2,
+  decryptJson: () => decryptJson,
+  decryptMnemonic: () => decryptMnemonic,
+  decryptSimple: () => decryptSimple,
+  decryptWithSalt: () => decryptWithSalt,
+  deriveAddressInfo: () => deriveAddressInfo,
+  deriveChildKey: () => deriveChildKey,
+  deriveKeyAtPath: () => deriveKeyAtPath,
+  deserializeEncrypted: () => deserializeEncrypted,
+  doubleSha256: () => doubleSha256,
+  ec: () => ec,
+  encodeBech32: () => encodeBech32,
+  encrypt: () => encrypt2,
+  encryptMnemonic: () => encryptMnemonic,
+  encryptSimple: () => encryptSimple,
+  entropyToMnemonic: () => entropyToMnemonic2,
+  extractFromText: () => extractFromText,
+  findPattern: () => findPattern,
+  formatAmount: () => formatAmount,
+  generateAddressInfo: () => generateAddressInfo,
+  generateMasterKey: () => generateMasterKey,
+  generateMnemonic: () => generateMnemonic2,
+  generateRandomKey: () => generateRandomKey,
+  getAddressHrp: () => getAddressHrp,
+  getPublicKey: () => getPublicKey,
+  getSphere: () => getSphere,
+  hash160: () => hash160,
+  hash160ToBytes: () => hash160ToBytes,
+  hexToBytes: () => hexToBytes,
+  identityFromMnemonic: () => identityFromMnemonic,
+  identityFromMnemonicSync: () => identityFromMnemonicSync,
+  importSphere: () => importSphere,
+  initSphere: () => initSphere,
+  isEncryptedData: () => isEncryptedData,
+  isValidBech32: () => isValidBech32,
+  isValidPrivateKey: () => isValidPrivateKey,
+  loadSphere: () => loadSphere,
+  mnemonicToEntropy: () => mnemonicToEntropy2,
+  mnemonicToSeed: () => mnemonicToSeed2,
+  mnemonicToSeedSync: () => mnemonicToSeedSync2,
+  privateKeyToAddressInfo: () => privateKeyToAddressInfo,
+  publicKeyToAddress: () => publicKeyToAddress,
+  randomBytes: () => randomBytes,
+  randomHex: () => randomHex,
+  randomUUID: () => randomUUID,
+  ripemd160: () => ripemd160,
+  scanAddressesImpl: () => scanAddressesImpl,
+  serializeEncrypted: () => serializeEncrypted,
+  sha256: () => sha256,
+  sleep: () => sleep,
+  sphereExists: () => sphereExists,
+  toHumanReadable: () => toHumanReadable,
+  toSmallestUnit: () => toSmallestUnit,
+  validateMnemonic: () => validateMnemonic2
+});
+module.exports = __toCommonJS(core_exports);
+
+// 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"
+);
+var DEFAULT_DERIVATION_PATH = "m/44'/0'/0'";
+function generateMnemonic2(strength = 128) {
+  return bip39.generateMnemonic(strength);
+}
+function validateMnemonic2(mnemonic) {
+  return bip39.validateMnemonic(mnemonic);
+}
+async function mnemonicToSeed2(mnemonic, passphrase = "") {
+  const seedBuffer = await bip39.mnemonicToSeed(mnemonic, passphrase);
+  return Buffer.from(seedBuffer).toString("hex");
+}
+function mnemonicToSeedSync2(mnemonic, passphrase = "") {
+  const seedBuffer = bip39.mnemonicToSeedSync(mnemonic, passphrase);
+  return Buffer.from(seedBuffer).toString("hex");
+}
+function mnemonicToEntropy2(mnemonic) {
+  return bip39.mnemonicToEntropy(mnemonic);
+}
+function entropyToMnemonic2(entropy) {
+  return bip39.entropyToMnemonic(entropy);
+}
+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)));
 }
-async function getBalance(address) {
-  const scriptHash = addressToScriptHash(address);
-  const result = await rpc("blockchain.scripthash.get_balance", [scriptHash]);
-  const confirmed = result.confirmed || 0;
-  const unconfirmed = result.unconfirmed || 0;
-  const totalSats = confirmed + unconfirmed;
-  const alpha = totalSats / 1e8;
-  return alpha;
+function publicKeyToAddress(publicKey, prefix = "alpha", witnessVersion = 0) {
+  const pubKeyHash = hash160(publicKey);
+  const programBytes = hash160ToBytes(pubKeyHash);
+  return encodeBech32(prefix, witnessVersion, programBytes);
 }
-async function broadcast(rawHex) {
-  return await rpc("blockchain.transaction.broadcast", [rawHex]);
+function privateKeyToAddressInfo(privateKey, prefix = "alpha") {
+  const publicKey = getPublicKey(privateKey);
+  const address = publicKeyToAddress(publicKey, prefix);
+  return { address, publicKey };
 }
-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 [];
+function hexToBytes(hex) {
+  const matches = hex.match(/../g);
+  if (!matches) {
+    return new Uint8Array(0);
   }
-  return result;
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
 }
-async function getTransaction(txid) {
-  return await rpc("blockchain.transaction.get", [txid, true]);
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-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 randomBytes(length) {
+  const words = import_crypto_js2.default.lib.WordArray.random(length);
+  return words.toString(import_crypto_js2.default.enc.Hex);
+}
+async function identityFromMnemonic(mnemonic, passphrase = "") {
+  if (!validateMnemonic2(mnemonic)) {
+    throw new Error("Invalid mnemonic phrase");
   }
+  const seedHex = await mnemonicToSeed2(mnemonic, passphrase);
+  return generateMasterKey(seedHex);
 }
-function disconnect() {
-  if (ws) {
-    intentionalClose = true;
-    ws.close();
-    ws = null;
+function identityFromMnemonicSync(mnemonic, passphrase = "") {
+  if (!validateMnemonic2(mnemonic)) {
+    throw new Error("Invalid mnemonic phrase");
   }
-  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;
+  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);
+
+// l1/address.ts
+var import_crypto_js4 = __toESM(require("crypto-js"), 1);
+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);
 }
 
+// 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 {
@@ -895,6 +983,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();
 
@@ -4139,7 +4245,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`);
       }
@@ -4165,7 +4271,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();
@@ -4314,7 +4420,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,
@@ -4820,35 +4926,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) => {
@@ -5051,6 +5161,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) {
@@ -5108,6 +5224,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",
@@ -5120,6 +5237,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
   // ===========================================================================
@@ -6624,6 +6766,20 @@ 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;
+  }
+}
 function encryptMnemonic(mnemonic, password) {
   return encryptSimple(mnemonic, password);
 }
@@ -6651,6 +6807,81 @@ function generateRandomKey(bytes = 32) {
   return import_crypto_js6.default.lib.WordArray.random(bytes).toString(import_crypto_js6.default.enc.Hex);
 }
 
+// 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);
 
@@ -6907,10 +7138,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 {
@@ -6953,10 +7185,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 {
@@ -7546,6 +7779,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,
@@ -7625,6 +7861,7 @@ var Sphere = class _Sphere {
     if (tokenStorage?.clear) {
       await tokenStorage.clear();
     }
+    await vestingClassifier.destroy();
     if (_Sphere.instance) {
       await _Sphere.instance.destroy();
     }
@@ -7807,7 +8044,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
@@ -7860,7 +8097,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;
@@ -7937,7 +8174,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) {
@@ -8145,19 +8382,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" };
   }
@@ -8455,7 +8757,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({
@@ -8500,6 +8802,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,
@@ -8571,6 +8876,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
   // ===========================================================================
@@ -9152,8 +9517,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) {
@@ -9164,8 +9529,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");
@@ -9205,7 +9574,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({
@@ -9292,6 +9661,9 @@ var CurrencyUtils = {
   toHumanReadable,
   format: formatAmount
 };
+
+// core/index.ts
+init_bech32();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHARSET,
@@ -9313,6 +9685,7 @@ var CurrencyUtils = {
   decryptJson,
   decryptMnemonic,
   decryptSimple,
+  decryptWithSalt,
   deriveAddressInfo,
   deriveChildKey,
   deriveKeyAtPath,
@@ -9354,6 +9727,7 @@ var CurrencyUtils = {
   randomHex,
   randomUUID,
   ripemd160,
+  scanAddressesImpl,
   serializeEncrypted,
   sha256,
   sleep,