@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/errors/RequestError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An error returned by the intermediary in a http response
+ * @category Errors
+ */
+export declare class RequestError extends Error {
+    httpCode: number;
+    constructor(msg: string, httpCode: number);
+    static parse(msg: string, httpCode: number): RequestError;
+}
+/**
+ * An error indicating out of bounds (amount too high or too low) on swap initialization
+ * @category Errors
+ */
+export declare class OutOfBoundsError extends RequestError {
+    min: bigint;
+    max: bigint;
+    constructor(msg: string, httpCode: number, min: bigint, max: bigint);
+}

package/dist/errors/RequestError.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutOfBoundsError = exports.RequestError = void 0;
+/**
+ * An error returned by the intermediary in a http response
+ * @category Errors
+ */
+class RequestError extends Error {
+    constructor(msg, httpCode) {
+        try {
+            const parsed = JSON.parse(msg);
+            if (parsed.msg != null)
+                msg = parsed.msg;
+        }
+        catch (e) { }
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestError.prototype);
+        this.httpCode = httpCode;
+    }
+    static parse(msg, httpCode) {
+        try {
+            const parsed = JSON.parse(msg);
+            msg = parsed.msg;
+            if (parsed.code === 20003 || parsed.code === 20004) {
+                return new OutOfBoundsError(parsed.msg, httpCode, BigInt(parsed.data.min), BigInt(parsed.data.max));
+            }
+        }
+        catch (e) { }
+        return new RequestError(msg, httpCode);
+    }
+}
+exports.RequestError = RequestError;
+/**
+ * An error indicating out of bounds (amount too high or too low) on swap initialization
+ * @category Errors
+ */
+class OutOfBoundsError extends RequestError {
+    constructor(msg, httpCode, min, max) {
+        super(msg, httpCode);
+        this.max = max;
+        this.min = min;
+        Object.setPrototypeOf(this, OutOfBoundsError.prototype);
+    }
+}
+exports.OutOfBoundsError = OutOfBoundsError;

package/dist/errors/UserError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * An error on the user side, such as invalid address provided
+ * @category Errors
+ */
+export declare class UserError extends Error {
+    constructor(msg: string);
+}

package/dist/errors/UserError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserError = void 0;
+/**
+ * An error on the user side, such as invalid address provided
+ * @category Errors
+ */
+class UserError extends Error {
+    constructor(msg) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, UserError.prototype);
+    }
+}
+exports.UserError = UserError;

package/dist/events/UnifiedSwapEventListener.d.ts

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

package/dist/events/UnifiedSwapEventListener.js

@@ -0,0 +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;

package/dist/http/HttpUtils.d.ts

@@ -0,0 +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>;

package/dist/http/HttpUtils.js

@@ -0,0 +1,91 @@
+"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;

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

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

package/dist/http/paramcoders/IParamReader.js

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

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IParamReader } from "./IParamReader";
+import { Buffer } from "buffer";
+export declare class ParamDecoder implements IParamReader {
+    frameHeader?: Buffer;
+    frameData: Buffer[];
+    frameDataLength: number;
+    closed: boolean;
+    params: {
+        [key: string]: {
+            promise: Promise<any>;
+            resolve?: (data: any) => void;
+            reject?: (err: any) => void;
+        };
+    };
+    /**
+     * Called when a frame is fully ready such that it can be parsed
+     *
+     * @param data Frame data
+     * @private
+     */
+    private onFrameRead;
+    /**
+     * Called when data is read from the underlying source
+     *
+     * @param data Data that has been read from the underlying source
+     * @protected
+     */
+    protected onData(data: Buffer): void;
+    /**
+     * Called when the underlying source ends/closes/cancels
+     * @protected
+     */
+    protected onEnd(): void;
+    /**
+     * Called when an error happens with the underlying stream
+     *
+     * @param e Error
+     * @protected
+     */
+    protected onError(e: any): void;
+    getParam<T>(key: string): Promise<T>;
+}

package/dist/http/paramcoders/ParamDecoder.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamDecoder = void 0;
+const buffer_1 = require("buffer");
+class ParamDecoder {
+    constructor() {
+        this.frameData = [];
+        this.frameDataLength = 0;
+        this.closed = false;
+        this.params = {};
+    }
+    /**
+     * Called when a frame is fully ready such that it can be parsed
+     *
+     * @param data Frame data
+     * @private
+     */
+    onFrameRead(data) {
+        const obj = JSON.parse(data.toString());
+        for (let key in obj) {
+            if (this.params[key] == null) {
+                this.params[key] = {
+                    promise: Promise.resolve(obj[key])
+                };
+            }
+            else {
+                const resolveFn = this.params[key].resolve;
+                if (resolveFn != null) {
+                    resolveFn(obj[key]);
+                    delete this.params[key].resolve;
+                    delete this.params[key].reject;
+                }
+            }
+        }
+    }
+    /**
+     * Called when data is read from the underlying source
+     *
+     * @param data Data that has been read from the underlying source
+     * @protected
+     */
+    onData(data) {
+        let leavesBuffer = data;
+        while (leavesBuffer != null && leavesBuffer.length > 0) {
+            if (this.frameHeader == null) {
+                if (leavesBuffer.length <= 4) {
+                    this.frameHeader = leavesBuffer;
+                    leavesBuffer = null;
+                }
+                else {
+                    this.frameHeader = leavesBuffer.subarray(0, 4);
+                    leavesBuffer = leavesBuffer.subarray(4);
+                }
+            }
+            else if (this.frameHeader.length < 4) {
+                const requiredLen = 4 - this.frameHeader.length;
+                if (leavesBuffer.length <= requiredLen) {
+                    this.frameHeader = buffer_1.Buffer.concat([this.frameHeader, leavesBuffer]);
+                    leavesBuffer = null;
+                }
+                else {
+                    this.frameHeader = buffer_1.Buffer.concat([this.frameHeader, leavesBuffer.subarray(0, requiredLen)]);
+                    leavesBuffer = leavesBuffer.subarray(requiredLen);
+                }
+            }
+            if (leavesBuffer == null)
+                continue;
+            if (this.frameHeader == null || this.frameHeader.length < 4)
+                continue;
+            const frameLength = this.frameHeader.readUint32LE();
+            const requiredLen = frameLength - this.frameDataLength;
+            if (leavesBuffer.length <= requiredLen) {
+                this.frameData.push(leavesBuffer);
+                this.frameDataLength += leavesBuffer.length;
+                leavesBuffer = null;
+            }
+            else {
+                this.frameData.push(leavesBuffer.subarray(0, requiredLen));
+                this.frameDataLength += requiredLen;
+                leavesBuffer = leavesBuffer.subarray(requiredLen);
+            }
+            if (frameLength === this.frameDataLength) {
+                //Message read success
+                this.onFrameRead(buffer_1.Buffer.concat(this.frameData));
+                delete this.frameHeader;
+                this.frameData = [];
+                this.frameDataLength = 0;
+            }
+        }
+    }
+    /**
+     * Called when the underlying source ends/closes/cancels
+     * @protected
+     */
+    onEnd() {
+        for (let key in this.params) {
+            this.params[key].reject?.(new Error("EOF before field seen!"));
+        }
+        this.closed = true;
+    }
+    /**
+     * Called when an error happens with the underlying stream
+     *
+     * @param e Error
+     * @protected
+     */
+    onError(e) {
+        for (let key in this.params) {
+            this.params[key].reject?.(e);
+        }
+        this.closed = true;
+    }
+    getParam(key) {
+        if (this.params[key] == null) {
+            if (this.closed)
+                return Promise.reject(new Error("Stream already closed without param received!"));
+            let resolve;
+            let reject;
+            const promise = new Promise((_resolve, _reject) => {
+                resolve = _resolve;
+                reject = _reject;
+            });
+            this.params[key] = {
+                resolve: resolve,
+                reject: reject,
+                promise
+            };
+        }
+        return this.params[key].promise;
+    }
+}
+exports.ParamDecoder = ParamDecoder;

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export declare class ParamEncoder {
+    private readonly writeFN;
+    private readonly endFN;
+    constructor(write: (data: Buffer) => Promise<void>, end: () => Promise<void>);
+    /**
+     * Write a set of parameters to the underlying sink
+     *
+     * @param data
+     */
+    writeParams(data: {
+        [key: string]: any;
+    }): Promise<void>;
+    /**
+     * Cancels the underlying sink and encoder
+     */
+    end(): Promise<void>;
+}

package/dist/http/paramcoders/ParamEncoder.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamEncoder = void 0;
+const buffer_1 = require("buffer");
+class ParamEncoder {
+    constructor(write, end) {
+        this.writeFN = write;
+        this.endFN = end;
+    }
+    /**
+     * Write a set of parameters to the underlying sink
+     *
+     * @param data
+     */
+    writeParams(data) {
+        const serialized = buffer_1.Buffer.from(JSON.stringify(data));
+        const frameLengthBuffer = buffer_1.Buffer.alloc(4);
+        frameLengthBuffer.writeUint32LE(serialized.length);
+        return this.writeFN(buffer_1.Buffer.concat([
+            frameLengthBuffer,
+            serialized
+        ]));
+    }
+    /**
+     * Cancels the underlying sink and encoder
+     */
+    end() {
+        return this.endFN();
+    }
+}
+exports.ParamEncoder = ParamEncoder;

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

@@ -0,0 +1,26 @@
+export declare function parseBigInt(str: string | number): bigint | null;
+export declare enum FieldTypeEnum {
+    String = 0,
+    Boolean = 1,
+    Number = 2,
+    BigInt = 3,
+    Any = 4,
+    StringOptional = 100,
+    BooleanOptional = 101,
+    NumberOptional = 102,
+    BigIntOptional = 103,
+    AnyOptional = 104
+}
+export type FieldType<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))> = T extends FieldTypeEnum.String ? string : T extends FieldTypeEnum.Boolean ? boolean : T extends FieldTypeEnum.Number ? number : T extends FieldTypeEnum.BigInt ? bigint : T extends FieldTypeEnum.Any ? any : T extends FieldTypeEnum.StringOptional ? (string | null) : T extends FieldTypeEnum.BooleanOptional ? (boolean | null) : T extends FieldTypeEnum.NumberOptional ? (number | null) : T extends FieldTypeEnum.BigIntOptional ? (bigint | null) : T extends FieldTypeEnum.AnyOptional ? (any | null) : T extends RequestSchema ? RequestSchemaResult<T> : T extends ((val: any) => string) ? string : T extends ((val: any) => boolean) ? boolean : T extends ((val: any) => number) ? number : T extends ((val: any) => bigint) ? bigint : T extends ((val: any) => any) ? any : never;
+export type RequestSchemaResult<T extends RequestSchema> = {
+    [key in keyof T]: FieldType<T[key]>;
+};
+export type RequestSchemaResultPromise<T extends RequestSchema> = {
+    [key in keyof T]: Promise<FieldType<T[key]>>;
+};
+export type RequestSchema = {
+    [fieldName: string]: FieldTypeEnum | RequestSchema | ((val: any) => any);
+};
+export declare function isOptionalField(type: FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))): boolean;
+export declare function verifyField<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))>(fieldType: T, val: any): FieldType<T> | undefined;
+export declare function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> | null;