@atomiqlabs/lp-lib 10.3.11

package/dist/plugins/PluginManager.d.ts

@@ -0,0 +1,89 @@
+import { BitcoinRpc, SwapData } from "@atomiqlabs/base";
+import { IPlugin, PluginQuote, QuoteAmountTooHigh, QuoteAmountTooLow, QuoteSetFees, QuoteThrow, ToBtcPluginQuote } from "./IPlugin";
+import { FromBtcLnRequestType, FromBtcRequestType, ISwapPrice, MultichainData, RequestData, SwapHandler, ToBtcLnRequestType, ToBtcRequestType } from "..";
+import { SwapHandlerSwap } from "../swaps/SwapHandlerSwap";
+import { AuthenticatedLnd } from "lightning";
+import * as BN from "bn.js";
+import { FromBtcLnTrustedRequestType } from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+export type FailSwapResponse = {
+    type: "fail";
+    code?: number;
+    msg?: string;
+};
+export type FeeSwapResponse = {
+    type: "fee";
+    baseFee: BN;
+    feePPM: BN;
+};
+export type AmountAndFeeSwapResponse = {
+    type: "amountAndFee";
+    baseFee?: BN;
+    feePPM?: BN;
+    amount: BN;
+};
+export type SwapResponse = FailSwapResponse | FeeSwapResponse | AmountAndFeeSwapResponse;
+export declare class PluginManager {
+    static plugins: Map<string, IPlugin>;
+    static registerPlugin(name: string, plugin: IPlugin): void;
+    static unregisterPlugin(name: string): boolean;
+    static enable<T extends SwapData>(chainsData: MultichainData, bitcoinRpc: BitcoinRpc<any>, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, tokens: {
+        [ticker: string]: {
+            [chainId: string]: {
+                address: string;
+                decimals: number;
+            };
+        };
+    }, directory: string): Promise<void>;
+    static disable(): Promise<void>;
+    static serviceInitialize(handler: SwapHandler<any>): Promise<void>;
+    static onHttpServerStarted(httpServer: any): Promise<void>;
+    static swapStateChange<T extends SwapData>(swap: SwapHandlerSwap<T>, oldState?: any): Promise<void>;
+    static swapCreate<T extends SwapData>(swap: SwapHandlerSwap<T>): Promise<void>;
+    static swapRemove<T extends SwapData>(swap: SwapHandlerSwap<T>): Promise<void>;
+    static onHandlePostFromBtcQuote(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, chainIdentifier: string, token: string, constraints: {
+        minInBtc: BN;
+        maxInBtc: BN;
+    }, fees: {
+        baseFeeInBtc: BN;
+        feePPM: BN;
+    }, pricePrefetchPromise?: Promise<BN> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
+    static onHandlePreFromBtcQuote(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, chainIdentifier: string, token: string, constraints: {
+        minInBtc: BN;
+        maxInBtc: BN;
+    }, fees: {
+        baseFeeInBtc: BN;
+        feePPM: BN;
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
+    static onHandlePostToBtcQuote<T extends {
+        networkFee: BN;
+    }>(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, chainIdentifier: string, token: string, constraints: {
+        minInBtc: BN;
+        maxInBtc: BN;
+    }, fees: {
+        baseFeeInBtc: BN;
+        feePPM: BN;
+        networkFeeGetter: (amount: BN) => Promise<T>;
+    }, pricePrefetchPromise?: Promise<BN> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | (ToBtcPluginQuote & {
+        networkFeeData: T;
+    })>;
+    static onHandlePreToBtcQuote(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, chainIdentifier: string, token: string, constraints: {
+        minInBtc: BN;
+        maxInBtc: BN;
+    }, fees: {
+        baseFeeInBtc: BN;
+        feePPM: BN;
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
+    static getWhitelistedTxIds(): Set<string>;
+}

package/dist/plugins/PluginManager.js

@@ -0,0 +1,263 @@
+"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.PluginManager = void 0;
+const IPlugin_1 = require("./IPlugin");
+const fs = require("fs");
+const Utils_1 = require("../utils/Utils");
+const logger = (0, Utils_1.getLogger)("PluginManager: ");
+const pluginLogger = {
+    debug: (plugin, msg, ...args) => logger.debug(plugin.name + ": " + msg, ...args),
+    info: (plugin, msg, ...args) => logger.info(plugin.name + ": " + msg, ...args),
+    warn: (plugin, msg, ...args) => logger.warn(plugin.name + ": " + msg, ...args),
+    error: (plugin, msg, ...args) => logger.error(plugin.name + ": " + msg, ...args)
+};
+class PluginManager {
+    static registerPlugin(name, plugin) {
+        PluginManager.plugins.set(name, plugin);
+    }
+    static unregisterPlugin(name) {
+        return PluginManager.plugins.delete(name);
+    }
+    static enable(chainsData, bitcoinRpc, lnd, swapPricing, tokens, directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                fs.mkdirSync(directory);
+            }
+            catch (e) { }
+            for (let [name, plugin] of PluginManager.plugins.entries()) {
+                try {
+                    try {
+                        fs.mkdirSync(directory + "/" + name);
+                    }
+                    catch (e) { }
+                    yield plugin.onEnable(chainsData, bitcoinRpc, lnd, swapPricing, tokens, directory + "/" + name);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "enable(): plugin enable error", e);
+                }
+            }
+        });
+    }
+    static disable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    yield plugin.onDisable();
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "disable(): plugin disable error", e);
+                }
+            }
+        });
+    }
+    static serviceInitialize(handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    yield plugin.onServiceInitialize(handler);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "serviceInitialize(): plugin error", e);
+                }
+            }
+        });
+    }
+    static onHttpServerStarted(httpServer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onHttpServerStarted != null)
+                        yield plugin.onHttpServerStarted(httpServer);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "onHttpServerStarted(): plugin error", e);
+                }
+            }
+        });
+    }
+    static swapStateChange(swap, oldState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onSwapStateChange != null)
+                        yield plugin.onSwapStateChange(swap);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "swapStateChange(): plugin error", e);
+                }
+            }
+        });
+    }
+    static swapCreate(swap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onSwapCreate != null)
+                        yield plugin.onSwapCreate(swap);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "swapCreate(): plugin error", e);
+                }
+            }
+        });
+    }
+    static swapRemove(swap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onSwapRemove != null)
+                        yield plugin.onSwapRemove(swap);
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "swapRemove(): plugin error", e);
+                }
+            }
+        });
+    }
+    static onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onHandlePostFromBtcQuote != null) {
+                        const result = yield plugin.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise);
+                        if (result != null) {
+                            if ((0, IPlugin_1.isQuoteSetFees)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteThrow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isPluginQuote)(result)) {
+                                if (result.amount.input === requestedAmount.input)
+                                    throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
+                                return result;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+                }
+            }
+            return null;
+        });
+    }
+    static onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onHandlePreFromBtcQuote != null) {
+                        const result = yield plugin.onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                        if (result != null) {
+                            if ((0, IPlugin_1.isQuoteSetFees)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteThrow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                                return result;
+                        }
+                    }
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+                }
+            }
+            return null;
+        });
+    }
+    static onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onHandlePostToBtcQuote != null) {
+                        let networkFeeData;
+                        const result = yield plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
+                            baseFeeInBtc: fees.baseFeeInBtc,
+                            feePPM: fees.feePPM,
+                            networkFeeGetter: (amount) => __awaiter(this, void 0, void 0, function* () {
+                                networkFeeData = yield fees.networkFeeGetter(amount);
+                                return networkFeeData.networkFee;
+                            })
+                        }, pricePrefetchPromise);
+                        if (result != null) {
+                            if ((0, IPlugin_1.isQuoteSetFees)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteThrow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isToBtcPluginQuote)(result)) {
+                                if (result.amount.input === requestedAmount.input)
+                                    throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
+                                return Object.assign(Object.assign({}, result), { networkFeeData: networkFeeData });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+                }
+            }
+            return null;
+        });
+    }
+    static onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let plugin of PluginManager.plugins.values()) {
+                try {
+                    if (plugin.onHandlePreToBtcQuote != null) {
+                        const result = yield plugin.onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                        if (result != null) {
+                            if ((0, IPlugin_1.isQuoteSetFees)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteThrow)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                                return result;
+                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                                return result;
+                        }
+                    }
+                }
+                catch (e) {
+                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+                }
+            }
+            return null;
+        });
+    }
+    static getWhitelistedTxIds() {
+        const whitelist = new Set();
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.getWhitelistedTxIds != null) {
+                    const result = plugin.getWhitelistedTxIds();
+                    if (result != null) {
+                        result.forEach(e => whitelist.add(e));
+                    }
+                }
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "getWhitelistedTxIds(): plugin error", e);
+            }
+        }
+        return whitelist;
+    }
+}
+exports.PluginManager = PluginManager;
+PluginManager.plugins = new Map();

package/dist/prices/BinanceSwapPrice.d.ts

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

package/dist/prices/BinanceSwapPrice.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.BinanceSwapPrice = void 0;
+const BN = require("bn.js");
+const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const CACHE_DURATION = 15000;
+class BinanceSwapPrice 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://api.binance.com/api/v3";
+    }
+    fetchPrice(pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.url + "/ticker/price?symbol=" + 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.price);
+        });
+    }
+    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.BinanceSwapPrice = BinanceSwapPrice;

package/dist/prices/CoinGeckoSwapPrice.d.ts

@@ -0,0 +1,31 @@
+import * as BN from "bn.js";
+import { ISwapPrice } from "../swaps/ISwapPrice";
+export type CoinGeckoPriceData = {
+    [coinId: string]: {
+        [chainId: string]: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class CoinGeckoSwapPrice extends ISwapPrice<{
+    coinId: string;
+    decimals: number;
+}> {
+    url: string;
+    cache: {
+        [coinId: string]: {
+            price: BN;
+            expiry: number;
+        };
+    };
+    constructor(url: string, coins: CoinGeckoPriceData);
+    /**
+     * Returns coin price in mSat
+     *
+     * @param coin
+     */
+    getPrice(coin: {
+        coinId: string;
+    }): Promise<BN>;
+}

package/dist/prices/CoinGeckoSwapPrice.js

@@ -0,0 +1,76 @@
+"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.CoinGeckoSwapPrice = void 0;
+const BN = require("bn.js");
+const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const CACHE_DURATION = 15000;
+class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        const coinsMap = {};
+        for (let coinId in coins) {
+            const chains = coins[coinId];
+            for (let chainId in chains) {
+                const tokenData = chains[chainId];
+                if (coinsMap[chainId] == null)
+                    coinsMap[chainId] = {};
+                coinsMap[chainId][tokenData.address] = {
+                    coinId,
+                    decimals: tokenData.decimals
+                };
+            }
+        }
+        super(coinsMap);
+        this.cache = {};
+        this.url = url || "https://api.coingecko.com/api/v3";
+    }
+    /**
+     * Returns coin price in mSat
+     *
+     * @param coin
+     */
+    getPrice(coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coinId = coin.coinId;
+            if (coinId.startsWith("$fixed-")) {
+                const amt = parseFloat(coinId.substring(7));
+                return new BN(Math.floor(amt * 1000));
+            }
+            const cachedValue = this.cache[coinId];
+            if (cachedValue != null && cachedValue.expiry > Date.now()) {
+                return cachedValue.price;
+            }
+            const response = yield fetch(this.url + "/simple/price?ids=" + coinId + "&vs_currencies=sats&precision=3", {
+                method: "GET",
+                headers: { 'Content-Type': 'application/json' }
+            });
+            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();
+            const amt = jsonBody[coinId].sats;
+            const result = new BN(amt * 1000);
+            this.cache[coinId] = {
+                price: result,
+                expiry: Date.now() + CACHE_DURATION
+            };
+            return result;
+        });
+    }
+}
+exports.CoinGeckoSwapPrice = CoinGeckoSwapPrice;

package/dist/storage/IIntermediaryStorage.d.ts

@@ -0,0 +1,15 @@
+import { StorageObject } from "@atomiqlabs/base";
+import * as BN from "bn.js";
+export type StorageQueryParam = {
+    key: string;
+    value?: any;
+    values?: any[];
+};
+export interface IIntermediaryStorage<T extends StorageObject> {
+    init(): Promise<void>;
+    query(params: StorageQueryParam[]): Promise<T[]>;
+    getData(hash: string, sequence: BN | null): Promise<T>;
+    saveData(hash: string, sequence: BN | null, object: T): Promise<void>;
+    removeData(hash: string, sequence: BN | null): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<void>;
+}

package/dist/storage/IIntermediaryStorage.js

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

package/dist/storagemanager/IntermediaryStorageManager.d.ts

@@ -0,0 +1,15 @@
+import { StorageObject } from "@atomiqlabs/base";
+import { IIntermediaryStorage, StorageQueryParam } from "../storage/IIntermediaryStorage";
+import * as BN from "bn.js";
+export declare class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
+    private readonly directory;
+    private type;
+    private data;
+    constructor(directory: string);
+    init(): Promise<void>;
+    query(params: StorageQueryParam[]): Promise<T[]>;
+    getData(paymentHash: string, sequence: BN | null): Promise<T>;
+    saveData(hash: string, sequence: BN | null, object: T): Promise<void>;
+    removeData(hash: string, sequence: BN | null): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<void>;
+}