@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/dist/swaps/tobtc_abstract/ToBtcAbs.js

@@ -11,15 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToBtcAbs = void 0;
 const BN = require("bn.js");
-const bitcoin = require("bitcoinjs-lib");
-const lncli = require("ln-service");
 const ToBtcSwapAbs_1 = require("./ToBtcSwapAbs");
 const SwapHandler_1 = require("../SwapHandler");
 const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../utils/Utils");
 const PluginManager_1 = require("../../plugins/PluginManager");
-const coinselect2_1 = require("../../utils/coinselect2");
-const utils_1 = require("../../utils/coinselect2/utils");
 const crypto_1 = require("crypto");
 const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
 const ServerParamDecoder_1 = require("../../utils/paramcoders/server/ServerParamDecoder");
@@ -30,23 +26,14 @@ const OUTPUT_SCRIPT_MAX_LENGTH = 200;
  * Handler for to BTC swaps, utilizing PTLCs (proof-time locked contracts) using btc relay (on-chain bitcoin SPV)
  */
 class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
-    constructor(storageDirectory, path, chainData, lnd, swapPricing, bitcoinRpc, config) {
-        super(storageDirectory, path, chainData, lnd, swapPricing);
-        this.CONFIRMATIONS_REQUIRED = 1;
-        this.ADDRESS_FORMAT_MAP = {
-            "p2wpkh": "p2wpkh",
-            "np2wpkh": "p2sh-p2wpkh",
-            "p2tr": "p2tr"
-        };
-        this.LND_CHANGE_OUTPUT_TYPE = "p2tr";
-        this.UTXO_CACHE_TIMEOUT = 5 * 1000;
-        this.CHANNEL_COUNT_CACHE_TIMEOUT = 30 * 1000;
+    constructor(storageDirectory, path, chainData, bitcoin, swapPricing, bitcoinRpc, config) {
+        super(storageDirectory, path, chainData, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.TO_BTC;
         this.activeSubscriptions = {};
         this.sendBtcQueue = new promise_queue_ts_1.PromiseQueue();
         this.bitcoinRpc = bitcoinRpc;
+        this.bitcoin = bitcoin;
         this.config = config;
-        this.config.onchainReservedPerChannel = this.config.onchainReservedPerChannel || 40000;
     }
     /**
      * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
@@ -55,189 +42,17 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      * @param address
      * @param nonce
      * @param amount
-     * @param bitcoinNetwork
      */
-    getHash(chainIdentifier, address, nonce, amount, bitcoinNetwork) {
-        const parsedOutputScript = bitcoin.address.toOutputScript(address, bitcoinNetwork);
+    getHash(chainIdentifier, address, nonce, amount) {
+        const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const { swapContract } = this.getChain(chainIdentifier);
         return swapContract.getHashForOnchain(parsedOutputScript, amount, nonce);
     }
-    /**
-     * 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
-     */
-    getSpendableUtxos() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resBlockheight = yield lncli.getHeight({
-                lnd: this.LND
-            });
-            const blockheight = resBlockheight.current_block_height;
-            const resChainTxns = yield lncli.getChainTransactions({
-                lnd: this.LND,
-                after: blockheight - this.CONFIRMATIONS_REQUIRED
-            });
-            const selfUTXOs = PluginManager_1.PluginManager.getWhitelistedTxIds();
-            const transactions = resChainTxns.transactions;
-            for (let tx of transactions) {
-                if (tx.is_outgoing) {
-                    selfUTXOs.add(tx.id);
-                }
-            }
-            const resUtxos = yield lncli.getUtxos({
-                lnd: this.LND
-            });
-            return resUtxos.utxos.filter(utxo => utxo.confirmation_count >= this.CONFIRMATIONS_REQUIRED || selfUTXOs.has(utxo.transaction_id));
-        });
-    }
-    /**
-     * Returns utxo pool to be used by the coinselection algorithm
-     *
-     * @private
-     */
-    getUtxoPool(useCached = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!useCached || this.cachedUtxos == null || this.cachedUtxos.timestamp < Date.now() - this.UTXO_CACHE_TIMEOUT) {
-                const utxos = yield this.getSpendableUtxos();
-                let totalSpendable = 0;
-                const utxoPool = utxos.map(utxo => {
-                    totalSpendable += utxo.tokens;
-                    return {
-                        vout: utxo.transaction_vout,
-                        txId: utxo.transaction_id,
-                        value: utxo.tokens,
-                        type: this.ADDRESS_FORMAT_MAP[utxo.address_format],
-                        outputScript: Buffer.from(utxo.output_script, "hex"),
-                        address: utxo.address,
-                        confirmations: utxo.confirmation_count
-                    };
-                });
-                this.cachedUtxos = {
-                    utxos: utxoPool,
-                    timestamp: Date.now()
-                };
-                this.logger.info("getUtxoPool(): total spendable value: " + totalSpendable + " num utxos: " + utxoPool.length);
-            }
-            return this.cachedUtxos.utxos;
-        });
-    }
-    /**
-     * 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
-     */
-    isLeavingEnoughForLightningAnchors(utxoPool, obj, satsPerVbyte, useCached = false, initialOutputLength = 1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (obj.inputs == null || obj.outputs == null)
-                return false;
-            const spentInputs = new Set();
-            obj.inputs.forEach(txIn => {
-                spentInputs.add(txIn.txId + ":" + txIn.vout);
-            });
-            let leavesValue = new BN(0);
-            utxoPool.forEach(val => {
-                const utxoEconomicalValue = new BN(val.value).sub(satsPerVbyte.mul(new BN(utils_1.utils.inputBytes(val).length)));
-                if (
-                //Utxo not spent
-                !spentInputs.has(val.txId + ":" + val.vout) &&
-                    //Only economical utxos at current fees
-                    !utxoEconomicalValue.isNeg()) {
-                    leavesValue = leavesValue.add(utxoEconomicalValue);
-                }
-            });
-            if (obj.outputs.length > initialOutputLength) {
-                const changeUtxo = obj.outputs[obj.outputs.length - 1];
-                leavesValue = leavesValue.add(new BN(changeUtxo.value).sub(satsPerVbyte.mul(new BN(utils_1.utils.inputBytes(changeUtxo).length))));
-            }
-            if (!useCached || this.cachedChannelCount == null || this.cachedChannelCount.timestamp < Date.now() - this.CHANNEL_COUNT_CACHE_TIMEOUT) {
-                const { channels } = yield lncli.getChannels({ lnd: this.LND });
-                this.cachedChannelCount = {
-                    count: channels.length,
-                    timestamp: Date.now()
-                };
-            }
-            return leavesValue.gt(new BN(this.config.onchainReservedPerChannel).mul(new BN(this.cachedChannelCount.count)));
-        });
-    }
-    /**
-     * Gets the change address from the underlying LND instance
-     *
-     * @private
-     */
-    getChangeAddress() {
-        return new Promise((resolve, reject) => {
-            this.LND.wallet.nextAddr({
-                type: 4,
-                change: true
-            }, (err, res) => {
-                if (err != null) {
-                    reject([503, 'UnexpectedErrGettingNextAddr', { err }]);
-                    return;
-                }
-                resolve(res.addr);
-            });
-        });
-    }
-    /**
-     * 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
-     */
-    getChainFee(targetAddress, targetAmount, estimate = false, multiplierPPM) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let feeRate = this.config.feeEstimator == null
-                ? yield lncli.getChainFeeRate({ lnd: this.LND })
-                    .then(res => res.tokens_per_vbyte)
-                    .catch(e => this.logger.error("getChainFee(): LND getChainFeeRate error", e))
-                : yield this.config.feeEstimator.estimateFee();
-            if (feeRate == null)
-                return null;
-            let satsPerVbyte = new BN(Math.ceil(feeRate));
-            if (multiplierPPM != null)
-                satsPerVbyte = satsPerVbyte.mul(multiplierPPM).div(new BN(1000000));
-            const utxoPool = yield this.getUtxoPool(estimate);
-            let obj = (0, coinselect2_1.coinSelect)(utxoPool, [{
-                    address: targetAddress,
-                    value: targetAmount,
-                    script: bitcoin.address.toOutputScript(targetAddress, this.config.bitcoinNetwork)
-                }], satsPerVbyte.toNumber(), this.LND_CHANGE_OUTPUT_TYPE);
-            if (obj.inputs == null || obj.outputs == null)
-                return null;
-            if (!(yield this.isLeavingEnoughForLightningAnchors(utxoPool, obj, satsPerVbyte, estimate)))
-                return null;
-            this.logger.info("getChainFee(): fee estimated," +
-                " target: " + targetAddress +
-                " amount: " + targetAmount.toString(10) +
-                " fee: " + obj.fee +
-                " sats/vB: " + satsPerVbyte +
-                " inputs: " + obj.inputs.length +
-                " outputs: " + obj.outputs.length +
-                " multiplier: " + (multiplierPPM == null ? 1 : multiplierPPM.toNumber() / 1000000));
-            return {
-                networkFee: new BN(obj.fee),
-                satsPerVbyte,
-                outputs: obj.outputs,
-                inputs: obj.inputs
-            };
-        });
-    }
     /**
      * Tries to claim the swap after our transaction was confirmed
      *
      * @param tx
-     * @param payment
+     * @param swap
      * @param vout
      */
     tryClaimSwap(tx, swap, vout) {
@@ -268,9 +83,8 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
     processPastSwap(swap) {
         return __awaiter(this, void 0, void 0, function* () {
             const { swapContract, signer } = this.getChain(swap.chainIdentifier);
-            const timestamp = new BN(Math.floor(Date.now() / 1000)).sub(new BN(this.config.maxSkew));
-            if (swap.state === ToBtcSwapAbs_1.ToBtcSwapState.SAVED && swap.signatureExpiry != null) {
-                const isSignatureExpired = swap.signatureExpiry.lt(timestamp);
+            if (swap.state === ToBtcSwapAbs_1.ToBtcSwapState.SAVED) {
+                const isSignatureExpired = swapContract.isInitAuthorizationExpired(swap.data, swap);
                 if (isSignatureExpired) {
                     const isCommitted = yield swapContract.isCommited(swap.data);
                     if (!isCommitted) {
@@ -286,8 +100,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 }
             }
             if (swap.state === ToBtcSwapAbs_1.ToBtcSwapState.NON_PAYABLE || swap.state === ToBtcSwapAbs_1.ToBtcSwapState.SAVED) {
-                const isSwapExpired = swap.data.getExpiry().lt(timestamp);
-                if (isSwapExpired) {
+                if (swapContract.isExpired(signer.getAddress(), swap.data)) {
                     this.swapLogger.info(swap, "processPastSwap(state=NON_PAYABLE|SAVED): swap expired, cancelling, address: " + swap.address);
                     yield this.removeSwapData(swap, ToBtcSwapAbs_1.ToBtcSwapState.CANCELED);
                     return;
@@ -349,7 +162,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             }
             this.swapLogger.debug(swap, "processBtcTx(): address: " + swap.address + " amount: " + swap.amount.toString(10) + " btcTx: " + tx);
             //Search for required transaction output (vout)
-            const outputScript = bitcoin.address.toOutputScript(swap.address, this.config.bitcoinNetwork);
+            const outputScript = this.bitcoin.toOutputScript(swap.address);
             const vout = tx.outs.find(e => new BN(e.value).eq(swap.amount) && Buffer.from(e.scriptPubKey.hex, "hex").equals(outputScript));
             if (vout == null) {
                 this.swapLogger.warn(swap, "processBtcTx(): cannot find correct vout," +
@@ -374,7 +187,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 const swap = this.activeSubscriptions[txId];
                 //TODO: RBF the transaction if it's already taking too long to confirm
                 try {
-                    let tx = yield this.bitcoinRpc.getTransaction(txId);
+                    let tx = yield this.bitcoin.getWalletTransaction(txId);
                     if (tx == null)
                         continue;
                     if (yield this.processBtcTx(swap, tx)) {
@@ -445,117 +258,11 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 code: 90003,
                 msg: "Fee changed too much!",
                 data: {
-                    quotedFee: actualSatsPerVbyte.toString(10),
-                    actualFee: quotedSatsPerVbyte.toString(10)
+                    quotedFee: quotedSatsPerVbyte.toString(10),
+                    actualFee: actualSatsPerVbyte.toString(10)
                 }
             };
     }
-    /**
-     * 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
-     */
-    checkPsbtFee(psbt, tx, maxAllowedSatsPerVbyte, actualSatsPerVbyte) {
-        const txFee = new BN(psbt.getFee());
-        //Sanity check on sats/vB
-        const maxAllowedFee = new BN(tx.virtualSize())
-            //Considering the extra output was not added, because was detrminetal
-            .add(new BN(utils_1.utils.outputBytes({ type: this.LND_CHANGE_OUTPUT_TYPE })))
-            //Multiply by maximum allowed feerate
-            .mul(maxAllowedSatsPerVbyte)
-            //Possibility that extra output was not added due to it being lower than dust
-            .add(new BN(utils_1.utils.dustThreshold({ type: this.LND_CHANGE_OUTPUT_TYPE })));
-        if (txFee.gt(maxAllowedFee))
-            throw new Error("Generated tx fee too high: " + JSON.stringify({
-                maxAllowedFee: maxAllowedFee.toString(10),
-                actualFee: txFee.toString(10),
-                psbtHex: psbt.toHex(),
-                maxAllowedSatsPerVbyte: maxAllowedSatsPerVbyte.toString(10),
-                actualSatsPerVbyte: actualSatsPerVbyte.toString(10)
-            }));
-        return txFee;
-    }
-    /**
-     * Create PSBT for swap payout from coinselection result
-     *
-     * @param address
-     * @param amount
-     * @param escrowNonce
-     * @param coinselectResult
-     * @private
-     */
-    getPsbt(address, amount, escrowNonce, coinselectResult) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let psbt = new bitcoin.Psbt();
-            //Apply nonce
-            const nonceBuffer = Buffer.from(escrowNonce.toArray("be", 8));
-            const locktimeBN = new BN(nonceBuffer.slice(0, 5), "be");
-            let locktime = locktimeBN.toNumber() + 500000000;
-            psbt.setLocktime(locktime);
-            const sequenceBN = new BN(nonceBuffer.slice(5, 8), "be");
-            const sequence = 0xFE000000 + sequenceBN.toNumber();
-            psbt.addInputs(coinselectResult.inputs.map(input => {
-                return {
-                    hash: input.txId,
-                    index: input.vout,
-                    witnessUtxo: {
-                        script: input.outputScript,
-                        value: input.value
-                    },
-                    sighashType: 0x01,
-                    sequence
-                };
-            }));
-            psbt.addOutput({
-                script: bitcoin.address.toOutputScript(address, this.config.bitcoinNetwork),
-                value: amount.toNumber()
-            });
-            //Add change output
-            if (coinselectResult.outputs.length > 1)
-                psbt.addOutput({
-                    script: bitcoin.address.toOutputScript(yield this.getChangeAddress(), this.config.bitcoinNetwork),
-                    value: coinselectResult.outputs[1].value
-                });
-            return psbt;
-        });
-    }
-    /**
-     * Signs provided PSBT and also returns a raw signed transaction
-     *
-     * @param psbt
-     * @private
-     */
-    signPsbt(psbt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signedPsbt = yield lncli.signPsbt({
-                lnd: this.LND,
-                psbt: psbt.toHex()
-            });
-            return {
-                psbt: bitcoin.Psbt.fromHex(signedPsbt.psbt),
-                rawTx: signedPsbt.transaction
-            };
-        });
-    }
-    /**
-     * Sends raw bitcoin transaction
-     *
-     * @param rawTx
-     * @private
-     */
-    sendRawTransaction(rawTx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield lncli.broadcastChainTransaction({
-                lnd: this.LND,
-                transaction: rawTx
-            });
-        });
-    }
     /**
      * Sends a bitcoin transaction to payout BTC for a swap
      *
@@ -571,35 +278,27 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             this.checkExpiresTooSoon(swap);
             if (swap.metadata != null)
                 swap.metadata.times.payCLTVChecked = Date.now();
-            const coinselectResult = yield this.getChainFee(swap.address, swap.amount.toNumber());
-            if (coinselectResult == null)
+            const satsPerVbyte = yield this.bitcoin.getFeeRate();
+            this.checkCalculatedTxFee(swap.satsPerVbyte, new BN(satsPerVbyte));
+            if (swap.metadata != null)
+                swap.metadata.times.payChainFee = Date.now();
+            const signResult = yield this.bitcoin.getSignedTransaction(swap.address, swap.amount.toNumber(), satsPerVbyte, swap.data.getEscrowNonce(), swap.satsPerVbyte.toNumber());
+            if (signResult == null)
                 throw {
                     code: 90002,
-                    msg: "Failed to run coinselect algorithm (not enough funds?)"
+                    msg: "Failed to create signed transaction (not enough funds?)"
                 };
-            if (swap.metadata != null)
-                swap.metadata.times.payChainFee = Date.now();
-            this.checkCalculatedTxFee(swap.satsPerVbyte, coinselectResult.satsPerVbyte);
-            //Construct payment PSBT
-            let unsignedPsbt = yield this.getPsbt(swap.address, swap.amount, swap.data.getEscrowNonce(), coinselectResult);
-            this.swapLogger.debug(swap, "sendBitcoinPayment(): generated psbt: " + unsignedPsbt.toHex());
-            //Sign the PSBT
-            const { psbt, rawTx } = yield this.signPsbt(unsignedPsbt);
             if (swap.metadata != null)
                 swap.metadata.times.paySignPSBT = Date.now();
-            this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: " + rawTx);
-            const tx = bitcoin.Transaction.fromHex(rawTx);
-            const txFee = this.checkPsbtFee(psbt, tx, swap.satsPerVbyte, coinselectResult.satsPerVbyte);
-            swap.txId = tx.getId();
-            swap.setRealNetworkFee(txFee);
+            this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: " + signResult.raw);
+            swap.txId = signResult.tx.getId();
+            swap.setRealNetworkFee(new BN(signResult.networkFee));
             yield swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING);
             yield this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
-            yield this.sendRawTransaction(rawTx);
+            yield this.bitcoin.sendRawTransaction(signResult.raw);
             if (swap.metadata != null)
                 swap.metadata.times.payTxSent = Date.now();
-            this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: " + tx.getId() + " address: " + swap.address);
-            //Invalidate the UTXO cache
-            this.cachedUtxos = null;
+            this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: " + signResult.tx.getId() + " address: " + swap.address);
             yield swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENT);
             yield this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
         }));
@@ -613,7 +312,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         return __awaiter(this, void 0, void 0, function* () {
             if (swap.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING) {
                 //Bitcoin transaction was signed (maybe also sent)
-                const tx = yield this.bitcoinRpc.getTransaction(swap.txId);
+                const tx = yield this.bitcoin.getWalletTransaction(swap.txId);
                 const isTxSent = tx != null;
                 if (!isTxSent) {
                     //Reset the state to COMMITED
@@ -782,7 +481,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
     checkAddress(address) {
         let parsedOutputScript;
         try {
-            parsedOutputScript = bitcoin.address.toOutputScript(address, this.config.bitcoinNetwork);
+            parsedOutputScript = this.bitcoin.toOutputScript(address);
         }
         catch (e) {
             throw {
@@ -803,7 +502,8 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      * @throws {DefinedRuntimeError} will throw an error if the swap is expired
      */
     checkExpired(swap) {
-        const isExpired = swap.data.getExpiry().lt(new BN(Math.floor(Date.now() / 1000)).sub(new BN(this.config.maxSkew)));
+        const { swapContract, signer } = this.getChain(swap.chainIdentifier);
+        const isExpired = swapContract.isExpired(signer.getAddress(), swap.data);
         if (isExpired)
             throw {
                 _httpStatus: 200,
@@ -820,14 +520,17 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      */
     checkAndGetNetworkFee(address, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            let chainFeeResp = yield this.getChainFee(address, amount.toNumber(), true, this.config.networkFeeMultiplierPPM);
+            let chainFeeResp = yield this.bitcoin.estimateFee(address, amount.toNumber(), null, this.config.networkFeeMultiplier);
             const hasEnoughFunds = chainFeeResp != null;
             if (!hasEnoughFunds)
                 throw {
                     code: 20002,
                     msg: "Not enough liquidity"
                 };
-            return chainFeeResp;
+            return {
+                networkFee: new BN(chainFeeResp.networkFee),
+                satsPerVbyte: new BN(chainFeeResp.satsPerVbyte)
+            };
         });
     }
     startRestServer(restServer) {
@@ -898,7 +601,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 return resp;
             }), abortController.signal, pricePrefetchPromise);
             metadata.times.priceCalculated = Date.now();
-            const paymentHash = this.getHash(chainIdentifier, parsedBody.address, parsedBody.nonce, amountBD, this.config.bitcoinNetwork).toString("hex");
+            const paymentHash = this.getHash(chainIdentifier, parsedBody.address, parsedBody.nonce, amountBD).toString("hex");
             //Add grace period another time, so the user has 1 hour to commit
             const expirySeconds = this.getExpiryFromCLTV(parsedBody.confirmationTarget, parsedBody.confirmations).add(new BN(this.config.gracePeriod));
             const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
@@ -909,9 +612,13 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             metadata.times.swapCreated = Date.now();
             const sigData = yield this.getToBtcSignatureData(chainIdentifier, payObject, req, abortController.signal, signDataPrefetchPromise);
             metadata.times.swapSigned = Date.now();
-            const createdSwap = new ToBtcSwapAbs_1.ToBtcSwapAbs(chainIdentifier, parsedBody.address, amountBD, swapFee, swapFeeInToken, networkFeeData.networkFee, networkFeeInToken, networkFeeData.satsPerVbyte, parsedBody.nonce, parsedBody.confirmationTarget, new BN(sigData.timeout));
+            const createdSwap = new ToBtcSwapAbs_1.ToBtcSwapAbs(chainIdentifier, parsedBody.address, amountBD, swapFee, swapFeeInToken, networkFeeData.networkFee, networkFeeInToken, networkFeeData.satsPerVbyte, parsedBody.nonce, parsedBody.confirmationTarget);
             createdSwap.data = payObject;
             createdSwap.metadata = metadata;
+            createdSwap.prefix = sigData.prefix;
+            createdSwap.timeout = sigData.timeout;
+            createdSwap.signature = sigData.signature;
+            createdSwap.feeRate = sigData.feeRate;
             yield PluginManager_1.PluginManager.swapCreate(createdSwap);
             yield this.storageManager.saveData(paymentHash, sequence, createdSwap);
             this.swapLogger.info(createdSwap, "REST: /payInvoice: created swap address: " + createdSwap.address + " amount: " + amountBD.toString(10));
@@ -959,7 +666,6 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     code: 20007,
                     msg: "Payment not found"
                 };
-            const { swapContract, signer } = this.getChain(payment.chainIdentifier);
             this.checkExpired(payment);
             if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.COMMITED)
                 throw {
@@ -976,6 +682,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                         txId: payment.txId
                     }
                 };
+            const { swapContract, signer } = this.getChain(payment.chainIdentifier);
             if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.NON_PAYABLE) {
                 const isCommited = yield swapContract.isCommited(payment.data);
                 if (!isCommited)

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

@@ -13,17 +13,14 @@ export declare enum ToBtcSwapState {
 }
 export declare class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
     readonly address: string;
-    readonly amount: BN;
     readonly satsPerVbyte: BN;
     readonly nonce: BN;
     readonly preferedConfirmationTarget: number;
-    readonly signatureExpiry: BN;
     txId: string;
-    constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN, networkFee: BN, networkFeeInToken: BN, satsPerVbyte: BN, nonce: BN, preferedConfirmationTarget: number, signatureExpiry: BN);
+    constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN, networkFee: BN, networkFeeInToken: BN, satsPerVbyte: BN, nonce: BN, preferedConfirmationTarget: number);
     constructor(obj: any);
     serialize(): any;
     isInitiated(): boolean;
     isFailed(): boolean;
     isSuccess(): boolean;
-    getOutputAmount(): BN;
 }

package/dist/swaps/tobtc_abstract/ToBtcSwapAbs.js

@@ -17,26 +17,22 @@ var ToBtcSwapState;
     ToBtcSwapState[ToBtcSwapState["CLAIMED"] = 4] = "CLAIMED";
 })(ToBtcSwapState = exports.ToBtcSwapState || (exports.ToBtcSwapState = {}));
 class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
-    constructor(chainIdOrObj, address, amount, swapFee, swapFeeInToken, networkFee, networkFeeInToken, satsPerVbyte, nonce, preferedConfirmationTarget, signatureExpiry) {
+    constructor(chainIdOrObj, address, amount, swapFee, swapFeeInToken, networkFee, networkFeeInToken, satsPerVbyte, nonce, preferedConfirmationTarget) {
         var _a;
         if (typeof (chainIdOrObj) === "string") {
-            super(chainIdOrObj, swapFee, swapFeeInToken, networkFee, networkFeeInToken);
+            super(chainIdOrObj, amount, swapFee, swapFeeInToken, networkFee, networkFeeInToken);
             this.state = ToBtcSwapState.SAVED;
             this.address = address;
-            this.amount = amount;
             this.satsPerVbyte = satsPerVbyte;
             this.nonce = nonce;
             this.preferedConfirmationTarget = preferedConfirmationTarget;
-            this.signatureExpiry = signatureExpiry;
         }
         else {
             super(chainIdOrObj);
             this.address = chainIdOrObj.address;
-            this.amount = new BN(chainIdOrObj.amount);
             this.satsPerVbyte = new BN(chainIdOrObj.satsPerVbyte);
             this.nonce = new BN(chainIdOrObj.nonce);
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;
-            this.signatureExpiry = (0, Utils_1.deserializeBN)(chainIdOrObj.signatureExpiry);
             this.txId = chainIdOrObj.txId;
             //Compatibility
             (_a = this.quotedNetworkFee) !== null && _a !== void 0 ? _a : (this.quotedNetworkFee = (0, Utils_1.deserializeBN)(chainIdOrObj.networkFee));
@@ -46,11 +42,9 @@ class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.address = this.address;
-        partialSerialized.amount = this.amount.toString(10);
         partialSerialized.satsPerVbyte = this.satsPerVbyte.toString(10);
         partialSerialized.nonce = this.nonce.toString(10);
         partialSerialized.preferedConfirmationTarget = this.preferedConfirmationTarget;
-        partialSerialized.signatureExpiry = (0, Utils_1.serializeBN)(this.signatureExpiry);
         partialSerialized.txId = this.txId;
         return partialSerialized;
     }
@@ -63,8 +57,5 @@ class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
     isSuccess() {
         return this.state === ToBtcSwapState.CLAIMED;
     }
-    getOutputAmount() {
-        return this.amount;
-    }
 }
 exports.ToBtcSwapAbs = ToBtcSwapAbs;