beignet 0.2.0 → 0.4.0

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

@@ -3,6 +3,7 @@ import { IChannelState } from '../channel/channel-state';
 import { IPaymentInfo } from '../node/types';
 import { IChainMonitorState } from '../chain/chain-monitor';
 import { IGraphChannel, IGraphNode } from '../gossip/types';
+import { IWatchtowerSession, IWatchtowerUpdate } from '../watchtower/types';
 export interface IStorageBackend {
     open(): void;
     close(): void;
@@ -84,6 +85,8 @@ export interface IStorageBackend {
     loadNextChannelIndex(): number;
     saveMetadata(key: string, value: string): void;
     loadMetadata(key: string): string | null;
+    saveWalletData?(key: string, value: string): void;
+    loadWalletData?(key: string): string | null;
     transaction<T>(fn: () => T): T;
     checkpoint?(): void;
     saveHtlcSharedSecret(key: string, secret: Buffer): void;
@@ -93,6 +96,23 @@ export interface IStorageBackend {
         secret: Buffer;
     }>;
     deleteGossipChannel?(scidHex: string): void;
+    saveChannelPolicy?(channelId: string, policy: IPersistedChannelPolicy): void;
+    loadAllChannelPolicies?(): Array<{
+        channelId: string;
+        policy: IPersistedChannelPolicy;
+    }>;
+    deleteChannelPolicy?(channelId: string): void;
+    savePeerStorageBlob?(peerPubkey: string, blob: Buffer, receivedAt: number): void;
+    loadPeerStorageBlob?(peerPubkey: string): {
+        blob: Buffer;
+        receivedAt: number;
+    } | null;
+    deletePeerStorageBlob?(peerPubkey: string): void;
+    saveForwardingEvent?(event: Omit<IForwardingEvent, 'id'>): void;
+    listForwardingEvents?(filter?: IForwardingEventFilter): IForwardingEvent[];
+    getForwardingSummary?(options?: {
+        since?: number;
+    }): IForwardingSummary;
     saveActionLog?(entry: {
         category: string;
         action: string;
@@ -109,6 +129,47 @@ export interface IStorageBackend {
         timestamp: number;
         data: string;
     }>;
+    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 IPersistedChannelPolicy {
+    feeBaseMsat?: number;
+    feeProportionalMillionths?: number;
+    cltvExpiryDelta?: number;
+    htlcMinimumMsat?: string;
+    htlcMaximumMsat?: string;
+}
+export interface IForwardingEvent {
+    id: number;
+    settledAt: number;
+    inChannelId: string;
+    outChannelId: string;
+    inScid?: string;
+    outScid?: string;
+    amountInMsat: bigint;
+    amountOutMsat: bigint;
+    feeMsat: bigint;
+}
+export interface IForwardingEventFilter {
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+    channelId?: string;
+}
+export interface IForwardingSummary {
+    count: number;
+    volumeOutMsat: bigint;
+    feesEarnedMsat: bigint;
 }
 export interface IInvoiceInfo {
     paymentHash: string;
@@ -118,4 +179,5 @@ export interface IInvoiceInfo {
     expiry: number;
     createdAt: number;
     hold?: boolean;
+    cancelledAt?: number;
 }

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

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+export declare enum BlobFlag {
+    REWARD = 1,
+    COMMIT_OUTPUTS = 2,
+    ANCHOR_CHANNEL = 4,
+    TAPROOT_CHANNEL = 8
+}
+export declare enum BlobType {
+    ALTRUIST_COMMIT = 2,
+    ALTRUIST_ANCHOR_COMMIT = 6,
+    ALTRUIST_TAPROOT_COMMIT = 10
+}
+export declare const BREACH_HINT_SIZE = 16;
+export declare const NONCE_SIZE = 24;
+export declare const CIPHERTEXT_EXPANSION = 16;
+export declare const MAX_SWEEP_ADDR_SIZE = 42;
+export declare const V0_PLAINTEXT_SIZE = 274;
+export declare const V1_PLAINTEXT_SIZE = 300;
+export declare function breachHintFromTxid(txidInternal: Buffer): Buffer;
+export declare function breachKeyFromTxid(txidInternal: Buffer): Buffer;
+export interface IJusticeKitV0 {
+    sweepAddress: Buffer;
+    revocationPubKey: Buffer;
+    localDelayPubKey: Buffer;
+    csvDelay: number;
+    commitToLocalSig: Buffer;
+    commitToRemotePubKey?: Buffer;
+    commitToRemoteSig?: Buffer;
+}
+export declare function encodeJusticeKitV0(kit: IJusticeKitV0): Buffer;
+export declare function decodeJusticeKitV0(pt: Buffer): IJusticeKitV0;
+export interface IJusticeKitV1 {
+    sweepAddress: Buffer;
+    revocationPubKey: Buffer;
+    localDelayPubKey: Buffer;
+    commitToLocalSig: Buffer;
+    delayScriptHash: Buffer;
+    commitToRemotePubKey?: Buffer;
+    commitToRemoteSig?: Buffer;
+}
+export declare function encodeJusticeKitV1(kit: IJusticeKitV1): Buffer;
+export declare function decodeJusticeKitV1(pt: Buffer): IJusticeKitV1;
+export declare function encryptJusticeKitV0(kit: IJusticeKitV0, key: Buffer): Buffer;
+export declare function decryptJusticeKitV0(blob: Buffer, key: Buffer): IJusticeKitV0;
+export declare function encryptJusticeKitV1(kit: IJusticeKitV1, key: Buffer): Buffer;
+export declare function decryptJusticeKitV1(blob: Buffer, key: Buffer): IJusticeKitV1;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export * from './types';
+export * from './wtwire';
+export * from './blob';
+export * from './justice';
+export { TowerConnection, parseTowerUri } from './tower-connection';
+export { WatchtowerClient, IWatchtowerClientOptions, IWatchtowerStore } from './watchtower-client';
+import * as bitcoin from 'bitcoinjs-lib';
+export declare function chainHashForNetwork(network: bitcoin.Network): Buffer;

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import * as bitcoin from 'bitcoinjs-lib';
+import { BlobType } from './blob';
+export interface IJusticeContext {
+    channelId: string;
+    revokedTx: bitcoin.Transaction;
+    perCommitmentSecret: Buffer;
+    revocationBasepoint: Buffer;
+    revocationBasepointSecret: Buffer;
+    remoteDelayedBasepoint: Buffer;
+    toSelfDelay: number;
+    isAnchor: boolean;
+    isTaproot?: boolean;
+    localPaymentPubkey?: Buffer;
+    paymentBasepointSecret?: Buffer;
+    sweepScript: Buffer;
+    network: bitcoin.Network;
+}
+export interface ISessionPolicy {
+    blobType: number;
+    sweepFeeRate: bigint;
+}
+export interface IJusticeBackup {
+    hint: Buffer;
+    encryptedBlob: Buffer;
+    revokedTxid: Buffer;
+    sweptSats: bigint;
+}
+export declare function buildJusticeBackup(ctx: IJusticeContext, policy: ISessionPolicy): IJusticeBackup;
+export declare function blobTypeForChannel(isAnchor: boolean, isTaproot?: boolean): BlobType;

package/dist/types/lightning/watchtower/tower-connection.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ITowerAddress, ITowerTransport } from './types';
+export interface ITowerConnectionOptions {
+    localPrivateKey: Buffer;
+    address: ITowerAddress;
+    connectTimeoutMs?: number;
+    socks5Proxy?: {
+        host: string;
+        port: number;
+    };
+}
+export declare class TowerConnection extends EventEmitter implements ITowerTransport {
+    private readonly localPrivateKey;
+    private readonly address;
+    private readonly connectTimeoutMs;
+    private readonly socks5Proxy?;
+    private socket;
+    private transport;
+    private readBuffer;
+    private pendingBodyLength;
+    private connected;
+    constructor(opts: ITowerConnectionOptions);
+    isConnected(): boolean;
+    connect(): Promise<void>;
+    send(type: number, payload: Buffer): void;
+    close(): void;
+    private onData;
+    private processReadBuffer;
+    private openSocket;
+    private readExact;
+}
+export declare function parseTowerUri(uri: string): ITowerAddress;

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

@@ -0,0 +1,46 @@
+/// <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, transportKey?: Buffer) => ITowerTransport;
+export interface IWatchtowerSession {
+    towerUri: string;
+    towerPubkey: string;
+    sessionId: string;
+    blobType: number;
+    maxUpdates: number;
+    sweepFeeRate: string;
+    seqNum: number;
+    lastApplied: number;
+    createdAt: number;
+    dialsWithSessionKey?: boolean;
+}
+export interface IWatchtowerUpdate {
+    towerUri: string;
+    channelId: string;
+    blobType: number;
+    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,68 @@
+/// <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 ensureSlot;
+    private connectSlot;
+    private onConnected;
+    private onMessage;
+    private onClose;
+    private ensureSessionAndDrain;
+    private negotiateSession;
+    private drainSlot;
+    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/logger.d.ts

@@ -0,0 +1,17 @@
+export type TLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export interface ILogger {
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+}
+export declare const LOG_LEVEL_PRIORITY: Record<TLogLevel, number>;
+export declare function shouldLog(level: Exclude<TLogLevel, 'silent'>, threshold: TLogLevel): boolean;
+export interface IConsoleSink {
+    debug(message?: unknown, ...optionalParams: unknown[]): void;
+    info(message?: unknown, ...optionalParams: unknown[]): void;
+    warn(message?: unknown, ...optionalParams: unknown[]): void;
+    error(message?: unknown, ...optionalParams: unknown[]): void;
+}
+export declare function createConsoleLogger(level?: TLogLevel, sink?: IConsoleSink): ILogger;
+export declare const noopLogger: ILogger;

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,8 @@ 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';
+import { ILogger } from '../logger';
+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 +22,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 +152,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 +187,15 @@ export interface IWallet {
     customGetScriptHash?: (data: ICustomGetScriptHash) => Promise<string>;
     rbf?: boolean;
     selectedFeeId?: EFeeId;
+    feeEstimationSource?: TFeeEstimationSource;
     disableMessages?: boolean;
     disableMessagesOnCreate?: boolean;
+    logger?: ILogger;
     addressTypesToMonitor?: EAddressType[];
     gapLimitOptions?: TGapLimitOptions;
     addressLookBehind?: number;
     addressLookAhead?: number;
+    multisig?: IMultisigOptions;
 }
 export interface IAddressData {
     path: string;
@@ -376,6 +392,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 +517,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 }: {