@atomiqlabs/sdk 8.6.4 → 8.6.6

package/dist/events/UnifiedSwapEventListener.d.ts

@@ -1,23 +1,23 @@
-import { ChainEvent, ChainType } from "@atomiqlabs/base";
-import { ISwap } from "../swaps/ISwap";
-import { EventListener } from "@atomiqlabs/base/src/events/ChainEvents";
-import { SwapType } from "../enums/SwapType";
-import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
-export type SwapEventListener<T extends ChainType, S extends ISwap<T>> = (event: ChainEvent<T["Data"]>, swap: S) => Promise<void>;
-export declare class UnifiedSwapEventListener<T extends ChainType> {
-    readonly storage: UnifiedSwapStorage<T>;
-    readonly events: T["Events"];
-    readonly listeners: {
-        [key in SwapType]?: {
-            listener: SwapEventListener<T, any>;
-            reviver: new (obj: any) => ISwap<T>;
-        };
-    };
-    constructor(unifiedStorage: UnifiedSwapStorage<T>, events: T["Events"]);
-    processEvents(events: ChainEvent<T["Data"]>[]): Promise<void>;
-    listener?: EventListener<T["Data"]>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    registerListener<S extends ISwap<T>>(type: SwapType, listener: SwapEventListener<T, S>, reviver: new (val: any) => S): void;
-    unregisterListener(type: SwapType): boolean;
-}
+import { ChainEvent, ChainType } from "@atomiqlabs/base";
+import { ISwap } from "../swaps/ISwap";
+import { EventListener } from "@atomiqlabs/base/src/events/ChainEvents";
+import { SwapType } from "../enums/SwapType";
+import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
+export type SwapEventListener<T extends ChainType, S extends ISwap<T>> = (event: ChainEvent<T["Data"]>, swap: S) => Promise<void>;
+export declare class UnifiedSwapEventListener<T extends ChainType> {
+    readonly storage: UnifiedSwapStorage<T>;
+    readonly events: T["Events"];
+    readonly listeners: {
+        [key in SwapType]?: {
+            listener: SwapEventListener<T, any>;
+            reviver: new (obj: any) => ISwap<T>;
+        };
+    };
+    constructor(unifiedStorage: UnifiedSwapStorage<T>, events: T["Events"]);
+    processEvents(events: ChainEvent<T["Data"]>[]): Promise<void>;
+    listener?: EventListener<T["Data"]>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    registerListener<S extends ISwap<T>>(type: SwapType, listener: SwapEventListener<T, S>, reviver: new (val: any) => S): void;
+    unregisterListener(type: SwapType): boolean;
+}

package/dist/events/UnifiedSwapEventListener.js

@@ -1,130 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnifiedSwapEventListener = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Logger_1 = require("../utils/Logger");
-function chainEventToEscrowHash(event) {
-    if (event instanceof base_1.SwapEvent)
-        return event.escrowHash;
-    if (event instanceof base_1.SpvVaultFrontEvent ||
-        event instanceof base_1.SpvVaultClaimEvent ||
-        event instanceof base_1.SpvVaultCloseEvent)
-        return event.btcTxId;
-}
-const logger = (0, Logger_1.getLogger)("UnifiedSwapEventListener: ");
-class UnifiedSwapEventListener {
-    constructor(unifiedStorage, events) {
-        this.listeners = {};
-        this.storage = unifiedStorage;
-        this.events = events;
-    }
-    async processEvents(events) {
-        const escrowHashesDeduped = new Set();
-        events.forEach(event => {
-            const escrowHash = chainEventToEscrowHash(event);
-            if (escrowHash != null)
-                escrowHashesDeduped.add(escrowHash);
-        });
-        const escrowHashes = Array.from(escrowHashesDeduped);
-        logger.debug("processEvents(): Processing events with escrow hashes: ", escrowHashes);
-        const swaps = await this.storage.query([
-            [{ key: "escrowHash", value: escrowHashes }]
-        ], (val) => {
-            const obj = this.listeners?.[val.type];
-            if (obj == null)
-                return null;
-            return new obj.reviver(val);
-        });
-        const swapsByEscrowHash = {};
-        swaps.forEach(swap => {
-            const escrowHash = swap._getEscrowHash();
-            if (escrowHash != null)
-                swapsByEscrowHash[escrowHash] = swap;
-        });
-        //We need to do this because FromBTCLNAutoSwaps might not yet know its escrowHash
-        // hence we try to get the claimHash and try to query based on that, FromBTCLNAutoSwaps
-        // will use their claimHash as escrowHash before they know the real escrowHash
-        const htlcCheckInitializeEvents = {};
-        for (let event of events) {
-            const escrowHash = chainEventToEscrowHash(event);
-            if (escrowHash != null) {
-                const swap = swapsByEscrowHash[escrowHash];
-                if (swap != null) {
-                    const obj = this.listeners[swap.getType()];
-                    if (obj == null)
-                        continue;
-                    await obj.listener(event, swap);
-                    continue;
-                }
-            }
-            if (event instanceof base_1.InitializeEvent) {
-                if (event.swapType === base_1.ChainSwapType.HTLC) {
-                    const swapData = await event.swapData();
-                    htlcCheckInitializeEvents[swapData.getClaimHash()] = event;
-                }
-            }
-        }
-        logger.debug("processEvents(): Additionally checking HTLC claim hashes: ", Object.keys(htlcCheckInitializeEvents));
-        if (Object.keys(htlcCheckInitializeEvents).length === 0)
-            return;
-        //Try to query based on claimData
-        const claimDataSwaps = await this.storage.query([
-            [{ key: "escrowHash", value: Object.keys(htlcCheckInitializeEvents) }]
-        ], (val) => {
-            const obj = this.listeners?.[val.type];
-            if (obj == null)
-                return null;
-            return new obj.reviver(val);
-        });
-        const swapsByClaimDataHash = {};
-        claimDataSwaps.forEach(swap => {
-            const escrowHash = swap._getEscrowHash();
-            if (escrowHash != null)
-                swapsByClaimDataHash[escrowHash] = swap;
-        });
-        logger.debug("processEvents(): Additional HTLC swaps founds: ", swapsByClaimDataHash);
-        for (let claimData in htlcCheckInitializeEvents) {
-            const event = htlcCheckInitializeEvents[claimData];
-            const swap = swapsByClaimDataHash[claimData];
-            if (swap != null) {
-                const obj = this.listeners[swap.getType()];
-                if (obj == null)
-                    continue;
-                await obj.listener(event, swap);
-            }
-        }
-    }
-    async start() {
-        if (this.listener != null)
-            return;
-        logger.info("start(): Starting unified swap event listener");
-        await this.storage.init();
-        logger.debug("start(): Storage initialized");
-        await this.events.init();
-        logger.debug("start(): Events initialized");
-        this.events.registerListener(this.listener = async (events) => {
-            await this.processEvents(events);
-            return true;
-        });
-        logger.info("start(): Successfully initiated the unified swap event listener!");
-    }
-    stop() {
-        logger.info("stop(): Stopping unified swap event listener");
-        if (this.listener != null)
-            this.events.unregisterListener(this.listener);
-        return this.events.stop();
-    }
-    registerListener(type, listener, reviver) {
-        this.listeners[type] = {
-            listener,
-            reviver
-        };
-    }
-    unregisterListener(type) {
-        if (this.listeners[type])
-            return false;
-        delete this.listeners[type];
-        return true;
-    }
-}
-exports.UnifiedSwapEventListener = UnifiedSwapEventListener;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedSwapEventListener = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Logger_1 = require("../utils/Logger");
+function chainEventToEscrowHash(event) {
+    if (event instanceof base_1.SwapEvent)
+        return event.escrowHash;
+    if (event instanceof base_1.SpvVaultFrontEvent ||
+        event instanceof base_1.SpvVaultClaimEvent ||
+        event instanceof base_1.SpvVaultCloseEvent)
+        return event.btcTxId;
+}
+const logger = (0, Logger_1.getLogger)("UnifiedSwapEventListener: ");
+class UnifiedSwapEventListener {
+    constructor(unifiedStorage, events) {
+        this.listeners = {};
+        this.storage = unifiedStorage;
+        this.events = events;
+    }
+    async processEvents(events) {
+        const escrowHashesDeduped = new Set();
+        events.forEach(event => {
+            const escrowHash = chainEventToEscrowHash(event);
+            if (escrowHash != null)
+                escrowHashesDeduped.add(escrowHash);
+        });
+        const escrowHashes = Array.from(escrowHashesDeduped);
+        logger.debug("processEvents(): Processing events with escrow hashes: ", escrowHashes);
+        const swaps = await this.storage.query([
+            [{ key: "escrowHash", value: escrowHashes }]
+        ], (val) => {
+            const obj = this.listeners?.[val.type];
+            if (obj == null)
+                return null;
+            return new obj.reviver(val);
+        });
+        const swapsByEscrowHash = {};
+        swaps.forEach(swap => {
+            const escrowHash = swap._getEscrowHash();
+            if (escrowHash != null)
+                swapsByEscrowHash[escrowHash] = swap;
+        });
+        //We need to do this because FromBTCLNAutoSwaps might not yet know its escrowHash
+        // hence we try to get the claimHash and try to query based on that, FromBTCLNAutoSwaps
+        // will use their claimHash as escrowHash before they know the real escrowHash
+        const htlcCheckInitializeEvents = {};
+        for (let event of events) {
+            const escrowHash = chainEventToEscrowHash(event);
+            if (escrowHash != null) {
+                const swap = swapsByEscrowHash[escrowHash];
+                if (swap != null) {
+                    const obj = this.listeners[swap.getType()];
+                    if (obj == null)
+                        continue;
+                    await obj.listener(event, swap);
+                    continue;
+                }
+            }
+            if (event instanceof base_1.InitializeEvent) {
+                if (event.swapType === base_1.ChainSwapType.HTLC) {
+                    const swapData = await event.swapData();
+                    htlcCheckInitializeEvents[swapData.getClaimHash()] = event;
+                }
+            }
+        }
+        logger.debug("processEvents(): Additionally checking HTLC claim hashes: ", Object.keys(htlcCheckInitializeEvents));
+        if (Object.keys(htlcCheckInitializeEvents).length === 0)
+            return;
+        //Try to query based on claimData
+        const claimDataSwaps = await this.storage.query([
+            [{ key: "escrowHash", value: Object.keys(htlcCheckInitializeEvents) }]
+        ], (val) => {
+            const obj = this.listeners?.[val.type];
+            if (obj == null)
+                return null;
+            return new obj.reviver(val);
+        });
+        const swapsByClaimDataHash = {};
+        claimDataSwaps.forEach(swap => {
+            const escrowHash = swap._getEscrowHash();
+            if (escrowHash != null)
+                swapsByClaimDataHash[escrowHash] = swap;
+        });
+        logger.debug("processEvents(): Additional HTLC swaps founds: ", swapsByClaimDataHash);
+        for (let claimData in htlcCheckInitializeEvents) {
+            const event = htlcCheckInitializeEvents[claimData];
+            const swap = swapsByClaimDataHash[claimData];
+            if (swap != null) {
+                const obj = this.listeners[swap.getType()];
+                if (obj == null)
+                    continue;
+                await obj.listener(event, swap);
+            }
+        }
+    }
+    async start() {
+        if (this.listener != null)
+            return;
+        logger.info("start(): Starting unified swap event listener");
+        await this.storage.init();
+        logger.debug("start(): Storage initialized");
+        await this.events.init();
+        logger.debug("start(): Events initialized");
+        this.events.registerListener(this.listener = async (events) => {
+            await this.processEvents(events);
+            return true;
+        });
+        logger.info("start(): Successfully initiated the unified swap event listener!");
+    }
+    stop() {
+        logger.info("stop(): Stopping unified swap event listener");
+        if (this.listener != null)
+            this.events.unregisterListener(this.listener);
+        return this.events.stop();
+    }
+    registerListener(type, listener, reviver) {
+        this.listeners[type] = {
+            listener,
+            reviver
+        };
+    }
+    unregisterListener(type) {
+        if (this.listeners[type])
+            return false;
+        delete this.listeners[type];
+        return true;
+    }
+}
+exports.UnifiedSwapEventListener = UnifiedSwapEventListener;

package/dist/http/HttpUtils.d.ts

@@ -1,27 +1,27 @@
-/**
- * Mimics fetch API byt adds a timeout to the request
- *
- * @param input
- * @param init
- */
-export declare function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit & {
-    timeout?: number;
-}): Promise<Response>;
-/**
- * Sends an HTTP GET request through a fetch API, handles non 200 response codes as errors
- * @param url Send request to this URL
- * @param timeout Timeout (in milliseconds) for the request to conclude
- * @param abortSignal
- * @param allowNon200 Whether to allow non-200 status code HTTP responses
- * @throws {RequestError} if non 200 response code was returned or body cannot be parsed
- */
-export declare function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200?: boolean): Promise<T>;
-/**
- * Sends an HTTP POST request through a fetch API, handles non 200 response codes as errors
- * @param url Send request to this URL
- * @param body A HTTP request body to send to the server
- * @param timeout Timeout (in milliseconds) for the request to conclude
- * @param abortSignal
- * @throws {RequestError} if non 200 response code was returned
- */
-export declare function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T>;
+/**
+ * Mimics fetch API byt adds a timeout to the request
+ *
+ * @param input
+ * @param init
+ */
+export declare function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit & {
+    timeout?: number;
+}): Promise<Response>;
+/**
+ * Sends an HTTP GET request through a fetch API, handles non 200 response codes as errors
+ * @param url Send request to this URL
+ * @param timeout Timeout (in milliseconds) for the request to conclude
+ * @param abortSignal
+ * @param allowNon200 Whether to allow non-200 status code HTTP responses
+ * @throws {RequestError} if non 200 response code was returned or body cannot be parsed
+ */
+export declare function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200?: boolean): Promise<T>;
+/**
+ * Sends an HTTP POST request through a fetch API, handles non 200 response codes as errors
+ * @param url Send request to this URL
+ * @param body A HTTP request body to send to the server
+ * @param timeout Timeout (in milliseconds) for the request to conclude
+ * @param abortSignal
+ * @throws {RequestError} if non 200 response code was returned
+ */
+export declare function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T>;

package/dist/http/HttpUtils.js

@@ -1,91 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpPost = exports.httpGet = exports.fetchWithTimeout = void 0;
-const RequestError_1 = require("../errors/RequestError");
-const TimeoutUtils_1 = require("../utils/TimeoutUtils");
-/**
- * Mimics fetch API byt adds a timeout to the request
- *
- * @param input
- * @param init
- */
-function fetchWithTimeout(input, init) {
-    if (init == null)
-        init = {};
-    if (init.timeout != null)
-        init.signal = (0, TimeoutUtils_1.timeoutSignal)(init.timeout, new Error("Network request timed out"), init.signal ?? undefined);
-    return fetch(input, init).catch(e => {
-        if (e.name === "AbortError" && init.signal != null) {
-            throw init.signal.reason;
-        }
-        else {
-            throw e;
-        }
-    });
-}
-exports.fetchWithTimeout = fetchWithTimeout;
-/**
- * Sends an HTTP GET request through a fetch API, handles non 200 response codes as errors
- * @param url Send request to this URL
- * @param timeout Timeout (in milliseconds) for the request to conclude
- * @param abortSignal
- * @param allowNon200 Whether to allow non-200 status code HTTP responses
- * @throws {RequestError} if non 200 response code was returned or body cannot be parsed
- */
-async function httpGet(url, timeout, abortSignal, allowNon200 = false) {
-    const init = {
-        method: "GET",
-        timeout,
-        signal: abortSignal
-    };
-    const response = await fetchWithTimeout(url, init);
-    if (response.status !== 200) {
-        let resp;
-        try {
-            resp = await response.text();
-        }
-        catch (e) {
-            throw new RequestError_1.RequestError(response.statusText, response.status);
-        }
-        if (allowNon200) {
-            try {
-                return JSON.parse(resp);
-            }
-            catch (e) {
-            }
-        }
-        throw RequestError_1.RequestError.parse(resp, response.status);
-    }
-    return await response.json();
-}
-exports.httpGet = httpGet;
-/**
- * Sends an HTTP POST request through a fetch API, handles non 200 response codes as errors
- * @param url Send request to this URL
- * @param body A HTTP request body to send to the server
- * @param timeout Timeout (in milliseconds) for the request to conclude
- * @param abortSignal
- * @throws {RequestError} if non 200 response code was returned
- */
-async function httpPost(url, body, timeout, abortSignal) {
-    const init = {
-        method: "POST",
-        timeout,
-        body: JSON.stringify(body),
-        headers: { 'Content-Type': 'application/json' },
-        signal: abortSignal
-    };
-    const response = timeout == null ? await fetch(url, init) : await fetchWithTimeout(url, init);
-    if (response.status !== 200) {
-        let resp;
-        try {
-            resp = await response.text();
-        }
-        catch (e) {
-            throw new RequestError_1.RequestError(response.statusText, response.status);
-        }
-        throw RequestError_1.RequestError.parse(resp, response.status);
-    }
-    return await response.json();
-}
-exports.httpPost = httpPost;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithTimeout = fetchWithTimeout;
+exports.httpGet = httpGet;
+exports.httpPost = httpPost;
+const RequestError_1 = require("../errors/RequestError");
+const TimeoutUtils_1 = require("../utils/TimeoutUtils");
+/**
+ * Mimics fetch API byt adds a timeout to the request
+ *
+ * @param input
+ * @param init
+ */
+function fetchWithTimeout(input, init) {
+    if (init == null)
+        init = {};
+    if (init.timeout != null)
+        init.signal = (0, TimeoutUtils_1.timeoutSignal)(init.timeout, new Error("Network request timed out"), init.signal ?? undefined);
+    return fetch(input, init).catch(e => {
+        if (e.name === "AbortError" && init.signal != null) {
+            throw init.signal.reason;
+        }
+        else {
+            throw e;
+        }
+    });
+}
+/**
+ * Sends an HTTP GET request through a fetch API, handles non 200 response codes as errors
+ * @param url Send request to this URL
+ * @param timeout Timeout (in milliseconds) for the request to conclude
+ * @param abortSignal
+ * @param allowNon200 Whether to allow non-200 status code HTTP responses
+ * @throws {RequestError} if non 200 response code was returned or body cannot be parsed
+ */
+async function httpGet(url, timeout, abortSignal, allowNon200 = false) {
+    const init = {
+        method: "GET",
+        timeout,
+        signal: abortSignal
+    };
+    const response = await fetchWithTimeout(url, init);
+    if (response.status !== 200) {
+        let resp;
+        try {
+            resp = await response.text();
+        }
+        catch (e) {
+            throw new RequestError_1.RequestError(response.statusText, response.status);
+        }
+        if (allowNon200) {
+            try {
+                return JSON.parse(resp);
+            }
+            catch (e) {
+            }
+        }
+        throw RequestError_1.RequestError.parse(resp, response.status);
+    }
+    return await response.json();
+}
+/**
+ * Sends an HTTP POST request through a fetch API, handles non 200 response codes as errors
+ * @param url Send request to this URL
+ * @param body A HTTP request body to send to the server
+ * @param timeout Timeout (in milliseconds) for the request to conclude
+ * @param abortSignal
+ * @throws {RequestError} if non 200 response code was returned
+ */
+async function httpPost(url, body, timeout, abortSignal) {
+    const init = {
+        method: "POST",
+        timeout,
+        body: JSON.stringify(body),
+        headers: { 'Content-Type': 'application/json' },
+        signal: abortSignal
+    };
+    const response = timeout == null ? await fetch(url, init) : await fetchWithTimeout(url, init);
+    if (response.status !== 200) {
+        let resp;
+        try {
+            resp = await response.text();
+        }
+        catch (e) {
+            throw new RequestError_1.RequestError(response.statusText, response.status);
+        }
+        throw RequestError_1.RequestError.parse(resp, response.status);
+    }
+    return await response.json();
+}

package/dist/http/paramcoders/IParamReader.d.ts

@@ -1,8 +1,8 @@
-export interface IParamReader {
-    /**
-     * Returns a promise when the specific property with the name is read from the stream
-     *
-     * @param name Name of the property
-     */
-    getParam<T>(name: string): Promise<T>;
-}
+export interface IParamReader {
+    /**
+     * Returns a promise when the specific property with the name is read from the stream
+     *
+     * @param name Name of the property
+     */
+    getParam<T>(name: string): Promise<T>;
+}

package/dist/http/paramcoders/IParamReader.js

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