@atomiqlabs/sdk 7.0.11 → 8.0.7

package/src/errors/RequestError.ts

@@ -0,0 +1,51 @@
+
+/**
+ * An error returned by the intermediary in a http response
+ * @category Errors
+ */
+export class RequestError extends Error {
+
+    httpCode: number;
+
+    constructor(msg: string, httpCode: number) {
+        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: string, httpCode: number): RequestError {
+        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);
+    }
+
+}
+
+
+/**
+ * An error indicating out of bounds (amount too high or too low) on swap initialization
+ * @category Errors
+ */
+export class OutOfBoundsError extends RequestError {
+
+    min: bigint;
+    max: bigint;
+
+    constructor(msg: string, httpCode: number, min: bigint, max: bigint) {
+        super(msg, httpCode);
+        this.max = max;
+        this.min = min;
+        Object.setPrototypeOf(this, OutOfBoundsError.prototype);
+    }
+
+}

package/src/errors/UserError.ts

@@ -0,0 +1,14 @@
+/**
+ * An error on the user side, such as invalid address provided
+ * @category Errors
+ */
+export class UserError extends Error {
+
+    constructor(msg: string) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, UserError.prototype);
+    }
+
+}
+

package/src/events/UnifiedSwapEventListener.ts

@@ -0,0 +1,171 @@
+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);
+            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 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 swap = swapsByClaimDataHash[claimData];
+            if(swap!=null) {
+                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

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

package/src/http/paramcoders/IParamReader.ts

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

package/src/http/paramcoders/ParamDecoder.ts

@@ -0,0 +1,142 @@
+import {IParamReader} from "./IParamReader";
+import {Buffer} from "buffer";
+
+
+export class ParamDecoder implements IParamReader {
+
+    frameHeader?: Buffer;
+    frameData: Buffer[] = [];
+    frameDataLength: number = 0;
+
+    closed: boolean = false;
+
+    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(data: Buffer) {
+        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
+     */
+    protected onData(data: Buffer): void {
+        let leavesBuffer: Buffer | null = 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.concat([this.frameHeader, leavesBuffer]);
+                    leavesBuffer = null;
+                } else {
+                    this.frameHeader = 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.concat(this.frameData));
+                delete this.frameHeader;
+                this.frameData = [];
+                this.frameDataLength = 0;
+            }
+        }
+    }
+
+    /**
+     * Called when the underlying source ends/closes/cancels
+     * @protected
+     */
+    protected onEnd(): void {
+        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
+     */
+    protected onError(e: any): void {
+        for(let key in this.params) {
+            this.params[key].reject?.(e);
+        }
+        this.closed = true;
+    }
+
+    getParam<T>(key: string): Promise<T> {
+        if(this.params[key]==null) {
+            if(this.closed) return Promise.reject(new Error("Stream already closed without param received!"));
+            let resolve: (data: any) => void;
+            let reject: (err: any) => void;
+            const promise = new Promise((_resolve, _reject) => {
+                resolve = _resolve
+                reject = _reject;
+            });
+            this.params[key] = {
+                resolve: resolve!,
+                reject: reject!,
+                promise
+            }
+        }
+        return this.params[key].promise;
+    }
+
+}

package/src/http/paramcoders/ParamEncoder.ts

@@ -0,0 +1,37 @@
+import {Buffer} from "buffer";
+
+export class ParamEncoder {
+
+    private readonly writeFN: (data: Buffer) => Promise<void>;
+    private readonly endFN: () => Promise<void>;
+
+    constructor(write: (data: Buffer) => Promise<void>, end: () => Promise<void>) {
+        this.writeFN = write;
+        this.endFN = end;
+    }
+
+    /**
+     * Write a set of parameters to the underlying sink
+     *
+     * @param data
+     */
+    writeParams(data: {[key: string]: any}): Promise<void> {
+        const serialized: Buffer = Buffer.from(JSON.stringify(data));
+
+        const frameLengthBuffer = Buffer.alloc(4);
+        frameLengthBuffer.writeUint32LE(serialized.length);
+
+        return this.writeFN(Buffer.concat([
+            frameLengthBuffer,
+            serialized
+        ]));
+    }
+
+    /**
+     * Cancels the underlying sink and encoder
+     */
+    end(): Promise<void> {
+        return this.endFN();
+    }
+
+}

package/src/http/paramcoders/SchemaVerifier.ts

@@ -0,0 +1,153 @@
+
+export function parseBigInt(str: string | number): bigint | null {
+    if(str==null) return null;
+    if(typeof(str)!=="string" && typeof(str)!=="number") return null;
+    try {
+        return BigInt(str);
+    } catch (e) {
+        return null;
+    }
+}
+
+export 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)
+}
+
+function isAllOptional(schema: RequestSchema) {
+    for(let key in schema) {
+        if(!isOptionalField(schema[key])) return false;
+    }
+    return true;
+}
+
+export function isOptionalField(type: FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))) {
+    if(typeof(type)==="function") return type(undefined)!=null;
+    if(typeof(type)==="object") return isAllOptional(type);
+    return type>=100;
+}
+
+export function verifyField<
+    T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))
+>(fieldType: T, val: any): FieldType<T> | undefined {
+
+    const type: FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any)) = fieldType;
+    if(typeof(type)==="function") {
+        const result = type(val);
+        if(result==null) return;
+        return result;
+    }
+
+    if(val==null && isOptionalField(type as FieldTypeEnum)) {
+        return null as FieldType<T>;
+    }
+
+    if(type===FieldTypeEnum.Any || type===FieldTypeEnum.AnyOptional) {
+        return val;
+    } else if(type===FieldTypeEnum.Boolean || type===FieldTypeEnum.BooleanOptional) {
+        if(typeof(val)!=="boolean") return;
+        return val as any;
+    } else if(type===FieldTypeEnum.Number || type===FieldTypeEnum.NumberOptional) {
+        if(typeof(val)!=="number") return;
+        if(isNaN(val as number)) return;
+        return val as any;
+    } else if(type===FieldTypeEnum.BigInt || type===FieldTypeEnum.BigIntOptional) {
+        const result = parseBigInt(val);
+        if(result==null) return;
+        return result as any;
+    } else if(type===FieldTypeEnum.String || type===FieldTypeEnum.StringOptional) {
+        if(typeof(val)!=="string") return;
+        return val as any;
+    } else {
+        //Probably another request schema
+        const result = verifySchema(val, type as RequestSchema);
+        if(result==null) return;
+        return result as any;
+    }
+
+}
+
+export function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> | null {
+    if(req==null) return null;
+    const resultSchema: any = {};
+    for(let fieldName in schema) {
+        const val: any = req[fieldName];
+
+        const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
+        if(typeof(type)==="function") {
+            const result = type(val);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+            continue;
+        }
+
+        if(val==null && isOptionalField(type as FieldTypeEnum)) {
+            resultSchema[fieldName] = null;
+            continue;
+        }
+
+        if(type===FieldTypeEnum.Any || type===FieldTypeEnum.AnyOptional) {
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.Boolean || type===FieldTypeEnum.BooleanOptional) {
+            if(typeof(val)!=="boolean") return null;
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.Number || type===FieldTypeEnum.NumberOptional) {
+            if(typeof(val)!=="number") return null;
+            if(isNaN(val as number)) return null;
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.BigInt || type===FieldTypeEnum.BigIntOptional) {
+            const result = parseBigInt(val);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+        } else if(type===FieldTypeEnum.String || type===FieldTypeEnum.StringOptional) {
+            if(typeof(val)!=="string") return null;
+            resultSchema[fieldName] = val;
+        } else {
+            //Probably another request schema
+            const result = verifySchema(val, type as RequestSchema);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}