@atomiqlabs/lp-lib 10.3.11 → 11.0.1

package/src/swaps/FromBtcLnBaseSwapHandler.ts

@@ -2,11 +2,27 @@ import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
 import {FromBtcBaseSwapHandler} from "./FromBtcBaseSwapHandler";
 import * as BN from "bn.js";
-import * as lncli from "ln-service";
+import {ILightningWallet, LightningNetworkChannel} from "../wallets/ILightningWallet";
+import {IIntermediaryStorage} from "../storage/IIntermediaryStorage";
+import {MultichainData} from "./SwapHandler";
+import {ISwapPrice} from "./ISwapPrice";
 
 
 export abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends FromBtcBaseSwapHandler<V, S> {
 
+    readonly lightning: ILightningWallet;
+
+    constructor(
+        storageDirectory: IIntermediaryStorage<V>,
+        path: string,
+        chains: MultichainData,
+        lightning: ILightningWallet,
+        swapPricing: ISwapPrice
+    ) {
+        super(storageDirectory, path, chains, swapPricing);
+        this.lightning = lightning;
+    }
+
     /**
      * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
      *
@@ -15,14 +31,14 @@ export abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapDat
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
      */
-    protected async checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<{channels: any[]}>, signal: AbortSignal) {
+    protected async checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal) {
         const channelsResponse = await channelsPrefetch;
 
         signal.throwIfAborted();
 
         let hasEnoughInboundLiquidity = false;
-        channelsResponse.channels.forEach(channel => {
-            if(new BN(channel.remote_balance).gte(amountBD)) hasEnoughInboundLiquidity = true;
+        channelsResponse.forEach(channel => {
+            if(channel.remoteBalance.gte(amountBD)) hasEnoughInboundLiquidity = true;
         });
         if(!hasEnoughInboundLiquidity) {
             throw {
@@ -37,8 +53,8 @@ export abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapDat
      *
      * @param abortController
      */
-    protected getChannelsPrefetch(abortController: AbortController): Promise<{channels: any[]}> {
-        return lncli.getChannels({is_active: true, lnd: this.LND}).catch(e => {
+    protected getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]> {
+        return this.lightning.getChannels(true).catch(e => {
             this.logger.error("getChannelsPrefetch(): error", e);
             abortController.abort(e);
             return null;

package/src/swaps/SwapHandler.ts

@@ -1,15 +1,12 @@
-import {Express, Request, Response} from "express";
+import {Express, Request} from "express";
 import {ISwapPrice} from "./ISwapPrice";
 import {
-    AbstractSigner,
     ChainType,
     ClaimEvent,
     InitializeEvent, RefundEvent,
-    SwapContract,
     SwapData,
     SwapEvent
 } from "@atomiqlabs/base";
-import {AuthenticatedLnd} from "lightning";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {PluginManager} from "../plugins/PluginManager";
 import {IIntermediaryStorage} from "../storage/IIntermediaryStorage";
@@ -48,7 +45,6 @@ export type SwapBaseConfig = {
     feePPM: BN,
     max: BN,
     min: BN,
-    maxSkew: number,
     safetyFactor: BN,
     swapCheckInterval: number
 };
@@ -88,7 +84,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
     readonly chains: MultichainData;
     readonly allowedTokens: {[chainId: string]: Set<string>};
     readonly swapPricing: ISwapPrice;
-    readonly LND: AuthenticatedLnd;
 
     abstract config: SwapBaseConfig;
 
@@ -110,14 +105,12 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
         storageDirectory: IIntermediaryStorage<V>,
         path: string,
         chainsData: MultichainData,
-        lnd: AuthenticatedLnd,
         swapPricing: ISwapPrice
     ) {
         this.storageManager = storageDirectory;
         this.chains = chainsData;
         if(this.chains.chains[this.chains.default]==null) throw new Error("Invalid default chain specified");
         this.path = path;
-        this.LND = lnd;
         this.swapPricing = swapPricing;
         this.allowedTokens = {};
         for(let chainId in chainsData.chains) {

package/src/swaps/SwapHandlerSwap.ts

@@ -24,6 +24,11 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
     readonly swapFee: BN;
     readonly swapFeeInToken: BN;
 
+    prefix: string;
+    timeout: string;
+    signature: string;
+    feeRate: string;
+
     protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN);
     protected constructor(obj: any);
 
@@ -42,6 +47,10 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
             this.state = obj.state;
             this.swapFee = deserializeBN(obj.swapFee);
             this.swapFeeInToken = deserializeBN(obj.swapFeeInToken);
+            this.prefix = obj.prefix;
+            this.timeout = obj.timeout;
+            this.signature = obj.signature;
+            this.feeRate = obj.feeRate;
         }
     }
 
@@ -53,7 +62,11 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
             metadata: this.metadata,
             txIds: this.txIds,
             swapFee: serializeBN(this.swapFee),
-            swapFeeInToken: serializeBN(this.swapFeeInToken)
+            swapFeeInToken: serializeBN(this.swapFeeInToken),
+            prefix: this.prefix,
+            timeout: this.timeout,
+            signature: this.signature,
+            feeRate: this.feeRate
         }
     }
 

package/src/swaps/ToBtcBaseSwap.ts

@@ -6,22 +6,26 @@ import {deserializeBN, serializeBN} from "../utils/Utils";
 
 export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
 
+    amount: BN;
+
     quotedNetworkFee: BN;
     readonly quotedNetworkFeeInToken: BN;
     realNetworkFee: BN;
     realNetworkFeeInToken: BN;
 
-    protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
+    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
     protected constructor(obj: any);
 
-    protected constructor(obj?: any | string, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN) {
-        if(typeof(obj)==="string" && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
+    protected constructor(obj?: any | string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN) {
+        if(typeof(obj)==="string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
             super(obj, swapFee, swapFeeInToken);
+            this.amount = amount;
             this.quotedNetworkFee = quotedNetworkFee;
             this.quotedNetworkFeeInToken = quotedNetworkFeeInToken;
             return;
         } else {
             super(obj);
+            this.amount = deserializeBN(obj.amount);
             this.quotedNetworkFee = deserializeBN(obj.quotedNetworkFee);
             this.quotedNetworkFeeInToken = deserializeBN(obj.quotedNetworkFeeInToken);
             this.realNetworkFee = deserializeBN(obj.realNetworkFee);
@@ -31,6 +35,7 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
 
     serialize(): any {
         const obj = super.serialize();
+        obj.amount = serializeBN(this.amount);
         obj.quotedNetworkFee = serializeBN(this.quotedNetworkFee);
         obj.quotedNetworkFeeInToken = serializeBN(this.quotedNetworkFeeInToken);
         obj.realNetworkFee = serializeBN(this.realNetworkFee);
@@ -73,4 +78,8 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
         return {inInputToken: this.realNetworkFeeInToken, inOutputToken: this.realNetworkFee};
     }
 
+    getOutputAmount(): BN {
+        return this.amount;
+    }
+
 }

package/src/swaps/ToBtcBaseSwapHandler.ts

@@ -280,7 +280,8 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
     ): Promise<{
         prefix: string,
         timeout: string,
-        signature: string
+        signature: string,
+        feeRate: string
     }> {
         const prefetchedSignData = signDataPrefetchPromise!=null ? await signDataPrefetchPromise : null;
         if(prefetchedSignData!=null) this.logger.debug("getToBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
@@ -303,7 +304,10 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         );
         abortSignal.throwIfAborted();
 
-        return sigData;
+        return {
+            ...sigData,
+            feeRate
+        };
     }
 
 }

package/src/swaps/frombtc_abstract/FromBtcAbs.ts

@@ -1,5 +1,4 @@
 import * as BN from "bn.js";
-import * as lncli from "ln-service";
 import {Express, Request, Response} from "express";
 import {FromBtcSwapAbs, FromBtcSwapState} from "./FromBtcSwapAbs";
 import {MultichainData, SwapHandlerType} from "../SwapHandler";
@@ -11,8 +10,6 @@ import {
     RefundEvent,
     SwapData
 } from "@atomiqlabs/base";
-import {AuthenticatedLnd} from "lightning";
-import * as bitcoin from "bitcoinjs-lib";
 import {createHash} from "crypto";
 import {expressHandlerWrapper} from "../../utils/Utils";
 import {PluginManager} from "../../plugins/PluginManager";
@@ -22,9 +19,9 @@ import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDeco
 import {IParamReader} from "../../utils/paramcoders/IParamReader";
 import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
 import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
+import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
 
 export type FromBtcConfig = FromBtcBaseConfig & {
-    bitcoinNetwork: bitcoin.networks.Network
     confirmations: number,
     swapCsvDelta: number
 };
@@ -46,18 +43,22 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
 
     readonly config: FromBtcConfig & {swapTsCsvDelta: BN};
 
+    readonly bitcoin: IBitcoinWallet;
+
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>,
         path: string,
         chains: MultichainData,
-        lnd: AuthenticatedLnd,
+        bitcoin: IBitcoinWallet,
         swapPricing: ISwapPrice,
         config: FromBtcConfig
     ) {
-        super(storageDirectory, path, chains, lnd, swapPricing);
-        const anyConfig = config as any;
-        anyConfig.swapTsCsvDelta = new BN(config.swapCsvDelta).mul(config.bitcoinBlocktime.div(config.safetyFactor));
-        this.config = anyConfig;
+        super(storageDirectory, path, chains, swapPricing);
+        this.bitcoin = bitcoin;
+        this.config = {
+            ...config,
+            swapTsCsvDelta: new BN(config.swapCsvDelta).mul(config.bitcoinBlocktime.div(config.safetyFactor))
+        };
     }
 
     /**
@@ -65,10 +66,9 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
      *
      * @param address
      * @param amount
-     * @param bitcoinNetwork
      */
-    private getTxoHash(address: string, amount: BN, bitcoinNetwork: bitcoin.networks.Network): Buffer {
-        const parsedOutputScript = bitcoin.address.toOutputScript(address, bitcoinNetwork);
+    private getTxoHash(address: string, amount: BN): Buffer {
+        const parsedOutputScript = this.bitcoin.toOutputScript(address);
 
         return createHash("sha256").update(Buffer.concat([
             Buffer.from(amount.toArray("le", 8)),
@@ -84,7 +84,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
      * @param amount
      */
     private getHash(chainIdentifier: string, address: string, amount: BN): Buffer {
-        const parsedOutputScript = bitcoin.address.toOutputScript(address, this.config.bitcoinNetwork);
+        const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const {swapContract} = this.getChain(chainIdentifier);
         return swapContract.getHashForOnchain(parsedOutputScript, amount, new BN(0));
     }
@@ -97,15 +97,11 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
      * @returns true if the swap should be refunded, false if nothing should be done
      */
     protected async processPastSwap(swap: FromBtcSwapAbs): Promise<boolean> {
-        //Current time, minus maximum chain time skew
-        const currentTime = new BN(Math.floor(Date.now()/1000)-this.config.maxSkew);
-
-        const {swapContract} = this.getChain(swap.chainIdentifier);
+        const {swapContract, signer} = this.getChain(swap.chainIdentifier);
 
         //Once authorization expires in CREATED state, the user can no more commit it on-chain
         if(swap.state===FromBtcSwapState.CREATED) {
-            const isExpired = swap.authorizationExpiry.lt(currentTime);
-            if(!isExpired) return false;
+            if(!await swapContract.isInitAuthorizationExpired(swap.data, swap)) return false;
 
             const isCommited = await swapContract.isCommited(swap.data);
             if(isCommited) {
@@ -116,15 +112,14 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             }
 
             this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: "+swap.address);
+            await this.bitcoin.addUnusedAddress(swap.address);
             await this.removeSwapData(swap, FromBtcSwapState.CANCELED);
             return false;
         }
 
-        const expiryTime = swap.data.getExpiry();
         //Check if commited swap expired by now
         if(swap.state===FromBtcSwapState.COMMITED) {
-            const isExpired = expiryTime.lt(currentTime);
-            if(!isExpired) return false;
+            if(!swapContract.isExpired(signer.getAddress(), swap.data)) return false;
 
             const isCommited = await swapContract.isCommited(swap.data);
             if(isCommited) {
@@ -233,6 +228,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         savedSwap.txIds.refund = (event as any).meta?.txId;
 
         this.swapLogger.info(event, "SC: RefundEvent: swap refunded, address: "+savedSwap.address);
+        await this.bitcoin.addUnusedAddress(savedSwap.address);
         await this.removeSwapData(savedSwap, FromBtcSwapState.REFUNDED);
     }
 
@@ -383,10 +379,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             metadata.times.balanceChecked = Date.now();
 
             //Create swap receive bitcoin address
-            const {address: receiveAddress} = await lncli.createChainAddress({
-                lnd: this.LND,
-                format: "p2wpkh"
-            });
+            const receiveAddress = await this.bitcoin.getAddress();
             abortController.signal.throwIfAborted();
             metadata.times.addressCreated = Date.now();
 
@@ -424,7 +417,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
                 totalSecurityDeposit,
                 totalClaimerBounty
             );
-            data.setTxoHash(this.getTxoHash(receiveAddress, amountBD, this.config.bitcoinNetwork).toString("hex"));
+            data.setTxoHash(this.getTxoHash(receiveAddress, amountBD).toString("hex"));
             abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
 
@@ -435,7 +428,10 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             const createdSwap: FromBtcSwapAbs = new FromBtcSwapAbs(chainIdentifier, receiveAddress, amountBD, swapFee, swapFeeInToken);
             createdSwap.data = data;
             createdSwap.metadata = metadata;
-            createdSwap.authorizationExpiry = new BN(sigData.timeout);
+            createdSwap.prefix = sigData.prefix;
+            createdSwap.timeout = sigData.timeout;
+            createdSwap.signature = sigData.signature;
+            createdSwap.feeRate = sigData.feeRate;
 
             await PluginManager.swapCreate(createdSwap);
             await this.storageManager.saveData(createdSwap.data.getHash(), createdSwap.data.getSequence(), createdSwap);

package/src/swaps/frombtc_abstract/FromBtcSwapAbs.ts

@@ -1,9 +1,6 @@
 import * as BN from "bn.js";
-import * as bitcoin from "bitcoinjs-lib";
-import {createHash} from "crypto";
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "../SwapHandler";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
 import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
 
 export enum FromBtcSwapState {
@@ -17,8 +14,6 @@ export enum FromBtcSwapState {
 export class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcSwapState> {
 
     readonly address: string;
-    readonly amount: BN;
-    authorizationExpiry: BN;
     txId: string;
 
     constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
@@ -26,15 +21,12 @@ export class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSw
 
     constructor(prOrObj: string | any, address?: string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN) {
         if(typeof(prOrObj)==="string") {
-            super(prOrObj, swapFee, swapFeeInToken);
+            super(prOrObj, amount, swapFee, swapFeeInToken);
             this.state = FromBtcSwapState.CREATED;
             this.address = address;
-            this.amount = amount;
         } else {
             super(prOrObj);
             this.address = prOrObj.address;
-            this.amount = new BN(prOrObj.amount);
-            this.authorizationExpiry = deserializeBN(prOrObj.authorizationExpiry);
             this.txId = prOrObj.txId;
         }
         this.type = SwapHandlerType.FROM_BTC;
@@ -43,19 +35,12 @@ export class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSw
     serialize(): any {
         const partialSerialized = super.serialize();
         partialSerialized.address = this.address;
-        partialSerialized.amount = this.amount.toString(10);
-        partialSerialized.authorizationExpiry = serializeBN(this.authorizationExpiry);
         partialSerialized.txId = this.txId;
         return partialSerialized;
     }
 
-    getTxoHash(bitcoinNetwork: bitcoin.networks.Network): Buffer {
-        const parsedOutputScript = bitcoin.address.toOutputScript(this.address, bitcoinNetwork);
-
-        return createHash("sha256").update(Buffer.concat([
-            Buffer.from(this.amount.toArray("le", 8)),
-            parsedOutputScript
-        ])).digest();
+    getTxoHash(): Buffer {
+        return Buffer.from(this.data.getTxoHash(), "hex");
     }
 
     isInitiated(): boolean {