@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/src/swaps/tobtcln_abstract/ToBtcLnSwapAbs.ts

@@ -1,5 +1,4 @@
 import * as BN from "bn.js";
-import * as bolt11 from "@atomiqlabs/bolt11";
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "../..";
 import {deserializeBN, serializeBN} from "../../utils/Utils";
@@ -18,31 +17,28 @@ export enum ToBtcLnSwapState {
 export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
 
     readonly pr: string;
-    readonly signatureExpiry: BN;
 
     secret: string;
 
     constructor(
         chainIdentifier: string,
         pr: string,
+        amountMtokens: BN,
         swapFee: BN,
         swapFeeInToken: BN,
         quotedNetworkFee: BN,
         quotedNetworkFeeInToken: BN,
-        signatureExpiry: BN
     );
     constructor(obj: any);
 
-    constructor(chainIdOrObj: string | any, pr?: string, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN, signatureExpiry?: BN) {
+    constructor(chainIdOrObj: string | any, pr?: string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN) {
         if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
+            super(chainIdOrObj, amount.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
             this.state = ToBtcLnSwapState.SAVED;
             this.pr = pr;
-            this.signatureExpiry = signatureExpiry;
         } else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
-            this.signatureExpiry = deserializeBN(chainIdOrObj.signatureExpiry);
             this.secret = chainIdOrObj.secret;
 
             //Compatibility with older versions
@@ -55,19 +51,10 @@ export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap
     serialize(): any {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
-        partialSerialized.signatureExpiry = serializeBN(this.signatureExpiry);
         partialSerialized.secret = this.secret;
         return partialSerialized;
     }
 
-    getHash(): string {
-        return bolt11.decode(this.pr).tagsObject.payment_hash;
-    }
-
-    getHashBuffer(): Buffer {
-        return Buffer.from(bolt11.decode(this.pr).tagsObject.payment_hash, "hex");
-    }
-
     isInitiated(): boolean {
         return this.state!==ToBtcLnSwapState.SAVED;
     }
@@ -80,8 +67,4 @@ export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap
         return this.state===ToBtcLnSwapState.CLAIMED;
     }
 
-    getOutputAmount(): BN {
-        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
-    }
-
 }

package/src/utils/Utils.ts

@@ -68,22 +68,6 @@ export function getLogger(prefix: string) {
 
 export const HEX_REGEX = /[0-9a-fA-F]+/;
 
-export function shuffle(array: any[]) {
-    let currentIndex = array.length;
-
-    // While there remain elements to shuffle...
-    while (currentIndex != 0) {
-
-        // Pick a remaining element...
-        let randomIndex = Math.floor(Math.random() * currentIndex);
-        currentIndex--;
-
-        // And swap it with the current element.
-        [array[currentIndex], array[randomIndex]] = [
-            array[randomIndex], array[currentIndex]];
-    }
-}
-
 export function serializeBN(bn: BN | null): string | null {
     return bn==null ? null : bn.toString(10);
 }
@@ -91,18 +75,3 @@ export function serializeBN(bn: BN | null): string | null {
 export function deserializeBN(str: string | null): BN | null {
     return str==null ? null : new BN(str);
 }
-
-/**
- * Handles & throws LND error if the error is:
- *  - network error
- *  - server side (LND) internal error
- *  - malformed input data error
- *
- * @param e
- */
-export function handleLndError(e: any) {
-    if(!Array.isArray(e)) throw e; //Throw errors that are not originating from the SDK
-    if(typeof(e[0])!=="number") throw e; //Throw errors that don't have proper format
-    if(e[0]>=500 && e[0]<600) throw e; //Throw server errors 5xx
-    if(e[0]===400) throw e; //Throw malformed request data errors
-}

package/src/wallets/IBitcoinWallet.ts

@@ -0,0 +1,66 @@
+import BN from "bn.js";
+import {Psbt, Transaction} from "bitcoinjs-lib";
+import {BtcTx} from "@atomiqlabs/base";
+import {Command} from "@atomiqlabs/server-base";
+
+export type BitcoinUtxo = {
+    address: string,
+    type: "p2wpkh" | "p2sh-p2wpkh" | "p2tr",
+    confirmations: number,
+    outputScript: Buffer,
+    value: number,
+    txId: string,
+    vout: number
+};
+
+export type SignPsbtResponse = {
+    psbt: Psbt,
+    tx: Transaction,
+    raw: string,
+    txId: string,
+    networkFee: number
+};
+
+export interface IBitcoinWallet {
+
+    init(): Promise<void>;
+
+    isReady(): boolean;
+    getStatus(): string;
+    getStatusInfo(): Promise<Record<string, string>>;
+    getCommands(): Command<any>[];
+
+    toOutputScript(address: string): Buffer;
+
+    getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
+    /**
+     * Returns an unused address suitable for receiving
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Adds previously returned address (with getAddress call), to the pool of unused addresses
+     * @param address
+     */
+    addUnusedAddress(address: string): Promise<void>;
+
+    getUtxos(): Promise<BitcoinUtxo[]>;
+    getBalance(): Promise<{confirmed: number, unconfirmed: number}>;
+    /**
+     * Returns required reserve amount that needs to be kept in the wallet (for e.g. lightning anchor channels)
+     */
+    getRequiredReserve(): Promise<number>;
+    getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
+    getWalletTransaction(txId: string): Promise<BtcTx | null>;
+    subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
+
+    signPsbt(psbt: Psbt): Promise<SignPsbtResponse>;
+    sendRawTransaction(tx: string): Promise<void>;
+    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: BN, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{satsPerVbyte: number, networkFee: number}>;
+    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
+    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
+
+    getBlockheight(): Promise<number>;
+    getFeeRate(): Promise<number>;
+
+}

package/src/wallets/ILightningWallet.ts

@@ -0,0 +1,179 @@
+import * as BN from "bn.js";
+import {Command} from "@atomiqlabs/server-base";
+
+export type IncomingLightningNetworkPayment = {
+    createdAt: number,
+    confirmedAt: number,
+
+    createdHeight: number,
+    timeout: number,
+
+    status: "held" | "canceled" | "confirmed"
+
+    mtokens: BN
+}
+
+export type LightningNetworkInvoice = {
+    id: string,
+    request: string,
+    secret?: string,
+
+    cltvDelta: number,
+    mtokens: BN,
+
+    createdAt: number,
+    expiresAt: number,
+
+    description: string,
+    descriptionHash?: string,
+
+    payments: IncomingLightningNetworkPayment[],
+
+    status: "unpaid" | "held" | "canceled" | "confirmed"
+};
+
+export type OutgoingLightningNetworkPayment = {
+    failedReason?: "insufficient_balance" | "invalid_payment" | "pathfinding_timeout" | "route_not_found",
+    status: "confirmed" | "failed" | "pending",
+    secret?: string,
+    feeMtokens?: BN
+};
+
+export type LightningNetworkChannel = {
+    id: string,
+    capacity: BN,
+    isActive: boolean,
+
+    localBalance: BN,
+    localReserve: BN,
+    remoteBalance: BN,
+    remoteReserve: BN,
+    unsettledBalance: BN,
+    transactionId: string,
+    transactionVout: number
+};
+
+export type InvoiceInit = {
+    mtokens: BN,
+    descriptionHash?: string
+    description?: string,
+    cltvDelta?: number,
+    expiresAt?: number,
+};
+
+export type HodlInvoiceInit = {
+    description: string,
+    cltvDelta: number,
+    expiresAt: number,
+    id: string,
+    mtokens: BN,
+    descriptionHash?: string
+};
+
+export type LNRoutes = {
+    publicKey: string,
+    feeRate?: number,
+    cltvDelta?: number,
+    channel?: string,
+    baseFeeMtokens?: BN
+}[][];
+
+export type ParsedPaymentRequest = {
+    id: string,
+    mtokens: BN,
+    expiryEpochMillis: number,
+    destination: string,
+    cltvDelta: number,
+    description: string,
+    routes: LNRoutes
+};
+
+export type LightningPaymentInit = {
+    request: string,
+    maxFeeMtokens?: BN,
+    maxTimeoutHeight?: number
+};
+
+export type LightningBalanceResponse = {
+    localBalance: BN,
+    remoteBalance: BN,
+    unsettledBalance: BN
+};
+
+export type ProbeAndRouteInit = {
+    request: string,
+    amountMtokens: BN,
+    maxFeeMtokens: BN,
+    maxTimeoutHeight: number
+}
+
+export type ProbeAndRouteResponse = {
+    confidence: number,
+    feeMtokens: BN,
+    destination: string,
+    privateRoutes: LNRoutes
+}
+
+export function routesMatch(routesA: LNRoutes, routesB: LNRoutes) {
+    if(routesA===routesB) return true;
+    if(routesA==null || routesB==null) {
+        return false;
+    }
+    if(routesA.length!==routesB.length) return false;
+    for(let i=0;i<routesA.length;i++) {
+        if(routesA[i]===routesB[i]) continue;
+        if(routesA[i]==null || routesB[i]==null) {
+            return false;
+        }
+        if(routesA[i].length!==routesB[i].length) return false;
+        for(let e=0;e<routesA[i].length;e++) {
+            if(routesA[i][e]===routesB[i][e]) continue;
+            if(routesA[i][e]==null || routesB[i][e]==null) {
+                return false;
+            }
+            if(
+                routesA[i][e].publicKey!==routesB[i][e].publicKey ||
+                !routesA[i][e].baseFeeMtokens.eq(routesB[i][e].baseFeeMtokens) ||
+                routesA[i][e].channel!==routesB[i][e].channel ||
+                routesA[i][e].cltvDelta!==routesB[i][e].cltvDelta ||
+                routesA[i][e].feeRate!==routesB[i][e].feeRate
+            ) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+export interface ILightningWallet {
+
+    init(): Promise<void>;
+
+    isReady(): boolean;
+    getStatus(): string;
+    getStatusInfo(): Promise<Record<string, string>>;
+    getCommands(): Command<any>[];
+
+    createInvoice(init: InvoiceInit): Promise<LightningNetworkInvoice>;
+    createHodlInvoice(init: HodlInvoiceInit): Promise<LightningNetworkInvoice>;
+    getInvoice(paymentHash: string): Promise<LightningNetworkInvoice | null>;
+    cancelHodlInvoice(paymentHash: string): Promise<void>;
+    settleHodlInvoice(secret: string): Promise<void>;
+    waitForInvoice(paymentHash: string, abortSignal?: AbortSignal): Promise<LightningNetworkInvoice>;
+
+    pay(init: LightningPaymentInit): Promise<void>;
+    getPayment(paymentHash: string): Promise<OutgoingLightningNetworkPayment | null>
+    waitForPayment(paymentHash: string, abortSignal?: AbortSignal): Promise<OutgoingLightningNetworkPayment>;
+    probe(init: ProbeAndRouteInit): Promise<ProbeAndRouteResponse | null>;
+    route(init: ProbeAndRouteInit): Promise<ProbeAndRouteResponse | null>;
+
+    parsePaymentRequest(request: string): Promise<ParsedPaymentRequest>;
+
+    getBlockheight(): Promise<number>;
+    getChannels(activeOnly?: boolean): Promise<LightningNetworkChannel[]>;
+    getLightningBalance(): Promise<LightningBalanceResponse>;
+
+    getIdentityPublicKey(): Promise<string>;
+
+}

package/dist/fees/OneDollarFeeEstimator.d.ts

@@ -1,16 +0,0 @@
-import { IBtcFeeEstimator } from "./IBtcFeeEstimator";
-export declare class OneDollarFeeEstimator implements IBtcFeeEstimator {
-    estimator: any;
-    receivedFee: [number, number, number, number];
-    iterations: number;
-    host: string;
-    port: number;
-    username: string;
-    password: string;
-    addFee: number;
-    feeMultiplier: number;
-    startFeeEstimator(): void;
-    constructor(host: string, port: number, username: string, password: string, addFee?: number, feeMultiplier?: number);
-    getFee(): number;
-    estimateFee(): Promise<number | null>;
-}

package/dist/fees/OneDollarFeeEstimator.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneDollarFeeEstimator = void 0;
-const Utils_1 = require("../utils/Utils");
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-const importPromise = dynamicImport('one-dollar-fee-estimator-failover');
-const logger = (0, Utils_1.getLogger)("OneDollarFeeEstimator: ");
-class OneDollarFeeEstimator {
-    startFeeEstimator() {
-        logger.info("startFeeEstimator(): starting fee estimator worker");
-        importPromise.then(({ FeeEstimator }) => {
-            this.estimator = new FeeEstimator({
-                mode: 'bundles',
-                refresh: 30,
-                rpcOptions: {
-                    host: this.host,
-                    port: this.port,
-                    username: this.username,
-                    password: this.password
-                }
-            });
-            this.estimator.on('error', (err) => {
-                logger.error("on(error): fee estimator error", err);
-                if (err.message.startsWith("FeeEstimator worker stopped")) {
-                    logger.info("on(error): restarting fee estimator worker");
-                    this.receivedFee = null;
-                    this.iterations = 0;
-                    this.startFeeEstimator();
-                }
-            });
-            // receive live fee rate updates from the FeeEstimator
-            this.estimator.on('fees', (fees) => {
-                this.receivedFee = fees;
-                this.iterations++;
-            });
-        });
-    }
-    constructor(host, port, username, password, addFee, feeMultiplier) {
-        this.iterations = 0;
-        this.host = host;
-        this.port = port;
-        this.username = username;
-        this.password = password;
-        this.addFee = addFee;
-        this.feeMultiplier = feeMultiplier;
-        this.startFeeEstimator();
-        process.on('exit', () => {
-            logger.info("process(exit): process exiting, stopping estimator");
-            if (this.estimator != null)
-                this.estimator.stop();
-        });
-        process.on('SIGINT', () => {
-            logger.info("process(SIGINT): process exiting, stopping estimator");
-            if (this.estimator != null)
-                this.estimator.stop();
-            process.exit();
-        });
-    }
-    getFee() {
-        let fee = this.receivedFee[3];
-        if (this.feeMultiplier != null)
-            fee *= this.feeMultiplier;
-        if (this.addFee != null)
-            fee += this.addFee;
-        return fee;
-    }
-    estimateFee() {
-        return Promise.resolve(this.iterations <= 1 ? null : this.getFee());
-    }
-}
-exports.OneDollarFeeEstimator = OneDollarFeeEstimator;

package/dist/utils/coinselect2/accumulative.d.ts

@@ -1,6 +0,0 @@
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
-export declare function accumulative(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    fee: number;
-};

package/dist/utils/coinselect2/accumulative.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accumulative = void 0;
-const utils_1 = require("./utils");
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-function accumulative(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
-        return null;
-    let bytesAccum = utils_1.utils.transactionBytes([], outputs, type);
-    let inAccum = 0;
-    const inputs = [];
-    if (requiredInputs != null)
-        for (let utxo of requiredInputs) {
-            const { length: utxoBytes } = utils_1.utils.inputBytes(utxo);
-            const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
-            bytesAccum += utxoBytes;
-            inAccum += utxoValue;
-            inputs.push(utxo);
-        }
-    const outAccum = utils_1.utils.sumOrNaN(outputs);
-    for (let i = 0; i < utxos.length; ++i) {
-        const utxo = utxos[i];
-        const { length: utxoBytes } = utils_1.utils.inputBytes(utxo);
-        const utxoFee = feeRate * utxoBytes;
-        const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
-        // skip detrimental input
-        if (utxoFee > utxo.value) {
-            if (i === utxos.length - 1)
-                return { fee: feeRate * (bytesAccum + utxoBytes) };
-            continue;
-        }
-        bytesAccum += utxoBytes;
-        inAccum += utxoValue;
-        inputs.push(utxo);
-        const fee = feeRate * bytesAccum;
-        // go again?
-        if (inAccum < outAccum + fee)
-            continue;
-        return utils_1.utils.finalize(inputs, outputs, feeRate, type);
-    }
-    return { fee: feeRate * bytesAccum };
-}
-exports.accumulative = accumulative;

package/dist/utils/coinselect2/blackjack.d.ts

@@ -1,6 +0,0 @@
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
-export declare function blackjack(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    fee: number;
-};

package/dist/utils/coinselect2/blackjack.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blackjack = void 0;
-const utils_1 = require("./utils");
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-function blackjack(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
-        return null;
-    let bytesAccum = utils_1.utils.transactionBytes([], outputs, type);
-    let inAccum = 0;
-    const inputs = [];
-    if (requiredInputs != null)
-        for (let utxo of requiredInputs) {
-            const { length: utxoBytes } = utils_1.utils.inputBytes(utxo);
-            const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
-            bytesAccum += utxoBytes;
-            inAccum += utxoValue;
-            inputs.push(utxo);
-        }
-    const outAccum = utils_1.utils.sumOrNaN(outputs);
-    const threshold = utils_1.utils.dustThreshold({ type });
-    for (let i = 0; i < utxos.length; ++i) {
-        const input = utxos[i];
-        const { length: inputBytes } = utils_1.utils.inputBytes(input);
-        const fee = feeRate * (bytesAccum + inputBytes);
-        const inputValue = utils_1.utils.uintOrNaN(input.value);
-        // would it waste value?
-        if ((inAccum + inputValue) > (outAccum + fee + threshold))
-            continue;
-        bytesAccum += inputBytes;
-        inAccum += inputValue;
-        inputs.push(input);
-        // go again?
-        if (inAccum < outAccum + fee)
-            continue;
-        return utils_1.utils.finalize(inputs, outputs, feeRate, type);
-    }
-    return { fee: feeRate * bytesAccum };
-}
-exports.blackjack = blackjack;

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

@@ -1,16 +0,0 @@
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
-/**
- * Runs a coinselection algorithm on given inputs, outputs and fee rate
- *
- * @param utxos Utxo pool to select additional inputs from
- * @param outputs Outputs of the transaction
- * @param feeRate Feerate in sats/vB
- * @param changeType Change address type
- * @param requiredInputs Utxos that need to be included as inputs to the transaction
- * @param randomize Randomize the UTXO order before running the coinselection algorithm
- */
-export declare function coinSelect(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[], randomize?: boolean): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    fee: number;
-};

package/dist/utils/coinselect2/index.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.coinSelect = void 0;
-const accumulative_1 = require("./accumulative");
-const blackjack_1 = require("./blackjack");
-const utils_1 = require("./utils");
-const BN = require("bn.js");
-const Utils_1 = require("../Utils");
-// order by descending value, minus the inputs approximate fee
-function utxoScore(x, feeRate) {
-    return x.value - (feeRate * utils_1.utils.inputBytes(x).length);
-}
-function utxoFeePPM(utxo, feeRate) {
-    return new BN(utxo.value).mul(new BN(1000000)).div(new BN(Math.ceil(feeRate * utils_1.utils.inputBytes(utxo).length))).toNumber();
-}
-/**
- * Runs a coinselection algorithm on given inputs, outputs and fee rate
- *
- * @param utxos Utxo pool to select additional inputs from
- * @param outputs Outputs of the transaction
- * @param feeRate Feerate in sats/vB
- * @param changeType Change address type
- * @param requiredInputs Utxos that need to be included as inputs to the transaction
- * @param randomize Randomize the UTXO order before running the coinselection algorithm
- */
-function coinSelect(utxos, outputs, feeRate, changeType, requiredInputs, randomize) {
-    if (randomize) {
-        (0, Utils_1.shuffle)(utxos);
-    }
-    else {
-        utxos.sort((a, b) => utxoScore(b, feeRate) - utxoScore(a, feeRate));
-    }
-    // attempt to use the blackjack strategy first (no change output)
-    let base = (0, blackjack_1.blackjack)(utxos, outputs, feeRate, changeType, requiredInputs);
-    if (base.inputs)
-        return base;
-    // else, try the accumulative strategy
-    return (0, accumulative_1.accumulative)(utxos, outputs, feeRate, changeType, requiredInputs);
-}
-exports.coinSelect = coinSelect;

package/dist/utils/coinselect2/utils.d.ts

@@ -1,64 +0,0 @@
-/// <reference types="node" />
-export type CoinselectAddressTypes = "p2sh-p2wpkh" | "p2wpkh" | "p2wsh" | "p2tr" | "p2pkh";
-export type CoinselectTxInput = {
-    script?: Buffer;
-    witness?: Buffer;
-    txId: string;
-    vout: number;
-    type?: CoinselectAddressTypes;
-    value: number;
-    outputScript?: Buffer;
-    address?: string;
-};
-export type CoinselectTxOutput = {
-    script?: Buffer;
-    address?: string;
-    type?: CoinselectAddressTypes;
-    value: number;
-};
-declare function inputBytes(input: {
-    script?: Buffer;
-    witness?: Buffer;
-    type?: CoinselectAddressTypes;
-}): {
-    length: number;
-    isWitness: boolean;
-};
-declare function outputBytes(output: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}): number;
-declare function dustThreshold(output: {
-    script?: Buffer;
-    type: CoinselectAddressTypes;
-}): number;
-declare function transactionBytes(inputs: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}[], outputs: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}[], changeType: CoinselectAddressTypes): number;
-declare function uintOrNaN(v: number): number;
-declare function sumForgiving(range: {
-    value: number;
-}[]): number;
-declare function sumOrNaN(range: {
-    value: number;
-}[]): number;
-declare function finalize(inputs: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    fee: number;
-};
-export declare const utils: {
-    dustThreshold: typeof dustThreshold;
-    finalize: typeof finalize;
-    inputBytes: typeof inputBytes;
-    outputBytes: typeof outputBytes;
-    sumOrNaN: typeof sumOrNaN;
-    sumForgiving: typeof sumForgiving;
-    transactionBytes: typeof transactionBytes;
-    uintOrNaN: typeof uintOrNaN;
-};
-export {};