@atomiqlabs/base 13.0.4 → 13.1.3

package/dist/btc/lightning/LightningNetworkApi.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A type defining total capacity of a given lightning network node
+ *
+ * @category Bitcoin
+ */
+export type LNNodeLiquidity = {
+    publicKey: string;
+    capacity: bigint;
+    numChannels: number;
+};
+/**
+ * An interface for Lightning API, provides view of the public lightning network data like channel graph
+ *
+ * @category Bitcoin
+ */
+export interface LightningNetworkApi {
+    /**
+     * Returns the lightning network's node liquidity as identified by an identity public key
+     *
+     * @param pubkey
+     */
+    getLNNodeLiquidity(pubkey: string): Promise<LNNodeLiquidity | null>;
+}

package/dist/btc/lightning/LightningNetworkApi.js

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

package/dist/btc/rpc/BitcoinRpc.d.ts

@@ -226,4 +226,10 @@ export interface BitcoinRpc<T extends BtcBlock> {
         fee: number;
         feeRate: number;
     }>;
+    /**
+     * Parses a bitcoin address from the passed output script in hexadecimal format
+     *
+     * @param outputScriptHex
+     */
+    outputScriptToAddress?(outputScriptHex: string): Promise<string>;
 }

package/dist/btc/rpc/BitcoinRpcWithAddressIndex.d.ts

@@ -0,0 +1,112 @@
+/// <reference types="node" />
+import { Buffer } from "buffer";
+import { BitcoinRpc, BtcTx } from "./BitcoinRpc";
+import { BtcBlock } from "../../btcrelay/types/BtcBlock";
+/**
+ * A type defining a bitcoin transaction with its blockheight and optional input addresses populated
+ *
+ * @category Bitcoin
+ */
+export type BtcTxWithBlockheight = BtcTx & {
+    blockheight?: number;
+    inputAddresses?: string[];
+};
+/**
+ * A type defining a single UTXO belonging to an address
+ *
+ * @category Bitcoin
+ */
+export type BtcAddressUtxo = {
+    txid: string;
+    vout: number;
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+    value: bigint;
+};
+/**
+ * An extended interface for Bitcoin, that allows querying balances and UTXOs of any address + other utilities
+ *
+ * @category Bitcoin
+ */
+export interface BitcoinRpcWithAddressIndex<T extends BtcBlock> extends BitcoinRpc<T> {
+    /**
+     * Returns the current fee rate required for submitted bitcoin transactions in sats/vB
+     */
+    getFeeRate(): Promise<number>;
+    /**
+     * Returns confirmed & unconfirmed balances for a given wallet address
+     *
+     * @param address
+     */
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    /**
+     * Returns UTXOs owned by the given wallet address
+     * @param address
+     */
+    getAddressUTXOs(address: string): Promise<BtcAddressUtxo[]>;
+    /**
+     * Returns CPFP (children-pay-for-parent) data for a given transaction, or null if transaction is not found
+     *  or already confirmed
+     *
+     * @param txId
+     */
+    getCPFPData(txId: string): Promise<{
+        effectiveFeePerVsize: number;
+        adjustedVsize: number;
+    } | null>;
+    /**
+     * @inheritDoc
+     */
+    getTransaction(txId: string): Promise<BtcTxWithBlockheight | null>;
+    /**
+     * Awaits till the given transaction gets confirmed
+     *
+     * @param txId Transaction ID to monitor
+     * @param requiredConfirmations Required number of confirmations
+     * @param stateUpdateCbk Optional update callback called with the current status of the bitcoin transaction
+     * @param abortSignal
+     * @param intervalSeconds How often to poll
+     */
+    waitForTransaction(txId: string, requiredConfirmations: number, stateUpdateCbk?: (btcTx?: BtcTxWithBlockheight, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<BtcTxWithBlockheight>;
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    getConfirmationDelay(tx: BtcTx, requiredConfirmations: number): Promise<number | null>;
+    /**
+     * Checks if an address received the transaction with the required txoHash, returns info about that
+     *  specific transaction if found, or null if not found
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     */
+    checkAddressTxos(address: string, txoHash: Buffer): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    } | null>;
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     * @param requiredConfirmations Required confirmations of the transaction
+     * @param stateUpdateCbk Callback for transaction state updates
+     * @param abortSignal Abort signal
+     * @param intervalSeconds How often to check new transaction
+     */
+    waitForAddressTxo(address: string, txoHash: Buffer, requiredConfirmations: number, stateUpdateCbk: (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    }>;
+}

package/dist/btc/rpc/BitcoinRpcWithAddressIndex.js

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

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./btcrelay/BtcRelay";
 export * from "./btc/rpc/BitcoinRpc";
+export * from "./btc/rpc/BitcoinRpcWithAddressIndex";
+export * from "./btc/lightning/LightningNetworkApi";
 export * from "./btcrelay/synchronizer/RelaySynchronizer";
 export * from "./btcrelay/types/BtcBlock";
 export * from "./btcrelay/types/BtcHeader";
@@ -12,6 +14,7 @@ export * from "./events/types/swap/RefundEvent";
 export * from "./events/types/swap/SwapEvent";
 export * from "./lockable/Lockable";
 export * from "./storage/IStorageManager";
+export * from "./storage/VoidStorageManager";
 export * from "./storage/StorageObject";
 export * from "./swaps/SwapContract";
 export * from "./swaps/SwapData";
@@ -24,6 +27,9 @@ export * from "./errors/TransactionRevertedError";
 export * from "./chains/ChainType";
 export * from "./chains/ChainData";
 export * from "./utils/BigIntBufferUtils";
+export * from "./utils/Logger";
+export * from "./utils/RetryUtils";
+export * from "./utils/TimeoutUtils";
 export * from "./btc/BitcoinNetwork";
 export * from "./chains/ChainInterface";
 export * from "./spv_swap/SpvVaultContract";

package/dist/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./btcrelay/BtcRelay"), exports);
 __exportStar(require("./btc/rpc/BitcoinRpc"), exports);
+__exportStar(require("./btc/rpc/BitcoinRpcWithAddressIndex"), exports);
+__exportStar(require("./btc/lightning/LightningNetworkApi"), exports);
 __exportStar(require("./btcrelay/synchronizer/RelaySynchronizer"), exports);
 __exportStar(require("./btcrelay/types/BtcBlock"), exports);
 __exportStar(require("./btcrelay/types/BtcHeader"), exports);
@@ -28,6 +30,7 @@ __exportStar(require("./events/types/swap/RefundEvent"), exports);
 __exportStar(require("./events/types/swap/SwapEvent"), exports);
 __exportStar(require("./lockable/Lockable"), exports);
 __exportStar(require("./storage/IStorageManager"), exports);
+__exportStar(require("./storage/VoidStorageManager"), exports);
 __exportStar(require("./storage/StorageObject"), exports);
 __exportStar(require("./swaps/SwapContract"), exports);
 __exportStar(require("./swaps/SwapData"), exports);
@@ -40,6 +43,9 @@ __exportStar(require("./errors/TransactionRevertedError"), exports);
 __exportStar(require("./chains/ChainType"), exports);
 __exportStar(require("./chains/ChainData"), exports);
 __exportStar(require("./utils/BigIntBufferUtils"), exports);
+__exportStar(require("./utils/Logger"), exports);
+__exportStar(require("./utils/RetryUtils"), exports);
+__exportStar(require("./utils/TimeoutUtils"), exports);
 __exportStar(require("./btc/BitcoinNetwork"), exports);
 __exportStar(require("./chains/ChainInterface"), exports);
 __exportStar(require("./spv_swap/SpvVaultContract"), exports);

package/dist/storage/VoidStorageManager.d.ts

@@ -0,0 +1,33 @@
+import { IStorageManager } from "./IStorageManager";
+/**
+ * A dummy storage manager that doesn't store anything, and should be only used as a placeholder
+ *
+ * @category Storage
+ * @internal
+ */
+export declare class VoidStorageManager implements IStorageManager<any> {
+    /**
+     * @inheritDoc
+     */
+    data: {
+        [p: string]: any;
+    };
+    /**
+     * @inheritDoc
+     */
+    init(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    loadData(type: {
+        new (data: any): any;
+    }): Promise<any[]>;
+    /**
+     * @inheritDoc
+     */
+    removeData(hash: string): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    saveData(hash: string, object: any): Promise<void>;
+}

package/dist/storage/VoidStorageManager.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoidStorageManager = void 0;
+/**
+ * A dummy storage manager that doesn't store anything, and should be only used as a placeholder
+ *
+ * @category Storage
+ * @internal
+ */
+class VoidStorageManager {
+    constructor() {
+        /**
+         * @inheritDoc
+         */
+        this.data = {};
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        return Promise.resolve();
+    }
+    /**
+     * @inheritDoc
+     */
+    loadData(type) {
+        return Promise.resolve([]);
+    }
+    /**
+     * @inheritDoc
+     */
+    removeData(hash) {
+        return Promise.resolve();
+    }
+    /**
+     * @inheritDoc
+     */
+    saveData(hash, object) {
+        return Promise.resolve();
+    }
+}
+exports.VoidStorageManager = VoidStorageManager;

package/dist/utils/Logger.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type of the logger
+ *
+ * @internal
+ */
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+};
+/**
+ * Getter function to create a logger instance
+ *
+ * @internal
+ */
+export declare function getLogger(prefix: string): LoggerType;

package/dist/utils/Logger.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = void 0;
+/**
+ * Getter function to create a logger instance
+ *
+ * @internal
+ */
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;

package/dist/utils/RetryUtils.d.ts

@@ -0,0 +1,23 @@
+type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ *
+ * @returns Result of the action executing callback
+ *
+ * @internal
+ */
+export declare function tryWithRetries<T>(func: (retryCount: number) => Promise<T>, retryPolicy?: {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+}, errorAllowed?: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[], abortSignal?: AbortSignal): Promise<T>;
+export {};

package/dist/utils/RetryUtils.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryWithRetries = void 0;
+const Logger_1 = require("./Logger");
+const TimeoutUtils_1 = require("./TimeoutUtils");
+const logger = (0, Logger_1.getLogger)("RetryUtils: ");
+function isConstructor(fn) {
+    return (typeof fn === 'function' &&
+        fn.prototype != null &&
+        fn.prototype.constructor === fn);
+}
+function isConstructorArray(fnArr) {
+    return Array.isArray(fnArr) && fnArr.every(isConstructor);
+}
+/**
+ * Checks whether the passed error is allowed to pass through
+ *
+ * @param e Error in question
+ * @param errorAllowed Allowed errors as defined as a callback function, specific error type, or an array of error types
+ */
+function checkError(e, errorAllowed) {
+    if (isConstructorArray(errorAllowed))
+        return errorAllowed.find(error => e instanceof error) != null;
+    if (isConstructor(errorAllowed))
+        return e instanceof errorAllowed;
+    return errorAllowed(e);
+}
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ *
+ * @returns Result of the action executing callback
+ *
+ * @internal
+ */
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            return await func(i);
+        }
+        catch (e) {
+            if (errorAllowed != null && checkError(e, errorAllowed))
+                throw e;
+            err = e;
+            logger.warn("tryWithRetries(): Error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw (abortSignal.reason || new Error("Aborted"));
+        if (i !== retryPolicy.maxRetries - 1) {
+            await (0, TimeoutUtils_1.timeoutPromise)(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;

package/dist/utils/TimeoutUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ *
+ * @internal
+ */
+export declare function timeoutPromise(timeout: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * Returns an abort signal that aborts after a specified timeout in milliseconds
+ *
+ * @param timeout Milliseconds to wait
+ * @param abortReason Abort with this abort reason
+ * @param abortSignal Abort signal to extend
+ *
+ * @internal
+ */
+export declare function timeoutSignal(timeout: number, abortReason?: any, abortSignal?: AbortSignal): AbortSignal;

package/dist/utils/TimeoutUtils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeoutSignal = exports.timeoutPromise = void 0;
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ *
+ * @internal
+ */
+function timeoutPromise(timeout, abortSignal) {
+    return new Promise((resolve, reject) => {
+        if (abortSignal != null && abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+        }
+        let abortSignalListener;
+        let timeoutHandle = setTimeout(() => {
+            if (abortSignalListener != null && abortSignal != null)
+                abortSignal.removeEventListener("abort", abortSignalListener);
+            resolve();
+        }, timeout);
+        if (abortSignal != null) {
+            abortSignal.addEventListener("abort", abortSignalListener = () => {
+                if (timeoutHandle != null)
+                    clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+                reject(abortSignal.reason);
+            });
+        }
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+/**
+ * Returns an abort signal that aborts after a specified timeout in milliseconds
+ *
+ * @param timeout Milliseconds to wait
+ * @param abortReason Abort with this abort reason
+ * @param abortSignal Abort signal to extend
+ *
+ * @internal
+ */
+function timeoutSignal(timeout, abortReason, abortSignal) {
+    if (timeout == null)
+        throw new Error("Timeout seconds cannot be null!");
+    const abortController = new AbortController();
+    const timeoutHandle = setTimeout(() => abortController.abort(abortReason || new Error("Timed out")), timeout);
+    if (abortSignal != null) {
+        abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutHandle);
+            abortController.abort(abortSignal.reason);
+        });
+    }
+    return abortController.signal;
+}
+exports.timeoutSignal = timeoutSignal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/base",
-  "version": "13.0.4",
+  "version": "13.1.3",
   "description": "Base classes and interfaces for atomiq protocol",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/btc/lightning/LightningNetworkApi.ts

@@ -0,0 +1,27 @@
+
+/**
+ * A type defining total capacity of a given lightning network node
+ *
+ * @category Bitcoin
+ */
+export type LNNodeLiquidity = {
+    publicKey: string,
+    capacity: bigint,
+    numChannels: number
+};
+
+/**
+ * An interface for Lightning API, provides view of the public lightning network data like channel graph
+ *
+ * @category Bitcoin
+ */
+export interface LightningNetworkApi {
+
+    /**
+     * Returns the lightning network's node liquidity as identified by an identity public key
+     *
+     * @param pubkey
+     */
+    getLNNodeLiquidity(pubkey: string): Promise<LNNodeLiquidity | null>
+
+}

package/src/btc/rpc/BitcoinRpc.ts

@@ -242,4 +242,11 @@ export interface BitcoinRpc<T extends BtcBlock> {
      */
     getEffectiveFeeRate(btcTx: BtcTx): Promise<{vsize: number, fee: number, feeRate: number}>;
 
+    /**
+     * Parses a bitcoin address from the passed output script in hexadecimal format
+     *
+     * @param outputScriptHex
+     */
+    outputScriptToAddress?(outputScriptHex: string): Promise<string>;
+
 }

package/src/btc/rpc/BitcoinRpcWithAddressIndex.ts

@@ -0,0 +1,138 @@
+import {Buffer} from "buffer";
+import {BitcoinRpc, BtcTx} from "./BitcoinRpc";
+import {BtcBlock} from "../../btcrelay/types/BtcBlock";
+
+
+/**
+ * A type defining a bitcoin transaction with its blockheight and optional input addresses populated
+ *
+ * @category Bitcoin
+ */
+export type BtcTxWithBlockheight = BtcTx & {
+    blockheight?: number,
+    inputAddresses?: string[]
+};
+
+/**
+ * A type defining a single UTXO belonging to an address
+ *
+ * @category Bitcoin
+ */
+export type BtcAddressUtxo = {
+    txid: string,
+    vout: number,
+    confirmed: boolean,
+    block_height: number,
+    block_hash: string,
+    block_time: number
+    value: bigint
+};
+
+/**
+ * An extended interface for Bitcoin, that allows querying balances and UTXOs of any address + other utilities
+ *
+ * @category Bitcoin
+ */
+export interface BitcoinRpcWithAddressIndex<T extends BtcBlock> extends BitcoinRpc<T> {
+
+    /**
+     * Returns the current fee rate required for submitted bitcoin transactions in sats/vB
+     */
+    getFeeRate(): Promise<number>;
+
+    /**
+     * Returns confirmed & unconfirmed balances for a given wallet address
+     *
+     * @param address
+     */
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint,
+        unconfirmedBalance: bigint
+    }>;
+
+    /**
+     * Returns UTXOs owned by the given wallet address
+     * @param address
+     */
+    getAddressUTXOs(address: string): Promise<BtcAddressUtxo[]>;
+
+    /**
+     * Returns CPFP (children-pay-for-parent) data for a given transaction, or null if transaction is not found
+     *  or already confirmed
+     *
+     * @param txId
+     */
+    getCPFPData(txId: string): Promise<{
+        effectiveFeePerVsize: number,
+        adjustedVsize: number
+    } | null>;
+
+    /**
+     * @inheritDoc
+     */
+    getTransaction(txId: string): Promise<BtcTxWithBlockheight | null>;
+
+    /**
+     * Awaits till the given transaction gets confirmed
+     *
+     * @param txId Transaction ID to monitor
+     * @param requiredConfirmations Required number of confirmations
+     * @param stateUpdateCbk Optional update callback called with the current status of the bitcoin transaction
+     * @param abortSignal
+     * @param intervalSeconds How often to poll
+     */
+    waitForTransaction(
+        txId: string,
+        requiredConfirmations: number,
+        stateUpdateCbk?: (btcTx?: BtcTxWithBlockheight, txEtaMS?: number) => void,
+        abortSignal?: AbortSignal,
+        intervalSeconds?: number
+    ): Promise<BtcTxWithBlockheight>;
+
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    getConfirmationDelay(tx: BtcTx, requiredConfirmations: number): Promise<number | null>
+
+    /**
+     * Checks if an address received the transaction with the required txoHash, returns info about that
+     *  specific transaction if found, or null if not found
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     */
+    checkAddressTxos(address: string, txoHash: Buffer): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">,
+        vout: number
+    } | null>;
+
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     * @param requiredConfirmations Required confirmations of the transaction
+     * @param stateUpdateCbk Callback for transaction state updates
+     * @param abortSignal Abort signal
+     * @param intervalSeconds How often to check new transaction
+     */
+    waitForAddressTxo(
+        address: string,
+        txoHash: Buffer,
+        requiredConfirmations: number,
+        stateUpdateCbk: (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMS?: number) => void,
+        abortSignal?: AbortSignal,
+        intervalSeconds?: number
+    ): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">,
+        vout: number
+    }>;
+
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from "./btcrelay/BtcRelay";
 export * from "./btc/rpc/BitcoinRpc";
+export * from "./btc/rpc/BitcoinRpcWithAddressIndex";
+export * from "./btc/lightning/LightningNetworkApi";
 export * from "./btcrelay/synchronizer/RelaySynchronizer";
 export * from "./btcrelay/types/BtcBlock";
 export * from "./btcrelay/types/BtcHeader";
@@ -12,6 +14,7 @@ export * from "./events/types/swap/RefundEvent";
 export * from "./events/types/swap/SwapEvent";
 export * from "./lockable/Lockable";
 export * from "./storage/IStorageManager";
+export * from "./storage/VoidStorageManager";
 export * from "./storage/StorageObject";
 export * from "./swaps/SwapContract";
 export * from "./swaps/SwapData";
@@ -27,6 +30,9 @@ export * from "./chains/ChainType";
 export * from "./chains/ChainData";
 
 export * from "./utils/BigIntBufferUtils";
+export * from "./utils/Logger";
+export * from "./utils/RetryUtils";
+export * from "./utils/TimeoutUtils";
 
 export * from "./btc/BitcoinNetwork";
 

package/src/storage/VoidStorageManager.ts

@@ -0,0 +1,42 @@
+import {IStorageManager} from "./IStorageManager";
+
+/**
+ * A dummy storage manager that doesn't store anything, and should be only used as a placeholder
+ *
+ * @category Storage
+ * @internal
+ */
+export class VoidStorageManager implements IStorageManager<any> {
+    /**
+     * @inheritDoc
+     */
+    data: { [p: string]: any } = {};
+
+    /**
+     * @inheritDoc
+     */
+    init(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    loadData(type: { new(data: any): any }): Promise<any[]> {
+        return Promise.resolve([]);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    removeData(hash: string): Promise<void> {
+        return Promise.resolve();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    saveData(hash: string, object: any): Promise<void> {
+        return Promise.resolve();
+    }
+}

package/src/utils/Logger.ts

@@ -0,0 +1,25 @@
+/**
+ * Type of the logger
+ *
+ * @internal
+ */
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void,
+    info: (msg: string, ...args: any[]) => void,
+    warn: (msg: string, ...args: any[]) => void,
+    error: (msg: string, ...args: any[]) => void
+};
+
+/**
+ * Getter function to create a logger instance
+ *
+ * @internal
+ */
+export function getLogger(prefix: string): LoggerType {
+    return {
+        debug: (msg, ...args) => (global as any).atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => (global as any).atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}

package/src/utils/RetryUtils.ts

@@ -0,0 +1,73 @@
+import {getLogger} from "./Logger";
+import {timeoutPromise} from "./TimeoutUtils";
+
+const logger = getLogger("RetryUtils: ");
+
+type Constructor<T = any> = new (...args: any[]) => T;
+
+function isConstructor(fn: any): fn is Constructor {
+    return (
+        typeof fn === 'function' &&
+        fn.prototype != null &&
+        fn.prototype.constructor === fn
+    );
+}
+
+function isConstructorArray(fnArr: any): fnArr is Constructor[] {
+    return Array.isArray(fnArr) && fnArr.every(isConstructor);
+}
+
+/**
+ * Checks whether the passed error is allowed to pass through
+ *
+ * @param e Error in question
+ * @param errorAllowed Allowed errors as defined as a callback function, specific error type, or an array of error types
+ */
+function checkError(e: any, errorAllowed: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[]) {
+    if (isConstructorArray(errorAllowed)) return errorAllowed.find(error => e instanceof error) != null;
+    if (isConstructor(errorAllowed)) return e instanceof errorAllowed;
+    return errorAllowed(e);
+}
+
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ *
+ * @returns Result of the action executing callback
+ *
+ * @internal
+ */
+export async function tryWithRetries<T>(func: (retryCount: number) => Promise<T>, retryPolicy?: {
+    maxRetries?: number, delay?: number, exponential?: boolean
+}, errorAllowed?: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[], abortSignal?: AbortSignal): Promise<T> {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+
+    let err = null;
+
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            return await func(i);
+        } catch (e) {
+            if (errorAllowed != null && checkError(e, errorAllowed)) throw e;
+            err = e;
+            logger.warn("tryWithRetries(): Error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted) throw (abortSignal.reason || new Error("Aborted"));
+        if (i !== retryPolicy.maxRetries - 1) {
+            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+
+    throw err;
+}

package/src/utils/TimeoutUtils.ts

@@ -0,0 +1,52 @@
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ *
+ * @internal
+ */
+export function timeoutPromise(timeout: number, abortSignal?: AbortSignal): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        if (abortSignal != null && abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+        }
+
+        let abortSignalListener: () => void;
+        let timeoutHandle: any | null = setTimeout(() => {
+            if (abortSignalListener != null && abortSignal != null) abortSignal.removeEventListener("abort", abortSignalListener);
+            resolve();
+        }, timeout);
+
+        if (abortSignal != null) {
+            abortSignal.addEventListener("abort", abortSignalListener = () => {
+                if (timeoutHandle != null) clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+                reject(abortSignal.reason);
+            });
+        }
+    });
+}
+
+/**
+ * Returns an abort signal that aborts after a specified timeout in milliseconds
+ *
+ * @param timeout Milliseconds to wait
+ * @param abortReason Abort with this abort reason
+ * @param abortSignal Abort signal to extend
+ *
+ * @internal
+ */
+export function timeoutSignal(timeout: number, abortReason?: any, abortSignal?: AbortSignal): AbortSignal {
+    if (timeout == null) throw new Error("Timeout seconds cannot be null!");
+    const abortController = new AbortController();
+    const timeoutHandle = setTimeout(() => abortController.abort(abortReason || new Error("Timed out")), timeout);
+    if (abortSignal != null) {
+        abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutHandle);
+            abortController.abort(abortSignal.reason);
+        });
+    }
+    return abortController.signal;
+}