@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/dist/swaps/frombtcln_trusted/FromBtcLnTrusted.js

@@ -12,8 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnTrusted = void 0;
 const BN = require("bn.js");
 const crypto_1 = require("crypto");
-const bolt11 = require("@atomiqlabs/bolt11");
-const lightning_1 = require("lightning");
 const FromBtcLnTrustedSwap_1 = require("./FromBtcLnTrustedSwap");
 const SwapHandler_1 = require("../SwapHandler");
 const Utils_1 = require("../../utils/Utils");
@@ -25,8 +23,8 @@ const ServerParamDecoder_1 = require("../../utils/paramcoders/server/ServerParam
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
 class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
-    constructor(storageDirectory, path, chains, lnd, swapPricing, config) {
-        super(storageDirectory, path, chains, lnd, swapPricing);
+    constructor(storageDirectory, path, chains, lightning, swapPricing, config) {
+        super(storageDirectory, path, chains, lightning, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_TRUSTED;
         this.activeSubscriptions = new Map();
         this.processedTxIds = new Map();
@@ -43,10 +41,10 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
      * @private
      */
     unsubscribeInvoice(paymentHash) {
-        const sub = this.activeSubscriptions.get(paymentHash);
-        if (sub == null)
+        const controller = this.activeSubscriptions.get(paymentHash);
+        if (controller == null)
             return false;
-        sub.removeAllListeners();
+        controller.abort("Unsubscribed");
         this.activeSubscriptions.delete(paymentHash);
         return true;
     }
@@ -58,19 +56,16 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
     subscribeToInvoice(invoiceData) {
         const hash = invoiceData.getHash();
         //Already subscribed
-        if (this.activeSubscriptions.has(invoiceData.getHash()))
+        if (this.activeSubscriptions.has(hash))
             return;
-        const sub = (0, lightning_1.subscribeToInvoice)({ id: hash, lnd: this.LND });
-        this.swapLogger.debug(invoiceData, "subscribeToInvoice(): Subscribed to invoice payment");
-        sub.on('invoice_updated', (invoice) => {
+        const abortController = new AbortController();
+        this.lightning.waitForInvoice(hash, abortController.signal).then(invoice => {
             this.swapLogger.debug(invoiceData, "subscribeToInvoice(): invoice_updated: ", invoice);
-            if (!invoice.is_held)
-                return;
             this.htlcReceived(invoiceData, invoice).catch(e => console.error(e));
-            sub.removeAllListeners();
             this.activeSubscriptions.delete(hash);
         });
-        this.activeSubscriptions.set(hash, sub);
+        this.swapLogger.debug(invoiceData, "subscribeToInvoice(): Subscribed to invoice payment");
+        this.activeSubscriptions.set(hash, abortController);
     }
     /**
      *
@@ -84,31 +79,29 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                 return true;
             if (swap.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.REFUNDED)
                 return true;
-            const parsedPR = bolt11.decode(swap.pr);
-            const invoice = yield (0, lightning_1.getInvoice)({
-                id: parsedPR.tagsObject.payment_hash,
-                lnd: this.LND
-            });
-            if (invoice.is_held) {
-                //Adjust the state of the swap and expiry
-                try {
-                    yield this.htlcReceived(swap, invoice);
-                    //Result is either FromBtcLnTrustedSwapState.RECEIVED or FromBtcLnTrustedSwapState.CANCELED
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            else if (!invoice.is_confirmed) {
-                //Not paid
-                const isInvoiceExpired = parsedPR.timeExpireDate < Date.now() / 1000;
-                if (isInvoiceExpired) {
-                    yield swap.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CANCELED);
-                    return true;
-                }
-                this.subscribeToInvoice(swap);
+            const parsedPR = yield this.lightning.parsePaymentRequest(swap.pr);
+            const invoice = yield this.lightning.getInvoice(parsedPR.id);
+            switch (invoice.status) {
+                case "held":
+                    try {
+                        yield this.htlcReceived(swap, invoice);
+                        //Result is either FromBtcLnTrustedSwapState.RECEIVED or FromBtcLnTrustedSwapState.CANCELED
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                    return false;
+                case "confirmed":
+                    return false;
+                default:
+                    const isInvoiceExpired = parsedPR.expiryEpochMillis < Date.now();
+                    if (isInvoiceExpired) {
+                        yield swap.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CANCELED);
+                        return true;
+                    }
+                    this.subscribeToInvoice(swap);
+                    return false;
             }
-            return false;
         });
     }
     cancelInvoices(swaps) {
@@ -117,10 +110,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                 //Cancel invoices
                 try {
                     const paymentHash = swap.getHash();
-                    yield (0, lightning_1.cancelHodlInvoice)({
-                        lnd: this.LND,
-                        id: paymentHash
-                    });
+                    yield this.lightning.cancelHodlInvoice(paymentHash);
                     this.unsubscribeInvoice(paymentHash);
                     this.swapLogger.info(swap, "cancelInvoices(): invoice cancelled!");
                     yield this.removeSwapData(swap);
@@ -163,10 +153,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                 return;
             yield swap.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CANCELED);
             const paymentHash = swap.getHash();
-            yield (0, lightning_1.cancelHodlInvoice)({
-                id: paymentHash,
-                lnd: this.LND
-            });
+            yield this.lightning.cancelHodlInvoice(paymentHash);
             this.unsubscribeInvoice(paymentHash);
             yield this.removeSwapData(swap);
             this.swapLogger.info(swap, "cancelSwapAndInvoice(): swap removed & invoice cancelled, invoice: ", swap.pr);
@@ -230,10 +217,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                     //Cancel invoice
                     yield invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.REFUNDED);
                     yield this.storageManager.saveData(invoice.id, null, invoiceData);
-                    yield (0, lightning_1.cancelHodlInvoice)({
-                        id: invoice.id,
-                        lnd: this.LND
-                    });
+                    yield this.lightning.cancelHodlInvoice(invoice.id);
                     this.unsubscribeInvoice(invoice.id);
                     yield this.removeSwapData(invoice.id, null);
                     this.swapLogger.info(invoiceData, "htlcReceived(): transaction reverted, refunding lightning: ", invoiceData.pr);
@@ -249,10 +233,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                 }
             }
             if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CONFIRMED) {
-                yield (0, lightning_1.settleHodlInvoice)({
-                    lnd: this.LND,
-                    secret: invoiceData.secret
-                });
+                yield this.lightning.settleHodlInvoice(invoiceData.secret);
                 if (invoiceData.metadata != null)
                     invoiceData.metadata.times.htlcSettled = Date.now();
                 const paymentHash = invoiceData.getHash();
@@ -274,10 +255,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
      */
     checkInvoiceStatus(paymentHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const invoice = yield (0, lightning_1.getInvoice)({
-                id: paymentHash,
-                lnd: this.LND
-            });
+            const invoice = yield this.lightning.getInvoice(paymentHash);
             const isInvoiceFound = invoice != null;
             if (!isInvoiceFound)
                 throw {
@@ -303,32 +281,33 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                     code: 10001,
                     msg: "Invoice expired/canceled"
                 };
-            const isBeingPaid = invoice.is_held;
-            if (!isBeingPaid) {
-                if (invoice.is_canceled)
+            switch (invoice.status) {
+                case "held":
+                    return invoice;
+                case "canceled":
                     throw {
                         _httpStatus: 200,
                         code: 10001,
                         msg: "Invoice expired/canceled"
                     };
-                if (invoice.is_confirmed) {
-                    const scTxId = this.processedTxIds.get(paymentHash);
+                case "confirmed":
                     throw {
                         _httpStatus: 200,
                         code: 10000,
                         msg: "Invoice already paid",
                         data: {
-                            txId: scTxId
+                            txId: this.processedTxIds.get(paymentHash)
                         }
                     };
-                }
-                throw {
-                    _httpStatus: 200,
-                    code: 10010,
-                    msg: "Invoice yet unpaid"
-                };
+                case "unpaid":
+                    throw {
+                        _httpStatus: 200,
+                        code: 10010,
+                        msg: "Invoice yet unpaid"
+                    };
+                default:
+                    throw new Error("Lightning invoice invalid state!");
             }
-            return invoice;
         });
     }
     startRestServer(restServer) {
@@ -388,20 +367,18 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             const hash = (0, crypto_1.createHash)("sha256").update(secret).digest();
             const hodlInvoiceObj = {
                 description: chainIdentifier + "-GAS-" + parsedBody.address,
-                cltv_delta: this.config.minCltv.add(new BN(5)).toNumber(),
-                expires_at: new Date(Date.now() + (this.config.invoiceTimeoutSeconds * 1000)).toISOString(),
+                cltvDelta: this.config.minCltv.add(new BN(5)).toNumber(),
+                expiresAt: Date.now() + (this.config.invoiceTimeoutSeconds * 1000),
                 id: hash.toString("hex"),
-                mtokens: amountBD.mul(new BN(1000)).toString(10),
-                lnd: null
+                mtokens: amountBD.mul(new BN(1000))
             };
-            metadata.invoiceRequest = Object.assign({}, hodlInvoiceObj);
-            hodlInvoiceObj.lnd = this.LND;
-            const hodlInvoice = yield (0, lightning_1.createHodlInvoice)(hodlInvoiceObj);
+            metadata.invoiceRequest = hodlInvoiceObj;
+            const hodlInvoice = yield this.lightning.createHodlInvoice(hodlInvoiceObj);
             abortController.signal.throwIfAborted();
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = Object.assign({}, hodlInvoice);
             console.log("[From BTC-LN: REST.CreateInvoice] hodl invoice created: ", hodlInvoice);
-            const createdSwap = new FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwap(chainIdentifier, hodlInvoice.request, swapFee, swapFeeInToken, totalInToken, secret.toString("hex"), parsedBody.address);
+            const createdSwap = new FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwap(chainIdentifier, hodlInvoice.request, hodlInvoice.mtokens, swapFee, swapFeeInToken, totalInToken, secret.toString("hex"), parsedBody.address);
             metadata.times.swapCreated = Date.now();
             createdSwap.metadata = metadata;
             yield PluginManager_1.PluginManager.swapCreate(createdSwap);
@@ -493,6 +470,13 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.storageManager.loadData(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwap);
+            //Check if all swaps contain a valid amount
+            for (let swap of yield this.storageManager.query([])) {
+                if (swap.amount == null) {
+                    const parsedPR = yield this.lightning.parsePaymentRequest(swap.pr);
+                    swap.amount = parsedPR.mtokens.add(new BN(999)).div(new BN(1000));
+                }
+            }
             yield PluginManager_1.PluginManager.serviceInitialize(this);
         });
     }

package/dist/swaps/frombtcln_trusted/FromBtcLnTrustedSwap.d.ts

@@ -16,12 +16,11 @@ export declare class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends
     readonly dstAddress: string;
     readonly secret: string;
     scRawTx: string;
-    constructor(chainIdentifier: string, pr: string, swapFee: BN, swapFeeInToken: BN, output: BN, secret: string, dstAddress: string);
+    constructor(chainIdentifier: string, pr: string, inputMtokens: BN, swapFee: BN, swapFeeInToken: BN, output: BN, secret: string, dstAddress: string);
     constructor(obj: any);
     getHash(): string;
     getSequence(): BN;
     serialize(): any;
-    getTotalInputAmount(): BN;
     isFailed(): boolean;
     isInitiated(): boolean;
     isSuccess(): boolean;

package/dist/swaps/frombtcln_trusted/FromBtcLnTrustedSwap.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnTrustedSwap = exports.FromBtcLnTrustedSwapState = void 0;
 const BN = require("bn.js");
 const crypto_1 = require("crypto");
-const bolt11 = require("@atomiqlabs/bolt11");
 const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
+const Utils_1 = require("../../utils/Utils");
 var FromBtcLnTrustedSwapState;
 (function (FromBtcLnTrustedSwapState) {
     FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["REFUNDED"] = -2] = "REFUNDED";
@@ -16,9 +16,9 @@ var FromBtcLnTrustedSwapState;
     FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["SETTLED"] = 4] = "SETTLED";
 })(FromBtcLnTrustedSwapState = exports.FromBtcLnTrustedSwapState || (exports.FromBtcLnTrustedSwapState = {}));
 class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
-    constructor(chainIdOrObj, pr, swapFee, swapFeeInToken, output, secret, dstAddress) {
+    constructor(chainIdOrObj, pr, inputMtokens, swapFee, swapFeeInToken, output, secret, dstAddress) {
         if (typeof (chainIdOrObj) === "string") {
-            super(chainIdOrObj, swapFee, swapFeeInToken);
+            super(chainIdOrObj, inputMtokens.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken);
             this.state = FromBtcLnTrustedSwapState.CREATED;
             this.pr = pr;
             this.output = output;
@@ -28,7 +28,7 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
-            this.output = new BN(chainIdOrObj.output);
+            this.output = (0, Utils_1.deserializeBN)(chainIdOrObj.output);
             this.secret = chainIdOrObj.secret;
             this.dstAddress = chainIdOrObj.dstAddress;
             this.scRawTx = chainIdOrObj.scRawTx;
@@ -44,15 +44,12 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
-        partialSerialized.output = this.output.toString(10);
+        partialSerialized.output = (0, Utils_1.serializeBN)(this.output);
         partialSerialized.secret = this.secret;
         partialSerialized.dstAddress = this.dstAddress;
         partialSerialized.scRawTx = this.scRawTx;
         return partialSerialized;
     }
-    getTotalInputAmount() {
-        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
-    }
     isFailed() {
         return this.state === FromBtcLnTrustedSwapState.CANCELED || this.state === FromBtcLnTrustedSwapState.REFUNDED;
     }

package/dist/swaps/tobtc_abstract/ToBtcAbs.d.ts

@@ -1,37 +1,22 @@
 import { Express } from "express";
 import * as BN from "bn.js";
-import * as bitcoin from "bitcoinjs-lib";
 import { ToBtcSwapAbs, ToBtcSwapState } from "./ToBtcSwapAbs";
 import { MultichainData, SwapHandlerType } from "../SwapHandler";
 import { ISwapPrice } from "../ISwapPrice";
 import { BtcTx, ClaimEvent, InitializeEvent, RefundEvent, SwapData, BitcoinRpc, BtcBlock } from "@atomiqlabs/base";
-import { AuthenticatedLnd } from "lightning";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
-import { IBtcFeeEstimator } from "../../fees/IBtcFeeEstimator";
-import { CoinselectTxInput, CoinselectTxOutput } from "../../utils/coinselect2/utils";
 import { ToBtcBaseConfig, ToBtcBaseSwapHandler } from "../ToBtcBaseSwapHandler";
 import { PromiseQueue } from "promise-queue-ts";
-type SpendableUtxo = {
-    address: string;
-    address_format: string;
-    confirmation_count: number;
-    output_script: string;
-    tokens: number;
-    transaction_id: string;
-    transaction_vout: number;
-};
+import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
 export type ToBtcConfig = ToBtcBaseConfig & {
     sendSafetyFactor: BN;
-    bitcoinNetwork: bitcoin.networks.Network;
     minChainCltv: BN;
-    networkFeeMultiplierPPM: BN;
+    networkFeeMultiplier: number;
     minConfirmations: number;
     maxConfirmations: number;
     maxConfTarget: number;
     minConfTarget: number;
     txCheckInterval: number;
-    feeEstimator?: IBtcFeeEstimator;
-    onchainReservedPerChannel?: number;
 };
 export type ToBtcRequestType = {
     address: string;
@@ -47,33 +32,15 @@ export type ToBtcRequestType = {
  * Handler for to BTC swaps, utilizing PTLCs (proof-time locked contracts) using btc relay (on-chain bitcoin SPV)
  */
 export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState> {
-    protected readonly CONFIRMATIONS_REQUIRED = 1;
-    protected readonly ADDRESS_FORMAT_MAP: {
-        p2wpkh: string;
-        np2wpkh: string;
-        p2tr: string;
-    };
-    protected readonly LND_CHANGE_OUTPUT_TYPE = "p2tr";
-    protected readonly UTXO_CACHE_TIMEOUT: number;
-    protected readonly CHANNEL_COUNT_CACHE_TIMEOUT: number;
     readonly type = SwapHandlerType.TO_BTC;
     activeSubscriptions: {
         [txId: string]: ToBtcSwapAbs;
     };
-    cachedUtxos: {
-        utxos: (CoinselectTxInput & {
-            confirmations: number;
-        })[];
-        timestamp: number;
-    };
-    cachedChannelCount: {
-        count: number;
-        timestamp: number;
-    };
     bitcoinRpc: BitcoinRpc<BtcBlock>;
+    bitcoin: IBitcoinWallet;
     sendBtcQueue: PromiseQueue;
     readonly config: ToBtcConfig;
-    constructor(storageDirectory: IIntermediaryStorage<ToBtcSwapAbs>, path: string, chainData: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: ToBtcConfig);
+    constructor(storageDirectory: IIntermediaryStorage<ToBtcSwapAbs>, path: string, chainData: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: ToBtcConfig);
     /**
      * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
      *
@@ -81,61 +48,13 @@ export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSw
      * @param address
      * @param nonce
      * @param amount
-     * @param bitcoinNetwork
      */
     private getHash;
-    /**
-     * Returns spendable UTXOs, these are either confirmed UTXOs, or unconfirmed ones that are either whitelisted,
-     *  or created by our transactions (and therefore only we could doublespend)
-     *
-     * @private
-     */
-    protected getSpendableUtxos(): Promise<SpendableUtxo[]>;
-    /**
-     * Returns utxo pool to be used by the coinselection algorithm
-     *
-     * @private
-     */
-    protected getUtxoPool(useCached?: boolean): Promise<(CoinselectTxInput & {
-        confirmations: number;
-    })[]>;
-    /**
-     * Checks whether a coinselect result leaves enough funds to cover potential lightning anchor transaction fees
-     *
-     * @param utxoPool
-     * @param obj
-     * @param satsPerVbyte
-     * @param useCached Whether to use a cached channel count
-     * @param initialOutputLength
-     * @private
-     * @returns true if alright, false if the coinselection doesn't leave enough funds for anchor fees
-     */
-    protected isLeavingEnoughForLightningAnchors(utxoPool: CoinselectTxInput[], obj: {
-        inputs?: CoinselectTxInput[];
-        outputs?: CoinselectTxOutput[];
-    }, satsPerVbyte: BN, useCached?: boolean, initialOutputLength?: number): Promise<boolean>;
-    /**
-     * Gets the change address from the underlying LND instance
-     *
-     * @private
-     */
-    protected getChangeAddress(): Promise<string>;
-    /**
-     * Computes bitcoin on-chain network fee, takes channel reserve & network fee multiplier into consideration
-     *
-     * @param targetAddress Bitcoin address to send the funds to
-     * @param targetAmount Amount of funds to send to the address
-     * @param estimate Whether the chain fee should be just estimated and therefore cached utxo set could be used
-     * @param multiplierPPM Multiplier for the sats/vB returned from the fee estimator in PPM (parts per million)
-     * @private
-     * @returns Fee estimate & inputs/outputs to use when constructing transaction, or null in case of not enough funds
-     */
-    private getChainFee;
     /**
      * Tries to claim the swap after our transaction was confirmed
      *
      * @param tx
-     * @param payment
+     * @param swap
      * @param vout
      */
     private tryClaimSwap;
@@ -173,44 +92,6 @@ export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSw
      * @throws DefinedRuntimeError will throw an error in case the actual fee is higher than quoted fee
      */
     protected checkCalculatedTxFee(quotedSatsPerVbyte: BN, actualSatsPerVbyte: BN): void;
-    /**
-     * Runs sanity check on the calculated fee for the transaction
-     *
-     * @param psbt
-     * @param tx
-     * @param maxAllowedSatsPerVbyte
-     * @param actualSatsPerVbyte
-     * @private
-     * @throws {Error} Will throw an error if the fee sanity check doesn't pass
-     */
-    protected checkPsbtFee(psbt: bitcoin.Psbt, tx: bitcoin.Transaction, maxAllowedSatsPerVbyte: BN, actualSatsPerVbyte: BN): BN;
-    /**
-     * Create PSBT for swap payout from coinselection result
-     *
-     * @param address
-     * @param amount
-     * @param escrowNonce
-     * @param coinselectResult
-     * @private
-     */
-    private getPsbt;
-    /**
-     * Signs provided PSBT and also returns a raw signed transaction
-     *
-     * @param psbt
-     * @private
-     */
-    protected signPsbt(psbt: bitcoin.Psbt): Promise<{
-        psbt: bitcoin.Psbt;
-        rawTx: string;
-    }>;
-    /**
-     * Sends raw bitcoin transaction
-     *
-     * @param rawTx
-     * @private
-     */
-    protected sendRawTransaction(rawTx: string): Promise<void>;
     /**
      * Sends a bitcoin transaction to payout BTC for a swap
      *
@@ -287,4 +168,3 @@ export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSw
     init(): Promise<void>;
     getInfoData(): any;
 }
-export {};