@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/dist/swaps/tobtcln_abstract/ToBtcLnSwapAbs.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as BN from "bn.js";
 import { SwapData } from "@atomiqlabs/base";
 import { ToBtcBaseSwap } from "../ToBtcBaseSwap";
@@ -13,15 +12,11 @@ export declare enum ToBtcLnSwapState {
 }
 export declare class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
     readonly pr: string;
-    readonly signatureExpiry: BN;
     secret: string;
-    constructor(chainIdentifier: string, pr: string, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN, signatureExpiry: BN);
+    constructor(chainIdentifier: string, pr: string, amountMtokens: BN, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
     constructor(obj: any);
     serialize(): any;
-    getHash(): string;
-    getHashBuffer(): Buffer;
     isInitiated(): boolean;
     isFailed(): boolean;
     isSuccess(): boolean;
-    getOutputAmount(): BN;
 }

package/dist/swaps/tobtcln_abstract/ToBtcLnSwapAbs.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToBtcLnSwapAbs = exports.ToBtcLnSwapState = void 0;
 const BN = require("bn.js");
-const bolt11 = require("@atomiqlabs/bolt11");
 const __1 = require("../..");
 const Utils_1 = require("../../utils/Utils");
 const ToBtcBaseSwap_1 = require("../ToBtcBaseSwap");
@@ -17,18 +16,16 @@ var ToBtcLnSwapState;
     ToBtcLnSwapState[ToBtcLnSwapState["CLAIMED"] = 3] = "CLAIMED";
 })(ToBtcLnSwapState = exports.ToBtcLnSwapState || (exports.ToBtcLnSwapState = {}));
 class ToBtcLnSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
-    constructor(chainIdOrObj, pr, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken, signatureExpiry) {
+    constructor(chainIdOrObj, pr, amount, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
         var _a, _b;
         if (typeof (chainIdOrObj) === "string") {
-            super(chainIdOrObj, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
+            super(chainIdOrObj, amount.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
             this.state = ToBtcLnSwapState.SAVED;
             this.pr = pr;
-            this.signatureExpiry = signatureExpiry;
         }
         else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
-            this.signatureExpiry = (0, Utils_1.deserializeBN)(chainIdOrObj.signatureExpiry);
             this.secret = chainIdOrObj.secret;
             //Compatibility with older versions
             (_a = this.quotedNetworkFee) !== null && _a !== void 0 ? _a : (this.quotedNetworkFee = (0, Utils_1.deserializeBN)(chainIdOrObj.maxFee));
@@ -39,16 +36,9 @@ class ToBtcLnSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
-        partialSerialized.signatureExpiry = (0, Utils_1.serializeBN)(this.signatureExpiry);
         partialSerialized.secret = this.secret;
         return partialSerialized;
     }
-    getHash() {
-        return bolt11.decode(this.pr).tagsObject.payment_hash;
-    }
-    getHashBuffer() {
-        return Buffer.from(bolt11.decode(this.pr).tagsObject.payment_hash, "hex");
-    }
     isInitiated() {
         return this.state !== ToBtcLnSwapState.SAVED;
     }
@@ -58,8 +48,5 @@ class ToBtcLnSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
     isSuccess() {
         return this.state === ToBtcLnSwapState.CLAIMED;
     }
-    getOutputAmount() {
-        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
-    }
 }
 exports.ToBtcLnSwapAbs = ToBtcLnSwapAbs;

package/dist/utils/Utils.d.ts

@@ -18,15 +18,5 @@ export declare function getLogger(prefix: string): {
     error: (msg: any, ...args: any[]) => void;
 };
 export declare const HEX_REGEX: RegExp;
-export declare function shuffle(array: any[]): void;
 export declare function serializeBN(bn: BN | null): string | null;
 export declare function deserializeBN(str: string | null): BN | null;
-/**
- * Handles & throws LND error if the error is:
- *  - network error
- *  - server side (LND) internal error
- *  - malformed input data error
- *
- * @param e
- */
-export declare function handleLndError(e: any): void;

package/dist/utils/Utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleLndError = exports.deserializeBN = exports.serializeBN = exports.shuffle = exports.HEX_REGEX = exports.getLogger = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = void 0;
+exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.getLogger = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = void 0;
 const BN = require("bn.js");
 function isDefinedRuntimeError(obj) {
     if (obj.code != null && typeof (obj.code) === "number") {
@@ -66,20 +66,6 @@ function getLogger(prefix) {
 }
 exports.getLogger = getLogger;
 exports.HEX_REGEX = /[0-9a-fA-F]+/;
-function shuffle(array) {
-    let currentIndex = array.length;
-    // While there remain elements to shuffle...
-    while (currentIndex != 0) {
-        // Pick a remaining element...
-        let randomIndex = Math.floor(Math.random() * currentIndex);
-        currentIndex--;
-        // And swap it with the current element.
-        [array[currentIndex], array[randomIndex]] = [
-            array[randomIndex], array[currentIndex]
-        ];
-    }
-}
-exports.shuffle = shuffle;
 function serializeBN(bn) {
     return bn == null ? null : bn.toString(10);
 }
@@ -88,22 +74,3 @@ function deserializeBN(str) {
     return str == null ? null : new BN(str);
 }
 exports.deserializeBN = deserializeBN;
-/**
- * Handles & throws LND error if the error is:
- *  - network error
- *  - server side (LND) internal error
- *  - malformed input data error
- *
- * @param e
- */
-function handleLndError(e) {
-    if (!Array.isArray(e))
-        throw e; //Throw errors that are not originating from the SDK
-    if (typeof (e[0]) !== "number")
-        throw e; //Throw errors that don't have proper format
-    if (e[0] >= 500 && e[0] < 600)
-        throw e; //Throw server errors 5xx
-    if (e[0] === 400)
-        throw e; //Throw malformed request data errors
-}
-exports.handleLndError = handleLndError;

package/dist/wallets/IBitcoinWallet.d.ts

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

package/dist/wallets/IBitcoinWallet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wallets/ILightningWallet.d.ts

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

package/dist/wallets/ILightningWallet.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routesMatch = void 0;
+function routesMatch(routesA, routesB) {
+    if (routesA === routesB)
+        return true;
+    if (routesA == null || routesB == null) {
+        return false;
+    }
+    if (routesA.length !== routesB.length)
+        return false;
+    for (let i = 0; i < routesA.length; i++) {
+        if (routesA[i] === routesB[i])
+            continue;
+        if (routesA[i] == null || routesB[i] == null) {
+            return false;
+        }
+        if (routesA[i].length !== routesB[i].length)
+            return false;
+        for (let e = 0; e < routesA[i].length; e++) {
+            if (routesA[i][e] === routesB[i][e])
+                continue;
+            if (routesA[i][e] == null || routesB[i][e] == null) {
+                return false;
+            }
+            if (routesA[i][e].publicKey !== routesB[i][e].publicKey ||
+                !routesA[i][e].baseFeeMtokens.eq(routesB[i][e].baseFeeMtokens) ||
+                routesA[i][e].channel !== routesB[i][e].channel ||
+                routesA[i][e].cltvDelta !== routesB[i][e].cltvDelta ||
+                routesA[i][e].feeRate !== routesB[i][e].feeRate) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.routesMatch = routesMatch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "10.3.11",
+  "version": "11.0.0",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,16 +22,11 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "7.2.0",
-    "@atomiqlabs/bolt11": "1.5.1",
-    "@atomiqlabs/server-base": "1.0.4",
-    "@bitcoinerlab/secp256k1": "1.0.5",
+    "@atomiqlabs/base": "7.2.2",
+    "@atomiqlabs/server-base": "1.0.5",
     "bitcoinjs-lib": "6.1.5",
     "bn.js": "5.2.1",
-    "express": "4.18.2",
-    "lightning": "10.2.1",
-    "ln-service": "57.2.0",
-    "one-dollar-fee-estimator-failover": "0.1.1",
+    "express": "4.21.1",
     "promise-queue-ts": "0.0.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,7 +1,3 @@
-import * as bitcoin from "bitcoinjs-lib";
-import * as tinySecpk256Interface from "@bitcoinerlab/secp256k1";
-bitcoin.initEccLib(tinySecpk256Interface);
-
 export * from "./info/InfoHandler";
 
 export * from "./prices/CoinGeckoSwapPrice";
@@ -34,7 +30,6 @@ export * from "./plugins/PluginManager";
 export * from "./plugins/IPlugin";
 
 export * from "./fees/IBtcFeeEstimator";
-export * from "./fees/OneDollarFeeEstimator";
 
 export * from "./utils/paramcoders/IParamReader";
 export * from "./utils/paramcoders/IParamWriter";
@@ -44,3 +39,6 @@ export * from "./utils/paramcoders/ParamEncoder";
 export * from "./utils/paramcoders/SchemaVerifier";
 export * from "./utils/paramcoders/server/ServerParamDecoder";
 export * from "./utils/paramcoders/server/ServerParamEncoder";
+
+export * from "./wallets/IBitcoinWallet";
+export * from "./wallets/ILightningWallet";

package/src/plugins/IPlugin.ts

@@ -8,10 +8,11 @@ import {
     ToBtcRequestType
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
-import {AuthenticatedLnd} from "lightning";
 import * as BN from "bn.js";
 import {Command} from "@atomiqlabs/server-base";
 import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+import {IBitcoinWallet} from "../wallets/IBitcoinWallet";
+import {ILightningWallet} from "../wallets/ILightningWallet";
 
 export type QuoteThrow = {
     type: "throw",
@@ -84,7 +85,8 @@ export interface IPlugin {
         chainsData: MultichainData,
 
         bitcoinRpc: BitcoinRpc<any>,
-        lnd: AuthenticatedLnd,
+        bitcoinWallet: IBitcoinWallet,
+        lightningWallet: ILightningWallet,
 
         swapPricing: ISwapPrice,
         tokens: {

package/src/plugins/PluginManager.ts

@@ -16,11 +16,12 @@ import {
     ToBtcRequestType
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
-import {AuthenticatedLnd} from "lightning";
 import * as BN from "bn.js";
 import * as fs from "fs";
 import {getLogger} from "../utils/Utils";
 import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+import {IBitcoinWallet} from "../wallets/IBitcoinWallet";
+import {ILightningWallet} from "../wallets/ILightningWallet";
 
 export type FailSwapResponse = {
     type: "fail",
@@ -67,7 +68,8 @@ export class PluginManager {
         chainsData: MultichainData,
 
         bitcoinRpc: BitcoinRpc<any>,
-        lnd: AuthenticatedLnd,
+        bitcoinWallet: IBitcoinWallet,
+        lightningWallet: ILightningWallet,
 
         swapPricing: ISwapPrice,
         tokens: {
@@ -92,7 +94,8 @@ export class PluginManager {
                 await plugin.onEnable(
                     chainsData,
                     bitcoinRpc,
-                    lnd,
+                    bitcoinWallet,
+                    lightningWallet,
                     swapPricing,
                     tokens,
                     directory+"/"+name

package/src/swaps/FromBtcBaseSwap.ts

@@ -1,14 +1,31 @@
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import * as BN from "bn.js";
+import {deserializeBN, serializeBN} from "../utils/Utils";
 
 export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
 
+    amount: BN;
+
+    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
+    protected constructor(obj: any);
+
+    protected constructor(obj?: any | string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN) {
+        super(obj, swapFee, swapFeeInToken);
+        if (typeof (obj) === "string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken)) {
+            this.amount = amount;
+        } else {
+            this.amount = deserializeBN(obj.amount);
+        }
+    };
+
     getInputAmount(): BN {
         return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
     }
 
-    abstract getTotalInputAmount(): BN;
+    getTotalInputAmount(): BN {
+        return this.amount;
+    }
 
     getOutputAmount(): BN {
         return this.data.getAmount();
@@ -18,4 +35,10 @@ export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapH
         return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
     }
 
+    serialize(): any {
+        const partialSerialized = super.serialize();
+        partialSerialized.amount = serializeBN(this.amount);
+        return partialSerialized;
+    }
+
 }

package/src/swaps/FromBtcBaseSwapHandler.ts

@@ -345,7 +345,8 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
     ): Promise<{
         prefix: string,
         timeout: string,
-        signature: string
+        signature: string,
+        feeRate: string
     }> {
         const {swapContract, signer} = this.getChain(chainIdentifier);
 
@@ -369,7 +370,10 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
         );
         abortSignal.throwIfAborted();
 
-        return sigData;
+        return {
+            ...sigData,
+            feeRate
+        };
     }
 
 }

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) {