beignet 0.2.0 → 0.3.0

package/dist/types/lightning/watchtower/types.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export interface ITowerAddress {
+    pubkey: string;
+    host: string;
+    port: number;
+    uri: string;
+}
+export interface ITowerTransport extends EventEmitter {
+    connect(): Promise<void>;
+    send(type: number, payload: Buffer): void;
+    close(): void;
+    isConnected(): boolean;
+}
+export type TowerTransportFactory = (addr: ITowerAddress) => ITowerTransport;
+export interface IWatchtowerSession {
+    towerUri: string;
+    towerPubkey: string;
+    sessionId: string;
+    blobType: number;
+    maxUpdates: number;
+    sweepFeeRate: string;
+    seqNum: number;
+    lastApplied: number;
+    createdAt: number;
+}
+export interface IWatchtowerUpdate {
+    towerUri: string;
+    channelId: string;
+    hint: string;
+    encryptedBlob: string;
+    seqNum: number;
+    acked: boolean;
+    createdAt: number;
+}
+export interface ITowerHealth {
+    uri: string;
+    pubkey: string;
+    connected: boolean;
+    sessions: number;
+    pendingBacklog: number;
+    lastAck: number | null;
+}

package/dist/types/lightning/watchtower/watchtower-client.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import * as bitcoin from 'bitcoinjs-lib';
+import { IJusticeContext } from './justice';
+import { TowerTransportFactory, IWatchtowerSession, IWatchtowerUpdate, ITowerHealth } from './types';
+export interface IWatchtowerStore {
+    saveWatchtowerSession(session: IWatchtowerSession, sessionKey: Buffer): void;
+    loadWatchtowerSessions(): Array<IWatchtowerSession & {
+        sessionKey: Buffer;
+    }>;
+    setWatchtowerSessionProgress(sessionId: string, seqNum: number, lastApplied: number): void;
+    deleteWatchtowerTower(towerUri: string): void;
+    addWatchtowerUpdate(update: IWatchtowerUpdate): number;
+    loadPendingWatchtowerUpdates(): Array<IWatchtowerUpdate & {
+        id: number;
+    }>;
+    markWatchtowerUpdateAcked(id: number, seqNum: number): void;
+}
+export interface IWatchtowerClientOptions {
+    localPrivateKey: Buffer;
+    chainHash: Buffer;
+    network: bitcoin.Network;
+    towers?: string[];
+    store?: IWatchtowerStore;
+    transportFactory?: TowerTransportFactory;
+    socks5Proxy?: {
+        host: string;
+        port: number;
+    };
+    maxUpdates?: number;
+    sweepFeeRateSatPerKw?: bigint;
+    connectTimeoutMs?: number;
+}
+export declare class WatchtowerClient extends EventEmitter {
+    private readonly localPrivateKey;
+    private readonly chainHash;
+    private readonly store?;
+    private readonly transportFactory;
+    private readonly socks5Proxy?;
+    private readonly maxUpdates;
+    private readonly sweepFeeRate;
+    private readonly connectTimeoutMs;
+    private readonly towers;
+    private started;
+    constructor(opts: IWatchtowerClientOptions);
+    get enabled(): boolean;
+    start(): Promise<void>;
+    stop(): void;
+    listTowers(): string[];
+    addTower(uri: string): void;
+    removeTower(uri: string): void;
+    getHealth(): ITowerHealth[];
+    backupRevokedState(ctx: IJusticeContext): void;
+    private registerTower;
+    private connectTower;
+    private onConnected;
+    private onMessage;
+    private onClose;
+    private ensureSessionAndDrain;
+    private negotiateSession;
+    private drainBacklog;
+    private shipUpdate;
+    private awaitReply;
+    private lastAckFor;
+    private emitLog;
+}

package/dist/types/lightning/watchtower/wtwire.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+export declare enum WtMessageType {
+    INIT = 600,
+    ERROR = 601,
+    CREATE_SESSION = 602,
+    CREATE_SESSION_REPLY = 603,
+    STATE_UPDATE = 604,
+    STATE_UPDATE_REPLY = 605,
+    DELETE_SESSION = 606,
+    DELETE_SESSION_REPLY = 607
+}
+export declare enum WtFeatureBit {
+    ALTRUIST_SESSIONS_REQUIRED = 0,
+    ALTRUIST_SESSIONS_OPTIONAL = 1,
+    ANCHOR_COMMIT_REQUIRED = 2,
+    ANCHOR_COMMIT_OPTIONAL = 3,
+    TAPROOT_COMMIT_REQUIRED = 4,
+    TAPROOT_COMMIT_OPTIONAL = 5
+}
+export declare enum WtErrorCode {
+    OK = 0,
+    TEMPORARY_FAILURE = 40,
+    PERMANENT_FAILURE = 50
+}
+export declare enum CreateSessionCode {
+    OK = 0,
+    REJECT_ALREADY_EXISTS = 60,
+    REJECT_MAX_UPDATES = 61,
+    REJECT_REWARD_RATE = 62,
+    REJECT_SWEEP_FEE_RATE = 63,
+    REJECT_BLOB_TYPE = 64
+}
+export declare enum StateUpdateCode {
+    OK = 0,
+    CLIENT_BEHIND = 40,
+    MAX_UPDATES_EXCEEDED = 41,
+    SEQ_NUM_OUT_OF_ORDER = 42
+}
+export interface IWtInit {
+    connFeatures: Buffer;
+    chainHash: Buffer;
+}
+export interface IWtError {
+    code: number;
+    data: Buffer;
+}
+export interface IWtCreateSession {
+    blobType: number;
+    maxUpdates: number;
+    rewardBase: number;
+    rewardRate: number;
+    sweepFeeRate: bigint;
+}
+export interface IWtCreateSessionReply {
+    code: number;
+    lastApplied: number;
+    data: Buffer;
+}
+export interface IWtStateUpdate {
+    seqNum: number;
+    lastApplied: number;
+    isComplete: number;
+    hint: Buffer;
+    encryptedBlob: Buffer;
+}
+export interface IWtStateUpdateReply {
+    code: number;
+    lastApplied: number;
+}
+export interface IWtDeleteSession {
+    _?: never;
+}
+export interface IWtDeleteSessionReply {
+    code: number;
+}
+export declare function encodeInit(msg: IWtInit): Buffer;
+export declare function decodeInit(payload: Buffer): IWtInit;
+export declare function encodeError(msg: IWtError): Buffer;
+export declare function decodeError(payload: Buffer): IWtError;
+export declare function encodeCreateSession(msg: IWtCreateSession): Buffer;
+export declare function decodeCreateSession(payload: Buffer): IWtCreateSession;
+export declare function encodeCreateSessionReply(msg: IWtCreateSessionReply): Buffer;
+export declare function decodeCreateSessionReply(payload: Buffer): IWtCreateSessionReply;
+export declare function encodeStateUpdate(msg: IWtStateUpdate): Buffer;
+export declare function decodeStateUpdate(payload: Buffer): IWtStateUpdate;
+export declare function encodeStateUpdateReply(msg: IWtStateUpdateReply): Buffer;
+export declare function decodeStateUpdateReply(payload: Buffer): IWtStateUpdateReply;
+export declare function encodeDeleteSession(): Buffer;
+export declare function encodeDeleteSessionReply(msg: IWtDeleteSessionReply): Buffer;
+export declare function decodeDeleteSessionReply(payload: Buffer): IWtDeleteSessionReply;

package/dist/types/shapes/electrum.d.ts

@@ -1,5 +1,7 @@
-import { TMessageKeys } from '../types';
+import { EElectrumNetworks, TMessageKeys, TServer } from '../types';
 export declare const onMessageKeys: {
     [K in TMessageKeys]: K;
 };
 export declare const POLLING_INTERVAL: number;
+export declare const ELECTRUM_SERVER_COOLDOWN_MS: number;
+export declare const defaultElectrumPeers: Partial<Record<EElectrumNetworks, TServer[]>>;

package/dist/types/transaction/index.d.ts

@@ -18,6 +18,7 @@ export declare class Transaction {
     }): Promise<Result<ISendTransaction>>;
     resetSendTransaction(): Promise<Result<string>>;
     removeBlackListedUtxos(utxos?: IUtxo[]): IUtxo[];
+    private applyMultisigInputWeights;
     getTotalFee: ({ satsPerByte, message, transaction, fundingLightning, coinSelectPreference }: {
         satsPerByte: number;
         message?: string | undefined;
@@ -52,6 +53,11 @@ export declare class Transaction {
         bip32Interface?: BIP32Interface | undefined;
         shuffleTargets?: boolean | undefined;
     }) => Promise<Result<Psbt>>;
+    createUnsignedPsbt: ({ transactionData, shuffleOutputs }?: {
+        transactionData?: ISendTransaction | undefined;
+        shuffleOutputs?: boolean | undefined;
+    }) => Promise<Result<Psbt>>;
+    private addSignerMetadata;
     addInput: ({ psbt, keyPair, input }: IAddInput) => Promise<Result<string>>;
     addExternalInputs({ inputs, keyPair }: {
         inputs: IUtxo[];

package/dist/types/transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/types/transaction.ts"],"names":[],"mappings":";;;AAwCA,IAAY,MAMX;AAND,WAAY,MAAM;IACjB,uBAAa,CAAA;IACb,2BAAiB,CAAA;IACjB,uBAAa,CAAA;IACb,2BAAiB,CAAA;IACjB,uBAAa,CAAA;AACd,CAAC,EANW,MAAM,GAAN,cAAM,KAAN,cAAM,QAMjB;AA8BD,IAAY,qBAMX;AAND,WAAY,qBAAqB;IAChC,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,oDAA2B,CAAA;IAC3B,4DAAmC,CAAA;IACnC,0DAAiC,CAAA;AAClC,CAAC,EANW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QAMhC"}
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/types/transaction.ts"],"names":[],"mappings":";;;AA0CA,IAAY,MAMX;AAND,WAAY,MAAM;IACjB,uBAAa,CAAA;IACb,2BAAiB,CAAA;IACjB,uBAAa,CAAA;IACb,2BAAiB,CAAA;IACjB,uBAAa,CAAA;AACd,CAAC,EANW,MAAM,GAAN,cAAM,KAAN,cAAM,QAMjB;AA8BD,IAAY,qBAMX;AAND,WAAY,qBAAqB;IAChC,wCAAe,CAAA;IACf,wCAAe,CAAA;IACf,oDAA2B,CAAA;IAC3B,4DAAmC,CAAA;IACnC,0DAAiC,CAAA;AAClC,CAAC,EANW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QAMhC"}

package/dist/types/types/electrum.d.ts

@@ -1,11 +1,12 @@
 import { EAvailableNetworks, IAddress, IGetAddressBalanceRes, ITransaction, IUtxo } from './wallet';
 export type Net = typeof import('net');
 export type Tls = typeof import('tls');
-export type TElectrumNetworks = 'bitcoin' | 'bitcoinTestnet' | 'bitcoinRegtest';
+export type TElectrumNetworks = 'bitcoin' | 'bitcoinTestnet' | 'bitcoinRegtest' | 'bitcoinSignet';
 export declare enum EElectrumNetworks {
     bitcoin = "bitcoin",
     bitcoinTestnet = "bitcoinTestnet",
-    bitcoinRegtest = "bitcoinRegtest"
+    bitcoinRegtest = "bitcoinRegtest",
+    bitcoinSignet = "bitcoinSignet"
 }
 export type TConnectToElectrumRes = string;
 export interface IElectrumGetAddressBalanceRes extends IGetAddressBalanceRes {

package/dist/types/types/transaction.d.ts

@@ -11,7 +11,7 @@ export interface ICreateTransaction {
 }
 export interface IAddInput {
     psbt: Psbt;
-    keyPair: BIP32Interface | ECPairInterface;
+    keyPair?: BIP32Interface | ECPairInterface;
     input: IUtxo;
 }
 export interface ITargets {

package/dist/types/types/wallet.d.ts

@@ -3,7 +3,7 @@ import { EElectrumNetworks, IHeader, INewBlock, Net, TServer, TTxResult, Tls } f
 import { ECoinSelectPreference, EFeeId, TGapLimitOptions } from './transaction';
 import { ECPairInterface } from 'ecpair';
 import { BIP32Interface } from 'bip32';
-export type TAvailableNetworks = 'bitcoin' | 'testnet' | 'regtest';
+export type TAvailableNetworks = 'bitcoin' | 'testnet' | 'regtest' | 'signet';
 export type TAddressType = 'p2wpkh' | 'p2sh' | 'p2pkh';
 export type TAddressLabel = 'bech32' | 'segwit' | 'legacy';
 export type TKeyDerivationPurpose = '84' | '49' | '44' | string;
@@ -21,13 +21,17 @@ export declare enum EAvailableNetworks {
     testnet = "testnet",
     bitcoinTestnet = "testnet",
     regtest = "regtest",
-    bitcoinRegtest = "regtest"
+    bitcoinRegtest = "regtest",
+    signet = "signet",
+    bitcoinSignet = "signet"
 }
+export type TFeeEstimationSource = 'electrum' | 'http' | 'auto';
 export declare enum EAddressType {
     p2wpkh = "p2wpkh",
     p2sh = "p2sh",
     p2pkh = "p2pkh",
-    p2tr = "p2tr"
+    p2tr = "p2tr",
+    p2wsh = "p2wsh"
 }
 export declare enum EPaymentType {
     sent = "sent",
@@ -147,17 +151,25 @@ export interface IWalletData {
     balance: number;
     selectedFeeId: EFeeId;
     feeEstimates: IOnchainFees;
+    addressLabels: TAddressLabels;
+    birthdayHeight: number;
 }
+export type TAddressLabels = {
+    [address: string]: string;
+};
 export type TWalletDataKeys = keyof IWalletData;
 export type TGetData = <K extends keyof IWalletData>(key: string) => Promise<Result<IWalletData[K]>>;
 export type TSetData = <K extends keyof IWalletData>(key: string, value: IWalletData[K]) => Promise<Result<boolean>>;
 export interface IWallet {
-    mnemonic: string;
+    mnemonic?: string;
+    xpub?: string;
     id?: string;
     name?: string;
     passphrase?: string;
     network?: EAvailableNetworks;
     addressType?: EAddressType;
+    account?: number;
+    birthdayHeight?: number;
     coinSelectPreference?: ECoinSelectPreference;
     data?: IWalletData;
     storage?: TStorage;
@@ -174,12 +186,14 @@ export interface IWallet {
     customGetScriptHash?: (data: ICustomGetScriptHash) => Promise<string>;
     rbf?: boolean;
     selectedFeeId?: EFeeId;
+    feeEstimationSource?: TFeeEstimationSource;
     disableMessages?: boolean;
     disableMessagesOnCreate?: boolean;
     addressTypesToMonitor?: EAddressType[];
     gapLimitOptions?: TGapLimitOptions;
     addressLookBehind?: number;
     addressLookAhead?: number;
+    multisig?: IMultisigOptions;
 }
 export interface IAddressData {
     path: string;
@@ -376,6 +390,48 @@ export interface ISend {
     txs: ISendTx | ISendTx[];
     satsPerByte?: number;
 }
+export type IWatchOnlyWallet = Omit<IWallet, 'mnemonic' | 'passphrase' | 'xpub'> & {
+    xpub: string;
+};
+export interface IMultisigOptions {
+    threshold: number;
+    cosigners: string[];
+    ourXpub?: string;
+}
+export type IMultisigWallet = Omit<IWallet, 'xpub' | 'addressType'> & IMultisigOptions;
+export interface IBuildPsbtArgs {
+    txs?: ISendTx[];
+    address?: string;
+    amount?: number;
+    message?: string;
+    satsPerByte?: number;
+    rbf?: boolean;
+    shuffleOutputs?: boolean;
+}
+export interface IBuildPsbtInputSummary {
+    tx_hash: string;
+    tx_pos: number;
+    address: string;
+    value: number;
+    path: string;
+}
+export interface IBuildPsbtOutputSummary {
+    address?: string;
+    value: number;
+    index: number;
+}
+export interface IBuildPsbtResponse {
+    psbtBase64: string;
+    fee: number;
+    vsizeEstimate: number;
+    satsPerByte: number;
+    inputs: IBuildPsbtInputSummary[];
+    outputs: IBuildPsbtOutputSummary[];
+}
+export interface IImportSignedPsbtResponse {
+    txHex: string;
+    txid: string;
+}
 export type TAddressIndexInfo = {
     addressIndex: IAddress;
     changeAddressIndex: IAddress;
@@ -459,4 +515,22 @@ export interface ICanBoostResponse {
     rbf: boolean;
     cpfp: boolean;
 }
+export interface IBalanceBreakdown {
+    total: number;
+    spendable: number;
+    frozen: number;
+}
+export interface IExportedDescriptor {
+    addressType: EAddressType;
+    external: string;
+    internal: string;
+}
+export interface IExportDescriptorsResponse {
+    fingerprint: string;
+    network: EAvailableNetworks;
+    account: number;
+    birthdayHeight?: number;
+    watchOnly: boolean;
+    descriptors: IExportedDescriptor[];
+}
 export {};

package/dist/types/utils/descriptors.d.ts

@@ -0,0 +1,2 @@
+export declare const descriptorChecksum: (descriptor: string) => string | null;
+export declare const appendDescriptorChecksum: (descriptor: string) => string;

package/dist/types/utils/fees.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_FEE_RATE_SAT_PER_VBYTE = 5000;
+export declare const clampFeeRate: (rate: number) => number;
+export declare const btcPerKbToSatPerVbyte: (btcPerKb: number) => number;

package/dist/types/utils/helpers.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
-import { EAddressType, EAvailableNetworks, IGetAddressesFromKeyPair, IGetAddressesFromPrivateKey, IKeyDerivationPath } from '../types';
+import { EAddressType, EAvailableNetworks, IGetAddressesFromKeyPair, IGetAddressesFromPrivateKey, IKeyDerivationPath, TAvailableNetworks } from '../types';
 import { Network } from 'bitcoinjs-lib';
 import { Result } from './result';
 import { ECPairInterface } from 'ecpair';
 import { BIP32Interface } from 'bip32';
+export declare const validatePsbtSignature: (pubkey: Buffer, msghash: Buffer, signature: Buffer) => boolean;
+export declare const getBitcoinJsNetwork: (network: EAvailableNetworks | TAvailableNetworks) => Network;
 export declare const getAddressFromScriptPubKey: (scriptPubKey: string, selectedNetwork: EAvailableNetworks) => string;
 export declare const getSha256: (str: string) => string;
 export declare const validateAddress: ({ address, network }: {

package/dist/types/utils/index.d.ts

@@ -1,6 +1,11 @@
 export * from './wallet';
+export * from './wallet-storage-encryption';
+export * from './watch-only';
+export * from './multisig';
 export * from './helpers';
 export * from './electrum';
+export * from './fees';
 export * from './derivation-path';
+export * from './descriptors';
 export * from './transaction';
 export * from './result';

package/dist/types/utils/multisig.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { BIP32Interface } from 'bip32';
+import { Network } from 'bitcoinjs-lib';
+import { Result } from './result';
+export declare class MultisigSpendError extends Error {
+    readonly code = "MULTISIG_REQUIRES_PSBT";
+    constructor(message?: string);
+}
+export declare const BIP48_SCRIPT_TYPE = "2";
+export interface IParsedBip48Path {
+    coinType: string;
+    account: string;
+    change: number;
+    index: number;
+}
+export declare const parseBip48Path: (path: string) => Result<IParsedBip48Path>;
+export interface ISortedMultisigPayment {
+    address: string;
+    output: Buffer;
+    witnessScript: Buffer;
+    sortedPublicKeys: Buffer[];
+}
+export declare const buildSortedMultisigPayment: ({ threshold, cosignerNodes, change, index, network }: {
+    threshold: number;
+    cosignerNodes: BIP32Interface[];
+    change: number;
+    index: number;
+    network: Network;
+}) => Result<ISortedMultisigPayment>;

package/dist/types/utils/transaction.d.ts

@@ -5,6 +5,13 @@ export declare const setReplaceByFee: ({ psbt, setRbf }: {
     psbt: Psbt;
     setRbf: boolean;
 }) => void;
+export interface IEncodeBip21 {
+    address: string;
+    amountSats?: number;
+    label?: string;
+    message?: string;
+}
+export declare const encodeBip21: ({ address, amountSats, label, message }: IEncodeBip21) => Result<string>;
 export declare const parseOnChainPaymentRequest: (data: string, network?: EAvailableNetworks) => Result<{
     address: string;
     network: EAvailableNetworks;

package/dist/types/utils/wallet-storage-encryption.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { TStorage } from '../types';
+export declare const createEncryptedStorage: (inner: TStorage, seed: Buffer) => TStorage;

package/dist/types/utils/wallet.d.ts

@@ -35,7 +35,7 @@ export declare const decodeOpReturnMessage: (opReturn?: string) => string[];
 export declare const getSeed: (mnemonic: any, bip39Passphrase: any) => Buffer;
 export declare const getSeedHash: (seed: Buffer) => string;
 export declare const generateWalletId: (seed: Buffer) => string;
-export declare const getWalletDataStorageKey: (name: string, network: EAvailableNetworks, key: keyof IWalletData) => string;
+export declare const getWalletDataStorageKey: (name: string, network: EAvailableNetworks, key: keyof IWalletData, account?: number) => string;
 export declare const getStorageKeyValues: (storageKey: string) => {
     walletName: string;
     network: EAvailableNetworks;

package/dist/types/utils/watch-only.d.ts

@@ -0,0 +1,12 @@
+import { BIP32Interface } from 'bip32';
+import { EAddressType, EAvailableNetworks } from '../types';
+import { Result } from './result';
+export declare class WatchOnlySigningError extends Error {
+    readonly code = "WATCH_ONLY_CANNOT_SIGN";
+    constructor(message?: string);
+}
+export interface IParsedExtendedPublicKey {
+    node: BIP32Interface;
+    addressType?: EAddressType;
+}
+export declare const parseExtendedPublicKey: (extendedKey: string, network: EAvailableNetworks) => Result<IParsedExtendedPublicKey>;

package/dist/types/wallet/constants.d.ts

@@ -9,6 +9,7 @@ export declare const DUST_LIMITS: {
     p2sh: number;
     p2wpkh: number;
     p2tr: number;
+    p2wsh: number;
 };
 export declare const TRANSACTION_DEFAULTS: {
     recommendedBaseFee: number;

package/dist/types/wallet/index.d.ts

@@ -1,14 +1,17 @@
+/// <reference types="node" />
 import { BIP32Interface } from 'bip32';
-import { EAddressType, EAvailableNetworks, EBoostType, ECoinSelectPreference, EFeeId, EScanningStrategy, IAddress, IBoostedTransaction, IBoostedTransactions, ICanBoostResponse, IFormattedTransaction, IFormattedTransactions, IGenerateAddresses, IGenerateAddressesResponse, IGetAddress, IGetAddressBalanceRes, IGetAddressByPath, IGetAddressesFromPrivateKey, IGetAddressResponse, IGetNextAvailableAddressResponse, IGetUtxosResponse, IHeader, IKeyDerivationPath, InputData, IOnchainFees, IPrivateKeyInfo, IRbfData, ISendTransaction, ISendTx, ISetupTransaction, ISweepPrivateKey, ISweepPrivateKeyRes, ITransaction, ITxHash, IUtxo, IWallet, IWalletData, Net, TAddressIndexInfo, TGapLimitOptions, TGetTotalFeeObj, Tls, TOnMessage, TServer, TSetupTransactionResponse, TTxDetails, TTxResult, TWalletDataKeys } from '../types';
+import { EAddressType, EAvailableNetworks, EBoostType, ECoinSelectPreference, EFeeId, EScanningStrategy, IAddress, IBalanceBreakdown, IBoostedTransaction, IBoostedTransactions, IBuildPsbtArgs, IBuildPsbtResponse, IImportSignedPsbtResponse, ICanBoostResponse, IExportDescriptorsResponse, IFormattedTransaction, IFormattedTransactions, IGenerateAddresses, IGenerateAddressesResponse, IGetAddress, IGetAddressBalanceRes, IGetAddressByPath, IGetAddressesFromPrivateKey, IGetAddressResponse, IGetNextAvailableAddressResponse, IGetUtxosResponse, IHeader, IKeyDerivationPath, IMultisigWallet, InputData, IOnchainFees, IPrivateKeyInfo, IRbfData, ISendTransaction, ISendTx, ISetupTransaction, ISweepPrivateKey, ISweepPrivateKeyRes, ITransaction, ITxHash, IUtxo, IWallet, IWalletData, IWatchOnlyWallet, Net, TAddressIndexInfo, TAddressLabels, TFeeEstimationSource, TGapLimitOptions, TGetTotalFeeObj, Tls, TOnMessage, TServer, TSetupTransactionResponse, TTxDetails, TTxResult, TWalletDataKeys } from '../types';
 import { Result } from '../utils';
 import { Electrum } from '../electrum';
 import { Transaction } from '../transaction';
 export declare class Wallet {
     private _network;
-    private readonly _mnemonic;
+    private readonly _mnemonic?;
     private readonly _passphrase;
-    private readonly _seed;
-    private readonly _root;
+    private readonly _seed?;
+    private readonly _root?;
+    private readonly _accountNode?;
+    private readonly _multisig?;
     private _data;
     private _getData;
     private _setData?;
@@ -16,8 +19,11 @@ export declare class Wallet {
     private _customGetScriptHash?;
     private _pendingRefreshPromises;
     private _disableMessagesOnCreate;
+    private readonly _account;
+    private readonly _birthdayHeightOption?;
     addressTypesToMonitor: EAddressType[];
     coinSelectPreference: ECoinSelectPreference;
+    readonly isWatchOnly: boolean;
     isRefreshing: boolean;
     isSwitchingNetworks: boolean;
     readonly id: string;
@@ -36,6 +42,7 @@ export declare class Wallet {
     feeEstimates: IOnchainFees;
     rbf: boolean;
     selectedFeeId: EFeeId;
+    feeEstimationSource: TFeeEstimationSource;
     disableMessages: boolean;
     gapLimitOptions: TGapLimitOptions;
     private constructor();
@@ -45,7 +52,28 @@ export declare class Wallet {
     get utxos(): IUtxo[];
     get balance(): number;
     get network(): EAvailableNetworks;
+    get account(): number;
+    get birthdayHeight(): number;
+    get isMultisig(): boolean;
+    get multisigInfo(): {
+        threshold: number;
+        totalCosigners: number;
+    } | undefined;
     static create(params: IWallet): Promise<Result<Wallet>>;
+    static createWatchOnly(params: IWatchOnlyWallet): Promise<Result<Wallet>>;
+    static createMultisig(params: IMultisigWallet): Promise<Result<Wallet>>;
+    private _initMultisig;
+    getMultisigPayment(path: string): Result<{
+        address: string;
+        output: Buffer;
+        witnessScript: Buffer;
+        publicKey: string;
+        derivations: {
+            masterFingerprint: Buffer;
+            path: string;
+            pubkey: Buffer;
+        }[];
+    }>;
     stop(): Promise<Result<string>>;
     updateCoinSelectPreference(coinSelectPreference: ECoinSelectPreference): void;
     switchNetwork(network: EAvailableNetworks, servers?: TServer | TServer[]): Promise<Result<Wallet>>;
@@ -60,9 +88,14 @@ export declare class Wallet {
     private setWalletData;
     private storageIdCheck;
     getWalletDataKey(key: keyof IWalletData): string;
+    private _applyBirthdayHeightOption;
     getWalletData(): Promise<Result<IWalletData>>;
     private getBitcoinNetwork;
     isValid(mnemonic: any): boolean;
+    private _derivePathKeyPair;
+    private _deriveWatchOnlyNode;
+    derivePublicNode(path: string): Result<BIP32Interface>;
+    getMasterFingerprint(): Buffer;
     private _getAddress;
     getAddress({ index, changeAddress, addressType }?: IGetAddress): Promise<string>;
     getAddressByPath({ path, addressType }: IGetAddressByPath): Promise<Result<IGetAddressResponse>>;
@@ -108,6 +141,22 @@ export declare class Wallet {
         additionalAddresses?: string[];
     }): Promise<Result<IGetUtxosResponse>>;
     listUtxos(): IUtxo[];
+    isUtxoFrozen(txid: string, index: number): boolean;
+    freezeUtxo({ txid, index }: {
+        txid: string;
+        index: number;
+    }): Promise<Result<string>>;
+    unfreezeUtxo({ txid, index }: {
+        txid: string;
+        index: number;
+    }): Promise<Result<string>>;
+    listFrozenUtxos(): IUtxo[];
+    getBalanceBreakdown(): IBalanceBreakdown;
+    setAddressLabel(address: string, label: string): Promise<Result<string>>;
+    getAddressLabel(address: string): string | undefined;
+    listAddressLabels(): TAddressLabels;
+    exportDescriptors(): Result<IExportDescriptorsResponse>;
+    private _toStandardBase58;
     private savingOperations;
     saveWalletData<K extends keyof IWalletData>(key: TWalletDataKeys, data: IWalletData[K]): Promise<string>;
     private updateAndSaveWalletData;
@@ -151,6 +200,8 @@ export declare class Wallet {
     validateAddress(address: string): boolean;
     getChangeAddress(addressType?: EAddressType): Promise<Result<IAddress>>;
     getFeeEstimates(network?: EAvailableNetworks): Promise<IOnchainFees>;
+    getFeeEstimatesFromElectrum(): Promise<Result<IOnchainFees>>;
+    getFeeEstimatesFromHttp(network?: EAvailableNetworks): Promise<IOnchainFees>;
     getFallbackFeeEstimates(network?: EAvailableNetworks): Promise<IOnchainFees>;
     setupTransaction(params?: ISetupTransaction): Promise<TSetupTransactionResponse>;
     getFeeInfo({ satsPerByte, message, transaction, fundingLightning, coinSelectPreference }?: {
@@ -182,6 +233,12 @@ export declare class Wallet {
         broadcast?: boolean;
         shuffleOutputs?: boolean;
     }): Promise<Result<string>>;
+    buildPsbt({ txs, address, amount, message, satsPerByte, rbf, shuffleOutputs }: IBuildPsbtArgs): Promise<Result<IBuildPsbtResponse>>;
+    importSignedPsbt(psbtBase64: string): Result<IImportSignedPsbtResponse>;
+    private _enforceMultisigThreshold;
+    signPsbtWithOurKey(psbtBase64: string): Result<string>;
+    combinePsbts(psbts: string[]): Result<string>;
+    broadcastTransaction(txHex: string): Promise<Result<string>>;
     getAddressFromScriptHash(scriptHash: string): IAddress | undefined;
     private setZeroIndexAddresses;
     private updateAddressIndex;

package/dist/types/wallet.js

@@ -10,6 +10,8 @@ var EAvailableNetworks;
     EAvailableNetworks["bitcoinTestnet"] = "testnet";
     EAvailableNetworks["regtest"] = "regtest";
     EAvailableNetworks["bitcoinRegtest"] = "regtest";
+    EAvailableNetworks["signet"] = "signet";
+    EAvailableNetworks["bitcoinSignet"] = "signet";
 })(EAvailableNetworks = exports.EAvailableNetworks || (exports.EAvailableNetworks = {}));
 var EAddressType;
 (function (EAddressType) {
@@ -17,6 +19,7 @@ var EAddressType;
     EAddressType["p2sh"] = "p2sh";
     EAddressType["p2pkh"] = "p2pkh";
     EAddressType["p2tr"] = "p2tr";
+    EAddressType["p2wsh"] = "p2wsh";
 })(EAddressType = exports.EAddressType || (exports.EAddressType = {}));
 var EPaymentType;
 (function (EPaymentType) {