beignet 0.0.52 → 0.0.53

package/dist/index.d.ts

@@ -0,0 +1,1188 @@
+import { BIP32Interface } from 'bip32';
+import { Network, Psbt } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+import { TLSSocket } from 'tls';
+import { Server } from 'net';
+
+type Result<T> = Ok<T> | Err<T>;
+declare class Ok<T> {
+    readonly value: T;
+    constructor(value: T);
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<T>;
+}
+declare class Err<T> {
+    readonly error: Error;
+    constructor(error: Error);
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<T>;
+}
+declare const ok: <T>(value: T) => Ok<T>;
+declare const err: <T>(error: Error | string) => Err<T>;
+
+declare const getDefaultWalletData: () => IWalletData;
+declare const getDefaultWalletDataKeys: () => (keyof IWalletData)[];
+declare const getKeyValue: (key: string) => string;
+declare const objectKeys: <Type extends object>(value: Type) => `${Exclude<keyof Type, symbol>}`[];
+declare const formatKeyDerivationPath: ({ path, purpose, network, changeAddress, index, addressType }: {
+    path: IKeyDerivationPath | string;
+    purpose?: string | undefined;
+    network: EAvailableNetworks;
+    changeAddress?: boolean | undefined;
+    index?: string | undefined;
+    addressType?: EAddressType | undefined;
+}) => Result<IKeyDerivationPathData>;
+declare const getHighestUsedIndexFromTxHashes: ({ txHashes, addresses, changeAddresses, addressIndex, changeAddressIndex }: {
+    txHashes: ITxHashes[];
+    addresses: IAddresses;
+    changeAddresses: IAddresses;
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+}) => Result<IIndexes>;
+declare const isValidBech32mEncodedString: (address: string) => {
+    isValid: boolean;
+    network: EAvailableNetworks;
+};
+declare const availableNetworks: () => EAvailableNetworks[];
+declare const reduceValue: <T>({ arr, value }: {
+    arr: T[];
+    value: keyof T;
+}) => Result<number>;
+declare const shuffleArray: <T>(array: T[]) => T[];
+declare const getDataFallback: TGetData;
+declare const decodeOpReturnMessage: (opReturn?: string) => string[];
+declare const getSeed: (mnemonic: any, bip39Passphrase: any) => Buffer;
+declare const getSeedHash: (seed: Buffer) => string;
+declare const generateWalletId: (seed: Buffer) => string;
+declare const getWalletDataStorageKey: (name: string, network: EAvailableNetworks, key: keyof IWalletData) => string;
+declare const getStorageKeyValues: (storageKey: string) => {
+    walletName: string;
+    network: EAvailableNetworks;
+    value: keyof IWalletData;
+};
+declare const getTxFee: ({ satsPerByte, transactionByteCount }: {
+    satsPerByte: number;
+    transactionByteCount: number;
+}) => number;
+declare const filterAddressesForGapLimit: ({ addresses, index, gapLimitOptions }: {
+    addresses: IAddress[];
+    index: number;
+    gapLimitOptions: TGapLimitOptions;
+}) => IAddress[];
+declare const filterAddressesObjForGapLimit: ({ addresses, index, gapLimitOptions }: {
+    addresses: IAddresses;
+    index: number;
+    gapLimitOptions: TGapLimitOptions;
+}) => IAddresses;
+declare const filterAddressesObjForStartingIndex: ({ addresses, index }: {
+    addresses: IAddresses;
+    index: number;
+}) => IAddresses;
+declare const filterAddressesObjForSingleIndex: ({ addresses, addressIndex }: {
+    addresses: IAddresses;
+    addressIndex: number;
+}) => IAddresses;
+
+declare const getAddressFromScriptPubKey: (scriptPubKey: string, selectedNetwork: EAvailableNetworks) => string;
+declare const getSha256: (str: string) => string;
+declare const validateAddress: ({ address, network }: {
+    address: string;
+    network?: EAvailableNetworks | undefined;
+}) => {
+    isValid: boolean;
+    network: EAvailableNetworks;
+};
+declare const getKeyDerivationPath: ({ addressType, network }: {
+    addressType: EAddressType;
+    network: EAvailableNetworks;
+}) => Result<IKeyDerivationPath>;
+declare const getScriptHash: ({ address, network }: {
+    address: string;
+    network: EAvailableNetworks;
+}) => string;
+declare const generateMnemonic: (strength?: number, rng?: ((size: number) => Buffer) | undefined, wordlist?: string[]) => string;
+declare const validateMnemonic: (mnemonic?: string) => boolean;
+declare const objectsMatch: (obj1: any, obj2: any) => boolean;
+declare const getAddressFromKeyPair: ({ keyPair, addressType, network }: {
+    keyPair: BIP32Interface | ECPairInterface;
+    addressType: EAddressType;
+    network: Network;
+}) => Result<IGetAddressesFromKeyPair>;
+declare const getTapRootAddressFromPublicKey: ({ publicKey, network }: {
+    publicKey: Buffer;
+    network: Network;
+}) => Result<{
+    address: string;
+    output: Buffer;
+    internalPubkey: Buffer;
+}>;
+declare const getAddressesFromPrivateKey: ({ privateKey, addrTypes, network }: {
+    privateKey: string;
+    addrTypes?: EAddressType[] | undefined;
+    network?: Network | undefined;
+}) => Result<IGetAddressesFromPrivateKey>;
+declare const sleep: (ms: any) => Promise<void>;
+declare const getAddressIndexDiff: (addrIndex1?: number, addrIndex2?: number) => number;
+declare const isPositive: (num: number) => boolean;
+
+declare const defaultElectrumPorts: string[];
+declare const getDefaultPort: (selectedNetwork: EAvailableNetworks, protocol: TProtocol) => number;
+declare const getProtocolForPort: (port: string, network: EAvailableNetworks) => TProtocol | undefined;
+declare const formatPeerData: (data: [string, string, [
+    string,
+    string,
+    string
+]]) => Result<IFormattedPeerData>;
+declare const getPeers: ({ selectedNetwork }: {
+    selectedNetwork: EAvailableNetworks;
+}) => Promise<Result<IFormattedPeerData[]>>;
+declare const electrumConnection: ElectrumConnectionPubSub;
+declare const getElectrumNetwork: (network: EAvailableNetworks) => EElectrumNetworks;
+
+declare const getKeyDerivationPathObject: ({ path, purpose, changeAddress, index, network }: {
+    path: string;
+    purpose?: string | undefined;
+    changeAddress?: boolean | undefined;
+    index?: string | undefined;
+    network: EAvailableNetworks;
+}) => Result<IKeyDerivationPath>;
+declare const getKeyDerivationPathString: ({ addressType, path, purpose, accountType, changeAddress, index, network }: {
+    addressType: EAddressType;
+    path?: IKeyDerivationPath | undefined;
+    purpose?: string | undefined;
+    accountType?: string | number | undefined;
+    changeAddress?: boolean | undefined;
+    index?: string | number | undefined;
+    network: EAvailableNetworks;
+}) => Result<string>;
+declare const getAddressTypeFromPath: (path: string | IKeyDerivationPath) => Result<EAddressType>;
+
+declare const setReplaceByFee: ({ psbt, setRbf }: {
+    psbt: Psbt;
+    setRbf: boolean;
+}) => void;
+declare const parseOnChainPaymentRequest: (data: string, network?: EAvailableNetworks) => Result<{
+    address: string;
+    network: EAvailableNetworks;
+    sats: number;
+    message: string;
+}>;
+declare const constructByteCountParam: (addresses: string[], increaseAddressCount?: {
+    addrType: EAddressType;
+    count: number;
+}[]) => TGetByteCountInputs | TGetByteCountOutputs;
+declare const getByteCount: (inputs: TGetByteCountInputs, outputs: TGetByteCountOutputs, message?: string, minByteCount?: number) => number;
+declare const removeDustOutputs: (outputs: IOutput[]) => IOutput[];
+declare const validateTransaction: (transaction: ISendTransaction) => Result<string>;
+declare const decodeRawTransaction: (hex: string, _network: EAvailableNetworks) => Result<TDecodeRawTx>;
+declare const isP2trPrefix: (address: string) => boolean;
+
+type TElectrumNetworks = 'bitcoin' | 'bitcoinTestnet' | 'bitcoinRegtest';
+declare enum EElectrumNetworks {
+    bitcoin = "bitcoin",
+    bitcoinTestnet = "bitcoinTestnet",
+    bitcoinRegtest = "bitcoinRegtest"
+}
+type TConnectToElectrumRes = string;
+interface IElectrumGetAddressBalanceRes extends IGetAddressBalanceRes {
+    error: boolean;
+}
+type TServer = {
+    host: string;
+    ssl: number;
+    tcp: number;
+    protocol: EProtocol;
+};
+type TProtocol = 'tcp' | 'ssl';
+declare enum EProtocol {
+    tcp = "tcp",
+    ssl = "ssl"
+}
+declare enum EScanningStrategy {
+    all = "all",
+    gapLimit = "gapLimit",
+    startingIndex = "startingIndex",
+    singleIndex = "singleIndex"
+}
+interface IGetUtxosResponse {
+    utxos: IUtxo[];
+    balance: number;
+}
+type TUnspentAddressScriptHashData = {
+    [x: string]: IUtxo | IAddress;
+};
+type TTxResult = {
+    tx_hash: string;
+    height: number;
+};
+interface IGetAddressScriptHashesHistoryResponse {
+    data: TTxResponse[];
+    error: boolean;
+    id: number;
+    method: string;
+    network: string;
+}
+type TTxResponse = {
+    data: IAddress;
+    id: number;
+    jsonrpc: string;
+    param: string;
+    result: TTxResult[];
+};
+interface IGetAddressScriptHashBalances {
+    error: boolean;
+    data: Array<{
+        id: number;
+        jsonrpc: string;
+        result: {
+            confirmed: number;
+            unconfirmed: number;
+        };
+        param: string;
+        data: Record<string, unknown>;
+    }> | string;
+    id: number;
+    method: string;
+    network: EElectrumNetworks;
+}
+interface IGetAddressHistoryResponse extends TTxResult, IAddress {
+}
+interface IHeader {
+    height: number;
+    hash: string;
+    hex: string;
+}
+interface INewBlock {
+    height: number;
+    hex: string;
+}
+interface IGetHeaderResponse {
+    id: number;
+    error: boolean;
+    method: 'getHeader';
+    data: string;
+    network: EAvailableNetworks;
+}
+interface IGetTransactionsFromInputs {
+    error: boolean;
+    id: number;
+    method: string;
+    network: string;
+    data: ITransaction<{
+        tx_hash: string;
+        vout: number;
+    }>[];
+}
+interface ISubscribeToHeader {
+    data: {
+        height: number;
+        hex: string;
+    };
+    error: boolean;
+    id: string;
+    method: string;
+}
+interface ISubscribeToAddress {
+    data: {
+        id: number;
+        jsonrpc: string;
+        result: null;
+    };
+    error: boolean;
+    id: number;
+    method: string;
+}
+type TSubscribedReceive = [string, string];
+interface IFormattedPeerData {
+    ip?: string;
+    host: string;
+    version?: string;
+    ssl: string | number;
+    tcp: string | number;
+}
+interface IPeerData {
+    host: string;
+    port: string;
+    protocol: TProtocol;
+}
+type ElectrumConnectionPubSub = {
+    publish: (isConnected: boolean) => void;
+    subscribe: (callback: (isConnected: boolean) => void) => ElectrumConnectionSubscription;
+};
+type ElectrumConnectionSubscription = {
+    remove(): void;
+};
+type TGetAddressHistory = {
+    txid: string;
+    height: number;
+};
+
+interface ICreateTransaction {
+    transactionData?: ISendTransaction;
+    shuffleOutputs?: boolean;
+}
+interface IAddInput {
+    psbt: Psbt;
+    keyPair: BIP32Interface | ECPairInterface;
+    input: IUtxo;
+}
+interface ITargets {
+    value: number;
+    index: number;
+    address?: string;
+    script?: Buffer;
+}
+interface ISetupTransaction {
+    inputTxHashes?: string[];
+    utxos?: IUtxo[];
+    rbf?: boolean;
+    satsPerByte?: number;
+    outputs?: IOutput[];
+}
+declare enum EFeeId {
+    fast = "fast",
+    normal = "normal",
+    slow = "slow",
+    custom = "custom",
+    none = "none"
+}
+type TSetupTransactionResponse = Result<Partial<ISendTransaction>>;
+type TDecodeRawTx = {
+    txid: string;
+    tx_hash: string;
+    size: number;
+    vsize: number;
+    weight: number;
+    version: number;
+    locktime: number;
+    vin: IVin[];
+    vout: IVout[];
+};
+type TGetTotalFeeObj = {
+    totalFee: number;
+    transactionByteCount: number;
+    satsPerByte: number;
+    maxSatPerByte: number;
+};
+type TGapLimitOptions = {
+    lookAhead: number;
+    lookBehind: number;
+};
+
+type TAvailableNetworks = 'bitcoin' | 'testnet' | 'regtest';
+type TAddressType = 'p2wpkh' | 'p2sh' | 'p2pkh';
+type TAddressLabel = 'bech32' | 'segwit' | 'legacy';
+type TKeyDerivationPurpose = '84' | '49' | '44' | string;
+type TKeyDerivationCoinType = '0' | '1' | string;
+type TKeyDerivationAccount = '0' | string;
+type TKeyDerivationChange = '0' | '1';
+type TKeyDerivationIndex = string;
+type TAddressTypes = {
+    [key in EAddressType]: Readonly<IAddressTypeData>;
+};
+declare enum EAvailableNetworks {
+    bitcoin = "bitcoin",
+    mainnet = "bitcoin",
+    bitcoinMainnet = "bitcoin",
+    testnet = "testnet",
+    bitcoinTestnet = "testnet",
+    regtest = "regtest",
+    bitcoinRegtest = "regtest"
+}
+declare enum EAddressType {
+    p2wpkh = "p2wpkh",
+    p2sh = "p2sh",
+    p2pkh = "p2pkh",
+    p2tr = "p2tr"
+}
+declare enum EPaymentType {
+    sent = "sent",
+    received = "received"
+}
+type TAddressTypeContent<T> = {
+    [key in EAddressType]: T;
+};
+interface IAddressTypeData {
+    type: EAddressType;
+    path: string;
+    name: string;
+    shortName: string;
+    description: string;
+    example: string;
+}
+interface IUtxo {
+    address: string;
+    index: number;
+    path: string;
+    scriptHash: string;
+    height: number;
+    tx_hash: string;
+    tx_pos: number;
+    value: number;
+    publicKey: string;
+    keyPair?: BIP32Interface | ECPairInterface;
+}
+interface IVin {
+    scriptSig: {
+        asm: string;
+        hex: string;
+    };
+    sequence: number;
+    txid: string;
+    txinwitness: string[];
+    vout: number;
+}
+interface IFormattedTransaction {
+    address: string;
+    height: number;
+    scriptHash: string;
+    totalInputValue: number;
+    matchedInputValue: number;
+    totalOutputValue: number;
+    matchedOutputValue: number;
+    fee: number;
+    satsPerByte: number;
+    type: EPaymentType;
+    value: number;
+    txid: string;
+    messages: string[];
+    vin: IVin[];
+    timestamp: number;
+    confirmTimestamp?: number;
+    exists?: boolean;
+    rbf?: boolean;
+    vsize: number;
+}
+interface IFormattedTransactions {
+    [key: string]: IFormattedTransaction;
+}
+interface IOutput {
+    address: string;
+    value: number;
+    index: number;
+}
+declare enum EBoostType {
+    rbf = "rbf",
+    cpfp = "cpfp"
+}
+interface ISendTransaction {
+    outputs: IOutput[];
+    inputs: IUtxo[];
+    changeAddress: string;
+    fiatAmount: number;
+    fee: number;
+    satsPerByte: number;
+    selectedFeeId: EFeeId;
+    message: string;
+    label: string;
+    rbf: boolean;
+    boostType: EBoostType;
+    minFee: number;
+    max: boolean;
+    tags: string[];
+    slashTagsUrl?: string;
+    lightningInvoice?: string;
+}
+interface IAddresses {
+    [scriptHash: string]: IAddress;
+}
+interface IAddress {
+    index: number;
+    path: string;
+    address: string;
+    scriptHash: string;
+    publicKey: string;
+}
+interface IWalletData {
+    id: string;
+    addressType: EAddressType;
+    header: IHeader;
+    addresses: TAddressTypeContent<IAddresses>;
+    changeAddresses: TAddressTypeContent<IAddresses>;
+    addressIndex: TAddressTypeContent<IAddress>;
+    changeAddressIndex: TAddressTypeContent<IAddress>;
+    lastUsedAddressIndex: TAddressTypeContent<IAddress>;
+    lastUsedChangeAddressIndex: TAddressTypeContent<IAddress>;
+    utxos: IUtxo[];
+    blacklistedUtxos: IUtxo[];
+    unconfirmedTransactions: IFormattedTransactions;
+    transactions: IFormattedTransactions;
+    boostedTransactions: IBoostedTransactions;
+    transaction: ISendTransaction;
+    balance: number;
+    selectedFeeId: EFeeId;
+    feeEstimates: IOnchainFees;
+}
+type TWalletDataKeys = keyof IWalletData;
+type TGetData = <K extends keyof IWalletData>(key: string) => Promise<Result<IWalletData[K]>>;
+type TSetData = <K extends keyof IWalletData>(key: string, value: IWalletData[K]) => Promise<Result<boolean>>;
+interface IWallet {
+    mnemonic: string;
+    id?: string;
+    name?: string;
+    passphrase?: string;
+    network?: EAvailableNetworks;
+    addressType?: EAddressType;
+    data?: IWalletData;
+    storage?: TStorage;
+    electrumOptions?: {
+        servers?: TServer | TServer[];
+        tls?: TLSSocket;
+        net?: Server;
+        batchLimit?: number;
+        batchDelay?: number;
+    };
+    remainOffline?: boolean;
+    onMessage?: TOnMessage;
+    customGetAddress?: (data: ICustomGetAddress) => Promise<Result<IGetAddressResponse>>;
+    customGetScriptHash?: (data: ICustomGetScriptHash) => Promise<string>;
+    rbf?: boolean;
+    selectedFeeId?: EFeeId;
+    disableMessages?: boolean;
+    disableMessagesOnCreate?: boolean;
+    addressTypesToMonitor?: EAddressType[];
+    gapLimitOptions?: TGapLimitOptions;
+    addressLookBehind?: number;
+    addressLookAhead?: number;
+}
+interface IAddressData {
+    path: string;
+    type: 'p2wpkh' | 'p2sh' | 'p2pkh';
+    label: string;
+}
+interface IAddressType {
+    [key: string]: IAddressData;
+}
+interface IKeyDerivationPath {
+    purpose?: TKeyDerivationPurpose;
+    coinType?: TKeyDerivationCoinType;
+    account?: TKeyDerivationAccount;
+    change?: TKeyDerivationChange;
+    index?: TKeyDerivationIndex;
+}
+interface IGetDerivationPath extends IKeyDerivationPath {
+    addressType?: EAddressType;
+}
+interface IGetAddress {
+    index?: TKeyDerivationIndex;
+    changeAddress?: boolean;
+    addressType?: EAddressType;
+}
+interface ICustomGetAddress {
+    path: string;
+    type: EAddressType;
+    selectedNetwork: EElectrumNetworks;
+}
+interface ICustomGetScriptHash {
+    address: string;
+    selectedNetwork: EElectrumNetworks;
+}
+interface IGetAddressByPath {
+    path: string;
+    addressType?: EAddressType;
+}
+interface IGetAddressBalanceRes {
+    confirmed: number;
+    unconfirmed: number;
+}
+interface IGenerateAddresses {
+    addressAmount?: number;
+    changeAddressAmount?: number;
+    addressIndex?: number;
+    changeAddressIndex?: number;
+    keyDerivationPath?: IKeyDerivationPath;
+    addressType?: EAddressType;
+    saveAddresses?: boolean;
+}
+interface IKeyDerivationPathData {
+    pathString: string;
+    pathObject: IKeyDerivationPath;
+}
+interface IGenerateAddressesResponse {
+    addresses: IAddresses;
+    changeAddresses: IAddresses;
+}
+interface IGetAddressResponse {
+    address: string;
+    path: string;
+    publicKey: string;
+}
+interface IGetAddressesFromPrivateKey {
+    keyPair: BIP32Interface | ECPairInterface;
+    addresses: IGetAddressesFromKeyPair[];
+}
+interface IGetAddressesFromKeyPair {
+    address: string;
+    publicKey: string;
+}
+interface IGetNextAvailableAddressResponse {
+    addressIndex: IAddress;
+    lastUsedAddressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    lastUsedChangeAddressIndex: IAddress;
+}
+interface ITxHashes extends TTxResult {
+    scriptHash: string;
+}
+interface IIndexes {
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    foundAddressIndex: boolean;
+    foundChangeAddressIndex: boolean;
+}
+interface ITxHash {
+    tx_hash: string;
+}
+interface IGetTransactions {
+    error: boolean;
+    id: number;
+    method: string;
+    network: string;
+    data: ITransaction<IUtxo>[];
+}
+interface ITransaction<T> {
+    id: number;
+    jsonrpc: string;
+    param: string;
+    data: T;
+    result: {
+        blockhash: string;
+        confirmations: number;
+        hash: string;
+        hex: string;
+        locktime: number;
+        size: number;
+        txid: string;
+        version: number;
+        vin: IVin[];
+        vout: IVout[];
+        vsize: number;
+        weight: number;
+        blocktime?: number;
+        time?: number;
+    };
+}
+interface IVout {
+    n: number;
+    scriptPubKey: {
+        addresses?: string[];
+        address?: string;
+        asm: string;
+        hex: string;
+        reqSigs?: number;
+        type?: string;
+    };
+    value: number;
+}
+type TProcessUnconfirmedTransactions = {
+    unconfirmedTxs: IFormattedTransactions;
+    outdatedTxs: IUtxo[];
+    ghostTxs: string[];
+};
+declare enum EUnit {
+    satoshi = "satoshi",
+    BTC = "BTC",
+    fiat = "fiat"
+}
+type InputData = {
+    [key: string]: {
+        addresses: string[];
+        value: number;
+    };
+};
+type TGetByteCountInputs = {
+    [key in TGetByteCountInput]?: number;
+};
+type TGetByteCountOutputs = {
+    [key in TGetByteCountOutput]?: number;
+};
+type TGetByteCountInput = `MULTISIG-P2SH:${number}-${number}` | `MULTISIG-P2WSH:${number}-${number}` | `MULTISIG-P2SH-P2WSH:${number}-${number}` | 'P2SH-P2WPKH' | 'P2PKH' | 'p2pkh' | 'P2WPKH' | 'p2wpkh' | 'P2SH' | 'p2sh' | 'P2TR' | 'p2tr';
+type TGetByteCountOutput = 'P2SH' | 'P2PKH' | 'P2WPKH' | 'P2WSH' | 'p2wpkh' | 'p2sh' | 'p2pkh' | 'P2TR' | 'p2tr';
+interface IGetFeeEstimatesResponse {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    minimumFee: number;
+}
+interface IOnchainFees {
+    fast: number;
+    normal: number;
+    slow: number;
+    minimum: number;
+    timestamp: number;
+}
+type TMessageDataMap = {
+    newBlock: INewBlock;
+    transactionReceived: TTransactionMessage;
+    transactionConfirmed: TTransactionMessage;
+    transactionSent: TTransactionMessage;
+    reorg: IUtxo[];
+    rbf: string[];
+    connectedToElectrum: boolean;
+};
+type TTransactionMessage = {
+    transaction: IFormattedTransaction;
+};
+type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+type TOnMessage = <K extends keyof TMessageDataMap>(key: K, data: TMessageDataMap[K]) => void;
+type TMessageKeys = keyof TMessageDataMap;
+interface ISendTx {
+    address: string;
+    amount: number;
+    message?: string;
+}
+interface ISend {
+    txs: ISendTx | ISendTx[];
+    satsPerByte?: number;
+}
+type TAddressIndexInfo = {
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    lastUsedAddressIndex: IAddress;
+    lastUsedChangeAddressIndex: IAddress;
+};
+type TStorage = {
+    getData?: TGetData;
+    setData?: TSetData;
+};
+interface IRbfData {
+    outputs: IOutput[];
+    balance: number;
+    addressType: EAddressType;
+    fee: number;
+    inputs: IUtxo[];
+    message: string;
+}
+interface IBoostedTransaction {
+    parentTransactions: string[];
+    childTransaction: string;
+    type: EBoostType;
+    fee: number;
+}
+interface IBoostedTransactions {
+    [txId: string]: IBoostedTransaction;
+}
+interface IPrivateKeyInfo {
+    balance: number;
+    utxos: IUtxo[];
+    keyPair: ECPairInterface | BIP32Interface;
+    addresses: IGetAddressesFromKeyPair[];
+}
+interface ISweepPrivateKey {
+    privateKey: string;
+    toAddress: string;
+    satsPerByte?: number;
+    broadcast?: boolean;
+    combineWithWalletUtxos?: boolean;
+}
+interface ISweepPrivateKeyRes {
+    balance: number;
+    id: string;
+    hex: string;
+}
+
+declare class Electrum {
+    private readonly _wallet;
+    private sendMessage;
+    private latestConnectionState;
+    private connectionPollingInterval;
+    private tls;
+    private net;
+    servers?: TServer | TServer[];
+    network: EAvailableNetworks;
+    electrumNetwork: EElectrumNetworks;
+    connectedToElectrum: boolean;
+    onReceive?: (data: unknown) => void;
+    batchLimit: number;
+    batchDelay: number;
+    constructor({ wallet, servers, network, onReceive, tls: _tls, net: _net, batchLimit, batchDelay }: {
+        wallet: Wallet;
+        servers?: TServer | TServer[];
+        network: EAvailableNetworks;
+        onReceive?: (data: unknown) => void;
+        tls?: TLSSocket;
+        net?: Server;
+        batchLimit?: number;
+        batchDelay?: number;
+    });
+    get wallet(): Wallet;
+    connectToElectrum({ network, servers, disableRegtestCheck }: {
+        network?: EAvailableNetworks;
+        servers?: TServer | TServer[];
+        disableRegtestCheck?: boolean;
+    }): Promise<Result<TConnectToElectrumRes>>;
+    isConnected(): Promise<boolean>;
+    getAddressBalance(scriptHash: string): Promise<IElectrumGetAddressBalanceRes>;
+    getAddressScriptHashBalances(scriptHashes: string[]): Promise<IGetAddressScriptHashBalances>;
+    getConnectedPeer(): Promise<Result<IPeerData>>;
+    listUnspentAddressScriptHashes({ addresses }: {
+        addresses: TUnspentAddressScriptHashData;
+    }): Promise<Result<IGetUtxosResponse>>;
+    getAddressHistory({ scriptHashes, scanAllAddresses }: {
+        scriptHashes?: IAddress[];
+        scanAllAddresses?: boolean;
+    }): Promise<Result<IGetAddressHistoryResponse[]>>;
+    getScriptPubKeyHistory(scriptPubkey: string): Promise<TGetAddressHistory[]>;
+    getUtxos({ scanningStrategy, addressIndex, changeAddressIndex, addressTypesToCheck }: {
+        scanningStrategy?: EScanningStrategy;
+        addressIndex?: number;
+        changeAddressIndex?: number;
+        addressTypesToCheck?: EAddressType[];
+    }): Promise<Result<IGetUtxosResponse>>;
+    getTransactions({ txHashes }: {
+        txHashes: ITxHash[];
+    }): Promise<Result<IGetTransactions>>;
+    transactionExists(txData: ITransaction<IUtxo>): boolean;
+    getBlockHex({ height }: {
+        height?: number;
+    }): Promise<Result<string>>;
+    getBlockHashFromHex({ blockHex }: {
+        blockHex?: string;
+    }): string;
+    getBlockHeader(): IHeader;
+    getTransactionsFromInputs({ txHashes }: {
+        txHashes: ITxHash[];
+    }): Promise<Result<IGetTransactionsFromInputs>>;
+    getTransactionMerkle({ tx_hash, height }: {
+        tx_hash: string;
+        height: number;
+    }): Promise<{
+        merkle: string[];
+        block_height: number;
+        pos: number;
+    }>;
+    subscribeToHeader(): Promise<Result<IHeader>>;
+    subscribeToAddresses({ scriptHashes, onReceive }?: {
+        scriptHashes?: string[];
+        onReceive?: (data: TSubscribedReceive) => void;
+    }): Promise<Result<string>>;
+    broadcastTransaction({ rawTx, subscribeToOutputAddress }: {
+        rawTx: string;
+        subscribeToOutputAddress?: boolean;
+    }): Promise<Result<string>>;
+    private checkConnection;
+    private publishConnectionChange;
+    disconnect(): Promise<void>;
+    startConnectionPolling(): void;
+    stopConnectionPolling(): void;
+}
+
+declare class Transaction {
+    private _data;
+    private readonly _wallet;
+    constructor({ wallet }: {
+        wallet: Wallet;
+    });
+    get data(): ISendTransaction;
+    setupTransaction({ inputTxHashes, utxos, rbf, satsPerByte, outputs }?: ISetupTransaction): Promise<TSetupTransactionResponse>;
+    resetSendTransaction(): Promise<Result<string>>;
+    removeBlackListedUtxos(utxos?: IUtxo[]): IUtxo[];
+    getTotalFee: ({ satsPerByte, message, transaction, fundingLightning }: {
+        satsPerByte: number;
+        message?: string | undefined;
+        transaction?: Partial<ISendTransaction> | undefined;
+        fundingLightning?: boolean | undefined;
+    }) => number;
+    getTotalFeeObj: ({ satsPerByte, message, transaction, fundingLightning }?: {
+        satsPerByte?: number | undefined;
+        message?: string | undefined;
+        transaction?: Partial<ISendTransaction> | undefined;
+        fundingLightning?: boolean | undefined;
+    }) => Result<TGetTotalFeeObj>;
+    getMaxSatsPerByte: ({ transactionByteCount, balance }: {
+        transactionByteCount: number;
+        balance?: number | undefined;
+    }) => number;
+    createTransaction: ({ transactionData, shuffleOutputs }?: ICreateTransaction) => Promise<Result<{
+        id: string;
+        hex: string;
+    }>>;
+    getTransactionInputValue: ({ inputs }: {
+        inputs?: IUtxo[] | undefined;
+    }) => number;
+    signPsbt: ({ psbt, bip32Interface }: {
+        psbt: Psbt;
+        bip32Interface: BIP32Interface;
+    }) => Promise<Result<Psbt>>;
+    createPsbtFromTransactionData: ({ transactionData, bip32Interface, shuffleTargets }: {
+        transactionData: ISendTransaction;
+        bip32Interface?: BIP32Interface | undefined;
+        shuffleTargets?: boolean | undefined;
+    }) => Promise<Result<Psbt>>;
+    addInput: ({ psbt, keyPair, input }: IAddInput) => Promise<Result<string>>;
+    addExternalInputs({ inputs, keyPair }: {
+        inputs: IUtxo[];
+        keyPair: BIP32Interface | ECPairInterface;
+    }): Result<IUtxo[]>;
+    addOutput: ({ address, value, index }: IOutput) => Promise<Result<string>>;
+    getTransactionOutputValue: ({ outputs }?: {
+        outputs?: IOutput[] | undefined;
+    }) => number;
+    updateSendTransaction: ({ transaction }: {
+        transaction: Partial<ISendTransaction>;
+    }) => Result<string>;
+    updateFee({ satsPerByte, selectedFeeId, index, transaction }: {
+        satsPerByte: number;
+        selectedFeeId?: EFeeId;
+        index?: number;
+        transaction?: ISendTransaction;
+    }): Result<{
+        fee: number;
+    }>;
+    sendMax: ({ address, transaction, index, satsPerByte, rbf }?: {
+        address?: string | undefined;
+        transaction?: ISendTransaction | undefined;
+        index?: number | undefined;
+        satsPerByte?: number | undefined;
+        rbf?: boolean | undefined;
+    }) => Promise<Result<string>>;
+    estimateTransactionCosts: ({ transaction, customFeeRate }: {
+        transaction?: ISendTransaction | undefined;
+        customFeeRate?: number | undefined;
+    }) => Result<{
+        amount: number;
+        fee: number;
+        satsPerByte: number;
+    }>;
+    getMaxSendAmount({ satsPerByte, selectedFeeId, transaction }: {
+        satsPerByte: number;
+        selectedFeeId?: EFeeId;
+        transaction?: ISendTransaction;
+    }): Result<{
+        amount: number;
+        fee: number;
+    }>;
+    setupCpfp({ txid, satsPerByte }: {
+        txid?: string;
+        satsPerByte?: number;
+    }): Promise<Result<ISendTransaction>>;
+}
+
+declare class Wallet {
+    private _network;
+    private readonly _mnemonic;
+    private readonly _passphrase;
+    private readonly _seed;
+    private readonly _root;
+    private _data;
+    private _getData;
+    private _setData?;
+    private _customGetAddress?;
+    private _customGetScriptHash?;
+    private _pendingRefreshPromises;
+    private _disableMessagesOnCreate;
+    addressTypesToMonitor: EAddressType[];
+    isRefreshing: boolean;
+    isSwitchingNetworks: boolean;
+    readonly id: string;
+    readonly name: string;
+    electrumOptions?: {
+        servers?: TServer | TServer[];
+        tls?: TLSSocket;
+        net?: Server;
+        batchLimit?: number;
+        batchDelay?: number;
+    };
+    electrum: Electrum;
+    addressType: EAddressType;
+    sendMessage: TOnMessage;
+    transaction: Transaction;
+    feeEstimates: IOnchainFees;
+    rbf: boolean;
+    selectedFeeId: EFeeId;
+    disableMessages: boolean;
+    gapLimitOptions: TGapLimitOptions;
+    private constructor();
+    get data(): IWalletData;
+    get network(): EAvailableNetworks;
+    static create(params: IWallet): Promise<Result<Wallet>>;
+    switchNetwork(network: EAvailableNetworks, servers?: TServer | TServer[]): Promise<Result<Wallet>>;
+    updateAddressType(addressType: EAddressType): Promise<void>;
+    refreshWallet({ scanAllAddresses }?: {
+        scanAllAddresses?: boolean | undefined;
+    }): Promise<Result<IWalletData>>;
+    private _resolveAllPendingRefreshPromises;
+    private _handleRefreshError;
+    private setWalletData;
+    private storageIdCheck;
+    getWalletDataKey(key: keyof IWalletData): string;
+    getWalletData(): Promise<Result<IWalletData>>;
+    private getBitcoinNetwork;
+    isValid(mnemonic: any): boolean;
+    private _getAddress;
+    getAddress({ index, changeAddress, addressType }?: IGetAddress): Promise<string>;
+    getAddressByPath({ path, addressType }: IGetAddressByPath): Promise<Result<IGetAddressResponse>>;
+    connectToElectrum(servers?: TServer | TServer[]): Promise<Result<string>>;
+    getAddressBalance(address: string): Promise<Result<IGetAddressBalanceRes>>;
+    getAddressesBalance(addresses?: string[]): Promise<Result<number>>;
+    getScriptHash({ address, network }: {
+        address: string;
+        network: EAvailableNetworks;
+    }): Promise<string>;
+    getPrivateKey(path: string): string;
+    getScriptHashBalance(scriptHash: string): Promise<Result<IGetAddressBalanceRes>>;
+    getBalance(): number;
+    generateAddresses({ addressAmount, changeAddressAmount, addressIndex, changeAddressIndex, keyDerivationPath, addressType }: IGenerateAddresses): Promise<Result<IGenerateAddressesResponse>>;
+    checkElectrumConnection(): Promise<Result<string>>;
+    getNextAvailableAddress(addressType?: EAddressType): Promise<Result<IGetNextAvailableAddressResponse>>;
+    getHighestStoredAddressIndex({ addressType }: {
+        addressType: EAddressType;
+    }): Result<{
+        addressIndex: IAddress;
+        changeAddressIndex: IAddress;
+    }>;
+    private addAddresses;
+    private removeDuplicateAddresses;
+    private updateAddressIndexes;
+    resetAddressIndexes(): Promise<void>;
+    generateNewReceiveAddress({ addressType, keyDerivationPath }: {
+        addressType?: EAddressType;
+        keyDerivationPath?: IKeyDerivationPath;
+    }): Promise<Result<IAddress>>;
+    getGapLimit({ addressType }: {
+        addressType?: EAddressType;
+    }): Result<{
+        addressDelta: number;
+        changeAddressDelta: number;
+    }>;
+    getUtxos({ scanningStrategy, addressIndex, changeAddressIndex, addressTypesToCheck }: {
+        scanningStrategy?: EScanningStrategy;
+        addressIndex?: number;
+        changeAddressIndex?: number;
+        addressTypesToCheck?: EAddressType[];
+    }): Promise<Result<IGetUtxosResponse>>;
+    listUtxos(): IUtxo[];
+    private savingOperations;
+    saveWalletData<K extends keyof IWalletData>(key: TWalletDataKeys, data: IWalletData[K]): Promise<string>;
+    private updateAndSaveWalletData;
+    updateTransactions({ scanAllAddresses, replaceStoredTransactions }: {
+        scanAllAddresses?: boolean;
+        replaceStoredTransactions?: boolean;
+    }): Promise<Result<string | undefined>>;
+    private checkUnconfirmedTransactions;
+    private processUnconfirmedTransactions;
+    getUnconfirmedTransactions(): IFormattedTransactions;
+    confirmationsToBlockHeight({ confirmations, currentHeight }: {
+        confirmations: number;
+        currentHeight?: number;
+    }): number;
+    updateHeader(headerData: IHeader): Promise<void>;
+    private updateGhostTransactions;
+    rescanAddresses({ shouldClearAddresses, shouldClearTransactions }: {
+        shouldClearAddresses?: boolean;
+        shouldClearTransactions?: boolean;
+    }): Promise<Result<IWalletData>>;
+    clearUtxos(): Promise<string>;
+    private clearTransactions;
+    private clearAddresses;
+    private updateTransactionHeights;
+    private addUnconfirmedTransactions;
+    blockHeightToConfirmations({ blockHeight, currentHeight }: {
+        blockHeight?: number;
+        currentHeight?: number;
+    }): number;
+    formatTransactions({ transactions }: {
+        transactions: ITransaction<IUtxo>[];
+    }): Promise<Result<IFormattedTransactions>>;
+    getInputData({ inputs }: {
+        inputs: {
+            tx_hash: string;
+            vout: number;
+        }[];
+    }): Promise<Result<InputData>>;
+    validateAddress(address: string): boolean;
+    getChangeAddress(addressType?: EAddressType): Promise<Result<IAddress>>;
+    getFeeEstimates(network?: EAvailableNetworks): Promise<IOnchainFees>;
+    setupTransaction(params?: ISetupTransaction): Promise<TSetupTransactionResponse>;
+    getFeeInfo({ satsPerByte, message, transaction, fundingLightning }?: {
+        satsPerByte?: number;
+        message?: string;
+        transaction?: Partial<ISendTransaction>;
+        fundingLightning?: boolean;
+    }): Result<TGetTotalFeeObj>;
+    sendMany({ txs, satsPerByte, rbf, broadcast, shuffleOutputs }: {
+        txs: ISendTx[];
+        satsPerByte?: number;
+        rbf?: boolean;
+        broadcast?: boolean;
+        shuffleOutputs?: boolean;
+    }): Promise<Result<string>>;
+    sendMax({ address, satsPerByte, rbf, broadcast }?: {
+        address?: string;
+        satsPerByte?: number;
+        rbf?: boolean;
+        broadcast?: boolean;
+    }): Promise<Result<string>>;
+    send({ address, amount, message, satsPerByte, rbf, broadcast, shuffleOutputs }: {
+        address: string;
+        amount: number;
+        message?: string;
+        satsPerByte?: number;
+        rbf?: boolean;
+        broadcast?: boolean;
+        shuffleOutputs?: boolean;
+    }): Promise<Result<string>>;
+    getAddressFromScriptHash(scriptHash: string): IAddress | undefined;
+    private setZeroIndexAddresses;
+    private updateAddressIndex;
+    getAddressIndexInfo(): TAddressIndexInfo;
+    getReceiveAddress: ({ addressType }: {
+        addressType?: EAddressType | undefined;
+    }) => Promise<Result<string>>;
+    getRbfData({ txHash }: {
+        txHash: ITxHash;
+    }): Promise<Result<IRbfData>>;
+    deleteOnChainTransactionById({ txid }: {
+        txid: string;
+    }): Promise<void>;
+    addGhostTransaction({ txid }: {
+        txid: string;
+    }): Promise<void>;
+    addBoostedTransaction({ newTxId, oldTxId, type, fee }: {
+        newTxId: string;
+        oldTxId: string;
+        type?: EBoostType;
+        fee: number;
+    }): Promise<Result<IBoostedTransaction>>;
+    getBoostedTransactionParents: ({ txid, boostedTransactions }: {
+        txid: string;
+        boostedTransactions?: IBoostedTransactions | undefined;
+    }) => string[];
+    getBoostedTransactions: () => IBoostedTransactions;
+    resetSendTransaction(): Promise<Result<string>>;
+    getBoostableTransactions(): {
+        cpfp: IFormattedTransaction[];
+        rbf: IFormattedTransaction[];
+    };
+    getBip32Interface: () => Promise<Result<BIP32Interface>>;
+    addTxInput({ input }: {
+        input: IUtxo;
+    }): Result<IUtxo[]>;
+    removeTxInput({ input }: {
+        input: IUtxo;
+    }): Result<IUtxo[]>;
+    addTxTag({ tag }: {
+        tag: string;
+    }): Result<string>;
+    removeTxTag({ tag }: {
+        tag: string;
+    }): Result<string>;
+    setupFeeForOnChainTransaction({ satsPerByte, selectedFeeId }: {
+        satsPerByte?: number;
+        selectedFeeId?: EFeeId;
+    }): Result<string>;
+    updateWalletBalance({ balance }: {
+        balance: number;
+    }): Result<string>;
+    updateFeeEstimates(forceUpdate?: boolean): Promise<Result<IOnchainFees>>;
+    getAddressesFromPrivateKey(privateKey: string, _addressTypes?: EAddressType[]): Result<IGetAddressesFromPrivateKey>;
+    getPrivateKeyInfo(privateKey: string): Promise<Result<IPrivateKeyInfo>>;
+    sweepPrivateKey({ privateKey, toAddress, satsPerByte, broadcast, combineWithWalletUtxos }: ISweepPrivateKey): Promise<Result<ISweepPrivateKeyRes>>;
+    getAddressInfoFromScriptHash(scriptHash: string): Result<{
+        address: IAddress;
+        addressType: EAddressType;
+    }>;
+    updateGapLimit(gapLimitOptions: TGapLimitOptions): Result<TGapLimitOptions>;
+}
+
+export { EAddressType, EAvailableNetworks, EBoostType, EElectrumNetworks, EFeeId, EPaymentType, EProtocol, EScanningStrategy, EUnit, Electrum, type ElectrumConnectionPubSub, type ElectrumConnectionSubscription, type IAddInput, type IAddress, type IAddressData, type IAddressType, type IAddressTypeData, type IAddresses, type IBoostedTransaction, type IBoostedTransactions, type ICreateTransaction, type ICustomGetAddress, type ICustomGetScriptHash, type IElectrumGetAddressBalanceRes, type IFormattedPeerData, type IFormattedTransaction, type IFormattedTransactions, type IGenerateAddresses, type IGenerateAddressesResponse, type IGetAddress, type IGetAddressBalanceRes, type IGetAddressByPath, type IGetAddressHistoryResponse, type IGetAddressResponse, type IGetAddressScriptHashBalances, type IGetAddressScriptHashesHistoryResponse, type IGetAddressesFromKeyPair, type IGetAddressesFromPrivateKey, type IGetDerivationPath, type IGetFeeEstimatesResponse, type IGetHeaderResponse, type IGetNextAvailableAddressResponse, type IGetTransactions, type IGetTransactionsFromInputs, type IGetUtxosResponse, type IHeader, type IIndexes, type IKeyDerivationPath, type IKeyDerivationPathData, type INewBlock, type IOnchainFees, type IOutput, type IPeerData, type IPrivateKeyInfo, type IRbfData, type ISend, type ISendTransaction, type ISendTx, type ISetupTransaction, type ISubscribeToAddress, type ISubscribeToHeader, type ISweepPrivateKey, type ISweepPrivateKeyRes, type ITargets, type ITransaction, type ITxHash, type ITxHashes, type IUtxo, type IVin, type IVout, type IWallet, type IWalletData, type InputData, type ObjectKeys, type Result, type TAddressIndexInfo, type TAddressLabel, type TAddressType, type TAddressTypeContent, type TAddressTypes, type TAvailableNetworks, type TConnectToElectrumRes, type TDecodeRawTx, type TElectrumNetworks, type TGapLimitOptions, type TGetAddressHistory, type TGetByteCountInput, type TGetByteCountInputs, type TGetByteCountOutput, type TGetByteCountOutputs, type TGetData, type TGetTotalFeeObj, type TKeyDerivationAccount, type TKeyDerivationChange, type TKeyDerivationCoinType, type TKeyDerivationIndex, type TKeyDerivationPurpose, type TMessageDataMap, type TMessageKeys, type TOnMessage, type TProcessUnconfirmedTransactions, type TProtocol, type TServer, type TSetData, type TSetupTransactionResponse, type TStorage, type TSubscribedReceive, type TTransactionMessage, type TTxResponse, type TTxResult, type TUnspentAddressScriptHashData, type TWalletDataKeys, Transaction, Wallet, availableNetworks, constructByteCountParam, decodeOpReturnMessage, decodeRawTransaction, defaultElectrumPorts, electrumConnection, err, filterAddressesForGapLimit, filterAddressesObjForGapLimit, filterAddressesObjForSingleIndex, filterAddressesObjForStartingIndex, formatKeyDerivationPath, formatPeerData, generateMnemonic, generateWalletId, getAddressFromKeyPair, getAddressFromScriptPubKey, getAddressIndexDiff, getAddressTypeFromPath, getAddressesFromPrivateKey, getByteCount, getDataFallback, getDefaultPort, getDefaultWalletData, getDefaultWalletDataKeys, getElectrumNetwork, getHighestUsedIndexFromTxHashes, getKeyDerivationPath, getKeyDerivationPathObject, getKeyDerivationPathString, getKeyValue, getPeers, getProtocolForPort, getScriptHash, getSeed, getSeedHash, getSha256, getStorageKeyValues, getTapRootAddressFromPublicKey, getTxFee, getWalletDataStorageKey, isP2trPrefix, isPositive, isValidBech32mEncodedString, objectKeys, objectsMatch, ok, parseOnChainPaymentRequest, reduceValue, removeDustOutputs, setReplaceByFee, shuffleArray, sleep, validateAddress, validateMnemonic, validateTransaction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beignet",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "description": "A self-custodial, JS Bitcoin wallet management library.",
   "main": "dist/index.js",
   "scripts": {
@@ -50,7 +50,7 @@
     "ecpair": "2.1.0",
     "lodash.clonedeep": "4.5.0",
     "net": "1.0.2",
-    "rn-electrum-client": "0.0.21"
+    "rn-electrum-client": "0.0.22"
   },
   "devDependencies": {
     "@types/chai": "4.3.0",

package/src/electrum/index.ts

@@ -137,6 +137,8 @@ export class Electrum {
 			return err('Regtest requires that you pre-specify a server.');
 		}
 		const startResponse = await electrum.start({
+			clientName: 'beignet',
+			protocolVersion: '1.4',
 			network: electrumNetwork,
 			net: this.net,
 			tls: this.tls,