@atomiqlabs/lp-lib 10.3.11 → 11.0.1

package/src/swaps/frombtc_trusted/FromBtcTrusted.ts

@@ -1,41 +1,36 @@
 import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
 import {FromBtcTrustedSwap, FromBtcTrustedSwapState} from "./FromBtcTrustedSwap";
-import {BitcoinRpc, BtcBlock, BtcTx, ClaimEvent, InitializeEvent, RefundEvent, SwapData} from "@atomiqlabs/base";
+import {
+    BitcoinRpc,
+    BtcBlock,
+    BtcTx,
+    BtcVout,
+    ClaimEvent,
+    InitializeEvent,
+    RefundEvent,
+    SwapData
+} from "@atomiqlabs/base";
 import {Express, Request, Response} from "express";
 import {MultichainData, SwapHandlerType} from "../SwapHandler";
 import * as BN from "bn.js";
 import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
-import {
-    AuthenticatedLnd,
-    broadcastChainTransaction,
-    ChainTransaction, createChainAddress, createHodlInvoice,
-    getChainTransactions, getHeight,
-    signPsbt,
-    subscribeToTransactions, SubscribeToTransactionsChainTransactionEvent
-} from "lightning";
 import {ISwapPrice} from "../ISwapPrice";
 import {PluginManager} from "../../plugins/PluginManager";
-import {address, networks, Psbt, Transaction, TxOutput} from "bitcoinjs-lib";
-import {IBtcFeeEstimator} from "../../fees/IBtcFeeEstimator";
-import {utils} from "../../utils/coinselect2/utils";
 import {expressHandlerWrapper, HEX_REGEX} from "../../utils/Utils";
 import {IParamReader} from "../../utils/paramcoders/IParamReader";
 import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
 import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import * as bitcoin from "bitcoinjs-lib";
 import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
+import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
 
 export type FromBtcTrustedConfig = FromBtcBaseConfig & {
-    bitcoinNetwork: networks.Network,
-    feeEstimator: IBtcFeeEstimator,
     doubleSpendCheckInterval: number,
     swapAddressExpiry: number,
-    recommendFeeMultiplier?: number,
+    recommendFeeMultiplier?: number
 }
 
 export type FromBtcTrustedRequestType = {
     address: string,
-    refundAddress: string,
     amount: BN,
     exactOut?: boolean
 };
@@ -44,6 +39,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
     readonly type: SwapHandlerType = SwapHandlerType.FROM_BTC_TRUSTED;
 
     readonly config: FromBtcTrustedConfig;
+    readonly bitcoin: IBitcoinWallet;
     readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
 
     readonly subscriptions: Map<string, FromBtcTrustedSwap> = new Map<string, FromBtcTrustedSwap>();
@@ -51,81 +47,72 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
 
     readonly refundedSwaps: Map<string, string> = new Map();
     readonly doubleSpentSwaps: Map<string, string> = new Map();
-    readonly processedTxIds: Map<string, { txId: string, adjustedAmount: BN, adjustedTotal: BN }> = new Map();
+    readonly processedTxIds: Map<string, { scTxId: string, txId: string, adjustedAmount: BN, adjustedTotal: BN }> = new Map();
 
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcTrustedSwap>,
         path: string,
         chains: MultichainData,
-        lnd: AuthenticatedLnd,
+        bitcoin: IBitcoinWallet,
         swapPricing: ISwapPrice,
         bitcoinRpc: BitcoinRpc<BtcBlock>,
         config: FromBtcTrustedConfig
     ) {
-        super(storageDirectory, path, chains, lnd, swapPricing);
+        super(storageDirectory, path, chains, swapPricing);
         this.config = config;
         this.config.recommendFeeMultiplier ??= 1.25;
+        this.bitcoin = bitcoin;
         this.bitcoinRpc = bitcoinRpc;
         for(let chainId in chains.chains) {
             this.allowedTokens[chainId] = new Set<string>([chains.chains[chainId].swapContract.getNativeCurrencyAddress()]);
         }
     }
 
-    private getAllAncestors(tx: ChainTransaction): Promise<{tx: BtcTx, vout: number}[]> {
-        return Promise.all(tx.inputs.map(input => this.bitcoinRpc.getTransaction(input.transaction_id).then(tx => {
-            return {tx, vout: input.transaction_vout}
+    private getAllAncestors(tx: BtcTx): Promise<{tx: BtcTx, vout: number}[]> {
+        return Promise.all(tx.ins.map(input => this.bitcoinRpc.getTransaction(input.txid).then(tx => {
+            return {tx, vout: input.vout}
         })));
     }
 
     private async refundSwap(swap: FromBtcTrustedSwap) {
+        if(swap.refundAddress==null) {
+            if(swap.state!==FromBtcTrustedSwapState.REFUNDABLE) {
+                await swap.setState(FromBtcTrustedSwapState.REFUNDABLE);
+                await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
+            }
+            return;
+        }
+
         let unlock = swap.lock(30*1000);
         if(unlock==null) return;
 
-        const feeRate = await this.config.feeEstimator.estimateFee();
+        const feeRate = await this.bitcoin.getFeeRate();
 
-        const initialTx = Transaction.fromHex(swap.rawTx);
-        const ourOutput = initialTx.outs[swap.vout];
+        const ourOutput = swap.btcTx.outs[swap.vout];
 
-        //Construct PSBT
-        const refundOutputScript = address.toOutputScript(swap.refundAddress, this.config.bitcoinNetwork);
-        const txBytes = utils.transactionBytes([{type: "p2wpkh"}], [{script: refundOutputScript}], "p2wpkh");
-        const txFee = txBytes*feeRate;
-        const adjustedOutput = ourOutput.value-txFee;
-        if(adjustedOutput<546) {
+        const resp = await this.bitcoin.drainAll(swap.refundAddress, [{
+            type: this.bitcoin.getAddressType(),
+            confirmations: swap.btcTx.confirmations,
+            outputScript: Buffer.from(ourOutput.scriptPubKey.hex, "hex"),
+            value: ourOutput.value,
+            txId: swap.btcTx.txid,
+            vout: swap.vout
+        }], feeRate);
+
+        if(resp==null) {
             this.swapLogger.error(swap, "refundSwap(): cannot refund swap because of dust limit, txId: "+swap.txId);
             unlock();
             return;
         }
 
-        //Construct PSBT
-        const _psbt = new Psbt({network: this.config.bitcoinNetwork});
-        _psbt.addInput({
-            hash: initialTx.getHash(),
-            index: swap.vout,
-            witnessUtxo: ourOutput,
-            sighashType: 0x01,
-            sequence: 0xfffffffd
-        });
-        _psbt.addOutput({
-            script: refundOutputScript,
-            value: adjustedOutput
-        });
-
-        //Sign
-        const {psbt, transaction} = await signPsbt({
-            lnd: this.LND,
-            psbt: _psbt.toHex()
-        });
         if(swap.metadata!=null) swap.metadata.times.refundSignPSBT = Date.now();
-        this.swapLogger.debug(swap, "refundSwap(): signed raw transaction: "+transaction);
+        this.swapLogger.debug(swap, "refundSwap(): signed raw transaction: "+resp.raw);
 
-        const signedTx = Transaction.fromHex(transaction);
-        const refundTxId = signedTx.getId();
+        const refundTxId = resp.txId;
         swap.refundTxId = refundTxId;
 
         //Send the refund TX
-        await broadcastChainTransaction({transaction, lnd: this.LND});
-
+        await this.bitcoin.sendRawTransaction(resp.raw);
         this.swapLogger.debug(swap, "refundSwap(): sent refund transaction: "+refundTxId);
 
         this.refundedSwaps.set(swap.getHash(), refundTxId);
@@ -134,128 +121,143 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
     }
 
     private async burn(swap: FromBtcTrustedSwap) {
-        const initialTx = Transaction.fromHex(swap.rawTx);
-        const ourOutput = initialTx.outs[swap.vout];
+        const ourOutput = swap.btcTx.outs[swap.vout];
+
+        //Check if we can even increase the feeRate by burning
+        const txSize = 110;
+        const burnTxFeeRate = Math.floor(ourOutput.value/txSize);
+        const initialTxFeeRate = Math.ceil(swap.txFee/swap.txSize);
+
+        if(burnTxFeeRate<initialTxFeeRate) {
+            this.swapLogger.warn(swap, "burn(): cannot send burn transaction, pays too little fee, " +
+                "initialTxId: "+swap.txId+" initialTxFeeRate: "+initialTxFeeRate+" burnTxFeeRate: "+burnTxFeeRate);
+            this.doubleSpentSwaps.set(swap.getHash(), null);
+            await this.removeSwapData(swap, FromBtcTrustedSwapState.DOUBLE_SPENT);
+            return;
+        }
 
         //Construct PSBT
-        const _psbt = new Psbt({network: this.config.bitcoinNetwork});
-        _psbt.addInput({
-            hash: initialTx.getHash(),
-            index: swap.vout,
-            witnessUtxo: ourOutput,
-            sighashType: 0x01,
-            sequence: 0xfffffffd
-        });
-        _psbt.addOutput({
-            script: Buffer.concat([Buffer.from([0x6a, 20]), Buffer.from("BURN, BABY, BURN! AQ", "ascii")]),
-            value: 0
-        });
-
-        //Sign
-        const {psbt, transaction} = await signPsbt({
-            lnd: this.LND,
-            psbt: _psbt.toHex()
-        });
+        const resp = await this.bitcoin.burnAll([{
+            type: this.bitcoin.getAddressType(),
+            confirmations: swap.btcTx.confirmations,
+            outputScript: Buffer.from(ourOutput.scriptPubKey.hex, "hex"),
+            value: ourOutput.value,
+            txId: swap.btcTx.txid,
+            vout: swap.vout
+        }]);
         if(swap.metadata!=null) swap.metadata.times.burnSignPSBT = Date.now();
-        this.swapLogger.debug(swap, "burn(): signed raw transaction: "+transaction);
+        this.swapLogger.debug(swap, "burn(): signed raw transaction: "+resp.raw);
 
-        const signedTx = Transaction.fromHex(transaction);
-        const burnTxId = signedTx.getId();
+        const burnTxId = resp.txId;
         swap.burnTxId = burnTxId;
 
         //Send the original TX + our burn TX as a package
-        const sendTxns = [swap.rawTx, transaction];
-        await this.bitcoinRpc.sendRawPackage(sendTxns);
+        const sendTxns = [swap.btcTx.raw, resp.raw];
+        //TODO: We should handle this in a better way
+        try {
+            await this.bitcoinRpc.sendRawPackage(sendTxns);
+            this.swapLogger.debug(swap, "burn(): sent burn transaction: "+burnTxId);
+        } catch (e) {
+            this.swapLogger.error(swap, "burn(): error sending burn package: ", e);
+        }
 
-        this.swapLogger.debug(swap, "burn(): sent burn transaction: "+burnTxId);
         this.doubleSpentSwaps.set(swap.getHash(), burnTxId);
         await this.removeSwapData(swap, FromBtcTrustedSwapState.DOUBLE_SPENT);
     }
 
-    protected async processPastSwap(swap: FromBtcTrustedSwap, tx: ChainTransaction | null): Promise<void> {
-        let parsedTx: Transaction = null;
-        let foundVout: TxOutput = null;
-        let vout: number = -1;
-        if(tx!=null) {
-            parsedTx = Transaction.fromHex(tx.transaction);
-            const requiredOutputScript = address.toOutputScript(swap.btcAddress, this.config.bitcoinNetwork);
-            vout = parsedTx.outs.findIndex(vout => vout.script.equals(requiredOutputScript));
-            if(vout!==-1) foundVout = parsedTx.outs[vout];
-        }
+    protected async processPastSwap(swap: FromBtcTrustedSwap, tx: BtcTx | null, vout: number | null): Promise<void> {
+        const foundVout: BtcVout = tx.outs[vout];
 
         const {swapContract, signer} = this.getChain(swap.chainIdentifier);
 
+        const outputScript = this.bitcoin.toOutputScript(swap.btcAddress).toString("hex");
+
         if(swap.state===FromBtcTrustedSwapState.CREATED) {
-            this.subscriptions.set(swap.btcAddress, swap);
+            this.subscriptions.set(outputScript, swap);
             if(foundVout==null) {
                 //Check expiry
                 if(swap.expiresAt<Date.now()) {
-                    this.subscriptions.delete(swap.btcAddress);
+                    this.subscriptions.delete(outputScript);
+                    await this.bitcoin.addUnusedAddress(swap.btcAddress);
                     await this.removeSwapData(swap, FromBtcTrustedSwapState.EXPIRED);
                     return;
                 }
                 return;
             }
             const sentSats = new BN(foundVout.value);
-            if(sentSats.eq(swap.inputSats)) {
-                swap.adjustedInput = swap.inputSats;
+            if(sentSats.eq(swap.amount)) {
+                swap.adjustedInput = swap.amount;
                 swap.adjustedOutput = swap.outputTokens;
             } else {
                 //If lower than minimum then ignore
                 if(sentSats.lt(this.config.min)) return;
                 if(sentSats.gt(this.config.max)) {
-                    swap.rawTx = tx.transaction;
-                    swap.txId = tx.id;
+                    swap.adjustedInput = sentSats;
+                    swap.btcTx = tx;
+                    swap.txId = tx.txid;
                     swap.vout = vout;
-                    this.subscriptions.delete(swap.btcAddress);
+                    this.subscriptions.delete(outputScript);
                     await this.refundSwap(swap);
                     return;
                 }
                 //Adjust the amount
                 swap.adjustedInput = sentSats;
-                swap.adjustedOutput = swap.outputTokens.mul(sentSats).div(swap.inputSats);
+                swap.adjustedOutput = swap.outputTokens.mul(sentSats).div(swap.amount);
             }
-            swap.rawTx = tx.transaction;
-            swap.txId = tx.id;
+            swap.btcTx = tx;
+            swap.txId = tx.txid;
             swap.vout = vout;
-            this.subscriptions.delete(swap.btcAddress);
+            this.subscriptions.delete(outputScript);
             await swap.setState(FromBtcTrustedSwapState.RECEIVED);
-            await this.storageManager.saveData(swap.getHash(), null, swap);
+            await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
         }
 
         if(swap.state===FromBtcTrustedSwapState.RECEIVED) {
             //Check if transaction still exists
-            if(tx==null || foundVout==null || tx.id!==swap.txId) {
+            if(tx==null || foundVout==null || tx.txid!==swap.txId) {
                 await swap.setState(FromBtcTrustedSwapState.CREATED);
-                await this.storageManager.saveData(swap.getHash(), null, swap);
+                await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
                 return;
             }
             //Check if it is confirmed
-            if(tx.confirmation_count>0) {
+            if(tx.confirmations>0) {
                 await swap.setState(FromBtcTrustedSwapState.BTC_CONFIRMED);
-                await this.storageManager.saveData(swap.getHash(), null, swap);
+                await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
             } else {
                 //Check if it pays high enough fee AND has confirmed ancestors
                 const ancestors = await this.getAllAncestors(tx);
                 const allAncestorsConfirmed = ancestors.reduce((prev, curr) => prev && curr.tx.confirmations>0, true);
                 const totalInput = ancestors.reduce((prev, curr) => prev + curr.tx.outs[curr.vout].value, 0);
-                const totalOutput = parsedTx.outs.reduce((prev, curr) => prev + curr.value, 0);
+                const totalOutput = tx.outs.reduce((prev, curr) => prev + curr.value, 0);
                 const fee = totalInput-totalOutput;
-                const feePerVbyte = Math.ceil(fee/parsedTx.virtualSize());
+                const feePerVbyte = Math.ceil(fee/tx.vsize);
                 if(
                     allAncestorsConfirmed &&
-                    (feePerVbyte>=swap.recommendedFee || feePerVbyte>=await this.config.feeEstimator.estimateFee())
+                    (feePerVbyte>=swap.recommendedFee || feePerVbyte>=await this.bitcoin.getFeeRate())
                 ) {
                     if(swap.state!==FromBtcTrustedSwapState.RECEIVED) return;
+                    swap.txSize = tx.vsize;
+                    swap.txFee = fee;
                     await swap.setState(FromBtcTrustedSwapState.BTC_CONFIRMED);
-                    await this.storageManager.saveData(swap.getHash(), null, swap);
+                    await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
                 } else {
                     return;
                 }
             }
         }
 
-        if(swap.doubleSpent || tx==null || foundVout==null || tx.id!==swap.txId) {
+        if(swap.state===FromBtcTrustedSwapState.REFUNDABLE) {
+            if(swap.refundAddress!=null) {
+                await this.refundSwap(swap);
+                return;
+            }
+        }
+
+        if(swap.doubleSpent || tx==null || foundVout==null || tx.txid!==swap.txId) {
+            if(swap.state===FromBtcTrustedSwapState.REFUNDABLE) {
+                await swap.setState(FromBtcTrustedSwapState.CREATED);
+                return;
+            }
             if(!swap.doubleSpent) {
                 swap.doubleSpent = true;
                 try {
@@ -268,14 +270,13 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             }
             return;
         } else {
-            if(!this.doubleSpendWatchdogSwaps.has(swap)) {
+            if(tx.confirmations<=0 && !this.doubleSpendWatchdogSwaps.has(swap)) {
                 this.swapLogger.debug(swap, "processPastSwap(): Adding swap transaction to double spend watchdog list: ", swap.txId);
                 this.doubleSpendWatchdogSwaps.add(swap);
             }
         }
-        if(tx.confirmation_count > 0) {
+        if(tx.confirmations>0 && this.doubleSpendWatchdogSwaps.delete(swap)) {
             this.swapLogger.debug(swap, "processPastSwap(): Removing confirmed swap transaction from double spend watchdog list: ", swap.txId);
-            this.doubleSpendWatchdogSwaps.delete(swap);
         }
 
         if(swap.state===FromBtcTrustedSwapState.BTC_CONFIRMED) {
@@ -301,7 +302,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 swap.scRawTx = rawTx;
                 if(swap.state===FromBtcTrustedSwapState.BTC_CONFIRMED) {
                     await swap.setState(FromBtcTrustedSwapState.SENT);
-                    await this.storageManager.saveData(swap.getHash(), null, swap);
+                    await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
                 }
                 if(unlock!=null) unlock();
                 unlock = null;
@@ -316,7 +317,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                     swap.txIds = {init: null};
                     swap.scRawTx = null;
                     await swap.setState(FromBtcTrustedSwapState.RECEIVED);
-                    await this.storageManager.saveData(swap.getHash(), null, swap);
+                    await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
                     break;
                 case "reverted":
                     //Cancel invoice
@@ -325,18 +326,19 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                     break;
                 case "success":
                     await swap.setState(FromBtcTrustedSwapState.CONFIRMED);
-                    await this.storageManager.saveData(swap.getHash(), null, swap);
+                    await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
                     break;
             }
         }
 
         if(swap.state===FromBtcTrustedSwapState.CONFIRMED) {
             this.processedTxIds.set(swap.getHash(), {
-                txId: swap.txIds.init,
+                txId: swap.txId,
+                scTxId: swap.txIds.init,
                 adjustedAmount: swap.adjustedInput,
                 adjustedTotal: swap.adjustedOutput
             });
-            if(tx.confirmation_count>0) await this.removeSwapData(swap, FromBtcTrustedSwapState.FINISHED);
+            if(tx.confirmations>0) await this.removeSwapData(swap, FromBtcTrustedSwapState.FINISHED);
         }
     }
 
@@ -345,6 +347,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             {
                 key: "state",
                 value: [
+                    FromBtcTrustedSwapState.REFUNDABLE,
                     FromBtcTrustedSwapState.CREATED,
                     FromBtcTrustedSwapState.RECEIVED,
                     FromBtcTrustedSwapState.BTC_CONFIRMED,
@@ -356,17 +359,34 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
 
         const startingBlockheight = queriedData.reduce((prev, swap) => Math.min(prev, swap.createdHeight), Infinity);
         if(startingBlockheight===Infinity) return;
-        const {transactions} = await getChainTransactions({lnd: this.LND, after: startingBlockheight});
+        const transactions = await this.bitcoin.getWalletTransactions(startingBlockheight);
+
+        const map = new Map<string, {tx: BtcTx, vout: number}[]>();
+        transactions.forEach(tx => {
+            tx.outs.forEach((out, vout) => {
+                const existing = map.get(out.scriptPubKey.hex);
+                if(existing==null) {
+                    map.set(out.scriptPubKey.hex, [{tx, vout}]);
+                } else {
+                    existing.push({tx, vout});
+                }
+            })
+        });
 
         for(let swap of queriedData) {
-            const tx = transactions.find(tx => tx.output_addresses.includes(swap.btcAddress));
-            await this.processPastSwap(swap, tx);
+            const outputScript = this.bitcoin.toOutputScript(swap.btcAddress).toString("hex");
+            const txs = map.get(outputScript) ?? [];
+            try {
+                await this.processPastSwap(swap, txs[0]?.tx, txs[0]?.vout);
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwaps(): Error ocurred while processing swap: ", e);
+            }
         }
     }
 
     private isValidBitcoinAddress(address: string) {
         try {
-            bitcoin.address.toOutputScript(address, this.config.bitcoinNetwork);
+            this.bitcoin.toOutputScript(address);
             return true;
         } catch (e) {}
         return false;
@@ -388,18 +408,14 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             metadata.times.requestReceived = Date.now();
             /**
              * address: string              solana address of the recipient
-             * refundAddress: string        bitcoin address to use in case of refund
+             * refundAddress?: string       bitcoin address to use in case of refund
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              * exactOut: boolean            whether to create and exact output swap
              */
-
             const parsedBody: FromBtcTrustedRequestType = await req.paramReader.getParams({
                 address: (val: string) => val!=null &&
                     typeof(val)==="string" &&
                     swapContract.isValidAddress(val) ? val : null,
-                refundAddress: (val: string) => val!=null &&
-                    typeof(val)==="string" &&
-                    this.isValidBitcoinAddress(val) ? val : null,
                 amount: FieldTypeEnum.BN,
                 exactOut: FieldTypeEnum.BooleanOptional
             });
@@ -409,6 +425,13 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             };
             metadata.request = parsedBody;
 
+            const refundAddressData = req.paramReader.getExistingParamsOrNull({
+                refundAddress: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    this.isValidBitcoinAddress(val) ? val : null
+            });
+            const refundAddress = refundAddressData?.refundAddress;
+
             const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount};
             const request = {
                 chainIdentifier,
@@ -443,21 +466,25 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
             metadata.times.priceCalculated = Date.now();
 
-            //Check if we have enough funds to honor the request
-            await this.checkBalance(totalInToken, balancePrefetch, abortController.signal)
+            //Make sure we have MORE THAN ENOUGH to honor the swap request
+            await this.checkBalance(totalInToken.mul(new BN(4)), balancePrefetch, abortController.signal)
             metadata.times.balanceChecked = Date.now();
 
-            const {address: receiveAddress} = await createChainAddress({
-                lnd: this.LND,
-                format: "p2wpkh"
-            });
+            const blockHeight = await this.bitcoin.getBlockheight();
+            const feeRate = await this.bitcoin.getFeeRate();
+            const recommendedFee = Math.ceil(feeRate*this.config.recommendFeeMultiplier);
+            if(recommendedFee===0) throw {
+                _httpStatus: 500,
+                code: 21100,
+                msg: "Cannot estimate bitcoin fee!"
+            };
+            metadata.times.feeEstimated = Date.now();
+
+            const receiveAddress = await this.bitcoin.getAddress();
+            const outputScript = this.bitcoin.toOutputScript(receiveAddress).toString("hex");
             abortController.signal.throwIfAborted();
             metadata.times.addressCreated = Date.now();
 
-            const {current_block_height} = await getHeight({lnd: this.LND});
-            const feeRate = await this.config.feeEstimator.estimateFee();
-            const recommendedFee = Math.ceil(feeRate*this.config.recommendFeeMultiplier);
-
             const createdSwap = new FromBtcTrustedSwap(
                 chainIdentifier,
                 swapFee,
@@ -466,17 +493,17 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 amountBD,
                 parsedBody.address,
                 totalInToken,
-                current_block_height,
+                blockHeight,
                 Date.now()+(this.config.swapAddressExpiry*1000),
                 recommendedFee,
-                parsedBody.refundAddress
+                refundAddress
             );
             metadata.times.swapCreated = Date.now();
             createdSwap.metadata = metadata;
 
             await PluginManager.swapCreate(createdSwap);
-            await this.storageManager.saveData(createdSwap.getHash(), null, createdSwap);
-            this.subscriptions.set(createdSwap.btcAddress, createdSwap);
+            await this.storageManager.saveData(createdSwap.getHash(), createdSwap.getSequence(), createdSwap);
+            this.subscriptions.set(outputScript, createdSwap);
 
             this.swapLogger.info(createdSwap, "REST: /getAddress: Created swap address: "+createdSwap.btcAddress+" amount: "+amountBD.toString(10));
 
@@ -485,6 +512,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 code: 10000,
                 data: {
                     paymentHash: createdSwap.getHash(),
+                    sequence: createdSwap.getSequence().toString(10),
                     btcAddress: receiveAddress,
                     amountSats: amountBD.toString(10),
                     swapFeeSats: swapFee.toString(10),
@@ -496,27 +524,37 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 }
             });
         });
-
         restServer.use(this.path+"/getAddress", serverParamDecoder(10*1000));
         restServer.post(this.path+"/getAddress", getAddress);
 
         const getInvoiceStatus = expressHandlerWrapper(async (req, res) => {
             /**
              * paymentHash: string          payment hash of the invoice
+             * sequence: BN                 secret sequence for the swap,
              */
             const parsedBody = verifySchema(req.query, {
                 paymentHash: (val: string) => val!=null &&
                     typeof(val)==="string" &&
                     val.length===64 &&
                     HEX_REGEX.test(val) ? val: null,
+                sequence: FieldTypeEnum.BN,
             });
+            if(parsedBody==null) throw {
+                code: 20100,
+                msg: "Invalid request"
+            };
 
             const processedTxData = this.processedTxIds.get(parsedBody.paymentHash);
             if(processedTxData!=null) throw {
                 _httpStatus: 200,
                 code: 10000,
                 msg: "Success, tx confirmed",
-                data: processedTxData
+                data: {
+                    adjustedAmount: processedTxData.adjustedAmount.toString(10),
+                    adjustedTotal: processedTxData.adjustedTotal.toString(10),
+                    txId: processedTxData.txId,
+                    scTxId: processedTxData.scTxId
+                }
             };
 
             const refundTxId = this.refundedSwaps.get(parsedBody.paymentHash);
@@ -539,7 +577,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 }
             };
 
-            const invoiceData: FromBtcTrustedSwap = await this.storageManager.getData(parsedBody.paymentHash, null);
+            const invoiceData: FromBtcTrustedSwap = await this.storageManager.getData(parsedBody.paymentHash, parsedBody.sequence);
             if (invoiceData==null) throw {
                 _httpStatus: 200,
                 code: 10001,
@@ -558,7 +596,8 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 msg: "Bitcoin received, payment processing",
                 data: {
                     adjustedAmount: invoiceData.adjustedInput.toString(10),
-                    adjustedTotal: invoiceData.adjustedOutput.toString(10)
+                    adjustedTotal: invoiceData.adjustedOutput.toString(10),
+                    txId: invoiceData.txId
                 }
             };
 
@@ -568,7 +607,8 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 msg: "Bitcoin accepted, payment processing",
                 data: {
                     adjustedAmount: invoiceData.adjustedInput.toString(10),
-                    adjustedTotal: invoiceData.adjustedOutput.toString(10)
+                    adjustedTotal: invoiceData.adjustedOutput.toString(10),
+                    txId: invoiceData.txId
                 }
             };
 
@@ -579,7 +619,8 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 data: {
                     adjustedAmount: invoiceData.adjustedInput.toString(10),
                     adjustedTotal: invoiceData.adjustedOutput.toString(10),
-                    txId: invoiceData.txIds.init
+                    txId: invoiceData.txId,
+                    scTxId: invoiceData.txIds.init
                 }
             };
 
@@ -590,22 +631,83 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 data: {
                     adjustedAmount: invoiceData.adjustedInput.toString(10),
                     adjustedTotal: invoiceData.adjustedOutput.toString(10),
-                    txId: invoiceData.txIds.init
+                    txId: invoiceData.txId,
+                    scTxId: invoiceData.txIds.init
                 }
             };
-        });
 
+            if (invoiceData.state === FromBtcTrustedSwapState.REFUNDABLE) throw {
+                _httpStatus: 200,
+                code: 10016,
+                msg: "Refundable",
+                data: {
+                    adjustedAmount: invoiceData.adjustedInput.toString(10)
+                }
+            };
+        });
         restServer.get(this.path+"/getAddressStatus", getInvoiceStatus);
 
+        const setRefundAddress = expressHandlerWrapper(async (req, res) => {
+            /**
+             * paymentHash: string          payment hash of the invoice
+             * sequence: BN                 secret sequence for the swap,
+             * refundAddress: string        valid bitcoin address to be used for refunds
+             */
+            const parsedBody = verifySchema({...req.body, ...req.query}, {
+                paymentHash: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    val.length===64 &&
+                    HEX_REGEX.test(val) ? val: null,
+                sequence: FieldTypeEnum.BN,
+                refundAddress: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    this.isValidBitcoinAddress(val) ? val : null
+            });
+            if(parsedBody==null) throw {
+                code: 20100,
+                msg: "Invalid request"
+            };
+
+            const invoiceData: FromBtcTrustedSwap = await this.storageManager.getData(parsedBody.paymentHash, null);
+            if (invoiceData==null || !invoiceData.getSequence().eq(parsedBody.sequence)) throw {
+                code: 10001,
+                msg: "Swap not found"
+            };
+
+            if(invoiceData.refundAddress!=null) throw {
+                code: 10080,
+                msg: "Refund address already set!",
+                data: {
+                    refundAddress: invoiceData.refundAddress
+                }
+            };
+
+            invoiceData.refundAddress = parsedBody.refundAddress;
+
+            if (invoiceData.state === FromBtcTrustedSwapState.REFUNDABLE) {
+                this.refundSwap(invoiceData).catch(e => {
+                    this.swapLogger.error(invoiceData, "/setRefundAddress: Failed to refund!");
+                });
+            }
+
+            throw {
+                _httpStatus: 200,
+                code: 10000,
+                msg: "Refund address set"
+            };
+        });
+        restServer.get(this.path+"/setRefundAddress", setRefundAddress);
+        restServer.post(this.path+"/setRefundAddress", setRefundAddress);
+
         this.logger.info("started at path: ", this.path);
     }
 
     private async checkDoubleSpends(): Promise<void> {
         for(let swap of this.doubleSpendWatchdogSwaps.keys()) {
-            const tx = await this.bitcoinRpc.getTransaction(swap.txId);
+            const tx = await this.bitcoin.getWalletTransaction(swap.txId);
             if(tx==null) {
                 this.swapLogger.debug(swap, "checkDoubleSpends(): Swap was double spent, burning... - original txId: "+swap.txId);
-                this.processPastSwap(swap, null);
+                this.processPastSwap(swap, null, null);
             }
         }
     }
@@ -620,12 +722,11 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
     }
 
     private listenToTxns() {
-        const res = subscribeToTransactions({lnd: this.LND});
-        res.on("chain_transaction", (tx: SubscribeToTransactionsChainTransactionEvent) => {
-            for(let address of tx.output_addresses) {
-                const savedSwap = this.subscriptions.get(address);
+        this.bitcoin.subscribeToWalletTransactions((btcTx: BtcTx) => {
+            for(let out of btcTx.outs) {
+                const savedSwap = this.subscriptions.get(out.scriptPubKey.hex);
                 if(savedSwap==null) continue;
-                this.processPastSwap(savedSwap, tx);
+                this.processPastSwap(savedSwap, btcTx, out.n);
                 return;
             }
         });