@atomiqlabs/lp-lib 11.0.0 → 11.0.1

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./info/InfoHandler";
 export * from "./prices/CoinGeckoSwapPrice";
 export * from "./prices/BinanceSwapPrice";
+export * from "./prices/OKXSwapPrice";
 export * from "./storage/IIntermediaryStorage";
 export * from "./storagemanager/StorageManager";
 export * from "./storagemanager/IntermediaryStorageManager";

package/dist/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./info/InfoHandler"), exports);
 __exportStar(require("./prices/CoinGeckoSwapPrice"), exports);
 __exportStar(require("./prices/BinanceSwapPrice"), exports);
+__exportStar(require("./prices/OKXSwapPrice"), exports);
 __exportStar(require("./storage/IIntermediaryStorage"), exports);
 __exportStar(require("./storagemanager/StorageManager"), exports);
 __exportStar(require("./storagemanager/IntermediaryStorageManager"), exports);

package/dist/prices/OKXSwapPrice.d.ts

@@ -0,0 +1,27 @@
+import * as BN from "bn.js";
+import { ISwapPrice } from "../swaps/ISwapPrice";
+export type OKXPriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class OKXSwapPrice extends ISwapPrice<{
+    pair: string;
+    decimals: number;
+}> {
+    url: string;
+    cache: {
+        [pair: string]: {
+            price: number;
+            expiry: number;
+        };
+    };
+    constructor(url: string, coins: OKXPriceData);
+    fetchPrice(pair: string): Promise<number>;
+    getPrice(tokenData: {
+        pair: string;
+    }): Promise<BN>;
+}

package/dist/prices/OKXSwapPrice.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OKXSwapPrice = void 0;
+const BN = require("bn.js");
+const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const CACHE_DURATION = 15000;
+class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        const coinsMap = {};
+        for (let pair in coins) {
+            const chains = coins[pair];
+            for (let chainId in chains) {
+                const tokenData = chains[chainId];
+                if (coinsMap[chainId] == null)
+                    coinsMap[chainId] = {};
+                coinsMap[chainId][tokenData.address] = {
+                    pair,
+                    decimals: tokenData.decimals
+                };
+            }
+        }
+        super(coinsMap);
+        this.cache = {};
+        this.url = url || "https://www.okx.com/api/v5";
+    }
+    fetchPrice(pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.url + "/market/index-tickers?instId=" + pair, {
+                method: "GET"
+            });
+            if (response.status !== 200) {
+                let resp;
+                try {
+                    resp = yield response.text();
+                }
+                catch (e) {
+                    throw new Error(response.statusText);
+                }
+                throw new Error(resp);
+            }
+            let jsonBody = yield response.json();
+            return parseFloat(jsonBody.data[0].idxPx);
+        });
+    }
+    getPrice(tokenData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pair = tokenData.pair;
+            if (pair.startsWith("$fixed-")) {
+                const amt = parseFloat(pair.substring(7));
+                return new BN(Math.floor(amt * 1000000));
+            }
+            const arr = pair.split(";");
+            const promises = [];
+            const cachedValue = this.cache[pair];
+            if (cachedValue == null || cachedValue.expiry < Date.now()) {
+                let resultPrice = 1;
+                for (let pair of arr) {
+                    let invert = false;
+                    if (pair.startsWith("!")) {
+                        invert = true;
+                        pair = pair.substring(1);
+                    }
+                    const cachedValue = this.cache[pair];
+                    if (cachedValue == null || cachedValue.expiry < Date.now()) {
+                        promises.push(this.fetchPrice(pair).then(price => {
+                            this.cache[pair] = {
+                                price,
+                                expiry: Date.now() + CACHE_DURATION
+                            };
+                            if (invert) {
+                                resultPrice /= price;
+                            }
+                            else {
+                                resultPrice *= price;
+                            }
+                        }));
+                    }
+                    else {
+                        if (invert) {
+                            resultPrice /= cachedValue.price;
+                        }
+                        else {
+                            resultPrice *= cachedValue.price;
+                        }
+                    }
+                }
+                yield Promise.all(promises);
+                this.cache[pair] = {
+                    price: resultPrice,
+                    expiry: Date.now() + CACHE_DURATION
+                };
+            }
+            return new BN(Math.floor(this.cache[pair].price * 100000000000000));
+        });
+    }
+}
+exports.OKXSwapPrice = OKXSwapPrice;

package/dist/swaps/frombtcln_trusted/FromBtcLnTrusted.js

@@ -188,23 +188,42 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                 }
                 if (invoiceData.state !== FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED)
                     return;
-                let unlock = invoiceData.lock(30 * 1000);
+                const txns = yield swapContract.txsTransfer(signer.getAddress(), swapContract.getNativeCurrencyAddress(), invoiceData.output, invoiceData.dstAddress);
+                let unlock = invoiceData.lock(Infinity);
                 if (unlock == null)
                     return;
-                const txns = yield swapContract.txsTransfer(signer.getAddress(), swapContract.getNativeCurrencyAddress(), invoiceData.output, invoiceData.dstAddress);
-                yield swapContract.sendAndConfirm(signer, txns, true, null, false, (txId, rawTx) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield swapContract.sendAndConfirm(signer, txns, true, null, false, (txId, rawTx) => __awaiter(this, void 0, void 0, function* () {
                     invoiceData.txIds = { init: txId };
                     invoiceData.scRawTx = rawTx;
                     if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED) {
                         yield invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.SENT);
                         yield this.storageManager.saveData(invoice.id, null, invoiceData);
                     }
-                    if (unlock != null)
-                        unlock();
-                    unlock = null;
-                }));
+                })).catch(e => console.error(e));
+                if (result == null) {
+                    //Cancel invoice
+                    yield invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.REFUNDED);
+                    yield this.storageManager.saveData(invoice.id, null, invoiceData);
+                    yield this.lightning.cancelHodlInvoice(invoice.id);
+                    this.unsubscribeInvoice(invoice.id);
+                    yield this.removeSwapData(invoice.id, null);
+                    this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed, refunding lightning: ", invoiceData.pr);
+                    throw {
+                        code: 20002,
+                        msg: "Transaction sending failed"
+                    };
+                }
+                else {
+                    //Successfully paid
+                    yield invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CONFIRMED);
+                    yield this.storageManager.saveData(invoice.id, null, invoiceData);
+                }
+                unlock();
+                unlock = null;
             }
             if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.SENT) {
+                if (invoiceData.isLocked())
+                    return;
                 const txStatus = yield swapContract.getTxStatus(invoiceData.scRawTx);
                 if (txStatus === "not_found") {
                     //Retry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "11.0.0",
+  "version": "11.0.1",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./info/InfoHandler";
 
 export * from "./prices/CoinGeckoSwapPrice";
 export * from "./prices/BinanceSwapPrice";
+export * from "./prices/OKXSwapPrice";
 
 export * from "./storage/IIntermediaryStorage";
 

package/src/prices/OKXSwapPrice.ts

@@ -0,0 +1,114 @@
+import * as BN from "bn.js";
+import {ISwapPrice} from "../swaps/ISwapPrice";
+
+const CACHE_DURATION = 15000;
+
+export type OKXPriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string,
+            decimals: number
+        }
+    }
+};
+
+export class OKXSwapPrice extends ISwapPrice<{ pair: string, decimals: number }> {
+
+    url: string;
+    cache: {
+        [pair: string]: {
+            price: number,
+            expiry: number
+        }
+    } = {};
+
+    constructor(url: string, coins: OKXPriceData) {
+        const coinsMap = {};
+        for(let pair in coins) {
+            const chains = coins[pair];
+            for(let chainId in chains) {
+                const tokenData = chains[chainId];
+                if(coinsMap[chainId]==null) coinsMap[chainId] = {};
+                coinsMap[chainId][tokenData.address] = {
+                    pair,
+                    decimals: tokenData.decimals
+                }
+            }
+        }
+        super(coinsMap);
+        this.url = url || "https://www.okx.com/api/v5";
+    }
+
+    async fetchPrice(pair: string) {
+        const response: Response = await fetch(this.url+"/market/index-tickers?instId=" + pair, {
+            method: "GET"
+        });
+
+        if (response.status !== 200) {
+            let resp: string;
+            try {
+                resp = await response.text();
+            } catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+
+        let jsonBody: any = await response.json();
+
+        return parseFloat(jsonBody.data[0].idxPx);
+    }
+
+    async getPrice(tokenData: {pair: string}): Promise<BN> {
+        const pair = tokenData.pair;
+        if(pair.startsWith("$fixed-")) {
+            const amt: number = parseFloat(pair.substring(7));
+            return new BN(Math.floor(amt*1000000));
+        }
+
+        const arr = pair.split(";");
+
+        const promises = [];
+        const cachedValue = this.cache[pair];
+        if(cachedValue==null || cachedValue.expiry<Date.now()) {
+            let resultPrice = 1;
+            for (let pair of arr) {
+                let invert = false
+                if (pair.startsWith("!")) {
+                    invert = true;
+                    pair = pair.substring(1);
+                }
+                const cachedValue = this.cache[pair];
+                if (cachedValue == null || cachedValue.expiry < Date.now()) {
+                    promises.push(this.fetchPrice(pair).then(price => {
+                        this.cache[pair] = {
+                            price,
+                            expiry: Date.now() + CACHE_DURATION
+                        };
+
+                        if (invert) {
+                            resultPrice /= price;
+                        } else {
+                            resultPrice *= price;
+                        }
+                    }));
+                } else {
+                    if (invert) {
+                        resultPrice /= cachedValue.price;
+                    } else {
+                        resultPrice *= cachedValue.price;
+                    }
+                }
+            }
+
+            await Promise.all(promises);
+
+            this.cache[pair] = {
+                price: resultPrice,
+                expiry: Date.now() + CACHE_DURATION
+            };
+        }
+
+        return new BN(Math.floor(this.cache[pair].price*100000000000000));
+    }
+}

package/src/swaps/frombtcln_trusted/FromBtcLnTrusted.ts

@@ -217,23 +217,45 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             if(invoiceData.state!==FromBtcLnTrustedSwapState.RECEIVED) return;
 
-            let unlock = invoiceData.lock(30*1000);
+            const txns = await swapContract.txsTransfer(signer.getAddress(), swapContract.getNativeCurrencyAddress(), invoiceData.output, invoiceData.dstAddress);
+
+            let unlock = invoiceData.lock(Infinity);
             if(unlock==null) return;
 
-            const txns = await swapContract.txsTransfer(signer.getAddress(), swapContract.getNativeCurrencyAddress(), invoiceData.output, invoiceData.dstAddress);
-            await swapContract.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
+            const result = await swapContract.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
                 invoiceData.txIds = {init: txId};
                 invoiceData.scRawTx = rawTx;
                 if(invoiceData.state===FromBtcLnTrustedSwapState.RECEIVED) {
                     await invoiceData.setState(FromBtcLnTrustedSwapState.SENT);
                     await this.storageManager.saveData(invoice.id, null, invoiceData);
                 }
-                if(unlock!=null) unlock();
-                unlock = null;
-            });
+            }).catch(e => console.error(e));
+
+            if(result==null) {
+                //Cancel invoice
+                await invoiceData.setState(FromBtcLnTrustedSwapState.REFUNDED);
+                await this.storageManager.saveData(invoice.id, null, invoiceData);
+                await this.lightning.cancelHodlInvoice(invoice.id);
+                this.unsubscribeInvoice(invoice.id);
+                await this.removeSwapData(invoice.id, null);
+                this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed, refunding lightning: ", invoiceData.pr);
+                throw {
+                    code: 20002,
+                    msg: "Transaction sending failed"
+                };
+            } else {
+                //Successfully paid
+                await invoiceData.setState(FromBtcLnTrustedSwapState.CONFIRMED);
+                await this.storageManager.saveData(invoice.id, null, invoiceData);
+            }
+
+            unlock();
+            unlock = null;
         }
 
         if(invoiceData.state===FromBtcLnTrustedSwapState.SENT) {
+            if(invoiceData.isLocked()) return;
+
             const txStatus = await swapContract.getTxStatus(invoiceData.scRawTx);
             if(txStatus==="not_found") {
                 //Retry