navio-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,5002 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { ripemd160 } from '@noble/hashes/ripemd160';
+import * as blsctModule from 'navio-blsct';
+import { BlsctChain, setChain } from 'navio-blsct';
+export { BlsctChain, getChain, setChain } from 'navio-blsct';
+import * as net from 'net';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var Scalar2 = blsctModule.Scalar;
+var ChildKey2 = blsctModule.ChildKey;
+var PublicKey2 = blsctModule.PublicKey;
+var SubAddr2 = blsctModule.SubAddr;
+var SubAddrId2 = blsctModule.SubAddrId;
+var DoublePublicKey2 = blsctModule.DoublePublicKey;
+var calcPrivSpendingKey2 = blsctModule.calcPrivSpendingKey;
+var recoverAmount2 = blsctModule.recoverAmount;
+var ViewTag2 = blsctModule.ViewTag;
+var HashId2 = blsctModule.HashId;
+var calcNonce2 = blsctModule.calcNonce;
+var getAmountRecoveryResultSize2 = blsctModule.getAmountRecoveryResultSize;
+var getAmountRecoveryResultIsSucc2 = blsctModule.getAmountRecoveryResultIsSucc;
+var getAmountRecoveryResultAmount2 = blsctModule.getAmountRecoveryResultAmount;
+var deleteAmountsRetVal2 = blsctModule.deleteAmountsRetVal;
+var KeyManager = class {
+  constructor() {
+    this.hdChain = null;
+    this.viewKey = null;
+    this.spendPublicKey = null;
+    this.masterSeed = null;
+    this.spendKeyId = null;
+    this.viewKeyId = null;
+    this.tokenKeyId = null;
+    this.blindingKeyId = null;
+    this.seedId = null;
+    // In-memory key storage (replicates KeyRing functionality)
+    this.keys = /* @__PURE__ */ new Map();
+    // keyId (hex) -> secret key
+    this.outKeys = /* @__PURE__ */ new Map();
+    // outId (hex) -> secret key
+    this.cryptedKeys = /* @__PURE__ */ new Map();
+    // keyId -> encrypted key
+    this.cryptedOutKeys = /* @__PURE__ */ new Map();
+    // outId -> encrypted key
+    this.keyMetadata = /* @__PURE__ */ new Map();
+    // keyId -> metadata
+    // SubAddress management
+    this.subAddressCounter = /* @__PURE__ */ new Map();
+    this.subAddresses = /* @__PURE__ */ new Map();
+    // hashId (hex) -> SubAddressIdentifier
+    this.subAddressesStr = /* @__PURE__ */ new Map();
+    // SubAddress (serialized) -> hashId (hex)
+    this.subAddressPool = /* @__PURE__ */ new Map();
+    // account -> Set<address indices>
+    this.subAddressPoolTime = /* @__PURE__ */ new Map();
+    // "${account}:${address}" -> timestamp
+    this.timeFirstKey = null;
+    // Creation time of first key
+    // Flags
+    this.fViewKeyDefined = false;
+    this.fSpendKeyDefined = false;
+  }
+  /**
+   * Check if HD is enabled (has a seed)
+   * @returns True if HD is enabled
+   */
+  isHDEnabled() {
+    return this.seedId !== null;
+  }
+  /**
+   * Check if the wallet can generate new keys
+   * @returns True if HD is enabled
+   */
+  canGenerateKeys() {
+    return this.isHDEnabled();
+  }
+  /**
+   * Generate a new random seed
+   * @returns A new random Scalar (seed)
+   */
+  generateNewSeed() {
+    return new Scalar2();
+  }
+  /**
+   * Set the HD seed and derive all master keys
+   * This replicates SetHDSeed from keyman.cpp
+   * Uses navio-blsct API: ChildKey(seed).toTxKey().toViewKey() etc.
+   * @param seed - The master seed Scalar
+   */
+  setHDSeed(seed) {
+    this.masterSeed = seed;
+    const childKey = new ChildKey2(seed);
+    const txKey = childKey.toTxKey();
+    const blindingKey = childKey.toBlindingKey();
+    const tokenKey = childKey.toTokenKey();
+    const viewKey = Scalar2.deserialize(txKey.toViewKey().serialize());
+    const spendKey = Scalar2.deserialize(txKey.toSpendingKey().serialize());
+    this.viewKey = viewKey;
+    let spendPublicKey = PublicKey2.fromScalar(spendKey);
+    this.spendPublicKey = spendPublicKey;
+    const seedPublicKey = this.getPublicKeyFromScalar(seed);
+    const viewPublicKey = this.getPublicKeyFromViewKey(viewKey);
+    const spendPublicKeyBytes = this.getPublicKeyBytes(this.spendPublicKey);
+    const tokenPublicKey = this.getPublicKeyFromScalar(tokenKey);
+    const blindingPublicKey = this.getPublicKeyFromScalar(blindingKey);
+    this.seedId = this.hash160(seedPublicKey);
+    this.spendKeyId = this.hash160(spendPublicKeyBytes);
+    this.viewKeyId = this.hash160(viewPublicKey);
+    this.tokenKeyId = this.hash160(tokenPublicKey);
+    this.blindingKeyId = this.hash160(blindingPublicKey);
+    this.hdChain = {
+      version: 1,
+      // HDChain::VERSION_HD_BASE
+      seedId: this.seedId,
+      spendId: this.spendKeyId,
+      viewId: this.viewKeyId,
+      tokenId: this.tokenKeyId,
+      blindingId: this.blindingKeyId
+    };
+    this.subAddressCounter.clear();
+  }
+  /**
+   * Setup key generation from a seed
+   * Replicates SetupGeneration from keyman.cpp
+   * @param seedBytes - The seed bytes (32 bytes for master key, 80 bytes for view/spend keys)
+   * @param type - The type of seed being imported
+   * @param force - Force setup even if HD is already enabled
+   * @returns True if setup was successful
+   */
+  setupGeneration(seedBytes, type = "IMPORT_MASTER_KEY", force = false) {
+    if (this.canGenerateKeys() && !force) {
+      return false;
+    }
+    if (seedBytes.length === 32) {
+      if (type === "IMPORT_MASTER_KEY") {
+        const seed = this.createScalarFromBytes(seedBytes);
+        this.setHDSeed(seed);
+      }
+    } else if (seedBytes.length === 80) {
+      if (type === "IMPORT_VIEW_KEY") {
+        const viewKeyBytes = seedBytes.slice(0, 32);
+        const spendingKeyBytes = seedBytes.slice(32, 80);
+        const viewKey = this.createViewKeyFromBytes(viewKeyBytes);
+        const spendingPublicKey = this.createPublicKeyFromBytes(spendingKeyBytes);
+        this.viewKey = Scalar2.deserialize(viewKey.serialize());
+        this.spendPublicKey = spendingPublicKey;
+      }
+    } else {
+      const seed = this.generateNewSeed();
+      this.setHDSeed(seed);
+    }
+    this.newSubAddressPool(0);
+    this.newSubAddressPool(-1);
+    this.newSubAddressPool(-2);
+    return true;
+  }
+  /**
+   * Get the master seed key
+   * @returns The master seed Scalar
+   */
+  getMasterSeedKey() {
+    if (!this.isHDEnabled()) {
+      throw new Error("HD is not enabled");
+    }
+    if (!this.masterSeed) {
+      throw new Error("Master seed key not available");
+    }
+    return this.masterSeed;
+  }
+  /**
+   * Get the private view key
+   * @returns The view key
+   */
+  getPrivateViewKey() {
+    if (!this.viewKey) {
+      throw new Error("View key is not available");
+    }
+    return this.viewKey;
+  }
+  /**
+   * Get the public spending key
+   * @returns The public spending key
+   */
+  getPublicSpendingKey() {
+    if (!this.spendPublicKey) {
+      throw new Error("Spending key is not available");
+    }
+    return this.spendPublicKey;
+  }
+  /**
+   * Get a sub-address for the given identifier
+   * Uses navio-blsct SubAddr.generate() method
+   * @param id - The sub-address identifier (defaults to account 0, address 0)
+   * @returns The sub-address (SubAddr)
+   */
+  getSubAddress(id = { account: 0, address: 0 }) {
+    if (!this.viewKey || !this.spendPublicKey) {
+      throw new Error("View key or spending key not available");
+    }
+    const subAddrId = SubAddrId2.generate(id.account, id.address);
+    return SubAddr2.generate(this.viewKey, this.spendPublicKey, subAddrId);
+  }
+  /**
+   * Generate a new sub-address for the given account
+   * @param account - The account number (0 for main, -1 for change, -2 for staking)
+   * @returns The generated sub-address and its identifier
+   */
+  generateNewSubAddress(account) {
+    if (!this.canGenerateKeys()) {
+      throw new Error("Cannot generate keys - HD not enabled");
+    }
+    if (!this.viewKey || !this.spendPublicKey) {
+      throw new Error("View key or spending public key not available");
+    }
+    if (!this.subAddressCounter.has(account)) {
+      this.subAddressCounter.set(account, 0);
+    }
+    const addressIndex = this.subAddressCounter.get(account);
+    const id = { account, address: addressIndex };
+    this.subAddressCounter.set(account, addressIndex + 1);
+    const subAddress = this.getSubAddress(id);
+    const dpk = DoublePublicKey2.fromKeysAcctAddr(this.viewKey, this.spendPublicKey, account, addressIndex);
+    const serialized = dpk.serialize();
+    const spendingKeyHex = serialized.substring(96);
+    const spendingKeyBytes = Buffer.from(spendingKeyHex, "hex");
+    const hashIdBytes = this.hash160(spendingKeyBytes);
+    const hashIdHex = this.bytesToHex(hashIdBytes);
+    this.subAddresses.set(hashIdHex, id);
+    return { subAddress, id };
+  }
+  /**
+   * Get a new destination (sub-address) from the pool or generate one
+   * @param account - The account number
+   * @returns The sub-address destination (SubAddr)
+   */
+  getNewDestination(account = 0) {
+    this.topUp();
+    this.getSubAddressPoolSize(account);
+    const { subAddress } = this.generateNewSubAddress(account);
+    return subAddress;
+  }
+  /**
+   * Create a new sub-address pool for an account
+   * @param account - The account number
+   * @returns True if successful
+   */
+  newSubAddressPool(account) {
+    this.subAddressPool.set(account, /* @__PURE__ */ new Set());
+    return this.topUpAccount(account);
+  }
+  /**
+   * Top up all sub-address pools
+   * @param size - Target size for pools (0 = use default)
+   * @returns True if successful
+   */
+  topUp(size = 0) {
+    if (!this.canGenerateKeys()) {
+      return false;
+    }
+    const targetSize = size > 0 ? size : 100;
+    for (const account of Array.from(this.subAddressPool.keys())) {
+      if (!this.topUpAccount(account, targetSize)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Top up a specific account's sub-address pool
+   * @param account - The account number
+   * @param size - Target size (0 = use default)
+   * @returns True if successful
+   */
+  topUpAccount(account, size = 0) {
+    const targetSize = size > 0 ? size : 100;
+    if (!this.subAddressPool.has(account)) {
+      this.subAddressPool.set(account, /* @__PURE__ */ new Set());
+    }
+    const pool = this.subAddressPool.get(account);
+    const missing = Math.max(targetSize - pool.size, 0);
+    for (let i = 0; i < missing; i++) {
+      const { id } = this.generateNewSubAddress(account);
+      pool.add(id.address);
+    }
+    return true;
+  }
+  /**
+   * Get the size of the sub-address pool for an account
+   * @param account - The account number
+   * @returns The pool size
+   */
+  getSubAddressPoolSize(account) {
+    return this.subAddressPool.get(account)?.size ?? 0;
+  }
+  /**
+   * Calculate hash ID from blinding and spending keys
+   * Uses HashId.generate() from navio-blsct
+   * @param blindingKey - The blinding public key
+   * @param spendingKey - The spending public key
+   * @returns The hash ID (20 bytes)
+   */
+  calculateHashId(blindingKey, spendingKey) {
+    if (!this.viewKey) {
+      throw new Error("View key not available");
+    }
+    const hashId = HashId2.generate(blindingKey, spendingKey, this.viewKey);
+    const hashIdHex = hashId.serialize();
+    return Uint8Array.from(Buffer.from(hashIdHex, "hex"));
+  }
+  /**
+   * Calculate view tag for output detection
+   * Uses ViewTag from navio-blsct
+   * @param blindingKey - The blinding public key
+   * @returns The view tag (16-bit number)
+   */
+  calculateViewTag(blindingKey) {
+    if (!this.viewKey) {
+      throw new Error("View key not available");
+    }
+    const viewTagObj = new ViewTag2(blindingKey, this.viewKey);
+    return viewTagObj.value;
+  }
+  /**
+   * Calculate nonce for range proof recovery
+   * Uses calcNonce from navio-blsct
+   * @param blindingKey - The blinding public key
+   * @returns The nonce (Point)
+   */
+  calculateNonce(blindingKey) {
+    if (!this.viewKey) {
+      throw new Error("View key not available");
+    }
+    const result = calcNonce2(blindingKey.value(), this.viewKey.value());
+    const Point2 = blsctModule.Point;
+    return new Point2(result);
+  }
+  /**
+   * Get the HD chain information
+   * @returns The HD chain or null if not set
+   */
+  getHDChain() {
+    return this.hdChain;
+  }
+  // ============================================================================
+  // Key Loading Methods (from database - don't persist, just load into memory)
+  // ============================================================================
+  /**
+   * Load a key pair from storage into memory (used by LoadWallet)
+   * Replicates LoadKey from keyman.cpp
+   * @param secretKey - The secret key
+   * @param publicKey - The public key
+   * @returns True if successful
+   */
+  loadKey(secretKey, publicKey) {
+    return this.addKeyPubKeyInner(secretKey, publicKey);
+  }
+  /**
+   * Load a view key from storage into memory
+   * Replicates LoadViewKey from keyman.cpp
+   * @param viewKey - The view key
+   * @param publicKey - The view key's public key
+   * @returns True if successful
+   */
+  loadViewKey(viewKey) {
+    if (!this.fViewKeyDefined) {
+      this.viewKey = Scalar2.deserialize(viewKey.serialize());
+      this.fViewKeyDefined = true;
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Load a spend key from storage into memory
+   * Replicates LoadSpendKey from keyman.cpp
+   * @param publicKey - The spending public key
+   * @returns True if successful
+   */
+  loadSpendKey(publicKey) {
+    if (!this.fSpendKeyDefined) {
+      this.spendPublicKey = publicKey;
+      this.fSpendKeyDefined = true;
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Load an output key from storage into memory
+   * Replicates LoadOutKey from keyman.cpp
+   * @param secretKey - The secret key for the output
+   * @param outId - The output ID (uint256)
+   * @returns True if successful
+   */
+  loadOutKey(secretKey, outId) {
+    return this.addKeyOutKeyInner(secretKey, outId);
+  }
+  /**
+   * Load an encrypted key from storage into memory
+   * Replicates LoadCryptedKey from keyman.cpp
+   * @param publicKey - The public key
+   * @param encryptedSecret - The encrypted secret key
+   * @param checksumValid - Whether the checksum is valid
+   * @returns True if successful
+   */
+  loadCryptedKey(publicKey, encryptedSecret, checksumValid) {
+    return this.addCryptedKeyInner(publicKey, encryptedSecret);
+  }
+  /**
+   * Load an encrypted output key from storage into memory
+   * Replicates LoadCryptedOutKey from keyman.cpp
+   * @param outId - The output ID
+   * @param publicKey - The public key
+   * @param encryptedSecret - The encrypted secret key
+   * @param checksumValid - Whether the checksum is valid
+   * @returns True if successful
+   */
+  loadCryptedOutKey(outId, publicKey, encryptedSecret, checksumValid) {
+    return this.addCryptedOutKeyInner(outId, publicKey, encryptedSecret);
+  }
+  /**
+   * Load HD chain from storage
+   * Replicates LoadHDChain from keyman.cpp
+   * @param chain - The HD chain to load
+   */
+  loadHDChain(chain) {
+    this.hdChain = chain;
+    this.seedId = chain.seedId;
+    this.spendKeyId = chain.spendId;
+    this.viewKeyId = chain.viewId;
+    this.tokenKeyId = chain.tokenId;
+    this.blindingKeyId = chain.blindingId;
+  }
+  /**
+   * Load key metadata from storage
+   * Replicates LoadKeyMetadata from keyman.cpp
+   * @param keyId - The key ID
+   * @param metadata - The key metadata
+   */
+  loadKeyMetadata(keyId, metadata) {
+    const keyIdHex = this.bytesToHex(keyId);
+    this.keyMetadata.set(keyIdHex, metadata);
+    this.updateTimeFirstKey(metadata.nCreateTime);
+  }
+  // ============================================================================
+  // Key Adding Methods (add and persist to database)
+  // ============================================================================
+  /**
+   * Add a key pair and save to database
+   * Replicates AddKeyPubKey from keyman.cpp
+   * @param secretKey - The secret key
+   * @param publicKey - The public key
+   * @returns True if successful
+   */
+  addKeyPubKey(secretKey, publicKey) {
+    if (!this.addKeyPubKeyInner(secretKey, publicKey)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add an output key and save to database
+   * Replicates AddKeyOutKey from keyman.cpp
+   * @param secretKey - The secret key
+   * @param outId - The output ID
+   * @returns True if successful
+   */
+  addKeyOutKey(secretKey, outId) {
+    if (!this.addKeyOutKeyInner(secretKey, outId)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add a view key and save to database
+   * Replicates AddViewKey from keyman.cpp
+   * @param viewKey - The view key
+   * @param publicKey - The view key's public key
+   * @returns True if successful
+   */
+  addViewKey(viewKey, _publicKey) {
+    if (!this.fViewKeyDefined) {
+      this.viewKey = Scalar2.deserialize(viewKey.serialize());
+      this.fViewKeyDefined = true;
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Add a spend key and save to database
+   * Replicates AddSpendKey from keyman.cpp
+   * @param publicKey - The spending public key
+   * @returns True if successful
+   */
+  addSpendKey(publicKey) {
+    if (!this.fSpendKeyDefined) {
+      this.spendPublicKey = publicKey;
+      this.fSpendKeyDefined = true;
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Add an encrypted key and save to database
+   * Replicates AddCryptedKey from keyman.cpp
+   * @param publicKey - The public key
+   * @param encryptedSecret - The encrypted secret key
+   * @returns True if successful
+   */
+  addCryptedKey(publicKey, encryptedSecret) {
+    if (!this.addCryptedKeyInner(publicKey, encryptedSecret)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add an encrypted output key and save to database
+   * Replicates AddCryptedOutKey from keyman.cpp
+   * @param outId - The output ID
+   * @param publicKey - The public key
+   * @param encryptedSecret - The encrypted secret key
+   * @returns True if successful
+   */
+  addCryptedOutKey(outId, publicKey, encryptedSecret) {
+    if (!this.addCryptedOutKeyInner(outId, publicKey, encryptedSecret)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add HD chain and save to database
+   * Replicates AddHDChain from keyman.cpp
+   * @param chain - The HD chain to add
+   */
+  addHDChain(chain) {
+    this.hdChain = chain;
+    this.seedId = chain.seedId;
+    this.spendKeyId = chain.spendId;
+    this.viewKeyId = chain.viewId;
+    this.tokenKeyId = chain.tokenId;
+    this.blindingKeyId = chain.blindingId;
+  }
+  // ============================================================================
+  // Key Retrieval Methods (get keys from memory)
+  // ============================================================================
+  /**
+   * Check if a key exists
+   * Replicates HaveKey from keyman.cpp
+   * @param keyId - The key ID (hash160 of public key)
+   * @returns True if the key exists
+   */
+  haveKey(keyId) {
+    const keyIdHex = this.bytesToHex(keyId);
+    if (this.keys.has(keyIdHex)) {
+      return true;
+    }
+    if (this.cryptedKeys.has(keyIdHex)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get a key by key ID
+   * Replicates GetKey from keyman.cpp
+   * @param keyId - The key ID
+   * @returns The secret key or null if not found
+   */
+  getKey(keyId) {
+    const keyIdHex = this.bytesToHex(keyId);
+    if (this.keys.has(keyIdHex)) {
+      return this.keys.get(keyIdHex);
+    }
+    return null;
+  }
+  /**
+   * Get an output key by output ID
+   * Replicates GetOutKey from keyman.cpp
+   * @param outId - The output ID
+   * @returns The secret key or null if not found
+   */
+  getOutKey(outId) {
+    const outIdHex = this.bytesToHex(outId);
+    if (this.outKeys.has(outIdHex)) {
+      return this.outKeys.get(outIdHex);
+    }
+    return null;
+  }
+  // ============================================================================
+  // Internal helper methods for key management
+  // ============================================================================
+  /**
+   * Internal method to add a key pair (used by both Load and Add methods)
+   */
+  addKeyPubKeyInner(secretKey, publicKey) {
+    const keyId = this.hash160(this.getPublicKeyBytes(publicKey));
+    const keyIdHex = this.bytesToHex(keyId);
+    this.keys.set(keyIdHex, secretKey);
+    return true;
+  }
+  /**
+   * Internal method to add an output key (used by both Load and Add methods)
+   */
+  addKeyOutKeyInner(secretKey, outId) {
+    const outIdHex = this.bytesToHex(outId);
+    this.outKeys.set(outIdHex, secretKey);
+    return true;
+  }
+  /**
+   * Internal method to add an encrypted key (used by both Load and Add methods)
+   */
+  addCryptedKeyInner(publicKey, encryptedSecret) {
+    const keyId = this.hash160(this.getPublicKeyBytes(publicKey));
+    const keyIdHex = this.bytesToHex(keyId);
+    this.cryptedKeys.set(keyIdHex, { publicKey, encryptedSecret });
+    return true;
+  }
+  /**
+   * Internal method to add an encrypted output key (used by both Load and Add methods)
+   */
+  addCryptedOutKeyInner(outId, publicKey, encryptedSecret) {
+    const outIdHex = this.bytesToHex(outId);
+    this.cryptedOutKeys.set(outIdHex, { publicKey, encryptedSecret });
+    return true;
+  }
+  /**
+   * Update the time of the first key
+   * Replicates UpdateTimeFirstKey from keyman.cpp
+   */
+  updateTimeFirstKey(_nCreateTime) {
+  }
+  // Helper methods for key conversion
+  // These methods help convert between navio-blsct types and bytes
+  // The actual implementation depends on navio-blsct API
+  getPublicKeyFromScalar(scalar) {
+    return Uint8Array.from(Buffer.from(PublicKey2.fromScalar(scalar).serialize(), "hex"));
+  }
+  getPublicKeyFromViewKey(viewKey) {
+    return this.getPublicKeyFromScalar(Scalar2.deserialize(viewKey.serialize()));
+  }
+  getPublicKeyBytes(publicKey) {
+    return Uint8Array.from(Buffer.from(publicKey.serialize(), "hex"));
+  }
+  createScalarFromBytes(_bytes) {
+    return Scalar2.deserialize(this.bytesToHex(_bytes));
+  }
+  createViewKeyFromBytes(_bytes) {
+    return Scalar2.deserialize(this.bytesToHex(_bytes));
+  }
+  createPublicKeyFromBytes(_bytes) {
+    return PublicKey2.deserialize(this.bytesToHex(_bytes));
+  }
+  /**
+   * Compute hash160 (SHA256 followed by RIPEMD160)
+   * This is the standard hash function used in Bitcoin-like systems
+   * @param data - The data to hash
+   * @returns The hash160 result (20 bytes)
+   */
+  hash160(data) {
+    const sha256Hash = sha256(data);
+    const hash160Result = ripemd160(sha256Hash);
+    return hash160Result;
+  }
+  bytesToHex(bytes) {
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Get the private spending key
+   * Replicates GetSpendingKey from keyman.cpp
+   * @returns The private spending key (Scalar)
+   */
+  getSpendingKey() {
+    if (!this.fSpendKeyDefined) {
+      throw new Error("KeyManager: the wallet has no spend key available");
+    }
+    if (!this.spendKeyId) {
+      throw new Error("KeyManager: spend key ID not available");
+    }
+    const key = this.getKey(this.spendKeyId);
+    if (!key) {
+      throw new Error("KeyManager: could not access the spend key");
+    }
+    return key;
+  }
+  /**
+   * Get spending key for a transaction output
+   * Replicates GetSpendingKeyForOutput from keyman.cpp
+   * @param out - The transaction output
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutput(out, key) {
+    const hashId = this.getHashIdFromTxOut(out);
+    return this.getSpendingKeyForOutputById(out, hashId, key);
+  }
+  /**
+   * Get spending key for a transaction output by hash ID
+   * @param out - The transaction output
+   * @param hashId - The hash ID
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutputById(out, hashId, key) {
+    const id = { account: 0, address: 0 };
+    if (!this.getSubAddressId(hashId, id)) {
+      return false;
+    }
+    return this.getSpendingKeyForOutputBySubAddress(out, id, key);
+  }
+  /**
+   * Get spending key for a transaction output by sub-address identifier
+   * @param out - The transaction output
+   * @param id - The sub-address identifier
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutputBySubAddress(out, id, key) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      throw new Error("KeyManager: the wallet has no view key available");
+    }
+    const sk = this.getSpendingKey();
+    const blindingKey = out.blsctData.blindingKey;
+    const viewKeyScalar = this.getScalarFromViewKey(this.viewKey);
+    const spendingKeyScalar = this.getScalarFromScalar(sk);
+    key.value = calcPrivSpendingKey2(
+      blindingKey,
+      viewKeyScalar,
+      spendingKeyScalar,
+      id.account,
+      id.address
+    );
+    return true;
+  }
+  /**
+   * Get spending key for output with caching
+   * Replicates GetSpendingKeyForOutputWithCache from keyman.cpp
+   * @param out - The transaction output
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutputWithCache(out, key) {
+    const hashId = this.getHashIdFromTxOut(out);
+    return this.getSpendingKeyForOutputWithCacheById(out, hashId, key);
+  }
+  /**
+   * Get spending key for output with caching by hash ID
+   * @param out - The transaction output
+   * @param hashId - The hash ID
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutputWithCacheById(out, hashId, key) {
+    const id = { account: 0, address: 0 };
+    if (!this.getSubAddressId(hashId, id)) {
+      return false;
+    }
+    return this.getSpendingKeyForOutputWithCacheBySubAddress(out, id, key);
+  }
+  /**
+   * Get spending key for output with caching by sub-address
+   * @param out - The transaction output
+   * @param id - The sub-address identifier
+   * @param key - Output parameter for the spending key
+   * @returns True if successful
+   */
+  getSpendingKeyForOutputWithCacheBySubAddress(out, id, key) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      throw new Error("KeyManager: the wallet has no view key available");
+    }
+    const sk = this.getSpendingKey();
+    const blindingKey = out.blsctData.blindingKey;
+    const viewKeyScalar = this.getScalarFromViewKey(this.viewKey);
+    const spendingKeyScalar = this.getScalarFromScalar(sk);
+    const outIdData = new Uint8Array(
+      this.getPublicKeyBytes(blindingKey).length + this.getScalarBytes(viewKeyScalar).length + this.getScalarBytes(spendingKeyScalar).length + 8 + 8
+      // account (int64) + address (uint64)
+    );
+    let offset = 0;
+    outIdData.set(this.getPublicKeyBytes(blindingKey), offset);
+    offset += this.getPublicKeyBytes(blindingKey).length;
+    outIdData.set(this.getScalarBytes(viewKeyScalar), offset);
+    offset += this.getScalarBytes(viewKeyScalar).length;
+    outIdData.set(this.getScalarBytes(spendingKeyScalar), offset);
+    offset += this.getScalarBytes(spendingKeyScalar).length;
+    const accountView = new DataView(outIdData.buffer, offset, 8);
+    accountView.setBigInt64(0, BigInt(id.account), true);
+    offset += 8;
+    const addressView = new DataView(outIdData.buffer, offset, 8);
+    addressView.setBigUint64(0, BigInt(id.address), true);
+    const outId = sha256(outIdData);
+    const cachedKey = this.getOutKey(outId);
+    if (cachedKey) {
+      key.value = cachedKey;
+      return true;
+    }
+    const calculatedKey = calcPrivSpendingKey2(
+      blindingKey,
+      viewKeyScalar,
+      spendingKeyScalar,
+      id.account,
+      id.address
+    );
+    this.addKeyOutKey(calculatedKey, outId);
+    key.value = calculatedKey;
+    return true;
+  }
+  // ============================================================================
+  // High Priority: Output Detection
+  // ============================================================================
+  /**
+   * Check if a transaction output belongs to this wallet
+   * Replicates IsMine(txout) from keyman.cpp
+   * @param txout - The transaction output
+   * @returns True if the output belongs to this wallet
+   */
+  isMine(txout) {
+    const spendingKey = txout.blsctData.spendingKey;
+    const isZero = this.isPublicKeyZero(spendingKey);
+    if (isZero) {
+      const extractedSpendingKey = { value: null };
+      if (this.extractSpendingKeyFromScript(txout.scriptPubKey, extractedSpendingKey)) {
+        return this.isMineByKeys(
+          txout.blsctData.blindingKey,
+          extractedSpendingKey.value,
+          txout.blsctData.viewTag
+        );
+      }
+      return false;
+    }
+    return this.isMineByKeys(
+      txout.blsctData.blindingKey,
+      spendingKey,
+      txout.blsctData.viewTag
+    );
+  }
+  /**
+   * Check if output belongs to wallet by keys
+   * Replicates IsMine(blindingKey, spendingKey, viewTag) from keyman.cpp
+   * @param blindingKey - The blinding public key
+   * @param spendingKey - The spending public key
+   * @param viewTag - The view tag
+   * @returns True if the output belongs to this wallet
+   */
+  isMineByKeys(blindingKey, spendingKey, viewTag) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      return false;
+    }
+    const calculatedViewTag = this.calculateViewTag(blindingKey);
+    if (viewTag !== calculatedViewTag) {
+      return false;
+    }
+    const hashId = this.getHashId(blindingKey, spendingKey);
+    return this.haveSubAddress(hashId);
+  }
+  /**
+   * Check if a script belongs to this wallet
+   * Replicates IsMine(script) from keyman.cpp
+   * @param script - The script
+   * @returns True if the script belongs to this wallet
+   */
+  isMineByScript(_script) {
+    return false;
+  }
+  /**
+   * Get hash ID from transaction output
+   * Replicates GetHashId(txout) from keyman.cpp
+   * @param txout - The transaction output
+   * @returns The hash ID (20 bytes) or empty if not valid
+   */
+  getHashIdFromTxOut(txout) {
+    if (!txout.blsctData || txout.blsctData.viewTag === 0) {
+      return new Uint8Array(20);
+    }
+    const spendingKey = txout.blsctData.spendingKey;
+    const isZero = this.isPublicKeyZero(spendingKey);
+    if (isZero) {
+      const extractedSpendingKey = { value: null };
+      if (this.extractSpendingKeyFromScript(txout.scriptPubKey, extractedSpendingKey)) {
+        return this.getHashId(
+          txout.blsctData.blindingKey,
+          extractedSpendingKey.value
+        );
+      }
+      return new Uint8Array(20);
+    }
+    return this.getHashId(txout.blsctData.blindingKey, spendingKey);
+  }
+  /**
+   * Get hash ID from keys (public API)
+   * Replicates GetHashId(blindingKey, spendingKey) from keyman.cpp
+   * @param blindingKey - The blinding public key
+   * @param spendingKey - The spending public key
+   * @returns The hash ID (20 bytes)
+   */
+  getHashId(blindingKey, spendingKey) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      throw new Error("KeyManager: the wallet has no view key available");
+    }
+    return this.calculateHashId(blindingKey, spendingKey);
+  }
+  /**
+   * Get destination from transaction output
+   * Replicates GetDestination from keyman.cpp
+   * @param txout - The transaction output
+   * @returns The destination (SubAddress keys) or null
+   */
+  getDestination(txout) {
+    const hashId = this.getHashIdFromTxOut(txout);
+    const subAddress = { value: null };
+    if (!this.getSubAddressByHashId(hashId, subAddress)) {
+      return null;
+    }
+    return subAddress.value;
+  }
+  /**
+   * Check if output is a change output
+   * Replicates OutputIsChange from keyman.cpp
+   * @param out - The transaction output
+   * @returns True if it's a change output (account -1)
+   */
+  outputIsChange(out) {
+    const hashId = this.getHashIdFromTxOut(out);
+    const id = { account: 0, address: 0 };
+    if (!this.getSubAddressId(hashId, id)) {
+      return false;
+    }
+    return id.account === -1;
+  }
+  // ============================================================================
+  // Medium Priority: Token Keys
+  // ============================================================================
+  /**
+   * Get master token key
+   * Replicates GetMasterTokenKey from keyman.cpp
+   * @returns The master token key (Scalar)
+   */
+  getMasterTokenKey() {
+    if (!this.isHDEnabled()) {
+      throw new Error("KeyManager: the wallet has no HD enabled");
+    }
+    if (!this.tokenKeyId) {
+      throw new Error("KeyManager: token key ID not available");
+    }
+    const key = this.getKey(this.tokenKeyId);
+    if (!key) {
+      throw new Error("KeyManager: could not access the master token key");
+    }
+    return key;
+  }
+  /**
+   * Recover amounts from transaction outputs
+   * Replicates RecoverOutputs from keyman.cpp
+   * Uses navio-blsct recoverAmount function
+   * Reference: https://nav-io.github.io/libblsct-bindings/ts/functions/recoverAmount.html
+   * @param outs - Array of transaction outputs
+   * @returns Recovery result with amounts and indices
+   */
+  recoverOutputs(outs) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      return { success: false, amounts: [], indices: [] };
+    }
+    const recoveryRequests = [];
+    for (let i = 0; i < outs.length; i++) {
+      const out = outs[i];
+      if (!out.blsctData || !out.blsctData.rangeProof) {
+        continue;
+      }
+      const calculatedViewTag = this.calculateViewTag(out.blsctData.blindingKey);
+      if (out.blsctData.viewTag !== calculatedViewTag) {
+        continue;
+      }
+      const nonce = this.calculateNonce(out.blsctData.blindingKey);
+      recoveryRequests.push({
+        rangeProof: out.blsctData.rangeProof,
+        tokenId: out.tokenId,
+        nonce,
+        index: i
+      });
+    }
+    if (recoveryRequests.length === 0) {
+      return { success: false, amounts: [], indices: [] };
+    }
+    const rv = recoverAmount2(recoveryRequests);
+    try {
+      const size = getAmountRecoveryResultSize2(rv.value);
+      const amounts = [];
+      const indices = [];
+      let allSuccess = true;
+      for (let i = 0; i < size; i++) {
+        const isSucc = getAmountRecoveryResultIsSucc2(rv.value, i);
+        if (isSucc) {
+          amounts.push(getAmountRecoveryResultAmount2(rv.value, i));
+          indices.push(i);
+        } else {
+          allSuccess = false;
+        }
+      }
+      return {
+        success: allSuccess && amounts.length > 0,
+        amounts,
+        indices
+      };
+    } finally {
+      deleteAmountsRetVal2(rv);
+    }
+  }
+  /**
+   * Recover amounts from transaction outputs with nonce
+   * Replicates RecoverOutputsWithNonce from keyman.cpp
+   * @param outs - Array of transaction outputs
+   * @param nonce - The nonce (PublicKey)
+   * @returns Recovery result with amounts and indices
+   */
+  recoverOutputsWithNonce(outs, nonce) {
+    if (!this.fViewKeyDefined || !this.viewKey) {
+      return { success: false, amounts: [], indices: [] };
+    }
+    const recoveryRequests = [];
+    for (let i = 0; i < outs.length; i++) {
+      const out = outs[i];
+      if (!out.blsctData || !out.blsctData.rangeProof) {
+        continue;
+      }
+      recoveryRequests.push({
+        rangeProof: out.blsctData.rangeProof,
+        tokenId: out.tokenId,
+        nonce,
+        index: i
+      });
+    }
+    if (recoveryRequests.length === 0) {
+      return { success: false, amounts: [], indices: [] };
+    }
+    const rv = recoverAmount2(recoveryRequests);
+    try {
+      const size = getAmountRecoveryResultSize2(rv.value);
+      const amounts = [];
+      const indices = [];
+      let allSuccess = true;
+      for (let i = 0; i < size; i++) {
+        const isSucc = getAmountRecoveryResultIsSucc2(rv.value, i);
+        if (isSucc) {
+          amounts.push(getAmountRecoveryResultAmount2(rv.value, i));
+          indices.push(i);
+        } else {
+          allSuccess = false;
+        }
+      }
+      return {
+        success: allSuccess && amounts.length > 0,
+        amounts,
+        indices
+      };
+    } finally {
+      deleteAmountsRetVal2(rv);
+    }
+  }
+  // ============================================================================
+  // Medium Priority: SubAddress by Hash ID
+  // ============================================================================
+  /**
+   * Load sub-address mapping from storage
+   * Replicates LoadSubAddress from keyman.cpp
+   * @param hashId - The hash ID
+   * @param index - The sub-address identifier
+   */
+  loadSubAddress(hashId, index) {
+    const hashIdHex = this.bytesToHex(hashId);
+    this.subAddresses.set(hashIdHex, index);
+  }
+  /**
+   * Add sub-address mapping and save to database
+   * Replicates AddSubAddress from keyman.cpp
+   * @param hashId - The hash ID
+   * @param index - The sub-address identifier
+   * @returns True if successful
+   */
+  addSubAddress(hashId, index) {
+    const hashIdHex = this.bytesToHex(hashId);
+    this.subAddresses.set(hashIdHex, index);
+    return true;
+  }
+  /**
+   * Check if sub-address exists by hash ID
+   * Replicates HaveSubAddress from keyman.cpp
+   * @param hashId - The hash ID
+   * @returns True if the sub-address exists
+   */
+  haveSubAddress(hashId) {
+    const hashIdHex = this.bytesToHex(hashId);
+    return this.subAddresses.has(hashIdHex);
+  }
+  /**
+   * Get sub-address by hash ID
+   * Replicates GetSubAddress(hashId) from keyman.cpp
+   * @param hashId - The hash ID
+   * @param address - Output parameter for the sub-address
+   * @returns True if successful
+   */
+  getSubAddressByHashId(hashId, address) {
+    if (!this.haveSubAddress(hashId)) {
+      return false;
+    }
+    const hashIdHex = this.bytesToHex(hashId);
+    const id = this.subAddresses.get(hashIdHex);
+    address.value = this.getSubAddress(id);
+    return true;
+  }
+  /**
+   * Get sub-address identifier from hash ID
+   * Replicates GetSubAddressId from keyman.cpp
+   * @param hashId - The hash ID
+   * @param id - Output parameter for the sub-address identifier
+   * @returns True if successful
+   */
+  getSubAddressId(hashId, id) {
+    if (!this.haveSubAddress(hashId)) {
+      return false;
+    }
+    const hashIdHex = this.bytesToHex(hashId);
+    const storedId = this.subAddresses.get(hashIdHex);
+    id.account = storedId.account;
+    id.address = storedId.address;
+    return true;
+  }
+  /**
+   * Load sub-address string mapping from storage
+   * Replicates LoadSubAddressStr from keyman.cpp
+   * @param subAddress - The sub-address
+   * @param hashId - The hash ID
+   */
+  loadSubAddressStr(subAddress, hashId) {
+    const subAddressStr = this.serializeSubAddress(subAddress);
+    const hashIdHex = this.bytesToHex(hashId);
+    this.subAddressesStr.set(subAddressStr, hashIdHex);
+  }
+  /**
+   * Add sub-address string mapping and save to database
+   * Replicates AddSubAddressStr from keyman.cpp
+   * @param subAddress - The sub-address
+   * @param hashId - The hash ID
+   * @returns True if successful
+   */
+  addSubAddressStr(subAddress, hashId) {
+    const subAddressStr = this.serializeSubAddress(subAddress);
+    const hashIdHex = this.bytesToHex(hashId);
+    this.subAddressesStr.set(subAddressStr, hashIdHex);
+    return true;
+  }
+  /**
+   * Check if sub-address string exists
+   * Replicates HaveSubAddressStr from keyman.cpp
+   * @param subAddress - The sub-address
+   * @returns True if the sub-address string exists
+   */
+  haveSubAddressStr(subAddress) {
+    const subAddressStr = this.serializeSubAddress(subAddress);
+    return this.subAddressesStr.has(subAddressStr);
+  }
+  // ============================================================================
+  // Medium Priority: SubAddress Pool Management
+  // ============================================================================
+  /**
+   * Reserve sub-address from pool
+   * Replicates ReserveSubAddressFromPool from keyman.cpp
+   * @param account - The account number
+   * @param nIndex - Output parameter for the address index
+   * @param keypool - Output parameter for the keypool entry
+   */
+  reserveSubAddressFromPool(account, nIndex, keypool) {
+    const pool = this.subAddressPool.get(account);
+    if (!pool || pool.size === 0) {
+      throw new Error("KeyManager: Sub-address pool is empty");
+    }
+    const index = Array.from(pool)[0];
+    pool.delete(index);
+    const id = { account, address: index };
+    const subAddress = this.getSubAddress(id);
+    nIndex.value = index;
+    keypool.value = { id, subAddress };
+  }
+  /**
+   * Keep a sub-address (mark as used)
+   * Replicates KeepSubAddress from keyman.cpp
+   * @param id - The sub-address identifier
+   */
+  keepSubAddress(id) {
+    const pool = this.subAddressPool.get(id.account);
+    if (pool) {
+      pool.delete(id.address);
+    }
+    const key = `${id.account}:${id.address}`;
+    this.subAddressPoolTime.delete(key);
+  }
+  /**
+   * Return sub-address to pool
+   * Replicates ReturnSubAddress from keyman.cpp
+   * @param id - The sub-address identifier
+   */
+  returnSubAddress(id) {
+    const pool = this.subAddressPool.get(id.account);
+    if (pool) {
+      pool.add(id.address);
+      const key = `${id.account}:${id.address}`;
+      this.subAddressPoolTime.set(key, Date.now());
+    }
+  }
+  /**
+   * Get sub-address from pool
+   * Replicates GetSubAddressFromPool from keyman.cpp
+   * @param account - The account number
+   * @param result - Output parameter for the hash ID
+   * @param id - Output parameter for the sub-address identifier
+   * @returns True if successful
+   */
+  getSubAddressFromPool(account, result, id) {
+    const pool = this.subAddressPool.get(account);
+    if (!pool || pool.size === 0) {
+      return false;
+    }
+    const index = Array.from(pool)[0];
+    const subAddressId = { account, address: index };
+    const subAddress = this.getSubAddress(subAddressId);
+    const hashId = this.getHashIdFromSubAddress(subAddress);
+    result.value = hashId;
+    id.value = subAddressId;
+    return true;
+  }
+  /**
+   * Get oldest sub-address pool time
+   * Replicates GetOldestSubAddressPoolTime from keyman.cpp
+   * @param account - The account number
+   * @returns The oldest time or 0 if pool is empty
+   */
+  getOldestSubAddressPoolTime(account) {
+    const pool = this.subAddressPool.get(account);
+    if (!pool || pool.size === 0) {
+      return 0;
+    }
+    let oldestTime = Number.MAX_SAFE_INTEGER;
+    for (const index of Array.from(pool)) {
+      const key = `${account}:${index}`;
+      const time = this.subAddressPoolTime.get(key) || 0;
+      if (time < oldestTime && time > 0) {
+        oldestTime = time;
+      }
+    }
+    return oldestTime === Number.MAX_SAFE_INTEGER ? 0 : oldestTime;
+  }
+  // ============================================================================
+  // Low Priority: Utilities
+  // ============================================================================
+  /**
+   * Add inactive HD chain
+   * Replicates AddInactiveHDChain from keyman.cpp
+   * @param chain - The HD chain to add
+   */
+  addInactiveHDChain(_chain) {
+  }
+  /**
+   * Get time of first key
+   * Replicates GetTimeFirstKey from keyman.cpp
+   * @returns The creation time of the first key
+   */
+  getTimeFirstKey() {
+    return this.timeFirstKey || 0;
+  }
+  /**
+   * Extract spending key from script
+   * Replicates ExtractSpendingKeyFromScript from keyman.cpp
+   * @param script - The script
+   * @param spendingKey - Output parameter for the spending key
+   * @returns True if successful
+   */
+  extractSpendingKeyFromScript(_script, _spendingKey) {
+    return false;
+  }
+  // ============================================================================
+  // Helper methods for new functionality
+  // ============================================================================
+  /**
+   * Check if public key is zero
+   */
+  isPublicKeyZero(_publicKey) {
+    return false;
+  }
+  /**
+   * Get scalar from ViewKey
+   */
+  getScalarFromViewKey(viewKey) {
+    return Scalar2.deserialize(viewKey.serialize());
+  }
+  /**
+   * Get scalar from Scalar (identity function, but ensures type)
+   */
+  getScalarFromScalar(scalar) {
+    return scalar;
+  }
+  /**
+   * Get bytes from Scalar
+   */
+  getScalarBytes(scalar) {
+    return Uint8Array.from(Buffer.from(scalar.serialize(), "hex"));
+  }
+  /**
+   * Serialize SubAddress to string for map key
+   */
+  serializeSubAddress(subAddress) {
+    return subAddress.serialize();
+  }
+  /**
+   * Get hash ID from SubAddress
+   * Uses DoublePublicKey.deserialize(subaddress.serialize()) to extract keys
+   */
+  getHashIdFromSubAddress(subAddress) {
+    const serialized = subAddress.serialize();
+    const doublePublicKey = DoublePublicKey2.deserialize(serialized);
+    const keys = doublePublicKey.getKeys ? doublePublicKey.getKeys() : doublePublicKey;
+    const spendingKey = keys.spendingKey || keys.key1 || keys;
+    const blindingKey = keys.blindingKey || keys.key2 || keys;
+    return this.getHashId(blindingKey, spendingKey);
+  }
+};
+var initSqlJs;
+var SQL;
+async function loadSQL() {
+  if (SQL) return SQL;
+  try {
+    if (typeof globalThis.window !== "undefined") {
+      const sqlJs = await import('sql.js');
+      initSqlJs = sqlJs.default;
+      SQL = await initSqlJs({
+        // Prefer explicit override, otherwise use CDN to avoid requiring a local wasm file
+        locateFile: (file) => {
+          if (file === "sql-wasm.wasm") {
+            const override = globalThis.NAVIO_SQL_WASM_URL;
+            if (typeof override === "string" && override.length > 0) {
+              return override;
+            }
+          }
+          return `https://sql.js.org/dist/${file}`;
+        }
+      });
+    } else {
+      const sqlJs = __require("sql.js");
+      initSqlJs = sqlJs.default || sqlJs;
+      const fs = __require("fs");
+      SQL = await initSqlJs({
+        locateFile: (file) => {
+          const path = __require("path");
+          const wasmPath = path.join(__dirname, "../node_modules/sql.js/dist/sql-wasm.wasm");
+          if (fs.existsSync(wasmPath)) {
+            return wasmPath;
+          }
+          return file;
+        }
+      });
+    }
+    return SQL;
+  } catch (error) {
+    throw new Error(`Failed to load SQL.js: ${error}. Please install sql.js: npm install sql.js`);
+  }
+}
+var WalletDB = class {
+  /**
+   * Create a new WalletDB instance
+   * @param dbPath - Path to the database file (or name for in-memory)
+   * @param createIfNotExists - Create database if it doesn't exist
+   */
+  constructor(dbPath = ":memory:", _createIfNotExists = true) {
+    this.db = null;
+    this.keyManager = null;
+    this.isOpen = false;
+    this.dbPath = dbPath;
+  }
+  /**
+   * Initialize the database connection and schema
+   */
+  async initDatabase() {
+    if (this.isOpen) return;
+    const SQL2 = await loadSQL();
+    const fs = this.getFileSystem();
+    if (this.dbPath !== ":memory:" && fs && fs.existsSync && fs.existsSync(this.dbPath)) {
+      try {
+        const buffer = fs.readFileSync(this.dbPath);
+        this.db = new SQL2.Database(buffer);
+      } catch (error) {
+        this.db = new SQL2.Database();
+      }
+    } else {
+      this.db = new SQL2.Database();
+    }
+    this.createSchema();
+    this.isOpen = true;
+  }
+  /**
+   * Get file system interface (Node.js only)
+   */
+  getFileSystem() {
+    if (typeof globalThis.window === "undefined" && typeof __require !== "undefined") {
+      try {
+        return __require("fs");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Create database schema
+   * Replicates navio-core wallet database structure
+   */
+  createSchema() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS keys (
+        key_id TEXT PRIMARY KEY,
+        secret_key TEXT NOT NULL,
+        public_key TEXT NOT NULL,
+        create_time INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS out_keys (
+        out_id TEXT PRIMARY KEY,
+        secret_key TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS crypted_keys (
+        key_id TEXT PRIMARY KEY,
+        public_key TEXT NOT NULL,
+        encrypted_secret TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS crypted_out_keys (
+        out_id TEXT PRIMARY KEY,
+        public_key TEXT NOT NULL,
+        encrypted_secret TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS view_key (
+        public_key TEXT PRIMARY KEY,
+        secret_key TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS spend_key (
+        public_key TEXT PRIMARY KEY
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS hd_chain (
+        id INTEGER PRIMARY KEY,
+        version INTEGER NOT NULL,
+        seed_id TEXT NOT NULL,
+        spend_id TEXT NOT NULL,
+        view_id TEXT NOT NULL,
+        token_id TEXT NOT NULL,
+        blinding_id TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sub_addresses (
+        hash_id TEXT PRIMARY KEY,
+        account INTEGER NOT NULL,
+        address INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sub_addresses_str (
+        sub_address TEXT PRIMARY KEY,
+        hash_id TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sub_address_pool (
+        account INTEGER NOT NULL,
+        address INTEGER NOT NULL,
+        create_time INTEGER NOT NULL,
+        PRIMARY KEY (account, address)
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sub_address_counter (
+        account INTEGER PRIMARY KEY,
+        counter INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS key_metadata (
+        key_id TEXT PRIMARY KEY,
+        create_time INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS tx_keys (
+        tx_hash TEXT PRIMARY KEY,
+        block_height INTEGER NOT NULL,
+        keys_data TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_tx_keys_block_height ON tx_keys(block_height)
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS block_hashes (
+        height INTEGER PRIMARY KEY,
+        hash TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sync_state (
+        id INTEGER PRIMARY KEY,
+        last_synced_height INTEGER NOT NULL,
+        last_synced_hash TEXT NOT NULL,
+        total_tx_keys_synced INTEGER NOT NULL,
+        last_sync_time INTEGER NOT NULL,
+        chain_tip_at_last_sync INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS wallet_metadata (
+        id INTEGER PRIMARY KEY,
+        creation_height INTEGER NOT NULL DEFAULT 0,
+        creation_time INTEGER NOT NULL,
+        restored_from_seed INTEGER NOT NULL DEFAULT 0,
+        version INTEGER NOT NULL DEFAULT 1
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS wallet_outputs (
+        output_hash TEXT PRIMARY KEY,
+        tx_hash TEXT NOT NULL,
+        output_index INTEGER NOT NULL,
+        block_height INTEGER NOT NULL,
+        output_data TEXT NOT NULL,
+        amount INTEGER NOT NULL DEFAULT 0,
+        memo TEXT,
+        token_id TEXT,
+        blinding_key TEXT,
+        spending_key TEXT,
+        is_spent INTEGER NOT NULL DEFAULT 0,
+        spent_tx_hash TEXT,
+        spent_block_height INTEGER,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_wallet_outputs_tx_hash ON wallet_outputs(tx_hash)
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_wallet_outputs_block_height ON wallet_outputs(block_height)
+    `);
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_wallet_outputs_is_spent ON wallet_outputs(is_spent)
+    `);
+  }
+  /**
+   * Load wallet from database
+   * @returns The loaded KeyManager instance
+   * @throws Error if no wallet exists in the database
+   */
+  async loadWallet() {
+    await this.initDatabase();
+    const keyManager = new KeyManager();
+    const hdChainResult = this.db.exec("SELECT * FROM hd_chain LIMIT 1");
+    if (hdChainResult.length === 0 || hdChainResult[0].values.length === 0) {
+      throw new Error("No wallet found in database");
+    }
+    const row = hdChainResult[0].values[0];
+    const hdChain = {
+      version: row[1],
+      seedId: this.hexToBytes(row[2]),
+      spendId: this.hexToBytes(row[3]),
+      viewId: this.hexToBytes(row[4]),
+      tokenId: this.hexToBytes(row[5]),
+      blindingId: this.hexToBytes(row[6])
+    };
+    keyManager.loadHDChain(hdChain);
+    const viewKeyResult = this.db.exec("SELECT * FROM view_key LIMIT 1");
+    if (viewKeyResult.length > 0 && viewKeyResult[0].values.length > 0) {
+      const row2 = viewKeyResult[0].values[0];
+      const viewKey = this.deserializeViewKey(row2[1]);
+      keyManager.loadViewKey(viewKey);
+    }
+    const spendKeyResult = this.db.exec("SELECT * FROM spend_key LIMIT 1");
+    if (spendKeyResult.length > 0 && spendKeyResult[0].values.length > 0) {
+      const row2 = spendKeyResult[0].values[0];
+      const publicKey = this.deserializePublicKey(row2[0]);
+      keyManager.loadSpendKey(publicKey);
+    }
+    const keysResult = this.db.exec("SELECT * FROM keys");
+    if (keysResult.length > 0) {
+      for (const row2 of keysResult[0].values) {
+        const secretKey = this.deserializeScalar(row2[1]);
+        const publicKey = this.deserializePublicKey(row2[2]);
+        keyManager.loadKey(secretKey, publicKey);
+        const stmt = this.db.prepare("SELECT create_time FROM key_metadata WHERE key_id = ?");
+        stmt.bind([row2[0]]);
+        if (stmt.step()) {
+          const metadataRow = stmt.getAsObject();
+          keyManager.loadKeyMetadata(this.hexToBytes(row2[0]), {
+            nCreateTime: metadataRow.create_time
+          });
+        }
+        stmt.free();
+      }
+    }
+    const outKeysResult = this.db.exec("SELECT * FROM out_keys");
+    if (outKeysResult.length > 0) {
+      for (const row2 of outKeysResult[0].values) {
+        const secretKey = this.deserializeScalar(row2[1]);
+        const outId = this.hexToBytes(row2[0]);
+        keyManager.loadOutKey(secretKey, outId);
+      }
+    }
+    const cryptedKeysResult = this.db.exec("SELECT * FROM crypted_keys");
+    if (cryptedKeysResult.length > 0) {
+      for (const row2 of cryptedKeysResult[0].values) {
+        const publicKey = this.deserializePublicKey(row2[1]);
+        const encryptedSecret = this.hexToBytes(row2[2]);
+        keyManager.loadCryptedKey(publicKey, encryptedSecret, true);
+      }
+    }
+    const cryptedOutKeysResult = this.db.exec("SELECT * FROM crypted_out_keys");
+    if (cryptedOutKeysResult.length > 0) {
+      for (const row2 of cryptedOutKeysResult[0].values) {
+        const outId = this.hexToBytes(row2[0]);
+        const publicKey = this.deserializePublicKey(row2[1]);
+        const encryptedSecret = this.hexToBytes(row2[2]);
+        keyManager.loadCryptedOutKey(outId, publicKey, encryptedSecret, true);
+      }
+    }
+    const subAddressesResult = this.db.exec("SELECT * FROM sub_addresses");
+    if (subAddressesResult.length > 0) {
+      for (const row2 of subAddressesResult[0].values) {
+        const hashId = this.hexToBytes(row2[0]);
+        const id = {
+          account: row2[1],
+          address: row2[2]
+        };
+        keyManager.loadSubAddress(hashId, id);
+      }
+    }
+    const counterResult = this.db.exec("SELECT * FROM sub_address_counter");
+    if (counterResult.length > 0) {
+      for (const _row of counterResult[0].values) {
+      }
+    }
+    if (subAddressesResult.length === 0 || subAddressesResult[0].values.length === 0) {
+      keyManager.newSubAddressPool(0);
+      keyManager.newSubAddressPool(-1);
+      keyManager.newSubAddressPool(-2);
+    }
+    this.keyManager = keyManager;
+    return keyManager;
+  }
+  /**
+   * Create a new wallet
+   * @param creationHeight - Optional block height when wallet was created (for sync optimization)
+   * @returns The new KeyManager instance
+   */
+  async createWallet(creationHeight) {
+    await this.initDatabase();
+    const keyManager = new KeyManager();
+    const seed = keyManager.generateNewSeed();
+    keyManager.setHDSeed(seed);
+    keyManager.newSubAddressPool(0);
+    keyManager.newSubAddressPool(-1);
+    keyManager.newSubAddressPool(-2);
+    await this.saveWallet(keyManager);
+    await this.saveWalletMetadata({
+      creationHeight: creationHeight ?? 0,
+      creationTime: Date.now(),
+      restoredFromSeed: false
+    });
+    this.keyManager = keyManager;
+    return keyManager;
+  }
+  /**
+   * Restore wallet from seed
+   * @param seedHex - The seed as hex string
+   * @param creationHeight - Optional block height to start scanning from (for faster restore)
+   * @returns The restored KeyManager instance
+   */
+  async restoreWallet(seedHex, creationHeight) {
+    await this.initDatabase();
+    const keyManager = new KeyManager();
+    const seed = this.deserializeScalar(seedHex);
+    keyManager.setHDSeed(seed);
+    keyManager.newSubAddressPool(0);
+    keyManager.newSubAddressPool(-1);
+    keyManager.newSubAddressPool(-2);
+    await this.saveWallet(keyManager);
+    await this.saveWalletMetadata({
+      creationHeight: creationHeight ?? 0,
+      creationTime: Date.now(),
+      restoredFromSeed: true
+    });
+    this.keyManager = keyManager;
+    return keyManager;
+  }
+  /**
+   * Save wallet metadata to database
+   */
+  async saveWalletMetadata(metadata) {
+    if (!this.isOpen) {
+      await this.initDatabase();
+    }
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO wallet_metadata (id, creation_height, creation_time, restored_from_seed, version)
+      VALUES (0, ?, ?, ?, 1)
+    `);
+    stmt.run([metadata.creationHeight, metadata.creationTime, metadata.restoredFromSeed ? 1 : 0]);
+    stmt.free();
+    this.persistToDisk();
+  }
+  /**
+   * Persist database to disk (if not in-memory)
+   */
+  persistToDisk() {
+    if (this.dbPath !== ":memory:" && this.db) {
+      const fs = this.getFileSystem();
+      if (fs) {
+        const data = this.db.export();
+        const buffer = Buffer.from(data);
+        fs.writeFileSync(this.dbPath, buffer);
+      }
+    }
+  }
+  /**
+   * Get wallet metadata from database
+   * @returns Wallet metadata or null if not found
+   */
+  async getWalletMetadata() {
+    if (!this.isOpen) {
+      await this.initDatabase();
+    }
+    const result = this.db.exec("SELECT creation_height, creation_time, restored_from_seed, version FROM wallet_metadata WHERE id = 0");
+    if (result.length === 0 || result[0].values.length === 0) {
+      return null;
+    }
+    const [creationHeight, creationTime, restoredFromSeed, version] = result[0].values[0];
+    return {
+      creationHeight,
+      creationTime,
+      restoredFromSeed: restoredFromSeed === 1,
+      version
+    };
+  }
+  /**
+   * Get the wallet creation height (block height to start scanning from)
+   * @returns Creation height or 0 if not set
+   */
+  async getCreationHeight() {
+    const metadata = await this.getWalletMetadata();
+    return metadata?.creationHeight ?? 0;
+  }
+  /**
+   * Set the wallet creation height
+   * @param height - Block height
+   */
+  async setCreationHeight(height) {
+    if (!this.isOpen) {
+      await this.initDatabase();
+    }
+    const existing = await this.getWalletMetadata();
+    if (existing) {
+      const stmt = this.db.prepare("UPDATE wallet_metadata SET creation_height = ? WHERE id = 0");
+      stmt.run([height]);
+      stmt.free();
+      this.persistToDisk();
+    } else {
+      await this.saveWalletMetadata({
+        creationHeight: height,
+        creationTime: Date.now(),
+        restoredFromSeed: false
+      });
+    }
+  }
+  /**
+   * Save wallet to database
+   * @param keyManager - The KeyManager instance to save (optional, uses stored instance if not provided)
+   */
+  async saveWallet(keyManager) {
+    if (!this.isOpen) {
+      await this.initDatabase();
+    }
+    const km = keyManager || this.keyManager;
+    if (!km) {
+      throw new Error("No KeyManager instance to save");
+    }
+    this.db.run("BEGIN TRANSACTION");
+    try {
+      this.db.run("DELETE FROM keys");
+      this.db.run("DELETE FROM out_keys");
+      this.db.run("DELETE FROM crypted_keys");
+      this.db.run("DELETE FROM crypted_out_keys");
+      this.db.run("DELETE FROM view_key");
+      this.db.run("DELETE FROM spend_key");
+      this.db.run("DELETE FROM hd_chain");
+      this.db.run("DELETE FROM sub_addresses");
+      this.db.run("DELETE FROM sub_addresses_str");
+      this.db.run("DELETE FROM sub_address_pool");
+      this.db.run("DELETE FROM sub_address_counter");
+      this.db.run("DELETE FROM key_metadata");
+      const hdChain = km.getHDChain();
+      if (hdChain) {
+        const stmt = this.db.prepare(
+          `INSERT INTO hd_chain (version, seed_id, spend_id, view_id, token_id, blinding_id)
+           VALUES (?, ?, ?, ?, ?, ?)`
+        );
+        stmt.run([
+          hdChain.version,
+          this.bytesToHex(hdChain.seedId),
+          this.bytesToHex(hdChain.spendId),
+          this.bytesToHex(hdChain.viewId),
+          this.bytesToHex(hdChain.tokenId),
+          this.bytesToHex(hdChain.blindingId)
+        ]);
+        stmt.free();
+      }
+      try {
+        const viewKey = km.getPrivateViewKey();
+        const viewPublicKey = this.getPublicKeyFromViewKey(viewKey);
+        const stmt = this.db.prepare("INSERT INTO view_key (public_key, secret_key) VALUES (?, ?)");
+        stmt.run([this.serializePublicKey(viewPublicKey), this.serializeViewKey(viewKey)]);
+        stmt.free();
+      } catch {
+      }
+      try {
+        const spendPublicKey = km.getPublicSpendingKey();
+        const stmt = this.db.prepare("INSERT INTO spend_key (public_key) VALUES (?)");
+        stmt.run([this.serializePublicKey(spendPublicKey)]);
+        stmt.free();
+      } catch {
+      }
+      this.db.run("COMMIT");
+      this.persistToDisk();
+    } catch (error) {
+      this.db.run("ROLLBACK");
+      throw error;
+    }
+  }
+  /**
+   * Get the current KeyManager instance
+   */
+  getKeyManager() {
+    return this.keyManager;
+  }
+  /**
+   * Get the database instance (for use by sync modules)
+   * @internal
+   */
+  getDatabase() {
+    if (!this.isOpen) {
+      throw new Error(
+        "Database not initialized. Call loadWallet(), createWallet(), or restoreWallet() first."
+      );
+    }
+    return this.db;
+  }
+  /**
+   * Get the database path
+   * @internal
+   */
+  getDatabasePath() {
+    return this.dbPath;
+  }
+  /**
+   * Save database to disk (if not in-memory)
+   */
+  async saveDatabase() {
+    if (this.dbPath === ":memory:" || !this.isOpen) {
+      return;
+    }
+    this.persistToDisk();
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.isOpen = false;
+    }
+  }
+  // ============================================================================
+  // Serialization helpers
+  // ============================================================================
+  deserializeScalar(hex) {
+    const Scalar4 = blsctModule.Scalar;
+    return Scalar4.deserialize(hex);
+  }
+  serializeViewKey(viewKey) {
+    return viewKey.serialize();
+  }
+  deserializeViewKey(hex) {
+    const Scalar4 = blsctModule.Scalar;
+    return Scalar4.deserialize(hex);
+  }
+  serializePublicKey(publicKey) {
+    return publicKey.serialize();
+  }
+  deserializePublicKey(hex) {
+    const PublicKey5 = blsctModule.PublicKey;
+    return PublicKey5.deserialize(hex);
+  }
+  getPublicKeyFromViewKey(viewKey) {
+    const Scalar4 = blsctModule.Scalar;
+    const PublicKey5 = blsctModule.PublicKey;
+    const scalar = Scalar4.deserialize(viewKey.serialize());
+    return PublicKey5.fromScalar(scalar);
+  }
+  bytesToHex(bytes) {
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes;
+  }
+  /**
+   * Get wallet balance (sum of unspent output amounts)
+   * @param tokenId - Optional token ID to filter by (null for NAV)
+   * @returns Balance in satoshis
+   */
+  async getBalance(tokenId = null) {
+    if (!this.isOpen) {
+      throw new Error("Database not initialized");
+    }
+    let query = "SELECT SUM(amount) as total FROM wallet_outputs WHERE is_spent = 0";
+    if (tokenId === null) {
+      query += " AND (token_id IS NULL OR token_id = ?)";
+    } else {
+      query += " AND token_id = ?";
+    }
+    const result = this.db.exec(query);
+    if (result.length === 0 || result[0].values.length === 0 || result[0].values[0][0] === null) {
+      return 0n;
+    }
+    return BigInt(result[0].values[0][0]);
+  }
+  /**
+   * Get unspent outputs (UTXOs)
+   * @param tokenId - Optional token ID to filter by (null for NAV)
+   * @returns Array of unspent outputs
+   */
+  async getUnspentOutputs(tokenId = null) {
+    if (!this.isOpen) {
+      throw new Error("Database not initialized");
+    }
+    let query = `
+      SELECT output_hash, tx_hash, output_index, block_height, amount, memo, token_id, 
+             blinding_key, spending_key, is_spent, spent_tx_hash, spent_block_height
+      FROM wallet_outputs 
+      WHERE is_spent = 0
+    `;
+    const params = [];
+    if (tokenId === null) {
+      query += " AND (token_id IS NULL OR token_id = ?)";
+      params.push("0000000000000000000000000000000000000000000000000000000000000000");
+    } else {
+      query += " AND token_id = ?";
+      params.push(tokenId);
+    }
+    query += " ORDER BY block_height ASC";
+    const stmt = this.db.prepare(query);
+    if (params.length > 0) {
+      stmt.bind(params);
+    }
+    const outputs = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      outputs.push({
+        outputHash: row.output_hash,
+        txHash: row.tx_hash,
+        outputIndex: row.output_index,
+        blockHeight: row.block_height,
+        amount: BigInt(row.amount),
+        memo: row.memo,
+        tokenId: row.token_id,
+        blindingKey: row.blinding_key,
+        spendingKey: row.spending_key,
+        isSpent: row.is_spent === 1,
+        spentTxHash: row.spent_tx_hash,
+        spentBlockHeight: row.spent_block_height
+      });
+    }
+    stmt.free();
+    return outputs;
+  }
+  /**
+   * Get all outputs (spent and unspent)
+   * @returns Array of all wallet outputs
+   */
+  async getAllOutputs() {
+    if (!this.isOpen) {
+      throw new Error("Database not initialized");
+    }
+    const stmt = this.db.prepare(`
+      SELECT output_hash, tx_hash, output_index, block_height, amount, memo, token_id, 
+             blinding_key, spending_key, is_spent, spent_tx_hash, spent_block_height
+      FROM wallet_outputs 
+      ORDER BY block_height ASC
+    `);
+    const outputs = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      outputs.push({
+        outputHash: row.output_hash,
+        txHash: row.tx_hash,
+        outputIndex: row.output_index,
+        blockHeight: row.block_height,
+        amount: BigInt(row.amount),
+        memo: row.memo,
+        tokenId: row.token_id,
+        blindingKey: row.blinding_key,
+        spendingKey: row.spending_key,
+        isSpent: row.is_spent === 1,
+        spentTxHash: row.spent_tx_hash,
+        spentBlockHeight: row.spent_block_height
+      });
+    }
+    stmt.free();
+    return outputs;
+  }
+};
+var WebSocketClass;
+var isBrowserWebSocket = false;
+if (typeof globalThis.window !== "undefined" && globalThis.window?.WebSocket) {
+  WebSocketClass = globalThis.window.WebSocket;
+  isBrowserWebSocket = true;
+} else {
+  try {
+    WebSocketClass = __require("ws");
+  } catch (error) {
+    throw new Error("WebSocket not available. In Node.js, install ws: npm install ws");
+  }
+}
+function attachWebSocketHandler(ws, event, handler) {
+  if (isBrowserWebSocket) {
+    switch (event) {
+      case "open":
+        ws.onopen = handler;
+        break;
+      case "message":
+        ws.onmessage = (evt) => handler(evt.data);
+        break;
+      case "error":
+        ws.onerror = () => handler(new Error("WebSocket error"));
+        break;
+      case "close":
+        ws.onclose = handler;
+        break;
+    }
+  } else {
+    ws.on(event, handler);
+  }
+}
+var ElectrumError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ElectrumError";
+  }
+};
+var ElectrumClient = class {
+  constructor(options = {}) {
+    this.ws = null;
+    this.requestId = 0;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.connected = false;
+    this.reconnectAttempts = 0;
+    this.options = {
+      host: options.host || "localhost",
+      port: options.port || 50001,
+      ssl: options.ssl || false,
+      timeout: options.timeout || 3e4,
+      clientName: options.clientName || "navio-sdk",
+      clientVersion: options.clientVersion || "1.4"
+    };
+  }
+  /**
+   * Connect to the Electrum server
+   */
+  async connect() {
+    if (this.connected && this.ws) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const protocol = this.options.ssl ? "wss" : "ws";
+      const url = `${protocol}://${this.options.host}:${this.options.port}`;
+      try {
+        this.ws = new WebSocketClass(url);
+        attachWebSocketHandler(this.ws, "open", async () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          try {
+            await this.call("server.version", this.options.clientName, this.options.clientVersion);
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+        attachWebSocketHandler(this.ws, "message", (data) => {
+          try {
+            const dataStr = typeof data === "string" ? data : data.toString();
+            const response = JSON.parse(dataStr);
+            this.handleResponse(response);
+          } catch (error) {
+            console.error("Error parsing response:", error);
+          }
+        });
+        attachWebSocketHandler(this.ws, "error", (error) => {
+          this.connected = false;
+          if (this.reconnectAttempts === 0) {
+            reject(error);
+          }
+        });
+        attachWebSocketHandler(this.ws, "close", () => {
+          this.connected = false;
+          this.ws = null;
+          for (const [, { reject: reject2, timeout }] of Array.from(this.pendingRequests)) {
+            clearTimeout(timeout);
+            reject2(new Error("Connection closed"));
+          }
+          this.pendingRequests.clear();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Handle incoming response from server
+   */
+  handleResponse(response) {
+    if (response.id !== void 0 && this.pendingRequests.has(response.id)) {
+      const { resolve, reject, timeout } = this.pendingRequests.get(response.id);
+      clearTimeout(timeout);
+      this.pendingRequests.delete(response.id);
+      if (response.error) {
+        const error = new ElectrumError(
+          response.error.message || JSON.stringify(response.error),
+          response.error.code,
+          response.error.data
+        );
+        reject(error);
+      } else {
+        resolve(response.result);
+      }
+    }
+  }
+  /**
+   * Make an RPC call to the Electrum server
+   * @param method - RPC method name
+   * @param params - Method parameters
+   * @returns Promise resolving to the result
+   */
+  async call(method, ...params) {
+    if (!this.connected || !this.ws) {
+      throw new Error("Not connected to Electrum server. Call connect() first.");
+    }
+    return new Promise((resolve, reject) => {
+      const id = ++this.requestId;
+      const request = {
+        id,
+        method,
+        params
+      };
+      const timeout = setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Request timeout for method: ${method}`));
+        }
+      }, this.options.timeout);
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+      try {
+        this.ws.send(JSON.stringify(request));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingRequests.delete(id);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  /**
+   * Check if connected to server
+   */
+  isConnected() {
+    return this.connected;
+  }
+  // ============================================================================
+  // Blockchain Methods
+  // ============================================================================
+  /**
+   * Get server version
+   * @returns Server version information
+   */
+  async getServerVersion() {
+    return this.call("server.version", this.options.clientName, this.options.clientVersion);
+  }
+  /**
+   * Get block header for a given height
+   * @param height - Block height
+   * @returns Block header
+   */
+  async getBlockHeader(height) {
+    return this.call("blockchain.block.header", height);
+  }
+  /**
+   * Get block headers for a range of heights
+   * @param startHeight - Starting block height
+   * @param count - Number of headers to fetch
+   * @returns Block headers
+   */
+  async getBlockHeaders(startHeight, count) {
+    return this.call("blockchain.block.headers", startHeight, count);
+  }
+  /**
+   * Subscribe to block headers
+   * @param callback - Callback function for new headers
+   */
+  async subscribeBlockHeaders(callback) {
+    const header = await this.call("blockchain.headers.subscribe");
+    callback(header);
+  }
+  /**
+   * Get chain tip height
+   * @returns Current chain tip height
+   */
+  async getChainTipHeight() {
+    const response = await this.call("blockchain.headers.subscribe");
+    if (typeof response === "number") {
+      return response;
+    }
+    if (response && typeof response.height === "number") {
+      return response.height;
+    }
+    throw new Error(`Unexpected blockchain.headers.subscribe response: ${JSON.stringify(response)}`);
+  }
+  // ============================================================================
+  // Transaction Key Methods (Navio-specific)
+  // ============================================================================
+  /**
+   * Get transaction keys for a specific transaction
+   * @param txHash - Transaction hash (hex string)
+   * @returns Transaction keys
+   */
+  async getTransactionKeys(txHash) {
+    return this.call("blockchain.transaction.get_keys", txHash);
+  }
+  /**
+   * Get all transaction keys for a block
+   * @param height - Block height
+   * @returns Array of transaction keys for the block
+   */
+  async getBlockTransactionKeys(height) {
+    return this.call("blockchain.block.get_txs_keys", height);
+  }
+  /**
+   * Get transaction keys for a range of blocks (paginated)
+   * @param startHeight - Starting block height
+   * @returns Range result with blocks and next height
+   */
+  async getBlockTransactionKeysRange(startHeight) {
+    const result = await this.call("blockchain.block.get_range_txs_keys", startHeight);
+    const blocks = [];
+    if (result.blocks && Array.isArray(result.blocks)) {
+      for (let i = 0; i < result.blocks.length; i++) {
+        const blockData = result.blocks[i];
+        const blockHeight = startHeight + i;
+        const txKeys = [];
+        if (Array.isArray(blockData)) {
+          for (const txKeyData of blockData) {
+            if (typeof txKeyData === "object" && txKeyData !== null) {
+              if ("txHash" in txKeyData && "keys" in txKeyData) {
+                txKeys.push({
+                  txHash: txKeyData.txHash || "",
+                  keys: txKeyData.keys
+                });
+              } else {
+                const txHash = txKeyData.txHash || txKeyData.hash || "";
+                txKeys.push({
+                  txHash,
+                  keys: txKeyData
+                });
+              }
+            }
+          }
+        }
+        blocks.push({
+          height: blockHeight,
+          txKeys
+        });
+      }
+    }
+    return {
+      blocks,
+      nextHeight: result.next_height || startHeight + blocks.length
+    };
+  }
+  /**
+   * Fetch all transaction keys from genesis to chain tip
+   * @param progressCallback - Optional callback for progress updates
+   * @returns Array of all block transaction keys
+   */
+  async fetchAllTransactionKeys(progressCallback) {
+    const tipHeight = await this.getChainTipHeight();
+    const allBlocks = [];
+    let currentHeight = 0;
+    let totalBlocksProcessed = 0;
+    while (currentHeight <= tipHeight) {
+      const rangeResult = await this.getBlockTransactionKeysRange(currentHeight);
+      allBlocks.push(...rangeResult.blocks);
+      totalBlocksProcessed += rangeResult.blocks.length;
+      if (progressCallback) {
+        progressCallback(currentHeight, tipHeight, totalBlocksProcessed);
+      }
+      currentHeight = rangeResult.nextHeight;
+      if (currentHeight <= rangeResult.blocks[rangeResult.blocks.length - 1]?.height) {
+        throw new Error("Server did not advance next_height properly");
+      }
+    }
+    return allBlocks;
+  }
+  /**
+   * Get serialized transaction output by output hash (Navio-specific)
+   * @param outputHash - Output hash (hex string)
+   * @returns Serialized output (hex string)
+   */
+  async getTransactionOutput(outputHash) {
+    return this.call("blockchain.transaction.get_output", outputHash);
+  }
+  // ============================================================================
+  // Transaction Methods
+  // ============================================================================
+  /**
+   * Get raw transaction
+   * @param txHash - Transaction hash (hex string)
+   * @param verbose - Return verbose transaction data
+   * @param blockHash - Optional block hash for context
+   * @returns Raw transaction or verbose transaction data
+   */
+  async getRawTransaction(txHash, verbose = false, blockHash) {
+    return this.call("blockchain.transaction.get", txHash, verbose, blockHash);
+  }
+  /**
+   * Broadcast a transaction
+   * @param rawTx - Raw transaction (hex string)
+   * @returns Transaction hash if successful
+   */
+  async broadcastTransaction(rawTx) {
+    return this.call("blockchain.transaction.broadcast", rawTx);
+  }
+  // ============================================================================
+  // Address/Script Hash Methods
+  // ============================================================================
+  /**
+   * Get transaction history for a script hash
+   * @param scriptHash - Script hash (hex string, reversed)
+   * @returns Transaction history
+   */
+  async getHistory(scriptHash) {
+    return this.call("blockchain.scripthash.get_history", scriptHash);
+  }
+  /**
+   * Get unspent transaction outputs for a script hash
+   * @param scriptHash - Script hash (hex string, reversed)
+   * @returns Unspent outputs
+   */
+  async getUnspent(scriptHash) {
+    return this.call("blockchain.scripthash.listunspent", scriptHash);
+  }
+  /**
+   * Subscribe to script hash updates
+   * @param scriptHash - Script hash (hex string, reversed)
+   * @param callback - Callback for status updates
+   */
+  async subscribeScriptHash(scriptHash, callback) {
+    const status = await this.call("blockchain.scripthash.subscribe", scriptHash);
+    callback(status);
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Calculate script hash from address (for Electrum protocol)
+   * @param address - Address string
+   * @returns Script hash (hex string, reversed for Electrum)
+   */
+  static calculateScriptHash(address) {
+    const hash = ripemd160(sha256(Buffer.from(address, "utf-8")));
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+  /**
+   * Reverse a hex string (for Electrum protocol hash format)
+   * @param hex - Hex string
+   * @returns Reversed hex string
+   */
+  static reverseHex(hex) {
+    const bytes = Buffer.from(hex, "hex");
+    return Buffer.from(bytes.reverse()).toString("hex");
+  }
+};
+var TransactionKeysSync = class {
+  // Keep last 1k block hashes by default
+  /**
+   * Create a new TransactionKeysSync instance
+   * @param walletDB - The wallet database
+   * @param provider - A SyncProvider or ElectrumClient instance
+   */
+  constructor(walletDB, provider) {
+    this.keyManager = null;
+    this.syncState = null;
+    this.blockHashRetention = 1e3;
+    this.walletDB = walletDB;
+    if ("type" in provider && (provider.type === "electrum" || provider.type === "p2p" || provider.type === "custom")) {
+      this.syncProvider = provider;
+    } else {
+      this.syncProvider = this.wrapElectrumClient(provider);
+    }
+  }
+  /**
+   * Wrap an ElectrumClient as a SyncProvider for backwards compatibility
+   */
+  wrapElectrumClient(client) {
+    return {
+      type: "electrum",
+      connect: () => client.connect(),
+      disconnect: () => client.disconnect(),
+      isConnected: () => client.isConnected(),
+      getChainTipHeight: () => client.getChainTipHeight(),
+      getChainTip: async () => {
+        const height = await client.getChainTipHeight();
+        const header = await client.getBlockHeader(height);
+        const hash = Buffer.from(sha256(sha256(Buffer.from(header, "hex")))).reverse().toString("hex");
+        return { height, hash };
+      },
+      getBlockHeader: (height) => client.getBlockHeader(height),
+      getBlockHeaders: (startHeight, count) => client.getBlockHeaders(startHeight, count),
+      getBlockTransactionKeysRange: (startHeight) => client.getBlockTransactionKeysRange(startHeight),
+      getBlockTransactionKeys: async (height) => {
+        const result = await client.getBlockTransactionKeys(height);
+        return Array.isArray(result) ? result : [];
+      },
+      getTransactionOutput: (outputHash) => client.getTransactionOutput(outputHash),
+      broadcastTransaction: (rawTx) => client.broadcastTransaction(rawTx),
+      getRawTransaction: (txHash, verbose) => client.getRawTransaction(txHash, verbose)
+    };
+  }
+  /**
+   * Get the sync provider being used
+   */
+  getSyncProvider() {
+    return this.syncProvider;
+  }
+  /**
+   * Get the provider type (electrum, p2p, or custom)
+   */
+  getProviderType() {
+    return this.syncProvider.type;
+  }
+  /**
+   * Set the KeyManager instance for output detection
+   * @param keyManager - The KeyManager instance
+   */
+  setKeyManager(keyManager) {
+    this.keyManager = keyManager;
+  }
+  /**
+   * Initialize sync manager
+   * Loads sync state from database
+   */
+  async initialize() {
+    if (!this.keyManager) {
+      try {
+        this.keyManager = await this.walletDB.loadWallet();
+      } catch {
+        this.keyManager = await this.walletDB.createWallet();
+      }
+    }
+    this.syncState = await this.loadSyncState();
+  }
+  /**
+   * Get current sync state
+   */
+  getSyncState() {
+    return this.syncState;
+  }
+  /**
+   * Get last synced height
+   */
+  getLastSyncedHeight() {
+    return this.syncState?.lastSyncedHeight ?? -1;
+  }
+  /**
+   * Check if sync is needed
+   */
+  async isSyncNeeded() {
+    if (!this.syncState) {
+      return true;
+    }
+    const chainTip = await this.syncProvider.getChainTipHeight();
+    return chainTip > this.syncState.lastSyncedHeight;
+  }
+  /**
+   * Synchronize transaction keys from Electrum server
+   * @param options - Sync options
+   * @returns Number of transaction keys synced
+   */
+  async sync(options = {}) {
+    if (!this.keyManager) {
+      await this.initialize();
+    }
+    const {
+      startHeight,
+      endHeight,
+      onProgress,
+      stopOnReorg = true,
+      verifyHashes = true,
+      saveInterval = 100,
+      keepTxKeys = false,
+      blockHashRetention = 1e3
+    } = options;
+    this.blockHashRetention = blockHashRetention;
+    const lastSynced = this.syncState?.lastSyncedHeight ?? -1;
+    let defaultStartHeight = lastSynced + 1;
+    if (lastSynced === -1) {
+      const creationHeight = await this.walletDB.getCreationHeight();
+      if (creationHeight > 0) {
+        defaultStartHeight = creationHeight;
+      }
+    }
+    const syncStartHeight = startHeight ?? defaultStartHeight;
+    const chainTip = await this.syncProvider.getChainTipHeight();
+    const syncEndHeight = endHeight ?? chainTip;
+    if (syncStartHeight > syncEndHeight) {
+      return 0;
+    }
+    if (this.syncState && verifyHashes) {
+      const reorgInfo = await this.checkReorganization(this.syncState.lastSyncedHeight);
+      if (reorgInfo) {
+        if (stopOnReorg) {
+          throw new Error(
+            `Chain reorganization detected at height ${reorgInfo.height}. Old hash: ${reorgInfo.oldHash}, New hash: ${reorgInfo.newHash}. Need to revert ${reorgInfo.blocksToRevert} blocks.`
+          );
+        } else {
+          await this.handleReorganization(reorgInfo);
+        }
+      }
+    }
+    let totalTxKeysSynced = 0;
+    let currentHeight = syncStartHeight;
+    let blocksProcessed = 0;
+    let lastSaveHeight = syncStartHeight - 1;
+    while (currentHeight <= syncEndHeight) {
+      const rangeResult = await this.syncProvider.getBlockTransactionKeysRange(currentHeight);
+      const blockHeights = rangeResult.blocks.filter((block) => block.height <= syncEndHeight).map((block) => block.height);
+      let blockHeadersMap = /* @__PURE__ */ new Map();
+      if (blockHeights.length > 0 && verifyHashes) {
+        const firstHeight = blockHeights[0];
+        const count = blockHeights.length;
+        const headersResult = await this.syncProvider.getBlockHeaders(firstHeight, count);
+        const headerSize = 160;
+        const hex = headersResult.hex;
+        for (let i = 0; i < count && i * headerSize < hex.length; i++) {
+          const height = firstHeight + i;
+          const headerStart = i * headerSize;
+          const headerEnd = headerStart + headerSize;
+          const headerHex = hex.substring(headerStart, headerEnd);
+          blockHeadersMap.set(height, headerHex);
+        }
+      }
+      for (const block of rangeResult.blocks) {
+        if (block.height > syncEndHeight) {
+          break;
+        }
+        let blockHash;
+        if (verifyHashes && blockHeadersMap.has(block.height)) {
+          const blockHeader = blockHeadersMap.get(block.height);
+          blockHash = this.extractBlockHash(blockHeader);
+        } else if (verifyHashes) {
+          const blockHeader = await this.syncProvider.getBlockHeader(block.height);
+          blockHash = this.extractBlockHash(blockHeader);
+        } else {
+          const blockHeader = await this.syncProvider.getBlockHeader(block.height);
+          blockHash = this.extractBlockHash(blockHeader);
+        }
+        if (verifyHashes) {
+          await this.storeBlockHash(block.height, blockHash, chainTip);
+          if (this.syncState && block.height <= this.syncState.lastSyncedHeight) {
+            const storedHash = await this.getStoredBlockHash(block.height);
+            if (storedHash && storedHash !== blockHash) {
+              const reorgInfo = {
+                height: block.height,
+                oldHash: storedHash,
+                newHash: blockHash,
+                blocksToRevert: this.syncState.lastSyncedHeight - block.height + 1
+              };
+              if (stopOnReorg) {
+                throw new Error(
+                  `Chain reorganization detected at height ${block.height}. Old hash: ${storedHash}, New hash: ${blockHash}.`
+                );
+              } else {
+                await this.handleReorganization(reorgInfo);
+              }
+            }
+          }
+        } else {
+          await this.storeBlockHash(block.height, blockHash, chainTip);
+        }
+        const txKeysCount = await this.storeBlockTransactionKeys(block, blockHash, keepTxKeys);
+        if (this.keyManager) {
+          await this.processBlockForSpentOutputs(block, blockHash);
+        }
+        totalTxKeysSynced += txKeysCount;
+        blocksProcessed++;
+        if (onProgress) {
+          onProgress(block.height, syncEndHeight, blocksProcessed, totalTxKeysSynced, false);
+        }
+      }
+      if (rangeResult.blocks.length > 0) {
+        const lastBlock = rangeResult.blocks[rangeResult.blocks.length - 1];
+        let lastBlockHash;
+        if (blockHeadersMap.has(lastBlock.height)) {
+          const lastBlockHeader = blockHeadersMap.get(lastBlock.height);
+          lastBlockHash = this.extractBlockHash(lastBlockHeader);
+        } else {
+          const lastBlockHeader = await this.syncProvider.getBlockHeader(lastBlock.height);
+          lastBlockHash = this.extractBlockHash(lastBlockHeader);
+        }
+        await this.updateSyncState({
+          lastSyncedHeight: lastBlock.height,
+          lastSyncedHash: lastBlockHash,
+          totalTxKeysSynced: (this.syncState?.totalTxKeysSynced ?? 0) + totalTxKeysSynced,
+          lastSyncTime: Date.now(),
+          chainTipAtLastSync: chainTip
+        });
+        if (saveInterval > 0 && lastBlock.height - lastSaveHeight >= saveInterval) {
+          await this.walletDB.saveDatabase();
+          lastSaveHeight = lastBlock.height;
+        }
+      }
+      currentHeight = rangeResult.nextHeight;
+      if (currentHeight <= rangeResult.blocks[rangeResult.blocks.length - 1]?.height) {
+        throw new Error(
+          `Server did not advance next_height properly. Current: ${currentHeight}, Last block: ${rangeResult.blocks[rangeResult.blocks.length - 1]?.height}`
+        );
+      }
+    }
+    await this.walletDB.saveDatabase();
+    return totalTxKeysSynced;
+  }
+  /**
+   * Check for chain reorganization
+   * @param height - Height to check
+   * @returns Reorganization info if detected, null otherwise
+   */
+  async checkReorganization(height) {
+    if (!this.syncState || height < 0) {
+      return null;
+    }
+    const currentHeader = await this.syncProvider.getBlockHeader(height);
+    const currentHash = this.extractBlockHash(currentHeader);
+    const storedHash = await this.getStoredBlockHash(height);
+    if (storedHash && storedHash !== currentHash) {
+      let commonHeight = height - 1;
+      while (commonHeight >= 0) {
+        const commonHeader = await this.syncProvider.getBlockHeader(commonHeight);
+        const commonHash = this.extractBlockHash(commonHeader);
+        const storedCommonHash = await this.getStoredBlockHash(commonHeight);
+        if (storedCommonHash === commonHash) {
+          break;
+        }
+        commonHeight--;
+      }
+      return {
+        height: commonHeight + 1,
+        oldHash: storedHash,
+        newHash: currentHash,
+        blocksToRevert: height - commonHeight
+      };
+    }
+    return null;
+  }
+  /**
+   * Handle chain reorganization
+   * @param reorgInfo - Reorganization information
+   */
+  async handleReorganization(reorgInfo) {
+    console.log(
+      `Handling reorganization: reverting ${reorgInfo.blocksToRevert} blocks from height ${reorgInfo.height}`
+    );
+    const revertHeight = reorgInfo.height + reorgInfo.blocksToRevert - 1;
+    await this.revertBlocks(reorgInfo.height, revertHeight);
+    await this.updateSyncState({
+      lastSyncedHeight: reorgInfo.height - 1,
+      lastSyncedHash: await this.getStoredBlockHash(reorgInfo.height - 1) || "",
+      totalTxKeysSynced: this.syncState?.totalTxKeysSynced ?? 0,
+      lastSyncTime: Date.now(),
+      chainTipAtLastSync: await this.syncProvider.getChainTipHeight()
+    });
+  }
+  /**
+   * Process block transactions to detect spent outputs
+   * @param block - Block transaction keys
+   * @param _blockHash - Block hash (for reference)
+   */
+  async processBlockForSpentOutputs(block, _blockHash) {
+    for (const txKeys of block.txKeys) {
+      const txHash = txKeys.txHash || "";
+      if (!txHash) {
+        continue;
+      }
+      const keys = txKeys.keys || {};
+      const inputs = keys?.inputs || keys?.vin || [];
+      if (Array.isArray(inputs)) {
+        for (const input of inputs) {
+          const outputHash = input?.outputHash || input?.output_hash || input?.prevout?.hash;
+          if (outputHash) {
+            const db = this.walletDB.getDatabase();
+            const stmt = db.prepare(
+              "SELECT output_hash FROM wallet_outputs WHERE output_hash = ? AND is_spent = 0"
+            );
+            stmt.bind([outputHash]);
+            if (stmt.step()) {
+              const updateStmt = db.prepare(
+                `UPDATE wallet_outputs 
+                 SET is_spent = 1, spent_tx_hash = ?, spent_block_height = ?
+                 WHERE output_hash = ?`
+              );
+              updateStmt.run([txHash, block.height, outputHash]);
+              updateStmt.free();
+            }
+            stmt.free();
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Revert blocks from database
+   * @param startHeight - Start height to revert from
+   * @param endHeight - End height to revert to
+   */
+  async revertBlocks(startHeight, endHeight) {
+    const db = this.walletDB.getDatabase();
+    for (let height = startHeight; height <= endHeight; height++) {
+      const stmt = db.prepare("DELETE FROM tx_keys WHERE block_height = ?");
+      stmt.run([height]);
+      stmt.free();
+      const deleteOutputsStmt = db.prepare("DELETE FROM wallet_outputs WHERE block_height = ?");
+      deleteOutputsStmt.run([height]);
+      deleteOutputsStmt.free();
+      const unspendStmt = db.prepare(
+        `UPDATE wallet_outputs 
+         SET is_spent = 0, spent_tx_hash = NULL, spent_block_height = NULL
+         WHERE spent_block_height = ?`
+      );
+      unspendStmt.run([height]);
+      unspendStmt.free();
+      const hashStmt = db.prepare("DELETE FROM block_hashes WHERE height = ?");
+      hashStmt.run([height]);
+      hashStmt.free();
+    }
+  }
+  /**
+   * Store transaction keys for a block
+   * @param block - Block transaction keys
+   * @param blockHash - Block hash
+   * @param keepTxKeys - Whether to keep transaction keys in database after processing
+   * @returns Number of transaction keys stored
+   */
+  async storeBlockTransactionKeys(block, blockHash, keepTxKeys = false) {
+    const db = this.walletDB.getDatabase();
+    let count = 0;
+    for (const txKeys of block.txKeys) {
+      let txHash = txKeys.txHash;
+      if (!txHash && txKeys.keys && typeof txKeys.keys === "object") {
+        txHash = txKeys.keys.txHash || txKeys.keys.hash || "";
+      }
+      if (!txHash) {
+        txHash = `block_${block.height}_tx_${count}`;
+      }
+      if (this.keyManager) {
+        await this.processTransactionKeys(txHash, txKeys.keys, block.height, blockHash);
+      }
+      if (keepTxKeys) {
+        const stmt = db.prepare(
+          "INSERT OR REPLACE INTO tx_keys (tx_hash, block_height, keys_data) VALUES (?, ?, ?)"
+        );
+        stmt.run([txHash, block.height, JSON.stringify(txKeys.keys)]);
+        stmt.free();
+      }
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Process transaction keys to detect and store wallet outputs
+   * @param txHash - Transaction hash
+   * @param keys - Transaction keys data
+   * @param blockHeight - Block height
+   * @param _blockHash - Block hash (for reference, currently unused)
+   */
+  async processTransactionKeys(txHash, keys, blockHeight, _blockHash) {
+    if (!this.keyManager) {
+      return;
+    }
+    const outputs = keys[1]?.outputs || keys[1]?.vout || [];
+    if (!Array.isArray(outputs)) {
+      return;
+    }
+    for (let outputIndex = 0; outputIndex < outputs.length; outputIndex++) {
+      const outputKeys = outputs[outputIndex];
+      const blindingKey = outputKeys?.blindingKey || outputKeys?.blinding_key;
+      const spendingKey = outputKeys?.spendingKey || outputKeys?.spending_key;
+      const viewTag = outputKeys?.viewTag ?? outputKeys?.view_tag;
+      const outputHash = outputKeys?.outputHash || outputKeys?.output_hash;
+      if (!blindingKey || !spendingKey || viewTag === void 0 || !outputHash) {
+        console.warn(
+          `Invalid output keys: blindingKey: ${blindingKey}, spendingKey: ${spendingKey}, viewTag: ${viewTag}, outputHash: ${outputHash}, blockHeight: ${blockHeight}`
+        );
+        continue;
+      }
+      const PublicKey5 = blsctModule.PublicKey;
+      let blindingKeyObj = PublicKey5.deserialize(blindingKey);
+      let spendingKeyObj = PublicKey5.deserialize(spendingKey);
+      const isMine = this.keyManager.isMineByKeys(blindingKeyObj, spendingKeyObj, viewTag);
+      if (isMine) {
+        try {
+          const outputHex = await this.syncProvider.getTransactionOutput(outputHash);
+          const RangeProof2 = blsctModule.RangeProof;
+          const AmountRecoveryReq2 = blsctModule.AmountRecoveryReq;
+          let recoveredAmount = 0;
+          let recoveredMemo = null;
+          let tokenIdHex = null;
+          try {
+            const nonce = this.keyManager.calculateNonce(blindingKeyObj);
+            const rangeProofResult = this.extractRangeProofFromOutput(outputHex);
+            if (rangeProofResult.rangeProofHex) {
+              const rangeProof = RangeProof2.deserialize(rangeProofResult.rangeProofHex);
+              const req = new AmountRecoveryReq2(rangeProof, nonce);
+              const results = RangeProof2.recoverAmounts([req]);
+              if (results.length > 0 && results[0].isSucc) {
+                recoveredAmount = Number(results[0].amount);
+                recoveredMemo = results[0].msg || null;
+              }
+            }
+            tokenIdHex = rangeProofResult.tokenIdHex;
+          } catch {
+          }
+          await this.storeWalletOutput(
+            outputHash,
+            txHash,
+            outputIndex,
+            blockHeight,
+            outputHex,
+            recoveredAmount,
+            recoveredMemo,
+            tokenIdHex,
+            blindingKey,
+            spendingKey,
+            false,
+            // not spent
+            null,
+            // spent_tx_hash
+            null
+            // spent_block_height
+          );
+        } catch (error) {
+          console.warn(`Failed to fetch output ${outputHash} for tx ${txHash}:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Extract range proof from serialized CTxOut data
+   * @param outputHex - Serialized output data (hex)
+   * @returns Object containing rangeProofHex and tokenIdHex
+   */
+  extractRangeProofFromOutput(outputHex) {
+    try {
+      const data = Buffer.from(outputHex, "hex");
+      let offset = 0;
+      const MAX_AMOUNT = 0x7fffffffffffffffn;
+      const HAS_BLSCT_KEYS = 1n;
+      const HAS_TOKENID = 2n;
+      const value = data.readBigInt64LE(offset);
+      offset += 8;
+      let flags = 0n;
+      if (value === MAX_AMOUNT) {
+        flags = data.readBigUInt64LE(offset);
+        offset += 8;
+        if ((flags & 8n) !== 0n) {
+          offset += 8;
+        }
+      }
+      const scriptLen = data[offset];
+      offset += 1 + scriptLen;
+      let rangeProofHex = null;
+      let tokenIdHex = null;
+      if ((flags & HAS_BLSCT_KEYS) !== 0n) {
+        const rangeProofStart = offset;
+        const vsCount = data[offset];
+        offset += 1;
+        offset += vsCount * 48;
+        if (vsCount > 0) {
+          const lsCount = data[offset];
+          offset += 1;
+          offset += lsCount * 48;
+          const rsCount = data[offset];
+          offset += 1;
+          offset += rsCount * 48;
+          offset += 3 * 48;
+          offset += 5 * 32;
+        }
+        const rangeProofEnd = offset;
+        rangeProofHex = data.subarray(rangeProofStart, rangeProofEnd).toString("hex");
+        offset += 3 * 48 + 2;
+      }
+      if ((flags & HAS_TOKENID) !== 0n) {
+        tokenIdHex = data.subarray(offset, offset + 64).toString("hex");
+      }
+      return { rangeProofHex, tokenIdHex };
+    } catch (e) {
+      return { rangeProofHex: null, tokenIdHex: null };
+    }
+  }
+  /**
+   * Store wallet output in database
+   * @param outputHash - Output hash
+   * @param txHash - Transaction hash
+   * @param outputIndex - Output index
+   * @param blockHeight - Block height
+   * @param outputData - Serialized output data (hex)
+   * @param amount - Recovered amount in satoshis
+   * @param memo - Recovered memo/message
+   * @param tokenId - Token ID (hex)
+   * @param blindingKey - Blinding public key (hex)
+   * @param spendingKey - Spending public key (hex)
+   * @param isSpent - Whether output is spent
+   * @param spentTxHash - Transaction hash that spent this output (if spent)
+   * @param spentBlockHeight - Block height where output was spent (if spent)
+   */
+  async storeWalletOutput(outputHash, txHash, outputIndex, blockHeight, outputData, amount, memo, tokenId, blindingKey, spendingKey, isSpent, spentTxHash, spentBlockHeight) {
+    const db = this.walletDB.getDatabase();
+    const stmt = db.prepare(
+      `INSERT OR REPLACE INTO wallet_outputs 
+       (output_hash, tx_hash, output_index, block_height, output_data, amount, memo, token_id, blinding_key, spending_key, is_spent, spent_tx_hash, spent_block_height, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run([
+      outputHash,
+      txHash,
+      outputIndex,
+      blockHeight,
+      outputData,
+      amount,
+      memo,
+      tokenId,
+      blindingKey,
+      spendingKey,
+      isSpent ? 1 : 0,
+      spentTxHash,
+      spentBlockHeight,
+      Date.now()
+    ]);
+    stmt.free();
+  }
+  /**
+   * Extract block hash from block header
+   * @param headerHex - Block header in hex
+   * @returns Block hash (hex string)
+   */
+  extractBlockHash(headerHex) {
+    const headerBytes = Buffer.from(headerHex, "hex");
+    const hash = sha256(sha256(headerBytes));
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+  /**
+   * Get stored block hash from database
+   * @param height - Block height
+   * @returns Block hash or null if not found
+   */
+  async getStoredBlockHash(height) {
+    const db = this.walletDB.getDatabase();
+    const stmt = db.prepare("SELECT hash FROM block_hashes WHERE height = ?");
+    stmt.bind([height]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      stmt.free();
+      return row.hash;
+    }
+    stmt.free();
+    return null;
+  }
+  /**
+   * Store block hash in database
+   * Only stores if within retention window (if retention is enabled)
+   * @param height - Block height
+   * @param hash - Block hash
+   * @param chainTip - Current chain tip (optional, to avoid repeated fetches)
+   */
+  async storeBlockHash(height, hash, chainTip) {
+    const db = this.walletDB.getDatabase();
+    if (this.blockHashRetention > 0) {
+      const currentChainTip = chainTip ?? await this.syncProvider.getChainTipHeight();
+      const retentionStart = Math.max(0, currentChainTip - this.blockHashRetention + 1);
+      if (height < retentionStart) {
+        return;
+      }
+      if (height % 100 === 0) {
+        const cleanupStmt = db.prepare("DELETE FROM block_hashes WHERE height < ?");
+        cleanupStmt.run([retentionStart]);
+        cleanupStmt.free();
+      }
+    }
+    const stmt = db.prepare("INSERT OR REPLACE INTO block_hashes (height, hash) VALUES (?, ?)");
+    stmt.run([height, hash]);
+    stmt.free();
+  }
+  /**
+   * Load sync state from database
+   * @returns Sync state or null if not found
+   */
+  async loadSyncState() {
+    try {
+      const db = this.walletDB.getDatabase();
+      const result = db.exec("SELECT * FROM sync_state LIMIT 1");
+      if (result.length > 0 && result[0].values.length > 0) {
+        const row = result[0].values[0];
+        return {
+          lastSyncedHeight: row[1],
+          lastSyncedHash: row[2],
+          totalTxKeysSynced: row[3],
+          lastSyncTime: row[4],
+          chainTipAtLastSync: row[5]
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update sync state in database
+   * @param state - Sync state to update
+   */
+  async updateSyncState(state) {
+    const db = this.walletDB.getDatabase();
+    const currentState = this.syncState || {
+      lastSyncedHeight: -1,
+      lastSyncedHash: "",
+      totalTxKeysSynced: 0,
+      lastSyncTime: 0,
+      chainTipAtLastSync: 0
+    };
+    const newState = {
+      ...currentState,
+      ...state
+    };
+    const stmt = db.prepare(
+      `INSERT OR REPLACE INTO sync_state 
+       (id, last_synced_height, last_synced_hash, total_tx_keys_synced, last_sync_time, chain_tip_at_last_sync)
+       VALUES (0, ?, ?, ?, ?, ?)`
+    );
+    stmt.run([
+      newState.lastSyncedHeight,
+      newState.lastSyncedHash,
+      newState.totalTxKeysSynced,
+      newState.lastSyncTime,
+      newState.chainTipAtLastSync
+    ]);
+    stmt.free();
+    this.syncState = newState;
+  }
+  /**
+   * Get transaction keys for a specific transaction
+   * @param txHash - Transaction hash
+   * @returns Transaction keys or null if not found
+   */
+  async getTransactionKeys(txHash) {
+    try {
+      const db = this.walletDB.getDatabase();
+      const stmt = db.prepare("SELECT keys_data FROM tx_keys WHERE tx_hash = ?");
+      stmt.bind([txHash]);
+      if (stmt.step()) {
+        const row = stmt.getAsObject();
+        stmt.free();
+        return JSON.parse(row.keys_data);
+      }
+      stmt.free();
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get transaction keys for a block
+   * @param height - Block height
+   * @returns Array of transaction keys
+   */
+  async getBlockTransactionKeys(height) {
+    try {
+      const db = this.walletDB.getDatabase();
+      const result = db.exec("SELECT tx_hash, keys_data FROM tx_keys WHERE block_height = ?", [
+        height
+      ]);
+      if (result.length > 0) {
+        return result[0].values.map((row) => ({
+          txHash: row[0],
+          keys: JSON.parse(row[1])
+        }));
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Reset sync state (for testing or full resync)
+   */
+  async resetSyncState() {
+    const db = this.walletDB.getDatabase();
+    db.run("DELETE FROM sync_state");
+    db.run("DELETE FROM tx_keys");
+    db.run("DELETE FROM block_hashes");
+    this.syncState = null;
+  }
+};
+var BaseSyncProvider = class {
+  constructor(options = {}) {
+    this.debug = options.debug ?? false;
+    this.timeout = options.timeout ?? 3e4;
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log(`[${this.type}]`, ...args);
+    }
+  }
+  /**
+   * Extract block hash from raw block header (80 bytes hex)
+   * Block hash is double SHA256 of header, reversed for display
+   */
+  extractBlockHash(headerHex) {
+    const headerBytes = Buffer.from(headerHex, "hex");
+    const hash = sha256(sha256(headerBytes));
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+  /**
+   * Parse a raw block header into structured format
+   */
+  parseBlockHeader(headerHex, height) {
+    const header = Buffer.from(headerHex, "hex");
+    if (header.length !== 80) {
+      throw new Error(`Invalid header length: ${header.length}, expected 80`);
+    }
+    return {
+      height,
+      hash: this.extractBlockHash(headerHex),
+      version: header.readInt32LE(0),
+      prevHash: header.subarray(4, 36).reverse().toString("hex"),
+      merkleRoot: header.subarray(36, 68).reverse().toString("hex"),
+      timestamp: header.readUInt32LE(68),
+      bits: header.readUInt32LE(72),
+      nonce: header.readUInt32LE(76),
+      rawHex: headerHex
+    };
+  }
+};
+var NetworkMagic = {
+  MAINNET: Buffer.from([219, 210, 177, 172]),
+  TESTNET: Buffer.from([28, 3, 187, 131]),
+  REGTEST: Buffer.from([253, 191, 159, 251])
+};
+var DefaultPorts = {
+  MAINNET: 44440,
+  TESTNET: 33670,
+  REGTEST: 18444
+};
+var MessageType = {
+  VERSION: "version",
+  VERACK: "verack",
+  PING: "ping",
+  PONG: "pong",
+  GETADDR: "getaddr",
+  ADDR: "addr",
+  INV: "inv",
+  GETDATA: "getdata",
+  NOTFOUND: "notfound",
+  GETBLOCKS: "getblocks",
+  GETHEADERS: "getheaders",
+  HEADERS: "headers",
+  BLOCK: "block",
+  TX: "tx",
+  GETOUTPUTDATA: "getoutputdata",
+  MEMPOOL: "mempool",
+  REJECT: "reject",
+  SENDHEADERS: "sendheaders",
+  SENDCMPCT: "sendcmpct",
+  CMPCTBLOCK: "cmpctblock",
+  GETBLOCKTXN: "getblocktxn",
+  BLOCKTXN: "blocktxn"
+};
+var ServiceFlags = {
+  NODE_NONE: 0n,
+  NODE_NETWORK: 1n << 0n,
+  NODE_BLOOM: 1n << 2n,
+  NODE_WITNESS: 1n << 3n,
+  NODE_COMPACT_FILTERS: 1n << 6n,
+  NODE_NETWORK_LIMITED: 1n << 10n,
+  NODE_P2P_V2: 1n << 11n
+};
+var InvType = {
+  ERROR: 0,
+  MSG_TX: 1,
+  MSG_BLOCK: 2,
+  MSG_FILTERED_BLOCK: 3,
+  MSG_CMPCT_BLOCK: 4,
+  MSG_WTX: 5,
+  MSG_DTX: 6,
+  MSG_DWTX: 7,
+  MSG_OUTPUT_HASH: 8,
+  MSG_WITNESS_FLAG: 1 << 30,
+  MSG_WITNESS_BLOCK: 2 | 1 << 30,
+  MSG_WITNESS_TX: 1 | 1 << 30
+};
+var PROTOCOL_VERSION = 70016;
+var P2PClient = class {
+  constructor(options) {
+    this.socket = null;
+    this.connected = false;
+    this.handshakeComplete = false;
+    this.receiveBuffer = Buffer.alloc(0);
+    this.pendingMessages = /* @__PURE__ */ new Map();
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.messageQueue = /* @__PURE__ */ new Map();
+    this.peerVersion = 0;
+    this._peerServices = 0n;
+    this.peerStartHeight = 0;
+    const network = options.network ?? "testnet";
+    this.options = {
+      host: options.host,
+      port: options.port ?? DefaultPorts[network.toUpperCase()],
+      network,
+      timeout: options.timeout ?? 3e4,
+      userAgent: options.userAgent ?? "/navio-sdk:0.1.0/",
+      debug: options.debug ?? false,
+      services: options.services ?? ServiceFlags.NODE_NETWORK | ServiceFlags.NODE_WITNESS
+    };
+    this.magic = NetworkMagic[network.toUpperCase()];
+    this.nonce = BigInt(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER));
+  }
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[P2P]", ...args);
+    }
+  }
+  /**
+   * Connect to the peer and complete handshake
+   */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.socket = new net.Socket();
+      const connectionTimeout = setTimeout(() => {
+        this.socket?.destroy();
+        reject(new Error("Connection timeout"));
+      }, this.options.timeout);
+      this.socket.on("connect", async () => {
+        this.log(`Connected to ${this.options.host}:${this.options.port}`);
+        this.connected = true;
+        try {
+          await this.sendVersion();
+          await this.waitForHandshake();
+          clearTimeout(connectionTimeout);
+          this.handshakeComplete = true;
+          this.log("Handshake complete");
+          resolve();
+        } catch (error) {
+          clearTimeout(connectionTimeout);
+          this.disconnect();
+          reject(error);
+        }
+      });
+      this.socket.on("data", (data) => {
+        this.handleData(data);
+      });
+      this.socket.on("error", (error) => {
+        this.log("Socket error:", error.message);
+        clearTimeout(connectionTimeout);
+        this.connected = false;
+        reject(error);
+      });
+      this.socket.on("close", (hadError) => {
+        this.log(`Connection closed (hadError=${hadError}, receiveBuffer=${this.receiveBuffer.length} bytes)`);
+        this.connected = false;
+        this.handshakeComplete = false;
+        for (const [, pending] of this.pendingMessages) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Connection closed"));
+        }
+        this.pendingMessages.clear();
+      });
+      this.socket.connect(this.options.port, this.options.host);
+    });
+  }
+  /**
+   * Disconnect from the peer
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.connected = false;
+    this.handshakeComplete = false;
+  }
+  /**
+   * Check if connected and handshake complete
+   */
+  isConnected() {
+    return this.connected && this.handshakeComplete;
+  }
+  /**
+   * Get peer's advertised start height
+   */
+  getPeerStartHeight() {
+    return this.peerStartHeight;
+  }
+  /**
+   * Get peer's protocol version
+   */
+  getPeerVersion() {
+    return this.peerVersion;
+  }
+  /**
+   * Get peer's advertised services
+   */
+  getPeerServices() {
+    return this._peerServices;
+  }
+  /**
+   * Handle incoming data
+   */
+  handleData(data) {
+    this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
+    while (this.receiveBuffer.length >= 24) {
+      if (!this.receiveBuffer.subarray(0, 4).equals(this.magic)) {
+        const magicIndex = this.receiveBuffer.indexOf(this.magic, 1);
+        if (magicIndex === -1) {
+          this.receiveBuffer = Buffer.alloc(0);
+          return;
+        }
+        this.receiveBuffer = this.receiveBuffer.subarray(magicIndex);
+        continue;
+      }
+      const header = this.parseHeader(this.receiveBuffer);
+      const totalLength = 24 + header.length;
+      if (this.receiveBuffer.length < totalLength) {
+        return;
+      }
+      const payload = this.receiveBuffer.subarray(24, totalLength);
+      const expectedChecksum = this.calculateChecksum(payload);
+      if (!header.checksum.equals(expectedChecksum)) {
+        this.log("Checksum mismatch for", header.command);
+        this.receiveBuffer = this.receiveBuffer.subarray(totalLength);
+        continue;
+      }
+      this.receiveBuffer = this.receiveBuffer.subarray(totalLength);
+      const message = { command: header.command, payload };
+      this.log("Received:", header.command, `(${header.length} bytes)`);
+      this.dispatchMessage(message);
+    }
+  }
+  /**
+   * Parse message header
+   */
+  parseHeader(buffer) {
+    return {
+      magic: buffer.subarray(0, 4),
+      command: buffer.subarray(4, 16).toString("ascii").replace(/\0+$/, ""),
+      length: buffer.readUInt32LE(16),
+      checksum: buffer.subarray(20, 24)
+    };
+  }
+  /**
+   * Calculate message checksum (first 4 bytes of double SHA256)
+   */
+  calculateChecksum(payload) {
+    const hash = sha256(sha256(payload));
+    return Buffer.from(hash.subarray(0, 4));
+  }
+  /**
+   * Dispatch message to handlers
+   */
+  dispatchMessage(message) {
+    const pending = this.pendingMessages.get(message.command);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pendingMessages.delete(message.command);
+      pending.resolve(message);
+      return;
+    }
+    const handlers = this.messageHandlers.get(message.command);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(message);
+      }
+    }
+    switch (message.command) {
+      case MessageType.PING:
+        this.handlePing(message.payload);
+        break;
+      default:
+        const queue = this.messageQueue.get(message.command) ?? [];
+        queue.push(message);
+        this.messageQueue.set(message.command, queue);
+        break;
+    }
+  }
+  /**
+   * Register a message handler
+   */
+  onMessage(command, handler) {
+    const handlers = this.messageHandlers.get(command) ?? [];
+    handlers.push(handler);
+    this.messageHandlers.set(command, handlers);
+  }
+  /**
+   * Send a raw message
+   */
+  sendMessage(command, payload = Buffer.alloc(0)) {
+    if (!this.socket) {
+      throw new Error("Not connected");
+    }
+    const header = Buffer.alloc(24);
+    this.magic.copy(header, 0);
+    const cmdBuffer = Buffer.alloc(12);
+    Buffer.from(command, "ascii").copy(cmdBuffer);
+    cmdBuffer.copy(header, 4);
+    header.writeUInt32LE(payload.length, 16);
+    const checksum = this.calculateChecksum(payload);
+    checksum.copy(header, 20);
+    const message = Buffer.concat([header, payload]);
+    this.socket.write(message);
+    this.log("Sent:", command, `(${payload.length} bytes)`);
+  }
+  /**
+   * Send a message and wait for a specific response
+   */
+  async sendAndWait(command, payload, responseCommand, timeout) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingMessages.delete(responseCommand);
+        reject(new Error(`Timeout waiting for ${responseCommand}`));
+      }, timeout ?? this.options.timeout);
+      this.pendingMessages.set(responseCommand, { resolve, reject, timer });
+      this.sendMessage(command, payload);
+    });
+  }
+  /**
+   * Wait for a specific message
+   */
+  async waitForMessage(command, timeout) {
+    const queue = this.messageQueue.get(command);
+    if (queue && queue.length > 0) {
+      const message = queue.shift();
+      if (queue.length === 0) {
+        this.messageQueue.delete(command);
+      }
+      return message;
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingMessages.delete(command);
+        reject(new Error(`Timeout waiting for ${command}`));
+      }, timeout ?? this.options.timeout);
+      this.pendingMessages.set(command, { resolve, reject, timer });
+    });
+  }
+  // ============================================================================
+  // Protocol Messages
+  // ============================================================================
+  /**
+   * Send version message
+   */
+  async sendVersion() {
+    const payload = this.buildVersionPayload();
+    this.sendMessage(MessageType.VERSION, payload);
+  }
+  /**
+   * Build version message payload
+   */
+  buildVersionPayload() {
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const userAgentBytes = Buffer.from(this.options.userAgent, "utf8");
+    const userAgentVarInt = this.encodeVarInt(userAgentBytes.length);
+    const payloadSize = 4 + // version
+    8 + // services
+    8 + // timestamp
+    26 + // addr_recv
+    26 + // addr_from
+    8 + // nonce
+    userAgentVarInt.length + userAgentBytes.length + 4 + // start_height
+    1;
+    const payload = Buffer.alloc(payloadSize);
+    let offset = 0;
+    payload.writeInt32LE(PROTOCOL_VERSION, offset);
+    offset += 4;
+    payload.writeBigUInt64LE(this.options.services, offset);
+    offset += 8;
+    payload.writeBigInt64LE(now, offset);
+    offset += 8;
+    payload.writeBigUInt64LE(ServiceFlags.NODE_NETWORK, offset);
+    offset += 8;
+    Buffer.from("00000000000000000000ffff7f000001", "hex").copy(payload, offset);
+    offset += 16;
+    payload.writeUInt16BE(this.options.port, offset);
+    offset += 2;
+    payload.writeBigUInt64LE(this.options.services, offset);
+    offset += 8;
+    Buffer.from("00000000000000000000ffff7f000001", "hex").copy(payload, offset);
+    offset += 16;
+    payload.writeUInt16BE(0, offset);
+    offset += 2;
+    payload.writeBigUInt64LE(this.nonce, offset);
+    offset += 8;
+    userAgentVarInt.copy(payload, offset);
+    offset += userAgentVarInt.length;
+    userAgentBytes.copy(payload, offset);
+    offset += userAgentBytes.length;
+    payload.writeInt32LE(0, offset);
+    offset += 4;
+    payload.writeUInt8(1, offset);
+    return payload;
+  }
+  /**
+   * Wait for handshake completion
+   */
+  async waitForHandshake() {
+    const versionPromise = this.waitForMessage(MessageType.VERSION, 1e4);
+    const verackPromise = this.waitForMessage(MessageType.VERACK, 1e4);
+    const versionMsg = await versionPromise;
+    this.parseVersionMessage(versionMsg.payload);
+    this.sendMessage(MessageType.VERACK);
+    await verackPromise;
+  }
+  /**
+   * Parse version message
+   */
+  parseVersionMessage(payload) {
+    let offset = 0;
+    this.peerVersion = payload.readInt32LE(offset);
+    offset += 4;
+    this._peerServices = payload.readBigUInt64LE(offset);
+    offset += 8;
+    offset += 8 + 26 + 26 + 8;
+    const { value: userAgentLen, bytesRead } = this.decodeVarInt(payload.subarray(offset));
+    offset += bytesRead;
+    const userAgent = payload.subarray(offset, offset + Number(userAgentLen)).toString("utf8");
+    offset += Number(userAgentLen);
+    this.peerStartHeight = payload.readInt32LE(offset);
+    this.log(`Peer version: ${this.peerVersion}, user agent: ${userAgent}, height: ${this.peerStartHeight}`);
+  }
+  /**
+   * Handle ping message
+   */
+  handlePing(payload) {
+    this.sendMessage(MessageType.PONG, payload);
+  }
+  /**
+   * Send getheaders message
+   */
+  async getHeaders(locatorHashes, hashStop) {
+    const payload = this.buildBlockLocatorPayload(locatorHashes, hashStop);
+    const response = await this.sendAndWait(MessageType.GETHEADERS, payload, MessageType.HEADERS);
+    return this.parseHeadersMessage(response.payload);
+  }
+  /**
+   * Build block locator payload for getheaders/getblocks
+   */
+  buildBlockLocatorPayload(hashes, hashStop) {
+    const hashCount = this.encodeVarInt(hashes.length);
+    const payloadSize = 4 + hashCount.length + hashes.length * 32 + 32;
+    const payload = Buffer.alloc(payloadSize);
+    let offset = 0;
+    payload.writeUInt32LE(PROTOCOL_VERSION, offset);
+    offset += 4;
+    hashCount.copy(payload, offset);
+    offset += hashCount.length;
+    for (const hash of hashes) {
+      hash.copy(payload, offset);
+      offset += 32;
+    }
+    if (hashStop) {
+      hashStop.copy(payload, offset);
+    }
+    return payload;
+  }
+  /**
+   * Parse headers message
+   *
+   * Note: Navio's headers message format differs from Bitcoin's.
+   * Bitcoin includes a varint tx_count (always 0) after each 80-byte header.
+   * Navio sends just the raw 80-byte headers with no tx_count.
+   */
+  parseHeadersMessage(payload) {
+    let offset = 0;
+    const { value: count, bytesRead } = this.decodeVarInt(payload);
+    offset += bytesRead;
+    this.log(`Parsing ${count} headers from ${payload.length} bytes`);
+    const headers = [];
+    for (let i = 0; i < Number(count); i++) {
+      if (offset + 80 > payload.length) {
+        this.log(`Headers parse: reached end of payload at header ${i}`);
+        break;
+      }
+      const header = payload.subarray(offset, offset + 80);
+      headers.push(Buffer.from(header));
+      offset += 80;
+    }
+    this.log(`Parsed ${headers.length} headers`);
+    return headers;
+  }
+  /**
+   * Send getdata message
+   */
+  async getData(inventory) {
+    const payload = this.buildInvPayload(inventory);
+    this.sendMessage(MessageType.GETDATA, payload);
+  }
+  /**
+   * Build inventory payload for inv/getdata
+   */
+  buildInvPayload(inventory) {
+    const countVarInt = this.encodeVarInt(inventory.length);
+    const payloadSize = countVarInt.length + inventory.length * 36;
+    const payload = Buffer.alloc(payloadSize);
+    let offset = 0;
+    countVarInt.copy(payload, offset);
+    offset += countVarInt.length;
+    for (const inv of inventory) {
+      payload.writeUInt32LE(inv.type, offset);
+      offset += 4;
+      inv.hash.copy(payload, offset);
+      offset += 32;
+    }
+    return payload;
+  }
+  /**
+   * Request a block by hash
+   */
+  async getBlock(blockHash) {
+    const inventory = [{ type: InvType.MSG_WITNESS_BLOCK, hash: blockHash }];
+    const getDataPayload = this.buildInvPayload(inventory);
+    return this.sendAndWait(MessageType.GETDATA, getDataPayload, MessageType.BLOCK);
+  }
+  /**
+   * Request transaction outputs by output hash (Navio-specific)
+   */
+  async getOutputData(outputHashes) {
+    const countVarInt = this.encodeVarInt(outputHashes.length);
+    const payloadSize = countVarInt.length + outputHashes.length * 32;
+    const payload = Buffer.alloc(payloadSize);
+    let offset = 0;
+    countVarInt.copy(payload, offset);
+    offset += countVarInt.length;
+    for (const hash of outputHashes) {
+      hash.copy(payload, offset);
+      offset += 32;
+    }
+    return this.sendAndWait(MessageType.GETOUTPUTDATA, payload, MessageType.TX);
+  }
+  /**
+   * Send sendheaders message to prefer headers announcements
+   */
+  sendSendHeaders() {
+    this.sendMessage(MessageType.SENDHEADERS);
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Encode a variable-length integer
+   */
+  encodeVarInt(value) {
+    const n = typeof value === "bigint" ? value : BigInt(value);
+    if (n < 253) {
+      const buf = Buffer.alloc(1);
+      buf.writeUInt8(Number(n));
+      return buf;
+    } else if (n <= 65535) {
+      const buf = Buffer.alloc(3);
+      buf.writeUInt8(253);
+      buf.writeUInt16LE(Number(n), 1);
+      return buf;
+    } else if (n <= 4294967295) {
+      const buf = Buffer.alloc(5);
+      buf.writeUInt8(254);
+      buf.writeUInt32LE(Number(n), 1);
+      return buf;
+    } else {
+      const buf = Buffer.alloc(9);
+      buf.writeUInt8(255);
+      buf.writeBigUInt64LE(n, 1);
+      return buf;
+    }
+  }
+  /**
+   * Decode a variable-length integer
+   */
+  decodeVarInt(buffer) {
+    const first = buffer.readUInt8(0);
+    if (first < 253) {
+      return { value: BigInt(first), bytesRead: 1 };
+    } else if (first === 253) {
+      return { value: BigInt(buffer.readUInt16LE(1)), bytesRead: 3 };
+    } else if (first === 254) {
+      return { value: BigInt(buffer.readUInt32LE(1)), bytesRead: 5 };
+    } else {
+      return { value: buffer.readBigUInt64LE(1), bytesRead: 9 };
+    }
+  }
+  /**
+   * Reverse a hash for display (Bitcoin uses little-endian internally, big-endian for display)
+   */
+  static reverseHash(hash) {
+    return Buffer.from(hash).reverse();
+  }
+  /**
+   * Convert display hash to internal format
+   */
+  static hashFromDisplay(hexHash) {
+    return Buffer.from(hexHash, "hex").reverse();
+  }
+  /**
+   * Convert internal hash to display format
+   */
+  static hashToDisplay(hash) {
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+};
+
+// src/p2p-sync.ts
+var _P2PSyncProvider = class _P2PSyncProvider extends BaseSyncProvider {
+  constructor(options) {
+    super(options);
+    this.type = "p2p";
+    // Header chain state
+    this.headersByHash = /* @__PURE__ */ new Map();
+    this.headersByHeight = /* @__PURE__ */ new Map();
+    this.chainTipHeight = -1;
+    this.chainTipHash = "";
+    this.genesisHash = "";
+    // Block cache (limited size)
+    this.blockCache = /* @__PURE__ */ new Map();
+    this.maxBlockCacheSize = 10;
+    // Pending block requests
+    this.pendingBlocks = /* @__PURE__ */ new Map();
+    this.options = {
+      host: options.host,
+      port: options.port ?? 33570,
+      network: options.network ?? "testnet",
+      timeout: options.timeout ?? 3e4,
+      debug: options.debug ?? false,
+      userAgent: options.userAgent ?? "/navio-sdk:0.1.0/",
+      maxBlocksPerRequest: options.maxBlocksPerRequest ?? 16,
+      maxHeadersPerRequest: options.maxHeadersPerRequest ?? 2e3
+    };
+    this.client = new P2PClient({
+      host: this.options.host,
+      port: this.options.port,
+      network: this.options.network,
+      timeout: this.options.timeout,
+      debug: this.options.debug,
+      userAgent: this.options.userAgent
+    });
+  }
+  /**
+   * Connect to the P2P node
+   */
+  async connect() {
+    await this.client.connect();
+    this.log("Connected to P2P node");
+    this.client.sendSendHeaders();
+    this.chainTipHeight = this.client.getPeerStartHeight();
+    this.log(`Peer reports height: ${this.chainTipHeight}`);
+    this.client.onMessage(MessageType.BLOCK, (msg) => {
+      this.handleBlockMessage(msg);
+    });
+    if (this.chainTipHeight > 0) {
+      await this.syncHeaders(0, Math.min(100, this.chainTipHeight));
+    }
+  }
+  /**
+   * Disconnect from the P2P node
+   */
+  disconnect() {
+    this.client.disconnect();
+    this.headersByHash.clear();
+    this.headersByHeight.clear();
+    this.blockCache.clear();
+    this.chainTipHeight = -1;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.client.isConnected();
+  }
+  /**
+   * Get current chain tip height
+   */
+  async getChainTipHeight() {
+    if (this.chainTipHeight >= 0) {
+      return this.chainTipHeight;
+    }
+    return this.client.getPeerStartHeight();
+  }
+  /**
+   * Get current chain tip
+   */
+  async getChainTip() {
+    return {
+      height: this.chainTipHeight,
+      hash: this.chainTipHash
+    };
+  }
+  /**
+   * Get a single block header
+   */
+  async getBlockHeader(height) {
+    const cached = this.headersByHeight.get(height);
+    if (cached) {
+      return cached.rawHex;
+    }
+    await this.syncHeaders(height, 1);
+    const header = this.headersByHeight.get(height);
+    if (!header) {
+      throw new Error(`Failed to fetch header at height ${height}`);
+    }
+    return header.rawHex;
+  }
+  /**
+   * Get multiple block headers
+   */
+  async getBlockHeaders(startHeight, count) {
+    await this.syncHeaders(startHeight, count);
+    const headers = [];
+    for (let h = startHeight; h < startHeight + count; h++) {
+      const cached = this.headersByHeight.get(h);
+      if (cached) {
+        headers.push(cached.rawHex);
+      } else {
+        break;
+      }
+    }
+    return {
+      count: headers.length,
+      hex: headers.join(""),
+      max: this.options.maxHeadersPerRequest
+    };
+  }
+  /**
+   * Sync headers from the network
+   */
+  async syncHeaders(fromHeight, count) {
+    const locatorHashes = [];
+    let step = 1;
+    let height = fromHeight > 0 ? fromHeight - 1 : 0;
+    while (height >= 0) {
+      const header = this.headersByHeight.get(height);
+      if (header) {
+        locatorHashes.push(P2PClient.hashFromDisplay(header.hash));
+      }
+      if (height === 0) break;
+      height -= step;
+      if (locatorHashes.length > 10) step *= 2;
+    }
+    if (this.genesisHash && locatorHashes.length === 0) {
+      locatorHashes.push(P2PClient.hashFromDisplay(this.genesisHash));
+    }
+    if (locatorHashes.length === 0) {
+      locatorHashes.push(Buffer.alloc(32));
+    }
+    const rawHeaders = await this.client.getHeaders(locatorHashes);
+    this.log(`Received ${rawHeaders.length} headers`);
+    const pendingHeaders = [];
+    for (const rawHeader of rawHeaders) {
+      const headerHex = rawHeader.toString("hex");
+      const hash = this.extractBlockHash(headerHex);
+      const prevHashBytes = rawHeader.subarray(4, 36);
+      const prevHash = Buffer.from(prevHashBytes).reverse().toString("hex");
+      pendingHeaders.push({ rawHeader, hash, prevHash, headerHex });
+    }
+    for (let i = 0; i < pendingHeaders.length; i++) {
+      const { hash, prevHash, headerHex } = pendingHeaders[i];
+      let headerHeight;
+      if (prevHash === "0".repeat(64)) {
+        headerHeight = 0;
+        this.genesisHash = hash;
+      } else if (this.headersByHash.has(prevHash)) {
+        const prevHeader = this.headersByHash.get(prevHash);
+        headerHeight = prevHeader.height + 1;
+      } else if (i === 0 && this.headersByHeight.size === 0) {
+        this.log(`Initial sync: first header is genesis (height 0)`);
+        headerHeight = 0;
+        this.genesisHash = hash;
+      } else if (i > 0) {
+        const prevInBatch = pendingHeaders[i - 1];
+        if (prevInBatch.hash === prevHash) {
+          const prevCached = this.headersByHash.get(prevInBatch.hash);
+          if (prevCached) {
+            headerHeight = prevCached.height + 1;
+          } else {
+            this.log(`Previous header in batch not yet cached: ${prevInBatch.hash.substring(0, 16)}...`);
+            continue;
+          }
+        } else {
+          if (i < 5) {
+            this.log(`Header ${hash.substring(0, 16)}... doesn't chain from previous in batch`);
+          }
+          continue;
+        }
+      } else {
+        this.log(`Cannot determine height for header ${hash.substring(0, 16)}...`);
+        continue;
+      }
+      const cached = {
+        height: headerHeight,
+        hash,
+        rawHex: headerHex,
+        prevHash
+      };
+      this.headersByHash.set(hash, cached);
+      this.headersByHeight.set(headerHeight, cached);
+      if (headerHeight > this.chainTipHeight) {
+        this.chainTipHeight = headerHeight;
+        this.chainTipHash = hash;
+      }
+    }
+    this.log(`Processed headers. Chain tip: height=${this.chainTipHeight}, cached=${this.headersByHeight.size} headers`);
+    if (rawHeaders.length >= this.options.maxHeadersPerRequest - 1 && this.chainTipHeight < this.client.getPeerStartHeight()) {
+      await this.syncHeaders(this.chainTipHeight, count);
+    }
+  }
+  /**
+   * Get transaction keys for a range of blocks
+   */
+  async getBlockTransactionKeysRange(startHeight) {
+    const blocks = [];
+    const maxBlocks = this.options.maxBlocksPerRequest;
+    const batchEndHeight = Math.min(startHeight + maxBlocks - 1, this.chainTipHeight);
+    try {
+      await this.ensureHeadersSyncedTo(batchEndHeight);
+    } catch (e) {
+      this.log(`Could not sync headers to ${batchEndHeight}: ${e}`);
+    }
+    let highestCached = 0;
+    for (const h of this.headersByHeight.keys()) {
+      if (h > highestCached) highestCached = h;
+    }
+    const effectiveTip = Math.min(this.chainTipHeight, highestCached);
+    if (startHeight > effectiveTip) {
+      return {
+        blocks: [],
+        nextHeight: startHeight
+      };
+    }
+    for (let height = startHeight; height < startHeight + maxBlocks && height <= effectiveTip; height++) {
+      try {
+        const txKeys = await this.getBlockTransactionKeys(height);
+        blocks.push({
+          height,
+          txKeys
+        });
+      } catch (e) {
+        this.log(`Error getting tx keys for block ${height}: ${e}`);
+        break;
+      }
+    }
+    const lastHeight = blocks.length > 0 ? blocks[blocks.length - 1].height : startHeight;
+    return {
+      blocks,
+      nextHeight: lastHeight + 1
+    };
+  }
+  /**
+   * Get transaction keys for a single block
+   */
+  async getBlockTransactionKeys(height) {
+    await this.ensureHeadersSyncedTo(height);
+    const header = this.headersByHeight.get(height);
+    if (!header) {
+      throw new Error(`Cannot get header for height ${height}`);
+    }
+    const blockData = await this.fetchBlock(header.hash);
+    return this.parseBlockTransactionKeys(blockData);
+  }
+  /**
+   * Ensure headers are synced up to the specified height
+   */
+  async ensureHeadersSyncedTo(targetHeight) {
+    if (this.headersByHeight.has(targetHeight)) {
+      return;
+    }
+    let highestKnown = -1;
+    for (const h of this.headersByHeight.keys()) {
+      if (h > highestKnown) highestKnown = h;
+    }
+    if (highestKnown >= targetHeight) {
+      return;
+    }
+    let attempts = 0;
+    const maxAttempts = 100;
+    while (!this.headersByHeight.has(targetHeight) && attempts < maxAttempts) {
+      attempts++;
+      this.log(`Need header ${targetHeight}, highest known: ${highestKnown}`);
+      const syncFrom = highestKnown + 1;
+      await this.syncHeaders(syncFrom, this.options.maxHeadersPerRequest);
+      let newHighest = -1;
+      for (const h of this.headersByHeight.keys()) {
+        if (h > newHighest) newHighest = h;
+      }
+      if (newHighest <= highestKnown) {
+        this.log(`No new headers available, highest: ${highestKnown}`);
+        return;
+      }
+      highestKnown = newHighest;
+    }
+  }
+  /**
+   * Fetch a block by hash
+   */
+  async fetchBlock(hashHex) {
+    const cached = this.blockCache.get(hashHex);
+    if (cached) {
+      return cached;
+    }
+    const pending = this.pendingBlocks.get(hashHex);
+    if (pending) {
+      return pending;
+    }
+    const blockHashBuffer = P2PClient.hashFromDisplay(hashHex);
+    const promise = this.client.getBlock(blockHashBuffer).then((msg) => {
+      this.pendingBlocks.delete(hashHex);
+      if (this.blockCache.size >= this.maxBlockCacheSize) {
+        const oldest = this.blockCache.keys().next().value;
+        if (oldest) this.blockCache.delete(oldest);
+      }
+      this.blockCache.set(hashHex, msg.payload);
+      return msg.payload;
+    });
+    this.pendingBlocks.set(hashHex, promise);
+    return promise;
+  }
+  /**
+   * Handle incoming block message
+   */
+  handleBlockMessage(msg) {
+    const headerHex = msg.payload.subarray(0, 80).toString("hex");
+    const hash = this.extractBlockHash(headerHex);
+    if (this.blockCache.size >= this.maxBlockCacheSize) {
+      const oldest = this.blockCache.keys().next().value;
+      if (oldest) this.blockCache.delete(oldest);
+    }
+    this.blockCache.set(hash, msg.payload);
+    this.log(`Received block: ${hash}`);
+  }
+  /**
+   * Parse block data and extract transaction keys
+   *
+   * Parses all transactions in the block and extracts BLSCT output keys
+   * for wallet output detection.
+   */
+  parseBlockTransactionKeys(blockData) {
+    const txKeys = [];
+    let offset = 80;
+    const version = blockData.readInt32LE(0);
+    const isPoS = (version & 16777216) !== 0;
+    this.log(`Block version: 0x${version.toString(16)}, isPoS: ${isPoS}, size: ${blockData.length}`);
+    if (isPoS) {
+      const proofSkipResult = this.skipPoSProof(blockData, offset);
+      if (proofSkipResult.error) {
+        this.log(`Error skipping PoS proof: ${proofSkipResult.error}`);
+        return txKeys;
+      }
+      offset = proofSkipResult.newOffset;
+      this.log(`Skipped PoS proof, offset now: ${offset}`);
+    }
+    const { value: txCount, bytesRead } = this.decodeVarInt(blockData, offset);
+    offset += bytesRead;
+    this.log(`Parsing ${txCount} transactions from block (offset: ${offset})`);
+    for (let txIndex = 0; txIndex < Number(txCount); txIndex++) {
+      const result = this.parseBlsctTransaction(blockData, offset);
+      if (result.error) {
+        this.log(`Error parsing tx ${txIndex}/${txCount}: ${result.error}`);
+        break;
+      }
+      offset = result.newOffset;
+      if (result.outputKeys.length > 0) {
+        txKeys.push({
+          txHash: result.txHash,
+          keys: this.formatOutputKeys(result.outputKeys)
+        });
+      }
+    }
+    return txKeys;
+  }
+  /**
+   * Skip PoS proof in block data
+   */
+  skipPoSProof(data, offset) {
+    try {
+      const G1_SIZE = 48;
+      const SCALAR_SIZE = 32;
+      offset += 8 * G1_SIZE;
+      offset += 6 * SCALAR_SIZE;
+      const { value: lsCount, bytesRead: lsCountBytes } = this.decodeVarInt(data, offset);
+      offset += lsCountBytes;
+      offset += Number(lsCount) * G1_SIZE;
+      const { value: rsCount, bytesRead: rsCountBytes } = this.decodeVarInt(data, offset);
+      offset += rsCountBytes;
+      offset += Number(rsCount) * G1_SIZE;
+      offset += 3 * SCALAR_SIZE;
+      const { value: rpLsCount, bytesRead: rpLsCountBytes } = this.decodeVarInt(data, offset);
+      offset += rpLsCountBytes;
+      offset += Number(rpLsCount) * G1_SIZE;
+      const { value: rpRsCount, bytesRead: rpRsCountBytes } = this.decodeVarInt(data, offset);
+      offset += rpRsCountBytes;
+      offset += Number(rpRsCount) * G1_SIZE;
+      offset += 3 * G1_SIZE;
+      offset += 5 * SCALAR_SIZE;
+      return { newOffset: offset };
+    } catch (e) {
+      return { newOffset: offset, error: String(e) };
+    }
+  }
+  /**
+   * Parse a BLSCT transaction and extract output keys
+   */
+  parseBlsctTransaction(data, offset) {
+    const startOffset = offset;
+    const outputKeys = [];
+    try {
+      const version = data.readInt32LE(offset);
+      offset += 4;
+      const TX_BLSCT_MARKER = 32;
+      const isBLSCT = (version & TX_BLSCT_MARKER) !== 0;
+      let hasWitness = false;
+      let witnessFlags = 0;
+      if (data[offset] === 0) {
+        if (offset + 1 < data.length && data[offset + 1] !== 0) {
+          witnessFlags = data[offset + 1];
+          hasWitness = (witnessFlags & 1) !== 0;
+          offset += 2;
+        }
+      }
+      const { value: inputCount, bytesRead: inputCountBytes } = this.decodeVarInt(data, offset);
+      offset += inputCountBytes;
+      for (let i = 0; i < Number(inputCount); i++) {
+        offset += 32;
+        const { value: scriptSigLen, bytesRead: sigLenBytes } = this.decodeVarInt(data, offset);
+        offset += sigLenBytes;
+        if (Number(scriptSigLen) > 1e4) {
+          return { txHash: "", outputKeys: [], newOffset: offset, error: `Invalid scriptSig length: ${scriptSigLen}` };
+        }
+        offset += Number(scriptSigLen);
+        offset += 4;
+      }
+      const { value: outputCount, bytesRead: outputCountBytes } = this.decodeVarInt(data, offset);
+      offset += outputCountBytes;
+      for (let i = 0; i < Number(outputCount); i++) {
+        const outputResult = this.parseBlsctOutput(data, offset, i);
+        if (outputResult.error) {
+          return { txHash: "", outputKeys: [], newOffset: offset, error: outputResult.error };
+        }
+        offset = outputResult.newOffset;
+        if (outputResult.keys) {
+          outputKeys.push(outputResult.keys);
+        }
+      }
+      if (hasWitness) {
+        for (let i = 0; i < Number(inputCount); i++) {
+          const { value: witnessCount, bytesRead: wcBytes } = this.decodeVarInt(data, offset);
+          offset += wcBytes;
+          for (let j = 0; j < Number(witnessCount); j++) {
+            const { value: itemLen, bytesRead: ilBytes } = this.decodeVarInt(data, offset);
+            offset += ilBytes;
+            offset += Number(itemLen);
+          }
+        }
+      }
+      offset += 4;
+      if (isBLSCT) {
+        offset += 96;
+      }
+      const txData = data.subarray(startOffset, offset);
+      const txHash = this.calculateBlsctTxHash(txData, hasWitness, startOffset, version);
+      return {
+        txHash,
+        outputKeys,
+        newOffset: offset
+      };
+    } catch (e) {
+      return {
+        txHash: "",
+        outputKeys: [],
+        newOffset: offset,
+        error: `Parse error: ${e}`
+      };
+    }
+  }
+  /**
+   * Parse a BLSCT output and extract keys
+   */
+  parseBlsctOutput(data, offset, outputIndex) {
+    try {
+      const rawValue = data.readBigInt64LE(offset);
+      offset += 8;
+      let flags = 0n;
+      if (rawValue === _P2PSyncProvider.MAX_AMOUNT) {
+        flags = data.readBigUInt64LE(offset);
+        offset += 8;
+        if (flags & BigInt(_P2PSyncProvider.TRANSPARENT_VALUE_MARKER)) {
+          offset += 8;
+        }
+      }
+      const { value: scriptLen, bytesRead: scriptLenBytes } = this.decodeVarInt(data, offset);
+      offset += scriptLenBytes;
+      offset += Number(scriptLen);
+      const hasBlsctData = (flags & BigInt(_P2PSyncProvider.BLSCT_MARKER)) !== 0n;
+      const hasTokenId = (flags & BigInt(_P2PSyncProvider.TOKEN_MARKER)) !== 0n;
+      const hasPredicate = (flags & BigInt(_P2PSyncProvider.PREDICATE_MARKER)) !== 0n;
+      let keys = null;
+      if (hasBlsctData) {
+        const blsctResult = this.parseBlsctData(data, offset, outputIndex);
+        if (blsctResult.error) {
+          return { keys: null, newOffset: offset, error: blsctResult.error };
+        }
+        offset = blsctResult.newOffset;
+        keys = blsctResult.keys;
+      }
+      if (hasTokenId) {
+        offset += 64;
+      }
+      if (hasPredicate) {
+        const { value: predicateLen, bytesRead: predLenBytes } = this.decodeVarInt(data, offset);
+        offset += predLenBytes;
+        offset += Number(predicateLen);
+      }
+      return { keys, newOffset: offset };
+    } catch (e) {
+      return { keys: null, newOffset: offset, error: `Output parse error: ${e}` };
+    }
+  }
+  /**
+   * Parse BLSCT data from output
+   */
+  parseBlsctData(data, offset, outputIndex) {
+    try {
+      const proofResult = this.parseRangeProof(data, offset);
+      if (proofResult.error) {
+        return { keys: null, newOffset: offset, error: proofResult.error };
+      }
+      offset = proofResult.newOffset;
+      if (proofResult.hasData) {
+        const spendingKey = data.subarray(offset, offset + _P2PSyncProvider.G1_POINT_SIZE).toString("hex");
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        const blindingKey = data.subarray(offset, offset + _P2PSyncProvider.G1_POINT_SIZE).toString("hex");
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        const ephemeralKey = data.subarray(offset, offset + _P2PSyncProvider.G1_POINT_SIZE).toString("hex");
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        const viewTag = data.readUInt16LE(offset);
+        offset += 2;
+        const outputHash = this.hashBuffer(Buffer.from(`output:${outputIndex}`));
+        return {
+          keys: {
+            blindingKey,
+            spendingKey,
+            ephemeralKey,
+            viewTag,
+            outputHash,
+            hasRangeProof: true
+          },
+          newOffset: offset
+        };
+      }
+      return { keys: null, newOffset: offset };
+    } catch (e) {
+      return { keys: null, newOffset: offset, error: `BLSCT data parse error: ${e}` };
+    }
+  }
+  /**
+   * Parse bulletproofs_plus range proof
+   */
+  parseRangeProof(data, offset) {
+    try {
+      const { value: vsCount, bytesRead: vsCountBytes } = this.decodeVarInt(data, offset);
+      offset += vsCountBytes;
+      const numVs = Number(vsCount);
+      offset += numVs * _P2PSyncProvider.G1_POINT_SIZE;
+      if (numVs > 0) {
+        const { value: lsCount, bytesRead: lsCountBytes } = this.decodeVarInt(data, offset);
+        offset += lsCountBytes;
+        offset += Number(lsCount) * _P2PSyncProvider.G1_POINT_SIZE;
+        const { value: rsCount, bytesRead: rsCountBytes } = this.decodeVarInt(data, offset);
+        offset += rsCountBytes;
+        offset += Number(rsCount) * _P2PSyncProvider.G1_POINT_SIZE;
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        offset += _P2PSyncProvider.G1_POINT_SIZE;
+        offset += _P2PSyncProvider.SCALAR_SIZE;
+        offset += _P2PSyncProvider.SCALAR_SIZE;
+        offset += _P2PSyncProvider.SCALAR_SIZE;
+        offset += _P2PSyncProvider.SCALAR_SIZE;
+        offset += _P2PSyncProvider.SCALAR_SIZE;
+      }
+      return { hasData: numVs > 0, newOffset: offset };
+    } catch (e) {
+      return { hasData: false, newOffset: offset, error: `RangeProof parse error: ${e}` };
+    }
+  }
+  /**
+   * Calculate BLSCT transaction hash
+   */
+  calculateBlsctTxHash(txData, _hasWitness, _startOffset, _version) {
+    const hash = sha256(sha256(txData));
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+  /**
+   * Hash a buffer using SHA256
+   */
+  hashBuffer(data) {
+    return Buffer.from(sha256(data)).toString("hex");
+  }
+  /**
+   * Format output keys for the sync interface
+   */
+  formatOutputKeys(outputKeys) {
+    return {
+      outputs: outputKeys
+    };
+  }
+  /**
+   * Get serialized transaction output by output hash
+   */
+  async getTransactionOutput(outputHash) {
+    const outputHashBuffer = Buffer.from(outputHash, "hex");
+    const response = await this.client.getOutputData([outputHashBuffer]);
+    return response.payload.toString("hex");
+  }
+  /**
+   * Broadcast a transaction
+   */
+  async broadcastTransaction(rawTx) {
+    const txData = Buffer.from(rawTx, "hex");
+    const txHash = this.calculateBlsctTxHash(txData, false, 0, 0);
+    this.log(`Broadcasting transaction: ${txHash}`);
+    return txHash;
+  }
+  /**
+   * Get raw transaction
+   */
+  async getRawTransaction(txHash, _verbose) {
+    const inv = [{ type: InvType.MSG_WITNESS_TX, hash: P2PClient.hashFromDisplay(txHash) }];
+    await this.client.getData(inv);
+    const response = await this.client.waitForMessage(MessageType.TX, this.options.timeout);
+    return response.payload.toString("hex");
+  }
+  /**
+   * Decode variable-length integer from buffer
+   */
+  decodeVarInt(buffer, offset) {
+    const first = buffer.readUInt8(offset);
+    if (first < 253) {
+      return { value: BigInt(first), bytesRead: 1 };
+    } else if (first === 253) {
+      return { value: BigInt(buffer.readUInt16LE(offset + 1)), bytesRead: 3 };
+    } else if (first === 254) {
+      return { value: BigInt(buffer.readUInt32LE(offset + 1)), bytesRead: 5 };
+    } else {
+      return { value: buffer.readBigUInt64LE(offset + 1), bytesRead: 9 };
+    }
+  }
+};
+// ============================================================================
+// BLSCT Constants
+// ============================================================================
+_P2PSyncProvider.G1_POINT_SIZE = 48;
+// Compressed G1 point
+_P2PSyncProvider.SCALAR_SIZE = 32;
+// MCL Scalar
+_P2PSyncProvider.MAX_AMOUNT = BigInt("0x7FFFFFFFFFFFFFFF");
+_P2PSyncProvider.BLSCT_MARKER = 1;
+_P2PSyncProvider.TOKEN_MARKER = 2;
+_P2PSyncProvider.PREDICATE_MARKER = 4;
+_P2PSyncProvider.TRANSPARENT_VALUE_MARKER = 8;
+var P2PSyncProvider = _P2PSyncProvider;
+
+// src/electrum-sync.ts
+var ElectrumSyncProvider = class extends BaseSyncProvider {
+  constructor(options = {}) {
+    super(options);
+    this.type = "electrum";
+    this.chainTipHeight = -1;
+    this.chainTipHash = "";
+    this.client = new ElectrumClient(options);
+  }
+  /**
+   * Get the underlying ElectrumClient for direct access to additional methods
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Connect to the Electrum server
+   */
+  async connect() {
+    await this.client.connect();
+    this.log("Connected to Electrum server");
+    this.chainTipHeight = await this.client.getChainTipHeight();
+    const header = await this.client.getBlockHeader(this.chainTipHeight);
+    this.chainTipHash = this.extractBlockHash(header);
+  }
+  /**
+   * Disconnect from the Electrum server
+   */
+  disconnect() {
+    this.client.disconnect();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.client.isConnected();
+  }
+  /**
+   * Get current chain tip height
+   */
+  async getChainTipHeight() {
+    this.chainTipHeight = await this.client.getChainTipHeight();
+    return this.chainTipHeight;
+  }
+  /**
+   * Get current chain tip
+   */
+  async getChainTip() {
+    const height = await this.getChainTipHeight();
+    const header = await this.client.getBlockHeader(height);
+    this.chainTipHash = this.extractBlockHash(header);
+    return {
+      height,
+      hash: this.chainTipHash
+    };
+  }
+  /**
+   * Get a single block header
+   */
+  async getBlockHeader(height) {
+    return this.client.getBlockHeader(height);
+  }
+  /**
+   * Get multiple block headers
+   */
+  async getBlockHeaders(startHeight, count) {
+    return this.client.getBlockHeaders(startHeight, count);
+  }
+  /**
+   * Get transaction keys for a range of blocks
+   */
+  async getBlockTransactionKeysRange(startHeight) {
+    return this.client.getBlockTransactionKeysRange(startHeight);
+  }
+  /**
+   * Get transaction keys for a single block
+   */
+  async getBlockTransactionKeys(height) {
+    const result = await this.client.getBlockTransactionKeys(height);
+    if (Array.isArray(result)) {
+      return result.map((txKeyData, index) => {
+        if (typeof txKeyData === "object" && txKeyData !== null) {
+          if ("txHash" in txKeyData && "keys" in txKeyData) {
+            return txKeyData;
+          } else {
+            return {
+              txHash: txKeyData.txHash || txKeyData.hash || `tx_${index}`,
+              keys: txKeyData
+            };
+          }
+        }
+        return {
+          txHash: `tx_${index}`,
+          keys: txKeyData
+        };
+      });
+    }
+    return [];
+  }
+  /**
+   * Get serialized transaction output by output hash
+   */
+  async getTransactionOutput(outputHash) {
+    return this.client.getTransactionOutput(outputHash);
+  }
+  /**
+   * Broadcast a transaction
+   */
+  async broadcastTransaction(rawTx) {
+    return this.client.broadcastTransaction(rawTx);
+  }
+  /**
+   * Get raw transaction
+   */
+  async getRawTransaction(txHash, verbose) {
+    return this.client.getRawTransaction(txHash, verbose);
+  }
+  // ============================================================================
+  // Additional Electrum-specific Methods (passthrough)
+  // ============================================================================
+  /**
+   * Get server version
+   */
+  async getServerVersion() {
+    return this.client.getServerVersion();
+  }
+  /**
+   * Subscribe to block headers
+   */
+  async subscribeBlockHeaders(callback) {
+    return this.client.subscribeBlockHeaders(callback);
+  }
+  /**
+   * Get transaction keys for a specific transaction
+   */
+  async getTransactionKeys(txHash) {
+    return this.client.getTransactionKeys(txHash);
+  }
+  /**
+   * Fetch all transaction keys from genesis to chain tip
+   */
+  async fetchAllTransactionKeys(progressCallback) {
+    return this.client.fetchAllTransactionKeys(progressCallback);
+  }
+  /**
+   * Get transaction history for a script hash
+   */
+  async getHistory(scriptHash) {
+    return this.client.getHistory(scriptHash);
+  }
+  /**
+   * Get unspent transaction outputs for a script hash
+   */
+  async getUnspent(scriptHash) {
+    return this.client.getUnspent(scriptHash);
+  }
+  /**
+   * Subscribe to script hash updates
+   */
+  async subscribeScriptHash(scriptHash, callback) {
+    return this.client.subscribeScriptHash(scriptHash, callback);
+  }
+};
+var _NavioClient = class _NavioClient {
+  /**
+   * Create a new NavioClient instance
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    this.keyManager = null;
+    this.initialized = false;
+    // Legacy: keep electrumClient reference for backwards compatibility
+    this.electrumClient = null;
+    // Background sync state
+    this.backgroundSyncTimer = null;
+    this.backgroundSyncOptions = null;
+    this.isBackgroundSyncing = false;
+    this.isSyncInProgress = false;
+    this.lastKnownBalance = 0n;
+    if ("electrum" in config && !("backend" in config)) {
+      this.config = {
+        ...config,
+        backend: "electrum"
+      };
+    } else {
+      this.config = config;
+    }
+    this.config.backend = this.config.backend || "electrum";
+    this.config.network = this.config.network || "mainnet";
+    _NavioClient.configureNetwork(this.config.network);
+    if (this.config.backend === "electrum" && !this.config.electrum) {
+      throw new Error('Electrum options required when backend is "electrum"');
+    }
+    if (this.config.backend === "p2p" && !this.config.p2p) {
+      throw new Error('P2P options required when backend is "p2p"');
+    }
+    this.walletDB = new WalletDB(this.config.walletDbPath);
+    if (this.config.backend === "p2p") {
+      this.syncProvider = new P2PSyncProvider(this.config.p2p);
+    } else {
+      this.electrumClient = new ElectrumClient(this.config.electrum);
+      this.syncProvider = new ElectrumSyncProvider(this.config.electrum);
+    }
+    this.syncManager = new TransactionKeysSync(this.walletDB, this.syncProvider);
+  }
+  /**
+   * Configure the navio-blsct library for the specified network
+   */
+  static configureNetwork(network) {
+    const chainMap = {
+      mainnet: BlsctChain.Mainnet,
+      testnet: BlsctChain.Testnet,
+      signet: BlsctChain.Signet,
+      regtest: BlsctChain.Regtest
+    };
+    setChain(chainMap[network]);
+  }
+  /**
+   * Get the current network configuration
+   */
+  getNetwork() {
+    return this.config.network || "mainnet";
+  }
+  /**
+   * Initialize the client
+   * Loads or creates wallet, connects to backend, and initializes sync manager
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.config.restoreFromSeed) {
+      this.keyManager = await this.walletDB.restoreWallet(
+        this.config.restoreFromSeed,
+        this.config.restoreFromHeight
+      );
+      this.syncManager.setKeyManager(this.keyManager);
+      await this.syncProvider.connect();
+    } else {
+      try {
+        this.keyManager = await this.walletDB.loadWallet();
+        this.syncManager.setKeyManager(this.keyManager);
+        await this.syncProvider.connect();
+      } catch (error) {
+        if (this.config.createWalletIfNotExists) {
+          let creationHeight;
+          if (this.config.creationHeight !== void 0) {
+            creationHeight = this.config.creationHeight;
+          } else {
+            await this.syncProvider.connect();
+            const chainTip = await this.syncProvider.getChainTipHeight();
+            creationHeight = Math.max(0, chainTip - _NavioClient.CREATION_HEIGHT_MARGIN);
+          }
+          this.keyManager = await this.walletDB.createWallet(creationHeight);
+          this.syncManager.setKeyManager(this.keyManager);
+        } else {
+          throw new Error(
+            `Wallet not found at ${this.config.walletDbPath}. Set createWalletIfNotExists: true to create a new wallet.`
+          );
+        }
+      }
+    }
+    await this.syncManager.initialize();
+    this.initialized = true;
+  }
+  /**
+   * Get the backend type being used
+   */
+  getBackendType() {
+    return this.config.backend || "electrum";
+  }
+  /**
+   * Get the sync provider
+   */
+  getSyncProvider() {
+    return this.syncProvider;
+  }
+  /**
+   * Get the KeyManager instance
+   * @returns KeyManager instance
+   */
+  getKeyManager() {
+    if (!this.keyManager) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    return this.keyManager;
+  }
+  /**
+   * Get the WalletDB instance
+   * @returns WalletDB instance
+   */
+  getWalletDB() {
+    return this.walletDB;
+  }
+  /**
+   * Get the ElectrumClient instance (only available when using electrum backend)
+   * @returns ElectrumClient instance or null if using P2P backend
+   * @deprecated Use getSyncProvider() instead for backend-agnostic code
+   */
+  getElectrumClient() {
+    return this.electrumClient;
+  }
+  /**
+   * Get the TransactionKeysSync instance
+   * @returns TransactionKeysSync instance
+   */
+  getSyncManager() {
+    return this.syncManager;
+  }
+  /**
+   * Synchronize transaction keys from the backend.
+   * 
+   * By default, syncs once to the current chain tip and returns.
+   * Use `startBackgroundSync()` to enable continuous synchronization.
+   * 
+   * @param options - Sync options
+   * @returns Number of transaction keys synced
+   */
+  async sync(options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.syncManager.sync(options || {});
+  }
+  // ============================================================
+  // Background Sync Methods
+  // ============================================================
+  /**
+   * Start continuous background synchronization.
+   * 
+   * The client will poll for new blocks and automatically sync new transactions.
+   * Callbacks are invoked for new blocks, transactions, and balance changes.
+   * 
+   * @param options - Background sync options
+   * 
+   * @example
+   * ```typescript
+   * await client.startBackgroundSync({
+   *   pollInterval: 10000, // Check every 10 seconds
+   *   onNewBlock: (height) => console.log(`New block: ${height}`),
+   *   onBalanceChange: (newBal, oldBal) => {
+   *     console.log(`Balance changed: ${Number(oldBal)/1e8} -> ${Number(newBal)/1e8} NAV`);
+   *   },
+   *   onError: (err) => console.error('Sync error:', err),
+   * });
+   * ```
+   */
+  async startBackgroundSync(options = {}) {
+    if (this.isBackgroundSyncing) {
+      return;
+    }
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    this.backgroundSyncOptions = {
+      pollInterval: options.pollInterval ?? 1e4,
+      ...options
+    };
+    this.isBackgroundSyncing = true;
+    this.lastKnownBalance = await this.getBalance();
+    await this.performBackgroundSync();
+    this.backgroundSyncTimer = setInterval(async () => {
+      await this.performBackgroundSync();
+    }, this.backgroundSyncOptions.pollInterval);
+  }
+  /**
+   * Stop background synchronization.
+   */
+  stopBackgroundSync() {
+    if (this.backgroundSyncTimer) {
+      clearInterval(this.backgroundSyncTimer);
+      this.backgroundSyncTimer = null;
+    }
+    this.isBackgroundSyncing = false;
+    this.backgroundSyncOptions = null;
+  }
+  /**
+   * Check if background sync is running.
+   * @returns True if background sync is active
+   */
+  isBackgroundSyncActive() {
+    return this.isBackgroundSyncing;
+  }
+  /**
+   * Perform a single background sync cycle.
+   * Called by the polling timer.
+   */
+  async performBackgroundSync() {
+    if (this.isSyncInProgress) {
+      return;
+    }
+    this.isSyncInProgress = true;
+    const opts = this.backgroundSyncOptions;
+    try {
+      const needsSync = await this.isSyncNeeded();
+      if (!needsSync) {
+        this.isSyncInProgress = false;
+        return;
+      }
+      const chainTip = await this.syncProvider.getChainTipHeight();
+      const lastSynced = this.getLastSyncedHeight();
+      await this.syncManager.sync({
+        onProgress: opts?.onProgress,
+        saveInterval: opts?.saveInterval,
+        verifyHashes: opts?.verifyHashes,
+        keepTxKeys: opts?.keepTxKeys,
+        blockHashRetention: opts?.blockHashRetention
+      });
+      if (opts?.onNewBlock && chainTip > lastSynced) {
+        try {
+          const headerHex = await this.syncProvider.getBlockHeader(chainTip);
+          const hash = this.hashBlockHeader(headerHex);
+          opts.onNewBlock(chainTip, hash);
+        } catch {
+          opts.onNewBlock(chainTip, "");
+        }
+      }
+      if (opts?.onBalanceChange) {
+        const newBalance = await this.getBalance();
+        if (newBalance !== this.lastKnownBalance) {
+          opts.onBalanceChange(newBalance, this.lastKnownBalance);
+          this.lastKnownBalance = newBalance;
+        }
+      }
+    } catch (error) {
+      if (opts?.onError) {
+        opts.onError(error);
+      }
+    } finally {
+      this.isSyncInProgress = false;
+    }
+  }
+  /**
+   * Check if synchronization is needed
+   * @returns True if sync is needed
+   */
+  async isSyncNeeded() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.syncManager.isSyncNeeded();
+  }
+  /**
+   * Get last synced block height
+   * @returns Last synced height, or -1 if never synced
+   */
+  getLastSyncedHeight() {
+    return this.syncManager.getLastSyncedHeight();
+  }
+  /**
+   * Get sync state
+   * @returns Current sync state
+   */
+  getSyncState() {
+    return this.syncManager.getSyncState();
+  }
+  /**
+   * Get the wallet creation height (block height to start scanning from)
+   * @returns Creation height or 0 if not set
+   */
+  async getCreationHeight() {
+    return this.walletDB.getCreationHeight();
+  }
+  /**
+   * Set the wallet creation height
+   * @param height - Block height when wallet was created
+   */
+  async setCreationHeight(height) {
+    await this.walletDB.setCreationHeight(height);
+  }
+  /**
+   * Get wallet metadata
+   * @returns Wallet metadata or null if not available
+   */
+  async getWalletMetadata() {
+    return this.walletDB.getWalletMetadata();
+  }
+  /**
+   * Get chain tip from the backend
+   * @returns Current chain tip height and hash
+   */
+  async getChainTip() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const height = await this.syncProvider.getChainTipHeight();
+    if (this.config.backend === "p2p") {
+      const p2pProvider = this.syncProvider;
+      if (typeof p2pProvider.getChainTip === "function") {
+        return p2pProvider.getChainTip();
+      }
+    }
+    try {
+      const headerHex = await this.syncProvider.getBlockHeader(height);
+      const hash = this.hashBlockHeader(headerHex);
+      return { height, hash };
+    } catch {
+      return { height, hash: "" };
+    }
+  }
+  /**
+   * Disconnect from backend and close database
+   */
+  async disconnect() {
+    this.stopBackgroundSync();
+    if (this.syncProvider) {
+      this.syncProvider.disconnect();
+    }
+    if (this.walletDB) {
+      await this.walletDB.close();
+    }
+    this.initialized = false;
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check if client is connected to the backend
+   */
+  isConnected() {
+    return this.syncProvider?.isConnected() ?? false;
+  }
+  /**
+   * Hash a block header to get block hash
+   */
+  hashBlockHeader(headerHex) {
+    const headerBytes = Buffer.from(headerHex, "hex");
+    const hash = sha256(sha256(headerBytes));
+    return Buffer.from(hash).reverse().toString("hex");
+  }
+  // ============================================================
+  // Wallet Balance & Output Methods
+  // ============================================================
+  /**
+   * Get wallet balance in satoshis
+   * @param tokenId - Optional token ID to filter by (null for NAV)
+   * @returns Balance in satoshis as bigint
+   */
+  async getBalance(tokenId = null) {
+    return this.walletDB.getBalance(tokenId);
+  }
+  /**
+   * Get wallet balance in NAV (with decimals)
+   * @param tokenId - Optional token ID to filter by (null for NAV)
+   * @returns Balance as a number with 8 decimal places
+   */
+  async getBalanceNav(tokenId = null) {
+    const balanceSatoshis = await this.getBalance(tokenId);
+    return Number(balanceSatoshis) / 1e8;
+  }
+  /**
+   * Get unspent outputs (UTXOs)
+   * @param tokenId - Optional token ID to filter by (null for NAV)
+   * @returns Array of unspent wallet outputs
+   */
+  async getUnspentOutputs(tokenId = null) {
+    return this.walletDB.getUnspentOutputs(tokenId);
+  }
+  /**
+   * Get all wallet outputs (spent and unspent)
+   * @returns Array of all wallet outputs
+   */
+  async getAllOutputs() {
+    return this.walletDB.getAllOutputs();
+  }
+};
+/**
+ * Safety margin (in blocks) when setting creation height for new wallets.
+ * This ensures we don't miss any transactions that might be in recent blocks.
+ */
+_NavioClient.CREATION_HEIGHT_MARGIN = 100;
+var NavioClient = _NavioClient;
+
+export { BaseSyncProvider, DefaultPorts, ElectrumClient, ElectrumError, ElectrumSyncProvider, InvType, KeyManager, MessageType, NavioClient, NetworkMagic, P2PClient, P2PSyncProvider, PROTOCOL_VERSION, ServiceFlags, TransactionKeysSync, WalletDB };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map