@atomiqlabs/sdk 8.7.7 → 8.8.4

package/src/events/UnifiedSwapEventListener.ts

@@ -1,173 +1,173 @@
-import {
-    ChainEvent,
-    ChainSwapType,
-    ChainType,
-    InitializeEvent,
-    SpvVaultClaimEvent,
-    SpvVaultCloseEvent,
-    SpvVaultFrontEvent,
-    SwapEvent
-} 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";
-
-import {getLogger} from "../utils/Logger";
-
-function chainEventToEscrowHash(event: ChainEvent<any>): string | undefined {
-    if(event instanceof SwapEvent) return event.escrowHash;
-    if(
-        event instanceof SpvVaultFrontEvent ||
-        event instanceof SpvVaultClaimEvent ||
-        event instanceof SpvVaultCloseEvent
-    ) return event.btcTxId;
-}
-
-export type SwapEventListener<
-    T extends ChainType,
-    S extends ISwap<T>
-> = (event: ChainEvent<T["Data"]>, swap: S) => Promise<void>;
-
-const logger = getLogger("UnifiedSwapEventListener: ");
-
-export 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"]) {
-        this.storage = unifiedStorage;
-        this.events = events;
-    }
-
-    async processEvents(events: ChainEvent<T["Data"]>[]) {
-        const escrowHashesDeduped = new Set<string>();
-        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<ISwap<T>>(
-            [
-                [{key: "escrowHash", value: escrowHashes}]
-            ],
-            (val: any) => {
-                const obj = this.listeners?.[val.type as SwapType];
-                if(obj==null) return null;
-                return new obj.reviver(val);
-            }
-        );
-        const swapsByEscrowHash: {[key: string]: ISwap<T>} = {};
-        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: {[claimHash: string]: InitializeEvent<T["Data"]>} = {};
-
-        for(let event of events) {
-            const escrowHash = chainEventToEscrowHash(event);
-            const eventVersion = event.contractVersion ?? "v1";
-            if(escrowHash!=null) {
-                const swap = swapsByEscrowHash[escrowHash];
-                if(swap!=null && (swap._contractVersion ?? "v1")===eventVersion) {
-                    const obj = this.listeners[swap.getType()];
-                    if(obj==null) continue;
-                    await obj.listener(event, swap);
-                    continue;
-                }
-            }
-            if(event instanceof InitializeEvent) {
-                if(event.swapType===ChainSwapType.HTLC) {
-                    const swapData: T["Data"] = 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<ISwap<T>>(
-            [
-                [{key: "escrowHash", value: Object.keys(htlcCheckInitializeEvents)}]
-            ],
-            (val: any) => {
-                const obj = this.listeners?.[val.type as SwapType];
-                if(obj==null) return null;
-                return new obj.reviver(val);
-            }
-        );
-        const swapsByClaimDataHash: {[claimData: string]: ISwap<T>} = {};
-        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 eventVersion = event.contractVersion ?? "v1";
-            const swap = swapsByClaimDataHash[claimData];
-            if(swap!=null && (swap._contractVersion ?? "v1")===eventVersion) {
-                const obj = this.listeners[swap.getType()];
-                if(obj==null) continue;
-                await obj.listener(event, swap);
-            }
-        }
-
-    }
-
-    listener?: EventListener<T["Data"]>;
-    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(): Promise<void> {
-        logger.info("stop(): Stopping unified swap event listener");
-        if(this.listener!=null) this.events.unregisterListener(this.listener);
-        return this.events.stop();
-    }
-
-    registerListener<S extends ISwap<T>>(type: SwapType, listener: SwapEventListener<T, S>, reviver: new (val: any) => S): void {
-        this.listeners[type] = {
-            listener,
-            reviver
-        };
-    }
-
-    unregisterListener(type: SwapType): boolean {
-        if(this.listeners[type]) return false;
-        delete this.listeners[type];
-        return true;
-    }
-
-}
+import {
+    ChainEvent,
+    ChainSwapType,
+    ChainType,
+    InitializeEvent,
+    SpvVaultClaimEvent,
+    SpvVaultCloseEvent,
+    SpvVaultFrontEvent,
+    SwapEvent
+} 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";
+
+import {getLogger} from "../utils/Logger";
+
+function chainEventToEscrowHash(event: ChainEvent<any>): string | undefined {
+    if(event instanceof SwapEvent) return event.escrowHash;
+    if(
+        event instanceof SpvVaultFrontEvent ||
+        event instanceof SpvVaultClaimEvent ||
+        event instanceof SpvVaultCloseEvent
+    ) return event.btcTxId;
+}
+
+export type SwapEventListener<
+    T extends ChainType,
+    S extends ISwap<T>
+> = (event: ChainEvent<T["Data"]>, swap: S) => Promise<void>;
+
+const logger = getLogger("UnifiedSwapEventListener: ");
+
+export 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"]) {
+        this.storage = unifiedStorage;
+        this.events = events;
+    }
+
+    async processEvents(events: ChainEvent<T["Data"]>[]) {
+        const escrowHashesDeduped = new Set<string>();
+        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<ISwap<T>>(
+            [
+                [{key: "escrowHash", value: escrowHashes}]
+            ],
+            (val: any) => {
+                const obj = this.listeners?.[val.type as SwapType];
+                if(obj==null) return null;
+                return new obj.reviver(val);
+            }
+        );
+        const swapsByEscrowHash: {[key: string]: ISwap<T>} = {};
+        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: {[claimHash: string]: InitializeEvent<T["Data"]>} = {};
+
+        for(let event of events) {
+            const escrowHash = chainEventToEscrowHash(event);
+            const eventVersion = event.contractVersion ?? "v1";
+            if(escrowHash!=null) {
+                const swap = swapsByEscrowHash[escrowHash];
+                if(swap!=null && (swap._contractVersion ?? "v1")===eventVersion) {
+                    const obj = this.listeners[swap.getType()];
+                    if(obj==null) continue;
+                    await obj.listener(event, swap);
+                    continue;
+                }
+            }
+            if(event instanceof InitializeEvent) {
+                if(event.swapType===ChainSwapType.HTLC) {
+                    const swapData: T["Data"] = 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<ISwap<T>>(
+            [
+                [{key: "escrowHash", value: Object.keys(htlcCheckInitializeEvents)}]
+            ],
+            (val: any) => {
+                const obj = this.listeners?.[val.type as SwapType];
+                if(obj==null) return null;
+                return new obj.reviver(val);
+            }
+        );
+        const swapsByClaimDataHash: {[claimData: string]: ISwap<T>} = {};
+        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 eventVersion = event.contractVersion ?? "v1";
+            const swap = swapsByClaimDataHash[claimData];
+            if(swap!=null && (swap._contractVersion ?? "v1")===eventVersion) {
+                const obj = this.listeners[swap.getType()];
+                if(obj==null) continue;
+                await obj.listener(event, swap);
+            }
+        }
+
+    }
+
+    listener?: EventListener<T["Data"]>;
+    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(): Promise<void> {
+        logger.info("stop(): Stopping unified swap event listener");
+        if(this.listener!=null) this.events.unregisterListener(this.listener);
+        return this.events.stop();
+    }
+
+    registerListener<S extends ISwap<T>>(type: SwapType, listener: SwapEventListener<T, S>, reviver: new (val: any) => S): void {
+        this.listeners[type] = {
+            listener,
+            reviver
+        };
+    }
+
+    unregisterListener(type: SwapType): boolean {
+        if(this.listeners[type]) return false;
+        delete this.listeners[type];
+        return true;
+    }
+
+}

package/src/http/HttpUtils.ts

@@ -1,92 +1,92 @@
-import {RequestError} from "../errors/RequestError";
-
-import {timeoutSignal} from "../utils/TimeoutUtils";
-
-/**
- * Mimics fetch API byt adds a timeout to the request
- *
- * @param input
- * @param init
- */
-export function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit & {
-    timeout?: number
-}): Promise<Response> {
-    if (init == null) init = {};
-    if (init.timeout != null) init.signal = 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
- */
-export async function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200: boolean = false): Promise<T> {
-    const init = {
-        method: "GET",
-        timeout,
-        signal: abortSignal
-    };
-
-    const response: Response = await fetchWithTimeout(url, init);
-
-    if (response.status !== 200) {
-        let resp: string;
-        try {
-            resp = await response.text();
-        } catch (e) {
-            throw new RequestError(response.statusText, response.status);
-        }
-        if (allowNon200) {
-            try {
-                return JSON.parse(resp);
-            } catch (e) {
-            }
-        }
-        throw 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
- */
-export async function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T> {
-    const init = {
-        method: "POST",
-        timeout,
-        body: JSON.stringify(body),
-        headers: {'Content-Type': 'application/json'},
-        signal: abortSignal
-    };
-
-    const response: Response = timeout == null ? await fetch(url, init) : await fetchWithTimeout(url, init);
-
-    if (response.status !== 200) {
-        let resp: string;
-        try {
-            resp = await response.text();
-        } catch (e) {
-            throw new RequestError(response.statusText, response.status);
-        }
-        throw RequestError.parse(resp, response.status);
-    }
-
-    return await response.json();
+import {RequestError} from "../errors/RequestError";
+
+import {timeoutSignal} from "../utils/TimeoutUtils";
+
+/**
+ * Mimics fetch API byt adds a timeout to the request
+ *
+ * @param input
+ * @param init
+ */
+export function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit & {
+    timeout?: number
+}): Promise<Response> {
+    if (init == null) init = {};
+    if (init.timeout != null) init.signal = 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
+ */
+export async function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200: boolean = false): Promise<T> {
+    const init = {
+        method: "GET",
+        timeout,
+        signal: abortSignal
+    };
+
+    const response: Response = await fetchWithTimeout(url, init);
+
+    if (response.status !== 200) {
+        let resp: string;
+        try {
+            resp = await response.text();
+        } catch (e) {
+            throw new RequestError(response.statusText, response.status);
+        }
+        if (allowNon200) {
+            try {
+                return JSON.parse(resp);
+            } catch (e) {
+            }
+        }
+        throw 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
+ */
+export async function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T> {
+    const init = {
+        method: "POST",
+        timeout,
+        body: JSON.stringify(body),
+        headers: {'Content-Type': 'application/json'},
+        signal: abortSignal
+    };
+
+    const response: Response = timeout == null ? await fetch(url, init) : await fetchWithTimeout(url, init);
+
+    if (response.status !== 200) {
+        let resp: string;
+        try {
+            resp = await response.text();
+        } catch (e) {
+            throw new RequestError(response.statusText, response.status);
+        }
+        throw RequestError.parse(resp, response.status);
+    }
+
+    return await response.json();
 }

package/src/http/paramcoders/IParamReader.ts

@@ -1,10 +1,10 @@
-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>;
+
 }