navio-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2500 @@
+import * as blsctModule from 'navio-blsct';
+export { BlsctChain, getChain, setChain } from 'navio-blsct';
+
+/**
+ * Type definitions for KeyManager
+ * These types represent the BLS CT key structures from navio-blsct
+ * Replicates types from navio-core's blsct::keyman
+ */
+/**
+ * Secret key type (opaque type from navio-blsct)
+ * This represents a BLS secret key (MclScalar)
+ */
+type SecretKey = unknown;
+/**
+ * Public key type (opaque type from navio-blsct)
+ * This represents a BLS public key (MclG1Point)
+ */
+type PublicKey$1 = unknown;
+/**
+ * Sub-address identifier
+ * Replicates SubAddressIdentifier from navio-core
+ */
+interface SubAddressIdentifier {
+    /** Account number (0 = main, -1 = change, -2 = staking) */
+    account: number;
+    /** Address index within the account */
+    address: number;
+}
+/**
+ * Sub-address type
+ * Replicates SubAddress from navio-core
+ */
+type SubAddress = unknown;
+/**
+ * HD Chain structure
+ * Replicates HDChain from navio-core
+ */
+interface HDChain {
+    /** Chain version */
+    version: number;
+    /** Seed ID (hash160 of seed public key) */
+    seedId: Uint8Array;
+    /** Spend key ID */
+    spendId: Uint8Array;
+    /** View key ID */
+    viewId: Uint8Array;
+    /** Token key ID */
+    tokenId: Uint8Array;
+    /** Blinding key ID */
+    blindingId: Uint8Array;
+}
+/**
+ * Seed type for import
+ * Replicates SeedType enum from navio-core
+ */
+type SeedType = 'IMPORT_MASTER_KEY' | 'IMPORT_VIEW_KEY';
+/**
+ * Key storage interface for persistent storage
+ */
+interface KeyStorage {
+    /** Save a key pair with a label */
+    save(label: string, secretKey: SecretKey, publicKey: PublicKey$1): Promise<void>;
+    /** Load a key pair by label */
+    load(label: string): Promise<{
+        secretKey: SecretKey;
+        publicKey: PublicKey$1;
+    } | null>;
+    /** Delete a key pair by label */
+    delete(label: string): Promise<boolean>;
+    /** List all stored key labels */
+    list(): Promise<string[]>;
+}
+/**
+ * BLS CT transaction output data
+ * Replicates CTxOutBLSCTData from navio-core
+ */
+interface CTxOutBLSCTData {
+    /** Spending public key */
+    spendingKey: unknown;
+    /** Ephemeral public key */
+    ephemeralKey: unknown;
+    /** Blinding public key */
+    blindingKey: unknown;
+    /** Range proof */
+    rangeProof: unknown;
+    /** View tag (16-bit) */
+    viewTag: number;
+}
+/**
+ * Transaction output
+ * Replicates CTxOut from navio-core
+ */
+interface CTxOut {
+    /** Value (amount) */
+    nValue: bigint;
+    /** Script public key */
+    scriptPubKey: Uint8Array;
+    /** BLS CT data */
+    blsctData: CTxOutBLSCTData;
+    /** Token ID */
+    tokenId: Uint8Array;
+    /** Predicate (optional) */
+    predicate?: unknown;
+}
+/**
+ * Transaction destination
+ * Replicates CTxDestination from navio-core
+ */
+type CTxDestination = unknown;
+/**
+ * Amount recovery result
+ * Replicates AmountRecoveryResult from navio-core
+ */
+interface AmountRecoveryResult {
+    /** Success flag */
+    success: boolean;
+    /** Recovered amounts */
+    amounts: bigint[];
+    /** Indices of outputs that were recovered */
+    indices: number[];
+}
+
+/**
+ * KeyManager - Replicates blsct::keyman functionality from navio-core
+ * Uses low-level functions from navio-blsct library
+ *
+ * Based on navio-blsct documentation: https://nav-io.github.io/libblsct-bindings/ts/
+ */
+
+declare const Scalar: typeof blsctModule.Scalar;
+declare const PublicKey: typeof blsctModule.PublicKey;
+declare const SubAddr: typeof blsctModule.SubAddr;
+type ScalarType = InstanceType<typeof Scalar>;
+type ViewKeyType = ScalarType;
+type PublicKeyType = InstanceType<typeof PublicKey>;
+type SubAddrType = InstanceType<typeof SubAddr>;
+
+/**
+ * KeyManager class for managing BLS CT keys.
+ * Replicates functionality from navio-core's blsct::keyman.
+ *
+ * Handles HD key derivation, sub-address generation, output detection,
+ * and amount recovery for BLSCT confidential transactions.
+ *
+ * @category Keys
+ */
+declare class KeyManager {
+    private hdChain;
+    private viewKey;
+    private spendPublicKey;
+    private masterSeed;
+    private spendKeyId;
+    private viewKeyId;
+    private tokenKeyId;
+    private blindingKeyId;
+    private seedId;
+    private keys;
+    private outKeys;
+    private cryptedKeys;
+    private cryptedOutKeys;
+    private keyMetadata;
+    private subAddressCounter;
+    private subAddresses;
+    private subAddressesStr;
+    private subAddressPool;
+    private subAddressPoolTime;
+    private timeFirstKey;
+    private fViewKeyDefined;
+    private fSpendKeyDefined;
+    /**
+     * Check if HD is enabled (has a seed)
+     * @returns True if HD is enabled
+     */
+    isHDEnabled(): boolean;
+    /**
+     * Check if the wallet can generate new keys
+     * @returns True if HD is enabled
+     */
+    canGenerateKeys(): boolean;
+    /**
+     * Generate a new random seed
+     * @returns A new random Scalar (seed)
+     */
+    generateNewSeed(): ScalarType;
+    /**
+     * 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: ScalarType): void;
+    /**
+     * 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: Uint8Array, type?: SeedType, force?: boolean): boolean;
+    /**
+     * Get the master seed key
+     * @returns The master seed Scalar
+     */
+    getMasterSeedKey(): ScalarType;
+    /**
+     * Get the private view key
+     * @returns The view key
+     */
+    getPrivateViewKey(): ViewKeyType;
+    /**
+     * Get the public spending key
+     * @returns The public spending key
+     */
+    getPublicSpendingKey(): PublicKeyType;
+    /**
+     * 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?: SubAddressIdentifier): SubAddrType;
+    /**
+     * 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: number): {
+        subAddress: SubAddrType;
+        id: SubAddressIdentifier;
+    };
+    /**
+     * 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?: number): SubAddrType;
+    /**
+     * Create a new sub-address pool for an account
+     * @param account - The account number
+     * @returns True if successful
+     */
+    newSubAddressPool(account: number): boolean;
+    /**
+     * Top up all sub-address pools
+     * @param size - Target size for pools (0 = use default)
+     * @returns True if successful
+     */
+    topUp(size?: number): boolean;
+    /**
+     * 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: number, size?: number): boolean;
+    /**
+     * Get the size of the sub-address pool for an account
+     * @param account - The account number
+     * @returns The pool size
+     */
+    getSubAddressPoolSize(account: number): number;
+    /**
+     * 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: PublicKeyType, spendingKey: PublicKeyType): Uint8Array;
+    /**
+     * 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: PublicKeyType): number;
+    /**
+     * Calculate nonce for range proof recovery
+     * Uses calcNonce from navio-blsct
+     * @param blindingKey - The blinding public key
+     * @returns The nonce (Point)
+     */
+    calculateNonce(blindingKey: PublicKeyType): any;
+    /**
+     * Get the HD chain information
+     * @returns The HD chain or null if not set
+     */
+    getHDChain(): HDChain | null;
+    /**
+     * 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: ScalarType, publicKey: PublicKeyType): boolean;
+    /**
+     * 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: ViewKeyType): boolean;
+    /**
+     * 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: PublicKeyType): boolean;
+    /**
+     * 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: ScalarType, outId: Uint8Array): boolean;
+    /**
+     * 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: PublicKeyType, encryptedSecret: Uint8Array, checksumValid: boolean): boolean;
+    /**
+     * 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: Uint8Array, publicKey: PublicKeyType, encryptedSecret: Uint8Array, checksumValid: boolean): boolean;
+    /**
+     * Load HD chain from storage
+     * Replicates LoadHDChain from keyman.cpp
+     * @param chain - The HD chain to load
+     */
+    loadHDChain(chain: HDChain): void;
+    /**
+     * Load key metadata from storage
+     * Replicates LoadKeyMetadata from keyman.cpp
+     * @param keyId - The key ID
+     * @param metadata - The key metadata
+     */
+    loadKeyMetadata(keyId: Uint8Array, metadata: {
+        nCreateTime: number;
+    }): void;
+    /**
+     * 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: ScalarType, publicKey: PublicKeyType): boolean;
+    /**
+     * 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: ScalarType, outId: Uint8Array): boolean;
+    /**
+     * 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: ViewKeyType, _publicKey: PublicKeyType): boolean;
+    /**
+     * 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: PublicKeyType): boolean;
+    /**
+     * 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: PublicKeyType, encryptedSecret: Uint8Array): boolean;
+    /**
+     * 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: Uint8Array, publicKey: PublicKeyType, encryptedSecret: Uint8Array): boolean;
+    /**
+     * Add HD chain and save to database
+     * Replicates AddHDChain from keyman.cpp
+     * @param chain - The HD chain to add
+     */
+    addHDChain(chain: HDChain): void;
+    /**
+     * 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: Uint8Array): boolean;
+    /**
+     * 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: Uint8Array): ScalarType | 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: Uint8Array): ScalarType | null;
+    /**
+     * Internal method to add a key pair (used by both Load and Add methods)
+     */
+    private addKeyPubKeyInner;
+    /**
+     * Internal method to add an output key (used by both Load and Add methods)
+     */
+    private addKeyOutKeyInner;
+    /**
+     * Internal method to add an encrypted key (used by both Load and Add methods)
+     */
+    private addCryptedKeyInner;
+    /**
+     * Internal method to add an encrypted output key (used by both Load and Add methods)
+     */
+    private addCryptedOutKeyInner;
+    /**
+     * Update the time of the first key
+     * Replicates UpdateTimeFirstKey from keyman.cpp
+     */
+    private updateTimeFirstKey;
+    private getPublicKeyFromScalar;
+    private getPublicKeyFromViewKey;
+    private getPublicKeyBytes;
+    private createScalarFromBytes;
+    private createViewKeyFromBytes;
+    private createPublicKeyFromBytes;
+    /**
+     * 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)
+     */
+    private hash160;
+    private bytesToHex;
+    /**
+     * Get the private spending key
+     * Replicates GetSpendingKey from keyman.cpp
+     * @returns The private spending key (Scalar)
+     */
+    getSpendingKey(): ScalarType;
+    /**
+     * 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: CTxOut, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut, hashId: Uint8Array, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut, id: SubAddressIdentifier, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut, hashId: Uint8Array, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut, id: SubAddressIdentifier, key: {
+        value: ScalarType | null;
+    }): boolean;
+    /**
+     * 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: CTxOut): boolean;
+    /**
+     * 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: PublicKeyType, spendingKey: PublicKeyType, viewTag: number): boolean;
+    /**
+     * 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: Uint8Array): boolean;
+    /**
+     * 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: CTxOut): Uint8Array;
+    /**
+     * 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: PublicKeyType, spendingKey: PublicKeyType): Uint8Array;
+    /**
+     * Get destination from transaction output
+     * Replicates GetDestination from keyman.cpp
+     * @param txout - The transaction output
+     * @returns The destination (SubAddress keys) or null
+     */
+    getDestination(txout: CTxOut): CTxDestination | null;
+    /**
+     * 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: CTxOut): boolean;
+    /**
+     * Get master token key
+     * Replicates GetMasterTokenKey from keyman.cpp
+     * @returns The master token key (Scalar)
+     */
+    getMasterTokenKey(): ScalarType;
+    /**
+     * 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: CTxOut[]): AmountRecoveryResult;
+    /**
+     * 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: CTxOut[], nonce: PublicKeyType): AmountRecoveryResult;
+    /**
+     * Load sub-address mapping from storage
+     * Replicates LoadSubAddress from keyman.cpp
+     * @param hashId - The hash ID
+     * @param index - The sub-address identifier
+     */
+    loadSubAddress(hashId: Uint8Array, index: SubAddressIdentifier): void;
+    /**
+     * 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: Uint8Array, index: SubAddressIdentifier): boolean;
+    /**
+     * 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: Uint8Array): boolean;
+    /**
+     * 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: Uint8Array, address: {
+        value: SubAddrType | null;
+    }): boolean;
+    /**
+     * 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: Uint8Array, id: SubAddressIdentifier): boolean;
+    /**
+     * Load sub-address string mapping from storage
+     * Replicates LoadSubAddressStr from keyman.cpp
+     * @param subAddress - The sub-address
+     * @param hashId - The hash ID
+     */
+    loadSubAddressStr(subAddress: SubAddrType, hashId: Uint8Array): void;
+    /**
+     * 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: SubAddrType, hashId: Uint8Array): boolean;
+    /**
+     * 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: SubAddrType): boolean;
+    /**
+     * 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: number, nIndex: {
+        value: number;
+    }, keypool: {
+        value: {
+            id: SubAddressIdentifier;
+            subAddress: SubAddrType;
+        } | null;
+    }): void;
+    /**
+     * Keep a sub-address (mark as used)
+     * Replicates KeepSubAddress from keyman.cpp
+     * @param id - The sub-address identifier
+     */
+    keepSubAddress(id: SubAddressIdentifier): void;
+    /**
+     * Return sub-address to pool
+     * Replicates ReturnSubAddress from keyman.cpp
+     * @param id - The sub-address identifier
+     */
+    returnSubAddress(id: SubAddressIdentifier): void;
+    /**
+     * 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: number, result: {
+        value: Uint8Array | null;
+    }, id: {
+        value: SubAddressIdentifier | null;
+    }): boolean;
+    /**
+     * 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: number): number;
+    /**
+     * Add inactive HD chain
+     * Replicates AddInactiveHDChain from keyman.cpp
+     * @param chain - The HD chain to add
+     */
+    addInactiveHDChain(_chain: HDChain): void;
+    /**
+     * Get time of first key
+     * Replicates GetTimeFirstKey from keyman.cpp
+     * @returns The creation time of the first key
+     */
+    getTimeFirstKey(): number;
+    /**
+     * 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: Uint8Array, _spendingKey: {
+        value: PublicKeyType | null;
+    }): boolean;
+    /**
+     * Check if public key is zero
+     */
+    private isPublicKeyZero;
+    /**
+     * Get scalar from ViewKey
+     */
+    private getScalarFromViewKey;
+    /**
+     * Get scalar from Scalar (identity function, but ensures type)
+     */
+    private getScalarFromScalar;
+    /**
+     * Get bytes from Scalar
+     */
+    private getScalarBytes;
+    /**
+     * Serialize SubAddress to string for map key
+     */
+    private serializeSubAddress;
+    /**
+     * Get hash ID from SubAddress
+     * Uses DoublePublicKey.deserialize(subaddress.serialize()) to extract keys
+     */
+    private getHashIdFromSubAddress;
+}
+
+/**
+ * WalletDB - Database persistence layer for KeyManager
+ * Uses SQL.js (SQLite compiled to WebAssembly) for cross-platform compatibility
+ * Works on web browsers, Node.js, and mobile platforms
+ *
+ * Database schema replicates navio-core wallet database structure
+ */
+
+/**
+ * Wallet output structure returned by getUnspentOutputs and getAllOutputs
+ */
+interface WalletOutput {
+    outputHash: string;
+    txHash: string;
+    outputIndex: number;
+    blockHeight: number;
+    amount: bigint;
+    memo: string | null;
+    tokenId: string | null;
+    blindingKey: string;
+    spendingKey: string;
+    isSpent: boolean;
+    spentTxHash: string | null;
+    spentBlockHeight: number | null;
+}
+/**
+ * WalletDB - Manages wallet database persistence.
+ *
+ * Uses SQL.js (SQLite compiled to WebAssembly) for cross-platform compatibility.
+ * Works on web browsers, Node.js, and mobile platforms.
+ *
+ * @category Wallet
+ */
+declare class WalletDB {
+    private db;
+    private dbPath;
+    private keyManager;
+    private isOpen;
+    /**
+     * 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?: string, _createIfNotExists?: boolean);
+    /**
+     * Initialize the database connection and schema
+     */
+    private initDatabase;
+    /**
+     * Get file system interface (Node.js only)
+     */
+    private getFileSystem;
+    /**
+     * Create database schema
+     * Replicates navio-core wallet database structure
+     */
+    private createSchema;
+    /**
+     * Load wallet from database
+     * @returns The loaded KeyManager instance
+     * @throws Error if no wallet exists in the database
+     */
+    loadWallet(): Promise<KeyManager>;
+    /**
+     * Create a new wallet
+     * @param creationHeight - Optional block height when wallet was created (for sync optimization)
+     * @returns The new KeyManager instance
+     */
+    createWallet(creationHeight?: number): Promise<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
+     */
+    restoreWallet(seedHex: string, creationHeight?: number): Promise<KeyManager>;
+    /**
+     * Save wallet metadata to database
+     */
+    private saveWalletMetadata;
+    /**
+     * Persist database to disk (if not in-memory)
+     */
+    private persistToDisk;
+    /**
+     * Get wallet metadata from database
+     * @returns Wallet metadata or null if not found
+     */
+    getWalletMetadata(): Promise<{
+        creationHeight: number;
+        creationTime: number;
+        restoredFromSeed: boolean;
+        version: number;
+    } | null>;
+    /**
+     * Get the wallet creation height (block height to start scanning from)
+     * @returns Creation height or 0 if not set
+     */
+    getCreationHeight(): Promise<number>;
+    /**
+     * Set the wallet creation height
+     * @param height - Block height
+     */
+    setCreationHeight(height: number): Promise<void>;
+    /**
+     * Save wallet to database
+     * @param keyManager - The KeyManager instance to save (optional, uses stored instance if not provided)
+     */
+    saveWallet(keyManager?: KeyManager): Promise<void>;
+    /**
+     * Get the current KeyManager instance
+     */
+    getKeyManager(): KeyManager | null;
+    /**
+     * Get the database instance (for use by sync modules)
+     * @internal
+     */
+    getDatabase(): any;
+    /**
+     * Get the database path
+     * @internal
+     */
+    getDatabasePath(): string;
+    /**
+     * Save database to disk (if not in-memory)
+     */
+    saveDatabase(): Promise<void>;
+    /**
+     * Close the database connection
+     */
+    close(): void;
+    private deserializeScalar;
+    private serializeViewKey;
+    private deserializeViewKey;
+    private serializePublicKey;
+    private deserializePublicKey;
+    private getPublicKeyFromViewKey;
+    private bytesToHex;
+    private hexToBytes;
+    /**
+     * Get wallet balance (sum of unspent output amounts)
+     * @param tokenId - Optional token ID to filter by (null for NAV)
+     * @returns Balance in satoshis
+     */
+    getBalance(tokenId?: string | null): Promise<bigint>;
+    /**
+     * Get unspent outputs (UTXOs)
+     * @param tokenId - Optional token ID to filter by (null for NAV)
+     * @returns Array of unspent outputs
+     */
+    getUnspentOutputs(tokenId?: string | null): Promise<WalletOutput[]>;
+    /**
+     * Get all outputs (spent and unspent)
+     * @returns Array of all wallet outputs
+     */
+    getAllOutputs(): Promise<WalletOutput[]>;
+}
+
+/**
+ * Electrum Client - Connect and interact with Electrum servers
+ *
+ * Supports WebSocket and TCP connections
+ * Implements Electrum protocol for fetching transaction keys and blockchain data
+ *
+ * Based on electrumx server implementation and Navio-specific extensions
+ */
+/**
+ * Electrum server connection options
+ */
+interface ElectrumOptions {
+    /** Server host (default: localhost) */
+    host?: string;
+    /** Server port (default: 50001) */
+    port?: number;
+    /** Use SSL/TLS (default: false) */
+    ssl?: boolean;
+    /** Connection timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Client name for server.version (default: 'navio-sdk') */
+    clientName?: string;
+    /** Client version for server.version (default: '1.4') */
+    clientVersion?: string;
+}
+/**
+ * Transaction keys structure
+ * Represents the keys associated with a transaction
+ */
+interface TransactionKeys {
+    /** Transaction hash */
+    txHash: string;
+    /** Transaction keys (structure depends on coin implementation) */
+    keys: any;
+}
+/**
+ * Block transaction keys
+ * Contains all transaction keys for a block
+ */
+interface BlockTransactionKeys {
+    /** Block height */
+    height: number;
+    /** Transaction keys for this block */
+    txKeys: TransactionKeys[];
+}
+/**
+ * Range result for block transaction keys
+ */
+interface BlockTransactionKeysRange {
+    /** Blocks with their transaction keys */
+    blocks: BlockTransactionKeys[];
+    /** Next height to query (for pagination) */
+    nextHeight: number;
+}
+/**
+ * Block header information
+ */
+interface BlockHeader {
+    /** Block height */
+    height: number;
+    /** Block hash */
+    hash: string;
+    /** Previous block hash */
+    prevHash: string;
+    /** Merkle root */
+    merkleRoot: string;
+    /** Block timestamp */
+    timestamp: number;
+    /** Block version */
+    version: number;
+    /** Difficulty target */
+    bits: number;
+    /** Nonce */
+    nonce: number;
+}
+/**
+ * Electrum RPC error
+ */
+declare class ElectrumError extends Error {
+    code?: number | undefined;
+    data?: any | undefined;
+    constructor(message: string, code?: number | undefined, data?: any | undefined);
+}
+/**
+ * Electrum Client - Connects to Electrum servers.
+ *
+ * Low-level client for the Electrum protocol. For most use cases,
+ * use NavioClient with the 'electrum' backend instead.
+ *
+ * @category Protocol
+ */
+declare class ElectrumClient {
+    private ws;
+    private requestId;
+    private pendingRequests;
+    private connected;
+    private options;
+    private reconnectAttempts;
+    constructor(options?: ElectrumOptions);
+    /**
+     * Connect to the Electrum server
+     */
+    connect(): Promise<void>;
+    /**
+     * Handle incoming response from server
+     */
+    private handleResponse;
+    /**
+     * Make an RPC call to the Electrum server
+     * @param method - RPC method name
+     * @param params - Method parameters
+     * @returns Promise resolving to the result
+     */
+    call(method: string, ...params: any[]): Promise<any>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Check if connected to server
+     */
+    isConnected(): boolean;
+    /**
+     * Get server version
+     * @returns Server version information
+     */
+    getServerVersion(): Promise<[string, string]>;
+    /**
+     * Get block header for a given height
+     * @param height - Block height
+     * @returns Block header
+     */
+    getBlockHeader(height: number): Promise<string>;
+    /**
+     * Get block headers for a range of heights
+     * @param startHeight - Starting block height
+     * @param count - Number of headers to fetch
+     * @returns Block headers
+     */
+    getBlockHeaders(startHeight: number, count: number): Promise<{
+        count: number;
+        hex: string;
+        max: number;
+    }>;
+    /**
+     * Subscribe to block headers
+     * @param callback - Callback function for new headers
+     */
+    subscribeBlockHeaders(callback: (header: any) => void): Promise<void>;
+    /**
+     * Get chain tip height
+     * @returns Current chain tip height
+     */
+    getChainTipHeight(): Promise<number>;
+    /**
+     * Get transaction keys for a specific transaction
+     * @param txHash - Transaction hash (hex string)
+     * @returns Transaction keys
+     */
+    getTransactionKeys(txHash: string): Promise<any>;
+    /**
+     * Get all transaction keys for a block
+     * @param height - Block height
+     * @returns Array of transaction keys for the block
+     */
+    getBlockTransactionKeys(height: number): Promise<any[]>;
+    /**
+     * Get transaction keys for a range of blocks (paginated)
+     * @param startHeight - Starting block height
+     * @returns Range result with blocks and next height
+     */
+    getBlockTransactionKeysRange(startHeight: number): Promise<BlockTransactionKeysRange>;
+    /**
+     * Fetch all transaction keys from genesis to chain tip
+     * @param progressCallback - Optional callback for progress updates
+     * @returns Array of all block transaction keys
+     */
+    fetchAllTransactionKeys(progressCallback?: (height: number, totalHeight: number, blocksProcessed: number) => void): Promise<BlockTransactionKeys[]>;
+    /**
+     * Get serialized transaction output by output hash (Navio-specific)
+     * @param outputHash - Output hash (hex string)
+     * @returns Serialized output (hex string)
+     */
+    getTransactionOutput(outputHash: string): Promise<string>;
+    /**
+     * 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
+     */
+    getRawTransaction(txHash: string, verbose?: boolean, blockHash?: string): Promise<string | any>;
+    /**
+     * Broadcast a transaction
+     * @param rawTx - Raw transaction (hex string)
+     * @returns Transaction hash if successful
+     */
+    broadcastTransaction(rawTx: string): Promise<string>;
+    /**
+     * Get transaction history for a script hash
+     * @param scriptHash - Script hash (hex string, reversed)
+     * @returns Transaction history
+     */
+    getHistory(scriptHash: string): Promise<any[]>;
+    /**
+     * Get unspent transaction outputs for a script hash
+     * @param scriptHash - Script hash (hex string, reversed)
+     * @returns Unspent outputs
+     */
+    getUnspent(scriptHash: string): Promise<any[]>;
+    /**
+     * Subscribe to script hash updates
+     * @param scriptHash - Script hash (hex string, reversed)
+     * @param callback - Callback for status updates
+     */
+    subscribeScriptHash(scriptHash: string, callback: (status: string) => void): Promise<void>;
+    /**
+     * Calculate script hash from address (for Electrum protocol)
+     * @param address - Address string
+     * @returns Script hash (hex string, reversed for Electrum)
+     */
+    static calculateScriptHash(address: string): string;
+    /**
+     * Reverse a hex string (for Electrum protocol hash format)
+     * @param hex - Hex string
+     * @returns Reversed hex string
+     */
+    static reverseHex(hex: string): string;
+}
+
+/**
+ * Sync Provider Interface
+ *
+ * Abstract interface for blockchain synchronization providers.
+ * Supports multiple backends: Electrum, P2P, or custom implementations.
+ */
+
+/**
+ * Block header information (for sync provider)
+ */
+interface SyncBlockHeader {
+    /** Block height */
+    height: number;
+    /** Block hash (hex string, little-endian display format) */
+    hash: string;
+    /** Previous block hash */
+    prevHash: string;
+    /** Merkle root */
+    merkleRoot: string;
+    /** Block timestamp */
+    timestamp: number;
+    /** Block version */
+    version: number;
+    /** Difficulty target (bits) */
+    bits: number;
+    /** Nonce */
+    nonce: number;
+    /** Raw header hex (80 bytes) */
+    rawHex?: string;
+}
+/**
+ * Block headers result (for batch fetches)
+ */
+interface BlockHeadersResult {
+    /** Number of headers returned */
+    count: number;
+    /** Concatenated headers hex */
+    hex: string;
+    /** Maximum headers the server can return */
+    max?: number;
+}
+/**
+ * Chain tip information
+ */
+interface ChainTip {
+    /** Current chain height */
+    height: number;
+    /** Block hash at tip */
+    hash: string;
+}
+/**
+ * Sync provider options
+ */
+interface SyncProviderOptions {
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Abstract sync provider interface
+ *
+ * Implementations must provide methods for:
+ * - Connecting/disconnecting
+ * - Fetching block headers
+ * - Fetching transaction keys for wallet scanning
+ * - Fetching transaction outputs by hash
+ * - Broadcasting transactions
+ *
+ * @category Sync
+ */
+interface SyncProvider {
+    /**
+     * Provider type identifier
+     */
+    readonly type: 'electrum' | 'p2p' | 'custom';
+    /**
+     * Connect to the provider
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the provider
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current chain tip height
+     */
+    getChainTipHeight(): Promise<number>;
+    /**
+     * Get the current chain tip
+     */
+    getChainTip(): Promise<ChainTip>;
+    /**
+     * Get a single block header
+     * @param height - Block height
+     * @returns Block header hex (80 bytes)
+     */
+    getBlockHeader(height: number): Promise<string>;
+    /**
+     * Get multiple block headers
+     * @param startHeight - Starting block height
+     * @param count - Number of headers to fetch
+     * @returns Block headers result
+     */
+    getBlockHeaders(startHeight: number, count: number): Promise<BlockHeadersResult>;
+    /**
+     * Get transaction keys for a range of blocks
+     * Used for wallet scanning - extracts keys needed for output detection
+     * @param startHeight - Starting block height
+     * @returns Block transaction keys with next height for pagination
+     */
+    getBlockTransactionKeysRange(startHeight: number): Promise<{
+        blocks: BlockTransactionKeys[];
+        nextHeight: number;
+    }>;
+    /**
+     * Get transaction keys for a single block
+     * @param height - Block height
+     * @returns Array of transaction keys
+     */
+    getBlockTransactionKeys(height: number): Promise<TransactionKeys[]>;
+    /**
+     * Get serialized transaction output by output hash
+     * @param outputHash - Output hash (hex string)
+     * @returns Serialized output (hex string)
+     */
+    getTransactionOutput(outputHash: string): Promise<string>;
+    /**
+     * Broadcast a transaction
+     * @param rawTx - Raw transaction (hex string)
+     * @returns Transaction hash if successful
+     */
+    broadcastTransaction(rawTx: string): Promise<string>;
+    /**
+     * Get raw transaction
+     * @param txHash - Transaction hash (hex string)
+     * @param verbose - Return verbose data
+     * @returns Raw transaction hex or verbose object
+     */
+    getRawTransaction(txHash: string, verbose?: boolean): Promise<string | unknown>;
+}
+/**
+ * Base class for sync providers with common utility methods.
+ *
+ * @category Sync
+ */
+declare abstract class BaseSyncProvider implements SyncProvider {
+    abstract readonly type: 'electrum' | 'p2p' | 'custom';
+    protected debug: boolean;
+    protected timeout: number;
+    constructor(options?: SyncProviderOptions);
+    protected log(...args: unknown[]): void;
+    /**
+     * Extract block hash from raw block header (80 bytes hex)
+     * Block hash is double SHA256 of header, reversed for display
+     */
+    protected extractBlockHash(headerHex: string): string;
+    /**
+     * Parse a raw block header into structured format
+     */
+    protected parseBlockHeader(headerHex: string, height: number): SyncBlockHeader;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): void;
+    abstract isConnected(): boolean;
+    abstract getChainTipHeight(): Promise<number>;
+    abstract getChainTip(): Promise<ChainTip>;
+    abstract getBlockHeader(height: number): Promise<string>;
+    abstract getBlockHeaders(startHeight: number, count: number): Promise<BlockHeadersResult>;
+    abstract getBlockTransactionKeysRange(startHeight: number): Promise<{
+        blocks: BlockTransactionKeys[];
+        nextHeight: number;
+    }>;
+    abstract getBlockTransactionKeys(height: number): Promise<TransactionKeys[]>;
+    abstract getTransactionOutput(outputHash: string): Promise<string>;
+    abstract broadcastTransaction(rawTx: string): Promise<string>;
+    abstract getRawTransaction(txHash: string, verbose?: boolean): Promise<string | unknown>;
+}
+
+/**
+ * Transaction Keys Sync Module
+ *
+ * Synchronizes transaction keys from a sync provider to wallet database
+ * - Supports multiple backends: Electrum, P2P, or custom providers
+ * - Tracks sync progress and resumes from last state
+ * - Handles block reorganizations
+ * - Persists sync state in wallet database
+ */
+
+/**
+ * Sync state stored in database
+ */
+interface SyncState {
+    /** Last synced block height */
+    lastSyncedHeight: number;
+    /** Last synced block hash */
+    lastSyncedHash: string;
+    /** Total transaction keys synced */
+    totalTxKeysSynced: number;
+    /** Last sync timestamp */
+    lastSyncTime: number;
+    /** Chain tip at last sync */
+    chainTipAtLastSync: number;
+}
+/**
+ * Sync progress callback
+ */
+type SyncProgressCallback = (currentHeight: number, chainTip: number, blocksProcessed: number, txKeysProcessed: number, isReorg: boolean) => void;
+/**
+ * Sync options
+ */
+interface SyncOptions {
+    /** Start height (default: last synced height + 1) */
+    startHeight?: number;
+    /** End height (default: chain tip) */
+    endHeight?: number;
+    /** Progress callback */
+    onProgress?: SyncProgressCallback;
+    /** Stop on reorganization (default: true) */
+    stopOnReorg?: boolean;
+    /** Verify block hashes (default: true) */
+    verifyHashes?: boolean;
+    /** Save database after N blocks (default: 100) - 0 to save only at end */
+    saveInterval?: number;
+    /** Keep transaction keys in database after processing (default: false) */
+    keepTxKeys?: boolean;
+    /** Keep block hashes for last N blocks only (default: 10000) - 0 to keep all */
+    blockHashRetention?: number;
+}
+/**
+ * Background sync options for continuous synchronization
+ */
+interface BackgroundSyncOptions extends SyncOptions {
+    /**
+     * Polling interval in milliseconds
+     * @default 10000 (10 seconds)
+     */
+    pollInterval?: number;
+    /**
+     * Callback when a new block is detected
+     */
+    onNewBlock?: (height: number, hash: string) => void;
+    /**
+     * Callback when new transactions are detected for the wallet
+     */
+    onNewTransaction?: (txHash: string, outputHash: string, amount: bigint) => void;
+    /**
+     * Callback when balance changes
+     */
+    onBalanceChange?: (newBalance: bigint, oldBalance: bigint) => void;
+    /**
+     * Callback on sync error (background sync continues after errors)
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Reorganization information
+ */
+interface ReorganizationInfo {
+    /** Height where reorganization occurred */
+    height: number;
+    /** Old block hash */
+    oldHash: string;
+    /** New block hash */
+    newHash: string;
+    /** Number of blocks to revert */
+    blocksToRevert: number;
+}
+/**
+ * Transaction Keys Sync Manager
+ *
+ * Can be initialized with either:
+ * - A SyncProvider (recommended) - works with Electrum, P2P, or custom backends
+ * - An ElectrumClient (legacy) - for backwards compatibility
+ *
+ * @category Sync
+ */
+declare class TransactionKeysSync {
+    private walletDB;
+    private syncProvider;
+    private keyManager;
+    private syncState;
+    private blockHashRetention;
+    /**
+     * Create a new TransactionKeysSync instance
+     * @param walletDB - The wallet database
+     * @param provider - A SyncProvider or ElectrumClient instance
+     */
+    constructor(walletDB: WalletDB, provider: SyncProvider | ElectrumClient);
+    /**
+     * Wrap an ElectrumClient as a SyncProvider for backwards compatibility
+     */
+    private wrapElectrumClient;
+    /**
+     * Get the sync provider being used
+     */
+    getSyncProvider(): SyncProvider;
+    /**
+     * Get the provider type (electrum, p2p, or custom)
+     */
+    getProviderType(): 'electrum' | 'p2p' | 'custom';
+    /**
+     * Set the KeyManager instance for output detection
+     * @param keyManager - The KeyManager instance
+     */
+    setKeyManager(keyManager: KeyManager): void;
+    /**
+     * Initialize sync manager
+     * Loads sync state from database
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get current sync state
+     */
+    getSyncState(): SyncState | null;
+    /**
+     * Get last synced height
+     */
+    getLastSyncedHeight(): number;
+    /**
+     * Check if sync is needed
+     */
+    isSyncNeeded(): Promise<boolean>;
+    /**
+     * Synchronize transaction keys from Electrum server
+     * @param options - Sync options
+     * @returns Number of transaction keys synced
+     */
+    sync(options?: SyncOptions): Promise<number>;
+    /**
+     * Check for chain reorganization
+     * @param height - Height to check
+     * @returns Reorganization info if detected, null otherwise
+     */
+    private checkReorganization;
+    /**
+     * Handle chain reorganization
+     * @param reorgInfo - Reorganization information
+     */
+    private handleReorganization;
+    /**
+     * Process block transactions to detect spent outputs
+     * @param block - Block transaction keys
+     * @param _blockHash - Block hash (for reference)
+     */
+    private processBlockForSpentOutputs;
+    /**
+     * Revert blocks from database
+     * @param startHeight - Start height to revert from
+     * @param endHeight - End height to revert to
+     */
+    private revertBlocks;
+    /**
+     * 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
+     */
+    private storeBlockTransactionKeys;
+    /**
+     * 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)
+     */
+    private processTransactionKeys;
+    /**
+     * Extract range proof from serialized CTxOut data
+     * @param outputHex - Serialized output data (hex)
+     * @returns Object containing rangeProofHex and tokenIdHex
+     */
+    private extractRangeProofFromOutput;
+    /**
+     * 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)
+     */
+    private storeWalletOutput;
+    /**
+     * Extract block hash from block header
+     * @param headerHex - Block header in hex
+     * @returns Block hash (hex string)
+     */
+    private extractBlockHash;
+    /**
+     * Get stored block hash from database
+     * @param height - Block height
+     * @returns Block hash or null if not found
+     */
+    private getStoredBlockHash;
+    /**
+     * 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)
+     */
+    private storeBlockHash;
+    /**
+     * Load sync state from database
+     * @returns Sync state or null if not found
+     */
+    private loadSyncState;
+    /**
+     * Update sync state in database
+     * @param state - Sync state to update
+     */
+    private updateSyncState;
+    /**
+     * Get transaction keys for a specific transaction
+     * @param txHash - Transaction hash
+     * @returns Transaction keys or null if not found
+     */
+    getTransactionKeys(txHash: string): Promise<any | null>;
+    /**
+     * Get transaction keys for a block
+     * @param height - Block height
+     * @returns Array of transaction keys
+     */
+    getBlockTransactionKeys(height: number): Promise<TransactionKeys[]>;
+    /**
+     * Reset sync state (for testing or full resync)
+     */
+    resetSyncState(): Promise<void>;
+}
+
+/**
+ * P2P Protocol Implementation for Navio
+ *
+ * Implements the Navio P2P protocol for direct node communication.
+ * Supports connection handshake, message framing, and core protocol messages.
+ */
+/**
+ * Network magic bytes for different chains
+ */
+declare const NetworkMagic: {
+    readonly MAINNET: Buffer<ArrayBuffer>;
+    readonly TESTNET: Buffer<ArrayBuffer>;
+    readonly REGTEST: Buffer<ArrayBuffer>;
+};
+/**
+ * Default ports for different chains
+ */
+declare const DefaultPorts: {
+    readonly MAINNET: 44440;
+    readonly TESTNET: 33670;
+    readonly REGTEST: 18444;
+};
+/**
+ * P2P message types
+ */
+declare const MessageType: {
+    readonly VERSION: "version";
+    readonly VERACK: "verack";
+    readonly PING: "ping";
+    readonly PONG: "pong";
+    readonly GETADDR: "getaddr";
+    readonly ADDR: "addr";
+    readonly INV: "inv";
+    readonly GETDATA: "getdata";
+    readonly NOTFOUND: "notfound";
+    readonly GETBLOCKS: "getblocks";
+    readonly GETHEADERS: "getheaders";
+    readonly HEADERS: "headers";
+    readonly BLOCK: "block";
+    readonly TX: "tx";
+    readonly GETOUTPUTDATA: "getoutputdata";
+    readonly MEMPOOL: "mempool";
+    readonly REJECT: "reject";
+    readonly SENDHEADERS: "sendheaders";
+    readonly SENDCMPCT: "sendcmpct";
+    readonly CMPCTBLOCK: "cmpctblock";
+    readonly GETBLOCKTXN: "getblocktxn";
+    readonly BLOCKTXN: "blocktxn";
+};
+/**
+ * Service flags
+ */
+declare const ServiceFlags: {
+    readonly NODE_NONE: 0n;
+    readonly NODE_NETWORK: bigint;
+    readonly NODE_BLOOM: bigint;
+    readonly NODE_WITNESS: bigint;
+    readonly NODE_COMPACT_FILTERS: bigint;
+    readonly NODE_NETWORK_LIMITED: bigint;
+    readonly NODE_P2P_V2: bigint;
+};
+/**
+ * Inventory types for getdata/inv messages
+ */
+declare const InvType: {
+    readonly ERROR: 0;
+    readonly MSG_TX: 1;
+    readonly MSG_BLOCK: 2;
+    readonly MSG_FILTERED_BLOCK: 3;
+    readonly MSG_CMPCT_BLOCK: 4;
+    readonly MSG_WTX: 5;
+    readonly MSG_DTX: 6;
+    readonly MSG_DWTX: 7;
+    readonly MSG_OUTPUT_HASH: 8;
+    readonly MSG_WITNESS_FLAG: number;
+    readonly MSG_WITNESS_BLOCK: number;
+    readonly MSG_WITNESS_TX: number;
+};
+/**
+ * Protocol version
+ */
+declare const PROTOCOL_VERSION = 70016;
+/**
+ * P2P connection options
+ */
+interface P2PConnectionOptions {
+    /** Host to connect to */
+    host: string;
+    /** Port (default based on network) */
+    port?: number;
+    /** Network type */
+    network?: 'mainnet' | 'testnet' | 'regtest';
+    /** Connection timeout in ms */
+    timeout?: number;
+    /** User agent string */
+    userAgent?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Services to advertise */
+    services?: bigint;
+}
+/**
+ * Message header structure
+ */
+interface MessageHeader {
+    magic: Buffer;
+    command: string;
+    length: number;
+    checksum: Buffer;
+}
+/**
+ * Parsed P2P message
+ */
+interface P2PMessage {
+    command: string;
+    payload: Buffer;
+}
+/**
+ * Version message payload
+ */
+interface VersionPayload {
+    version: number;
+    services: bigint;
+    timestamp: bigint;
+    addrRecv: {
+        services: bigint;
+        ip: Buffer;
+        port: number;
+    };
+    addrFrom: {
+        services: bigint;
+        ip: Buffer;
+        port: number;
+    };
+    nonce: bigint;
+    userAgent: string;
+    startHeight: number;
+    relay: boolean;
+}
+/**
+ * Inventory vector
+ */
+interface InvVector {
+    type: number;
+    hash: Buffer;
+}
+/**
+ * Block locator for getheaders/getblocks
+ */
+interface BlockLocator {
+    version: number;
+    hashes: Buffer[];
+    hashStop: Buffer;
+}
+/**
+ * P2P Protocol Client
+ *
+ * Low-level P2P protocol implementation for connecting to Navio nodes.
+ *
+ * @category Protocol
+ */
+declare class P2PClient {
+    private socket;
+    private options;
+    private magic;
+    private connected;
+    private handshakeComplete;
+    private receiveBuffer;
+    private pendingMessages;
+    private messageHandlers;
+    private messageQueue;
+    private nonce;
+    private peerVersion;
+    private _peerServices;
+    private peerStartHeight;
+    constructor(options: P2PConnectionOptions);
+    private log;
+    /**
+     * Connect to the peer and complete handshake
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the peer
+     */
+    disconnect(): void;
+    /**
+     * Check if connected and handshake complete
+     */
+    isConnected(): boolean;
+    /**
+     * Get peer's advertised start height
+     */
+    getPeerStartHeight(): number;
+    /**
+     * Get peer's protocol version
+     */
+    getPeerVersion(): number;
+    /**
+     * Get peer's advertised services
+     */
+    getPeerServices(): bigint;
+    /**
+     * Handle incoming data
+     */
+    private handleData;
+    /**
+     * Parse message header
+     */
+    private parseHeader;
+    /**
+     * Calculate message checksum (first 4 bytes of double SHA256)
+     */
+    private calculateChecksum;
+    /**
+     * Dispatch message to handlers
+     */
+    private dispatchMessage;
+    /**
+     * Register a message handler
+     */
+    onMessage(command: string, handler: (msg: P2PMessage) => void): void;
+    /**
+     * Send a raw message
+     */
+    private sendMessage;
+    /**
+     * Send a message and wait for a specific response
+     */
+    sendAndWait(command: string, payload: Buffer, responseCommand: string, timeout?: number): Promise<P2PMessage>;
+    /**
+     * Wait for a specific message
+     */
+    waitForMessage(command: string, timeout?: number): Promise<P2PMessage>;
+    /**
+     * Send version message
+     */
+    private sendVersion;
+    /**
+     * Build version message payload
+     */
+    private buildVersionPayload;
+    /**
+     * Wait for handshake completion
+     */
+    private waitForHandshake;
+    /**
+     * Parse version message
+     */
+    private parseVersionMessage;
+    /**
+     * Handle ping message
+     */
+    private handlePing;
+    /**
+     * Send getheaders message
+     */
+    getHeaders(locatorHashes: Buffer[], hashStop?: Buffer): Promise<Buffer[]>;
+    /**
+     * Build block locator payload for getheaders/getblocks
+     */
+    private buildBlockLocatorPayload;
+    /**
+     * 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.
+     */
+    private parseHeadersMessage;
+    /**
+     * Send getdata message
+     */
+    getData(inventory: InvVector[]): Promise<void>;
+    /**
+     * Build inventory payload for inv/getdata
+     */
+    private buildInvPayload;
+    /**
+     * Request a block by hash
+     */
+    getBlock(blockHash: Buffer): Promise<P2PMessage>;
+    /**
+     * Request transaction outputs by output hash (Navio-specific)
+     */
+    getOutputData(outputHashes: Buffer[]): Promise<P2PMessage>;
+    /**
+     * Send sendheaders message to prefer headers announcements
+     */
+    sendSendHeaders(): void;
+    /**
+     * Encode a variable-length integer
+     */
+    encodeVarInt(value: number | bigint): Buffer;
+    /**
+     * Decode a variable-length integer
+     */
+    decodeVarInt(buffer: Buffer): {
+        value: bigint;
+        bytesRead: number;
+    };
+    /**
+     * Reverse a hash for display (Bitcoin uses little-endian internally, big-endian for display)
+     */
+    static reverseHash(hash: Buffer): Buffer;
+    /**
+     * Convert display hash to internal format
+     */
+    static hashFromDisplay(hexHash: string): Buffer;
+    /**
+     * Convert internal hash to display format
+     */
+    static hashToDisplay(hash: Buffer): string;
+}
+
+/**
+ * Network type for Navio
+ */
+type NetworkType = 'mainnet' | 'testnet' | 'signet' | 'regtest';
+/**
+ * Backend type for NavioClient
+ */
+type BackendType = 'electrum' | 'p2p';
+/**
+ * P2P connection options for NavioClient
+ */
+interface P2POptions extends P2PConnectionOptions {
+    /** Maximum headers to fetch per request */
+    maxHeadersPerRequest?: number;
+}
+/**
+ * Configuration for NavioClient
+ */
+interface NavioClientConfig {
+    /** Path to wallet database file */
+    walletDbPath: string;
+    /**
+     * Backend type to use for synchronization
+     * - 'electrum': Connect to an Electrum server (recommended for wallets)
+     * - 'p2p': Connect directly to a Navio full node
+     * @default 'electrum'
+     */
+    backend?: BackendType;
+    /**
+     * Electrum server connection options
+     * Required when backend is 'electrum'
+     */
+    electrum?: ElectrumOptions;
+    /**
+     * P2P connection options
+     * Required when backend is 'p2p'
+     */
+    p2p?: P2POptions;
+    /** Create wallet if it doesn't exist (default: false) */
+    createWalletIfNotExists?: boolean;
+    /** Restore wallet from seed (hex string) */
+    restoreFromSeed?: string;
+    /**
+     * Block height to start scanning from when restoring a wallet from seed.
+     * This is the height when the wallet was originally created.
+     * Setting this avoids scanning blocks before the wallet existed.
+     *
+     * Note: This option is only used when `restoreFromSeed` is provided.
+     * For newly created wallets, the creation height is automatically set
+     * to the current chain tip minus a safety margin (100 blocks).
+     *
+     * @default 0 (scan from genesis when restoring)
+     */
+    restoreFromHeight?: number;
+    /**
+     * Override the creation height for newly created wallets.
+     * By default, new wallets use `chainTip - 100` to avoid scanning old blocks.
+     * Set this to 0 to sync from genesis (useful for testing).
+     *
+     * Note: This is only used when `createWalletIfNotExists` is true and
+     * no wallet exists. It does NOT override `restoreFromHeight` when
+     * restoring from seed.
+     */
+    creationHeight?: number;
+    /**
+     * Network to use for address encoding/decoding and cryptographic operations.
+     * This configures the navio-blsct library to use the correct chain parameters.
+     *
+     * @default 'mainnet'
+     */
+    network?: NetworkType;
+}
+/**
+ * Navio SDK Client
+ * Main client for wallet operations and blockchain synchronization.
+ *
+ * Supports two backend types:
+ * - Electrum: Connect to an Electrum server (recommended for light wallets)
+ * - P2P: Connect directly to a Navio full node (for advanced use cases)
+ *
+ * @example
+ * // Using Electrum backend (recommended)
+ * const client = new NavioClient({
+ *   walletDbPath: './wallet.db',
+ *   backend: 'electrum',
+ *   electrum: { host: 'electrum.example.com', port: 50001, ssl: true }
+ * });
+ *
+ * @example
+ * // Using P2P backend
+ * const client = new NavioClient({
+ *   walletDbPath: './wallet.db',
+ *   backend: 'p2p',
+ *   p2p: { host: '127.0.0.1', port: 44440, network: 'mainnet' }
+ * });
+ *
+ * @category Client
+ */
+declare class NavioClient {
+    private walletDB;
+    private syncProvider;
+    private syncManager;
+    private keyManager;
+    private config;
+    private initialized;
+    private electrumClient;
+    private backgroundSyncTimer;
+    private backgroundSyncOptions;
+    private isBackgroundSyncing;
+    private isSyncInProgress;
+    private lastKnownBalance;
+    /**
+     * Create a new NavioClient instance
+     * @param config - Client configuration
+     */
+    constructor(config: NavioClientConfig);
+    /**
+     * Configure the navio-blsct library for the specified network
+     */
+    private static configureNetwork;
+    /**
+     * Get the current network configuration
+     */
+    getNetwork(): NetworkType;
+    /**
+     * 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.
+     */
+    private static readonly CREATION_HEIGHT_MARGIN;
+    /**
+     * Initialize the client
+     * Loads or creates wallet, connects to backend, and initializes sync manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the backend type being used
+     */
+    getBackendType(): BackendType;
+    /**
+     * Get the sync provider
+     */
+    getSyncProvider(): SyncProvider;
+    /**
+     * Get the KeyManager instance
+     * @returns KeyManager instance
+     */
+    getKeyManager(): KeyManager;
+    /**
+     * Get the WalletDB instance
+     * @returns WalletDB instance
+     */
+    getWalletDB(): 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(): ElectrumClient | null;
+    /**
+     * Get the TransactionKeysSync instance
+     * @returns TransactionKeysSync instance
+     */
+    getSyncManager(): TransactionKeysSync;
+    /**
+     * 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
+     */
+    sync(options?: SyncOptions): Promise<number>;
+    /**
+     * 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),
+     * });
+     * ```
+     */
+    startBackgroundSync(options?: BackgroundSyncOptions): Promise<void>;
+    /**
+     * Stop background synchronization.
+     */
+    stopBackgroundSync(): void;
+    /**
+     * Check if background sync is running.
+     * @returns True if background sync is active
+     */
+    isBackgroundSyncActive(): boolean;
+    /**
+     * Perform a single background sync cycle.
+     * Called by the polling timer.
+     */
+    private performBackgroundSync;
+    /**
+     * Check if synchronization is needed
+     * @returns True if sync is needed
+     */
+    isSyncNeeded(): Promise<boolean>;
+    /**
+     * Get last synced block height
+     * @returns Last synced height, or -1 if never synced
+     */
+    getLastSyncedHeight(): number;
+    /**
+     * Get sync state
+     * @returns Current sync state
+     */
+    getSyncState(): SyncState | null;
+    /**
+     * Get the wallet creation height (block height to start scanning from)
+     * @returns Creation height or 0 if not set
+     */
+    getCreationHeight(): Promise<number>;
+    /**
+     * Set the wallet creation height
+     * @param height - Block height when wallet was created
+     */
+    setCreationHeight(height: number): Promise<void>;
+    /**
+     * Get wallet metadata
+     * @returns Wallet metadata or null if not available
+     */
+    getWalletMetadata(): Promise<{
+        creationHeight: number;
+        creationTime: number;
+        restoredFromSeed: boolean;
+        version: number;
+    } | null>;
+    /**
+     * Get chain tip from the backend
+     * @returns Current chain tip height and hash
+     */
+    getChainTip(): Promise<{
+        height: number;
+        hash: string;
+    }>;
+    /**
+     * Disconnect from backend and close database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): NavioClientConfig;
+    /**
+     * Check if client is connected to the backend
+     */
+    isConnected(): boolean;
+    /**
+     * Hash a block header to get block hash
+     */
+    private hashBlockHeader;
+    /**
+     * Get wallet balance in satoshis
+     * @param tokenId - Optional token ID to filter by (null for NAV)
+     * @returns Balance in satoshis as bigint
+     */
+    getBalance(tokenId?: string | null): Promise<bigint>;
+    /**
+     * 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
+     */
+    getBalanceNav(tokenId?: string | null): Promise<number>;
+    /**
+     * Get unspent outputs (UTXOs)
+     * @param tokenId - Optional token ID to filter by (null for NAV)
+     * @returns Array of unspent wallet outputs
+     */
+    getUnspentOutputs(tokenId?: string | null): Promise<WalletOutput[]>;
+    /**
+     * Get all wallet outputs (spent and unspent)
+     * @returns Array of all wallet outputs
+     */
+    getAllOutputs(): Promise<WalletOutput[]>;
+}
+
+/**
+ * Type definitions for Navio SDK
+ */
+/**
+ * Network type for Navio
+ */
+type NavioNetwork = 'mainnet' | 'testnet' | 'regtest';
+/**
+ * Generic hex string type
+ */
+type HexString = string;
+/**
+ * Transaction hash (64-character hex string)
+ */
+type TxHash = HexString;
+/**
+ * Block hash (64-character hex string)
+ */
+type BlockHash = HexString;
+/**
+ * Output hash (64-character hex string, Navio-specific)
+ */
+type OutputHash = HexString;
+
+/**
+ * Electrum Sync Provider
+ *
+ * Implements the SyncProvider interface using an Electrum server connection.
+ * This is a wrapper around ElectrumClient that provides the standardized sync interface.
+ */
+
+/**
+ * Electrum sync provider options
+ */
+interface ElectrumSyncOptions extends SyncProviderOptions, ElectrumOptions {
+}
+/**
+ * Electrum Sync Provider
+ *
+ * Uses an Electrum server for blockchain synchronization.
+ * Provides efficient transaction key fetching through Electrum's preprocessed data.
+ *
+ * @category Sync
+ */
+declare class ElectrumSyncProvider extends BaseSyncProvider {
+    readonly type: "electrum";
+    private client;
+    private chainTipHeight;
+    private chainTipHash;
+    constructor(options?: ElectrumSyncOptions);
+    /**
+     * Get the underlying ElectrumClient for direct access to additional methods
+     */
+    getClient(): ElectrumClient;
+    /**
+     * Connect to the Electrum server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Electrum server
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get current chain tip height
+     */
+    getChainTipHeight(): Promise<number>;
+    /**
+     * Get current chain tip
+     */
+    getChainTip(): Promise<ChainTip>;
+    /**
+     * Get a single block header
+     */
+    getBlockHeader(height: number): Promise<string>;
+    /**
+     * Get multiple block headers
+     */
+    getBlockHeaders(startHeight: number, count: number): Promise<BlockHeadersResult>;
+    /**
+     * Get transaction keys for a range of blocks
+     */
+    getBlockTransactionKeysRange(startHeight: number): Promise<{
+        blocks: BlockTransactionKeys[];
+        nextHeight: number;
+    }>;
+    /**
+     * Get transaction keys for a single block
+     */
+    getBlockTransactionKeys(height: number): Promise<TransactionKeys[]>;
+    /**
+     * Get serialized transaction output by output hash
+     */
+    getTransactionOutput(outputHash: string): Promise<string>;
+    /**
+     * Broadcast a transaction
+     */
+    broadcastTransaction(rawTx: string): Promise<string>;
+    /**
+     * Get raw transaction
+     */
+    getRawTransaction(txHash: string, verbose?: boolean): Promise<string | unknown>;
+    /**
+     * Get server version
+     */
+    getServerVersion(): Promise<[string, string]>;
+    /**
+     * Subscribe to block headers
+     */
+    subscribeBlockHeaders(callback: (header: any) => void): Promise<void>;
+    /**
+     * Get transaction keys for a specific transaction
+     */
+    getTransactionKeys(txHash: string): Promise<any>;
+    /**
+     * Fetch all transaction keys from genesis to chain tip
+     */
+    fetchAllTransactionKeys(progressCallback?: (height: number, totalHeight: number, blocksProcessed: number) => void): Promise<BlockTransactionKeys[]>;
+    /**
+     * Get transaction history for a script hash
+     */
+    getHistory(scriptHash: string): Promise<any[]>;
+    /**
+     * Get unspent transaction outputs for a script hash
+     */
+    getUnspent(scriptHash: string): Promise<any[]>;
+    /**
+     * Subscribe to script hash updates
+     */
+    subscribeScriptHash(scriptHash: string, callback: (status: string) => void): Promise<void>;
+}
+
+/**
+ * P2P Sync Provider
+ *
+ * Implements the SyncProvider interface using direct P2P connections
+ * to Navio full nodes. Parses blocks using navio-blsct for transaction
+ * key extraction.
+ */
+
+/**
+ * P2P sync provider options
+ */
+interface P2PSyncOptions extends SyncProviderOptions {
+    /** Host to connect to */
+    host: string;
+    /** Port (default based on network) */
+    port?: number;
+    /** Network type */
+    network?: 'mainnet' | 'testnet' | 'regtest';
+    /** User agent string */
+    userAgent?: string;
+    /** Maximum blocks to fetch per request */
+    maxBlocksPerRequest?: number;
+    /** Maximum headers to fetch per request */
+    maxHeadersPerRequest?: number;
+}
+/**
+ * P2P Sync Provider
+ *
+ * Connects directly to a Navio full node via P2P protocol.
+ * Fetches blocks and extracts transaction keys for wallet scanning.
+ *
+ * @category Sync
+ */
+declare class P2PSyncProvider extends BaseSyncProvider {
+    readonly type: "p2p";
+    private client;
+    private options;
+    private headersByHash;
+    private headersByHeight;
+    private chainTipHeight;
+    private chainTipHash;
+    private genesisHash;
+    private blockCache;
+    private maxBlockCacheSize;
+    private pendingBlocks;
+    constructor(options: P2PSyncOptions);
+    /**
+     * Connect to the P2P node
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the P2P node
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get current chain tip height
+     */
+    getChainTipHeight(): Promise<number>;
+    /**
+     * Get current chain tip
+     */
+    getChainTip(): Promise<ChainTip>;
+    /**
+     * Get a single block header
+     */
+    getBlockHeader(height: number): Promise<string>;
+    /**
+     * Get multiple block headers
+     */
+    getBlockHeaders(startHeight: number, count: number): Promise<BlockHeadersResult>;
+    /**
+     * Sync headers from the network
+     */
+    private syncHeaders;
+    /**
+     * Get transaction keys for a range of blocks
+     */
+    getBlockTransactionKeysRange(startHeight: number): Promise<{
+        blocks: BlockTransactionKeys[];
+        nextHeight: number;
+    }>;
+    /**
+     * Get transaction keys for a single block
+     */
+    getBlockTransactionKeys(height: number): Promise<TransactionKeys[]>;
+    /**
+     * Ensure headers are synced up to the specified height
+     */
+    private ensureHeadersSyncedTo;
+    /**
+     * Fetch a block by hash
+     */
+    private fetchBlock;
+    /**
+     * Handle incoming block message
+     */
+    private handleBlockMessage;
+    /**
+     * Parse block data and extract transaction keys
+     *
+     * Parses all transactions in the block and extracts BLSCT output keys
+     * for wallet output detection.
+     */
+    private parseBlockTransactionKeys;
+    /**
+     * Skip PoS proof in block data
+     */
+    private skipPoSProof;
+    private static readonly G1_POINT_SIZE;
+    private static readonly SCALAR_SIZE;
+    private static readonly MAX_AMOUNT;
+    private static readonly BLSCT_MARKER;
+    private static readonly TOKEN_MARKER;
+    private static readonly PREDICATE_MARKER;
+    private static readonly TRANSPARENT_VALUE_MARKER;
+    /**
+     * Parse a BLSCT transaction and extract output keys
+     */
+    private parseBlsctTransaction;
+    /**
+     * Parse a BLSCT output and extract keys
+     */
+    private parseBlsctOutput;
+    /**
+     * Parse BLSCT data from output
+     */
+    private parseBlsctData;
+    /**
+     * Parse bulletproofs_plus range proof
+     */
+    private parseRangeProof;
+    /**
+     * Calculate BLSCT transaction hash
+     */
+    private calculateBlsctTxHash;
+    /**
+     * Hash a buffer using SHA256
+     */
+    private hashBuffer;
+    /**
+     * Format output keys for the sync interface
+     */
+    private formatOutputKeys;
+    /**
+     * Get serialized transaction output by output hash
+     */
+    getTransactionOutput(outputHash: string): Promise<string>;
+    /**
+     * Broadcast a transaction
+     */
+    broadcastTransaction(rawTx: string): Promise<string>;
+    /**
+     * Get raw transaction
+     */
+    getRawTransaction(txHash: string, _verbose?: boolean): Promise<string>;
+    /**
+     * Decode variable-length integer from buffer
+     */
+    private decodeVarInt;
+}
+
+export { type AmountRecoveryResult, type BackendType, type BackgroundSyncOptions, BaseSyncProvider, type BlockHash, type BlockHeader, type BlockHeadersResult, type BlockLocator, type BlockTransactionKeys, type BlockTransactionKeysRange, type CTxDestination, type CTxOut, type CTxOutBLSCTData, type ChainTip, DefaultPorts, ElectrumClient, ElectrumError, type ElectrumOptions, type ElectrumSyncOptions, ElectrumSyncProvider, type HDChain, type HexString, InvType, type InvVector, KeyManager, type KeyStorage, type MessageHeader, MessageType, NavioClient, type NavioClientConfig, type NavioNetwork, NetworkMagic, type NetworkType, type OutputHash, P2PClient, type P2PConnectionOptions, type P2PMessage, type P2POptions, type P2PSyncOptions, P2PSyncProvider, PROTOCOL_VERSION, type PublicKey$1 as PublicKey, type ReorganizationInfo, type SecretKey, type SeedType, ServiceFlags, type SubAddress, type SubAddressIdentifier, type SyncBlockHeader, type SyncOptions, type SyncProgressCallback, type SyncProvider, type SyncProviderOptions, type SyncState, type TransactionKeys, TransactionKeysSync, type TxHash, type VersionPayload, WalletDB, type WalletOutput };