@unicitylabs/sphere-sdk 0.2.1 → 0.2.3

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;
@@ -631,6 +374,31 @@ async function getBalance(address) {
 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]);
@@ -638,45 +406,365 @@ async function getTransactionHistory(address) {
     console.warn("get_history returned non-array:", result);
     return [];
   }
-  return result;
+  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)));
+}
+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)));
 }
-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();
 
@@ -1447,7 +1553,7 @@ var L1PaymentsModule = class {
   _transport;
   constructor(config) {
     this._config = {
-      electrumUrl: config?.electrumUrl ?? "wss://fulcrum.alpha.unicity.network:50004",
+      electrumUrl: config?.electrumUrl ?? "wss://fulcrum.unicity.network:50004",
       network: config?.network ?? "mainnet",
       defaultFeeRate: config?.defaultFeeRate ?? 10,
       enableVesting: config?.enableVesting ?? true
@@ -1479,10 +1585,17 @@ var L1PaymentsModule = class {
         });
       }
     }
-    if (this._config.electrumUrl) {
+    this._initialized = true;
+  }
+  /**
+   * Ensure the Fulcrum WebSocket is connected. Called lazily before any
+   * operation that needs the network. If the singleton is already connected
+   * (e.g. by the address scanner), this is a no-op.
+   */
+  async ensureConnected() {
+    if (!isWebSocketConnected() && this._config.electrumUrl) {
       await connect(this._config.electrumUrl);
     }
-    this._initialized = true;
   }
   destroy() {
     if (isWebSocketConnected()) {
@@ -1540,6 +1653,7 @@ var L1PaymentsModule = class {
   }
   async send(request) {
     this.ensureInitialized();
+    await this.ensureConnected();
     if (!this._wallet || !this._identity) {
       return { success: false, error: "No wallet available" };
     }
@@ -1574,6 +1688,7 @@ var L1PaymentsModule = class {
   }
   async getBalance() {
     this.ensureInitialized();
+    await this.ensureConnected();
     const addresses = this._getWatchedAddresses();
     let totalAlpha = 0;
     let vestedSats = BigInt(0);
@@ -1605,6 +1720,7 @@ var L1PaymentsModule = class {
   }
   async getUtxos() {
     this.ensureInitialized();
+    await this.ensureConnected();
     const result = [];
     const currentHeight = await getCurrentBlockHeight();
     const allUtxos = await this._getAllUtxos();
@@ -1640,42 +1756,73 @@ var L1PaymentsModule = class {
     return result;
   }
   async getHistory(limit) {
+    await this.ensureConnected();
     this.ensureInitialized();
     const addresses = this._getWatchedAddresses();
     const transactions = [];
     const seenTxids = /* @__PURE__ */ new Set();
     const currentHeight = await getCurrentBlockHeight();
+    const txCache = /* @__PURE__ */ new Map();
+    const fetchTx = async (txid) => {
+      if (txCache.has(txid)) return txCache.get(txid);
+      const detail = await getTransaction(txid);
+      txCache.set(txid, detail);
+      return detail;
+    };
+    const addressSet = new Set(addresses.map((a) => a.toLowerCase()));
     for (const address of addresses) {
       const history = await getTransactionHistory(address);
       for (const item of history) {
         if (seenTxids.has(item.tx_hash)) continue;
         seenTxids.add(item.tx_hash);
-        const tx = await getTransaction(item.tx_hash);
+        const tx = await fetchTx(item.tx_hash);
         if (!tx) continue;
-        const isSend = tx.vin?.some(
-          (vin) => addresses.includes(vin.txid ?? "")
-        );
-        let amount = "0";
+        let isSend = false;
+        for (const vin of tx.vin ?? []) {
+          if (!vin.txid) continue;
+          const prevTx = await fetchTx(vin.txid);
+          if (prevTx?.vout?.[vin.vout]) {
+            const prevOut = prevTx.vout[vin.vout];
+            const prevAddrs = [
+              ...prevOut.scriptPubKey?.addresses ?? [],
+              ...prevOut.scriptPubKey?.address ? [prevOut.scriptPubKey.address] : []
+            ];
+            if (prevAddrs.some((a) => addressSet.has(a.toLowerCase()))) {
+              isSend = true;
+              break;
+            }
+          }
+        }
+        let amountToUs = 0;
+        let amountToOthers = 0;
         let txAddress = address;
+        let externalAddress = "";
         if (tx.vout) {
           for (const vout of tx.vout) {
-            const voutAddresses = vout.scriptPubKey?.addresses ?? [];
-            if (vout.scriptPubKey?.address) {
-              voutAddresses.push(vout.scriptPubKey.address);
-            }
-            const matchedAddr = voutAddresses.find((a) => addresses.includes(a));
-            if (matchedAddr) {
-              amount = Math.floor((vout.value ?? 0) * 1e8).toString();
-              txAddress = matchedAddr;
-              break;
+            const voutAddresses = [
+              ...vout.scriptPubKey?.addresses ?? [],
+              ...vout.scriptPubKey?.address ? [vout.scriptPubKey.address] : []
+            ];
+            const isOurs = voutAddresses.some((a) => addressSet.has(a.toLowerCase()));
+            const valueSats = Math.floor((vout.value ?? 0) * 1e8);
+            if (isOurs) {
+              amountToUs += valueSats;
+              if (!txAddress) txAddress = voutAddresses[0];
+            } else {
+              amountToOthers += valueSats;
+              if (!externalAddress && voutAddresses.length > 0) {
+                externalAddress = voutAddresses[0];
+              }
             }
           }
         }
+        const amount = isSend ? amountToOthers.toString() : amountToUs.toString();
+        const displayAddress = isSend ? externalAddress || txAddress : txAddress;
         transactions.push({
           txid: item.tx_hash,
           type: isSend ? "send" : "receive",
           amount,
-          address: txAddress,
+          address: displayAddress,
           confirmations: item.height > 0 ? currentHeight - item.height : 0,
           timestamp: tx.time ? tx.time * 1e3 : Date.now(),
           blockHeight: item.height > 0 ? item.height : void 0
@@ -1687,6 +1834,7 @@ var L1PaymentsModule = class {
   }
   async getTransaction(txid) {
     this.ensureInitialized();
+    await this.ensureConnected();
     const tx = await getTransaction(txid);
     if (!tx) return null;
     const addresses = this._getWatchedAddresses();
@@ -1722,6 +1870,7 @@ var L1PaymentsModule = class {
   }
   async estimateFee(to, amount) {
     this.ensureInitialized();
+    await this.ensureConnected();
     if (!this._wallet) {
       return { fee: "0", feeRate: this._config.defaultFeeRate ?? 10 };
     }
@@ -2241,7 +2390,9 @@ var STORAGE_KEYS_GLOBAL = {
   /** Nametag cache per address (separate from tracked addresses registry) */
   ADDRESS_NAMETAGS: "address_nametags",
   /** Active addresses registry (JSON: TrackedAddressesStorage) */
-  TRACKED_ADDRESSES: "tracked_addresses"
+  TRACKED_ADDRESSES: "tracked_addresses",
+  /** Last processed Nostr wallet event timestamp (unix seconds), keyed per pubkey */
+  LAST_WALLET_EVENT_TS: "last_wallet_event_ts"
 };
 var STORAGE_KEYS_ADDRESS = {
   /** Pending transfers for this address */
@@ -3645,7 +3796,7 @@ async function parseTokenInfo(tokenData) {
     try {
       const sdkToken = await import_Token6.Token.fromJSON(data);
       if (sdkToken.id) {
-        defaultInfo.tokenId = sdkToken.id.toString();
+        defaultInfo.tokenId = sdkToken.id.toJSON();
       }
       if (sdkToken.coins && sdkToken.coins.coins) {
         const rawCoins = sdkToken.coins.coins;
@@ -3936,8 +4087,7 @@ var PaymentsModule = class _PaymentsModule {
       maxRetries: config?.maxRetries ?? 3,
       debug: config?.debug ?? false
     };
-    const l1Enabled = config?.l1?.electrumUrl && config.l1.electrumUrl.length > 0;
-    this.l1 = l1Enabled ? new L1PaymentsModule(config?.l1) : null;
+    this.l1 = config?.l1 === null ? null : new L1PaymentsModule(config?.l1);
   }
   /** Get module configuration */
   getConfig() {
@@ -4139,7 +4289,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 +4315,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 +4464,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,
@@ -4599,13 +4749,16 @@ var PaymentsModule = class _PaymentsModule {
     if (this.paymentRequests.find((r) => r.id === transportRequest.id)) {
       return;
     }
+    const coinId = transportRequest.request.coinId;
+    const registry = TokenRegistry.getInstance();
+    const coinDef = registry.getDefinition(coinId);
     const request = {
       id: transportRequest.id,
       senderPubkey: transportRequest.senderTransportPubkey,
+      senderNametag: transportRequest.senderNametag,
       amount: transportRequest.request.amount,
-      coinId: transportRequest.request.coinId,
-      symbol: transportRequest.request.coinId,
-      // Use coinId as symbol for now
+      coinId,
+      symbol: coinDef?.symbol || coinId.slice(0, 8),
       message: transportRequest.request.message,
       recipientNametag: transportRequest.request.recipientNametag,
       requestId: transportRequest.request.requestId,
@@ -4820,35 +4973,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 +5208,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 +5271,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 +5284,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 +6813,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 +6854,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 +7185,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 +7232,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 {
@@ -7497,8 +7777,8 @@ var Sphere = class _Sphere {
     if (options.nametag) {
       await sphere.registerNametag(options.nametag);
     } else {
-      await sphere.syncIdentityWithTransport();
       await sphere.recoverNametagFromTransport();
+      await sphere.syncIdentityWithTransport();
     }
     return sphere;
   }
@@ -7545,7 +7825,15 @@ var Sphere = class _Sphere {
     if (!options.mnemonic && !options.masterKey) {
       throw new Error("Either mnemonic or masterKey is required");
     }
+    console.log("[Sphere.import] Starting import...");
+    console.log("[Sphere.import] Clearing existing wallet data...");
     await _Sphere.clear({ storage: options.storage, tokenStorage: options.tokenStorage });
+    console.log("[Sphere.import] Clear done");
+    if (!options.storage.isConnected()) {
+      console.log("[Sphere.import] Reconnecting storage...");
+      await options.storage.connect();
+      console.log("[Sphere.import] Storage reconnected");
+    }
     const sphere = new _Sphere(
       options.storage,
       options.transport,
@@ -7558,9 +7846,12 @@ var Sphere = class _Sphere {
       if (!_Sphere.validateMnemonic(options.mnemonic)) {
         throw new Error("Invalid mnemonic");
       }
+      console.log("[Sphere.import] Storing mnemonic...");
       await sphere.storeMnemonic(options.mnemonic, options.derivationPath, options.basePath);
+      console.log("[Sphere.import] Initializing identity from mnemonic...");
       await sphere.initializeIdentityFromMnemonic(options.mnemonic, options.derivationPath);
     } else if (options.masterKey) {
+      console.log("[Sphere.import] Storing master key...");
       await sphere.storeMasterKey(
         options.masterKey,
         options.chainCode,
@@ -7568,24 +7859,35 @@ var Sphere = class _Sphere {
         options.basePath,
         options.derivationMode
       );
+      console.log("[Sphere.import] Initializing identity from master key...");
       await sphere.initializeIdentityFromMasterKey(
         options.masterKey,
         options.chainCode,
         options.derivationPath
       );
     }
+    console.log("[Sphere.import] Initializing providers...");
     await sphere.initializeProviders();
+    console.log("[Sphere.import] Providers initialized. Initializing modules...");
     await sphere.initializeModules();
+    console.log("[Sphere.import] Modules initialized");
     if (!options.nametag) {
+      console.log("[Sphere.import] Recovering nametag from transport...");
       await sphere.recoverNametagFromTransport();
+      console.log("[Sphere.import] Nametag recovery done");
+      await sphere.syncIdentityWithTransport();
     }
+    console.log("[Sphere.import] Finalizing wallet creation...");
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
     _Sphere.instance = sphere;
+    console.log("[Sphere.import] Tracking address 0...");
     await sphere.ensureAddressTracked(0);
     if (options.nametag) {
+      console.log("[Sphere.import] Registering nametag...");
       await sphere.registerNametag(options.nametag);
     }
+    console.log("[Sphere.import] Import complete");
     return sphere;
   }
   /**
@@ -7610,6 +7912,10 @@ var Sphere = class _Sphere {
   static async clear(storageOrOptions) {
     const storage = "get" in storageOrOptions ? storageOrOptions : storageOrOptions.storage;
     const tokenStorage = "get" in storageOrOptions ? void 0 : storageOrOptions.tokenStorage;
+    if (!storage.isConnected()) {
+      await storage.connect();
+    }
+    console.log("[Sphere.clear] Removing storage keys...");
     await storage.remove(STORAGE_KEYS_GLOBAL.MNEMONIC);
     await storage.remove(STORAGE_KEYS_GLOBAL.MASTER_KEY);
     await storage.remove(STORAGE_KEYS_GLOBAL.CHAIN_CODE);
@@ -7622,11 +7928,30 @@ var Sphere = class _Sphere {
     await storage.remove(STORAGE_KEYS_GLOBAL.ADDRESS_NAMETAGS);
     await storage.remove(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
     await storage.remove(STORAGE_KEYS_ADDRESS.OUTBOX);
+    console.log("[Sphere.clear] Storage keys removed");
     if (tokenStorage?.clear) {
-      await tokenStorage.clear();
+      console.log("[Sphere.clear] Clearing token storage...");
+      try {
+        await Promise.race([
+          tokenStorage.clear(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("tokenStorage.clear() timed out after 2s")), 2e3)
+          )
+        ]);
+        console.log("[Sphere.clear] Token storage cleared");
+      } catch (err) {
+        console.warn("[Sphere.clear] Token storage clear failed/timed out:", err);
+      }
     }
+    console.log("[Sphere.clear] Destroying vesting classifier...");
+    await vestingClassifier.destroy();
+    console.log("[Sphere.clear] Vesting classifier destroyed");
     if (_Sphere.instance) {
+      console.log("[Sphere.clear] Destroying Sphere instance...");
       await _Sphere.instance.destroy();
+      console.log("[Sphere.clear] Sphere instance destroyed");
+    } else {
+      console.log("[Sphere.clear] No Sphere instance to destroy");
     }
   }
   /**
@@ -7807,7 +8132,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 +8185,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 +8262,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) {
@@ -8007,7 +8332,8 @@ var Sphere = class _Sphere {
           storage: options.storage,
           transport: options.transport,
           oracle: options.oracle,
-          tokenStorage: options.tokenStorage
+          tokenStorage: options.tokenStorage,
+          l1: options.l1
         });
         return { success: true, mnemonic };
       }
@@ -8020,7 +8346,8 @@ var Sphere = class _Sphere {
           storage: options.storage,
           transport: options.transport,
           oracle: options.oracle,
-          tokenStorage: options.tokenStorage
+          tokenStorage: options.tokenStorage,
+          l1: options.l1
         });
         return { success: true };
       }
@@ -8079,7 +8406,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere, mnemonic };
     }
@@ -8108,7 +8436,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere };
     }
@@ -8139,25 +8468,94 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, 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,
+          l1: options.l1
+        });
+        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,
+          l1: options.l1
+        });
+        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,
+        l1: options.l1
       });
-      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 +8853,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 +8898,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 +8972,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
   // ===========================================================================
@@ -8955,35 +9416,40 @@ var Sphere = class _Sphere {
     if (this._identity?.nametag) {
       return;
     }
-    if (!this._transport.recoverNametag) {
+    let recoveredNametag = null;
+    if (this._transport.recoverNametag) {
+      try {
+        recoveredNametag = await this._transport.recoverNametag();
+      } catch {
+      }
+    }
+    if (!recoveredNametag && this._transport.resolveAddressInfo && this._identity?.l1Address) {
+      try {
+        const info = await this._transport.resolveAddressInfo(this._identity.l1Address);
+        if (info?.nametag) {
+          recoveredNametag = info.nametag;
+        }
+      } catch {
+      }
+    }
+    if (!recoveredNametag) {
       return;
     }
     try {
-      const recoveredNametag = await this._transport.recoverNametag();
-      if (recoveredNametag) {
-        if (this._identity) {
-          this._identity.nametag = recoveredNametag;
-          await this._updateCachedProxyAddress();
-        }
-        const entry = await this.ensureAddressTracked(this._currentAddressIndex);
-        let nametags = this._addressNametags.get(entry.addressId);
-        if (!nametags) {
-          nametags = /* @__PURE__ */ new Map();
-          this._addressNametags.set(entry.addressId, nametags);
-        }
-        const nextIndex = nametags.size;
-        nametags.set(nextIndex, recoveredNametag);
-        await this.persistAddressNametags();
-        if (this._transport.publishIdentityBinding) {
-          await this._transport.publishIdentityBinding(
-            this._identity.chainPubkey,
-            this._identity.l1Address,
-            this._identity.directAddress || "",
-            recoveredNametag
-          );
-        }
-        this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
+      if (this._identity) {
+        this._identity.nametag = recoveredNametag;
+        await this._updateCachedProxyAddress();
+      }
+      const entry = await this.ensureAddressTracked(this._currentAddressIndex);
+      let nametags = this._addressNametags.get(entry.addressId);
+      if (!nametags) {
+        nametags = /* @__PURE__ */ new Map();
+        this._addressNametags.set(entry.addressId, nametags);
       }
+      const nextIndex = nametags.size;
+      nametags.set(nextIndex, recoveredNametag);
+      await this.persistAddressNametags();
+      this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
     } catch {
     }
   }
@@ -9152,8 +9618,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 +9630,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");
@@ -9188,8 +9658,12 @@ var Sphere = class _Sphere {
     for (const provider of this._tokenStorageProviders.values()) {
       provider.setIdentity(this._identity);
     }
-    await this._storage.connect();
-    await this._transport.connect();
+    if (!this._storage.isConnected()) {
+      await this._storage.connect();
+    }
+    if (!this._transport.isConnected()) {
+      await this._transport.connect();
+    }
     await this._oracle.initialize();
     for (const provider of this._tokenStorageProviders.values()) {
       await provider.initialize();
@@ -9205,7 +9679,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 +9766,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 +9790,7 @@ var CurrencyUtils = {
   decryptJson,
   decryptMnemonic,
   decryptSimple,
+  decryptWithSalt,
   deriveAddressInfo,
   deriveChildKey,
   deriveKeyAtPath,
@@ -9354,6 +9832,7 @@ var CurrencyUtils = {
   randomHex,
   randomUUID,
   ripemd160,
+  scanAddressesImpl,
   serializeEncrypted,
   sha256,
   sleep,