@atomiqlabs/lp-lib 10.3.11

package/dist/utils/paramcoders/ParamDecoder.js

@@ -0,0 +1,234 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamDecoder = void 0;
+const SchemaVerifier_1 = require("./SchemaVerifier");
+class ParamDecoder {
+    constructor() {
+        this.frameHeader = null;
+        this.frameData = [];
+        this.frameDataLength = 0;
+        this.closed = false;
+        this.params = {};
+    }
+    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]),
+                    resolve: null,
+                    reject: null,
+                    value: obj[key]
+                };
+            }
+            else {
+                if (this.params[key].resolve != null) {
+                    this.params[key].resolve(obj[key]);
+                    this.params[key].resolve = null;
+                    this.params[key].reject = null;
+                }
+            }
+        }
+    }
+    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.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));
+                this.frameHeader = null;
+                this.frameData = [];
+                this.frameDataLength = 0;
+            }
+        }
+    }
+    onEnd() {
+        for (let key in this.params) {
+            if (this.params[key].reject != null) {
+                this.params[key].reject(new Error("EOF before field seen!"));
+            }
+        }
+        this.closed = true;
+    }
+    onError(e) {
+        for (let key in this.params) {
+            if (this.params[key].reject != null) {
+                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,
+                reject,
+                promise,
+                value: null
+            };
+        }
+        return this.params[key].promise;
+    }
+    getParams(schema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resultSchema = {};
+            for (let fieldName in schema) {
+                const val = yield this.getParam(fieldName);
+                const type = schema[fieldName];
+                if (typeof (type) === "function") {
+                    const result = type(val);
+                    if (result == null)
+                        return null;
+                    resultSchema[fieldName] = result;
+                    continue;
+                }
+                if (val == null && type >= 100) {
+                    resultSchema[fieldName] = null;
+                    continue;
+                }
+                if (type === SchemaVerifier_1.FieldTypeEnum.Any || type === SchemaVerifier_1.FieldTypeEnum.AnyOptional) {
+                    resultSchema[fieldName] = val;
+                }
+                else if (type === SchemaVerifier_1.FieldTypeEnum.Boolean || type === SchemaVerifier_1.FieldTypeEnum.BooleanOptional) {
+                    if (typeof (val) !== "boolean")
+                        return null;
+                    resultSchema[fieldName] = val;
+                }
+                else if (type === SchemaVerifier_1.FieldTypeEnum.Number || type === SchemaVerifier_1.FieldTypeEnum.NumberOptional) {
+                    if (typeof (val) !== "number")
+                        return null;
+                    if (isNaN(val))
+                        return null;
+                    resultSchema[fieldName] = val;
+                }
+                else if (type === SchemaVerifier_1.FieldTypeEnum.BN || type === SchemaVerifier_1.FieldTypeEnum.BNOptional) {
+                    const result = (0, SchemaVerifier_1.parseBN)(val);
+                    if (result == null)
+                        return null;
+                    resultSchema[fieldName] = result;
+                }
+                else if (type === SchemaVerifier_1.FieldTypeEnum.String || type === SchemaVerifier_1.FieldTypeEnum.StringOptional) {
+                    if (typeof (val) !== "string")
+                        return null;
+                    resultSchema[fieldName] = val;
+                }
+                else {
+                    //Probably another request schema
+                    const result = (0, SchemaVerifier_1.verifySchema)(val, type);
+                    if (result == null)
+                        return null;
+                    resultSchema[fieldName] = result;
+                }
+            }
+            return resultSchema;
+        });
+    }
+    getExistingParamsOrNull(schema) {
+        var _a;
+        const resultSchema = {};
+        for (let fieldName in schema) {
+            const val = (_a = this.params[fieldName]) === null || _a === void 0 ? void 0 : _a.value;
+            if (val == null) {
+                resultSchema[fieldName] = null;
+                continue;
+            }
+            const type = schema[fieldName];
+            if (typeof (type) === "function") {
+                const result = type(val);
+                if (result == null)
+                    return null;
+                resultSchema[fieldName] = result;
+                continue;
+            }
+            if (type === SchemaVerifier_1.FieldTypeEnum.Any || type === SchemaVerifier_1.FieldTypeEnum.AnyOptional) {
+                resultSchema[fieldName] = val;
+            }
+            else if (type === SchemaVerifier_1.FieldTypeEnum.Boolean || type === SchemaVerifier_1.FieldTypeEnum.BooleanOptional) {
+                if (typeof (val) !== "boolean")
+                    return null;
+                resultSchema[fieldName] = val;
+            }
+            else if (type === SchemaVerifier_1.FieldTypeEnum.Number || type === SchemaVerifier_1.FieldTypeEnum.NumberOptional) {
+                if (typeof (val) !== "number")
+                    return null;
+                if (isNaN(val))
+                    return null;
+                resultSchema[fieldName] = val;
+            }
+            else if (type === SchemaVerifier_1.FieldTypeEnum.BN || type === SchemaVerifier_1.FieldTypeEnum.BNOptional) {
+                const result = (0, SchemaVerifier_1.parseBN)(val);
+                if (result == null)
+                    return null;
+                resultSchema[fieldName] = result;
+            }
+            else if (type === SchemaVerifier_1.FieldTypeEnum.String || type === SchemaVerifier_1.FieldTypeEnum.StringOptional) {
+                if (typeof (val) !== "string")
+                    return null;
+                resultSchema[fieldName] = val;
+            }
+            else {
+                //Probably another request schema
+                const result = (0, SchemaVerifier_1.verifySchema)(val, type);
+                if (result == null)
+                    return null;
+                resultSchema[fieldName] = result;
+            }
+        }
+        return resultSchema;
+    }
+}
+exports.ParamDecoder = ParamDecoder;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { IParamWriter } from "./IParamWriter";
+export declare class ParamEncoder implements IParamWriter {
+    private readonly writeFN;
+    private readonly endFN;
+    constructor(write: (data: Buffer) => Promise<void>, end: () => Promise<void>);
+    writeParams(data: any): Promise<void>;
+    end(): Promise<void>;
+}

package/dist/utils/paramcoders/ParamEncoder.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamEncoder = void 0;
+class ParamEncoder {
+    constructor(write, end) {
+        this.writeFN = write;
+        this.endFN = end;
+    }
+    writeParams(data) {
+        const serialized = Buffer.from(JSON.stringify(data));
+        const frameLengthBuffer = Buffer.alloc(4);
+        frameLengthBuffer.writeUint32LE(serialized.length);
+        return this.writeFN(Buffer.concat([
+            frameLengthBuffer,
+            serialized
+        ]));
+    }
+    end() {
+        return this.endFN();
+    }
+}
+exports.ParamEncoder = ParamEncoder;

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

@@ -0,0 +1,22 @@
+import * as BN from "bn.js";
+export declare function parseBN(str: string | number): BN | null;
+export declare enum FieldTypeEnum {
+    String = 0,
+    Boolean = 1,
+    Number = 2,
+    BN = 3,
+    Any = 4,
+    StringOptional = 100,
+    BooleanOptional = 101,
+    NumberOptional = 102,
+    BNOptional = 103,
+    AnyOptional = 104
+}
+export type FieldType<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | BN | any))> = T extends FieldTypeEnum.String ? string : T extends FieldTypeEnum.Boolean ? boolean : T extends FieldTypeEnum.Number ? number : T extends FieldTypeEnum.BN ? BN : T extends FieldTypeEnum.Any ? any : T extends FieldTypeEnum.StringOptional ? string : T extends FieldTypeEnum.BooleanOptional ? boolean : T extends FieldTypeEnum.NumberOptional ? number : T extends FieldTypeEnum.BNOptional ? BN : T extends FieldTypeEnum.AnyOptional ? any : 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) => BN) ? BN : T extends ((val: any) => any) ? any : never;
+export type RequestSchemaResult<T extends RequestSchema> = {
+    [key in keyof T]: FieldType<T[key]>;
+};
+export type RequestSchema = {
+    [fieldName: string]: FieldTypeEnum | RequestSchema | ((val: any) => any);
+};
+export declare function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T>;

package/dist/utils/paramcoders/SchemaVerifier.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySchema = exports.FieldTypeEnum = exports.parseBN = void 0;
+const BN = require("bn.js");
+function parseBN(str) {
+    if (str == null)
+        return null;
+    if (typeof (str) !== "string" && typeof (str) !== "number")
+        return null;
+    try {
+        return new BN(str);
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.parseBN = parseBN;
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum[FieldTypeEnum["String"] = 0] = "String";
+    FieldTypeEnum[FieldTypeEnum["Boolean"] = 1] = "Boolean";
+    FieldTypeEnum[FieldTypeEnum["Number"] = 2] = "Number";
+    FieldTypeEnum[FieldTypeEnum["BN"] = 3] = "BN";
+    FieldTypeEnum[FieldTypeEnum["Any"] = 4] = "Any";
+    FieldTypeEnum[FieldTypeEnum["StringOptional"] = 100] = "StringOptional";
+    FieldTypeEnum[FieldTypeEnum["BooleanOptional"] = 101] = "BooleanOptional";
+    FieldTypeEnum[FieldTypeEnum["NumberOptional"] = 102] = "NumberOptional";
+    FieldTypeEnum[FieldTypeEnum["BNOptional"] = 103] = "BNOptional";
+    FieldTypeEnum[FieldTypeEnum["AnyOptional"] = 104] = "AnyOptional";
+})(FieldTypeEnum = exports.FieldTypeEnum || (exports.FieldTypeEnum = {}));
+function verifySchema(req, schema) {
+    if (req == null)
+        return null;
+    const resultSchema = {};
+    for (let fieldName in schema) {
+        const val = req[fieldName];
+        const type = schema[fieldName];
+        if (typeof (type) === "function") {
+            const result = type(val);
+            if (result == null)
+                return null;
+            resultSchema[fieldName] = result;
+            continue;
+        }
+        if (val == null && type >= 100) {
+            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))
+                return null;
+            resultSchema[fieldName] = val;
+        }
+        else if (type === FieldTypeEnum.BN || type === FieldTypeEnum.BNOptional) {
+            const result = parseBN(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);
+            if (result == null)
+                return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}
+exports.verifySchema = verifySchema;

package/dist/utils/paramcoders/server/ServerParamDecoder.d.ts

@@ -0,0 +1,8 @@
+import { Request, Response } from "express";
+export declare class RequestTimeoutError extends Error {
+    constructor();
+}
+export declare class RequestParsingError extends Error {
+    constructor();
+}
+export declare const serverParamDecoder: (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => void;

package/dist/utils/paramcoders/server/ServerParamDecoder.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverParamDecoder = exports.RequestParsingError = exports.RequestTimeoutError = void 0;
+const SchemaVerifier_1 = require("../SchemaVerifier");
+const ParamDecoder_1 = require("../ParamDecoder");
+const ServerParamEncoder_1 = require("./ServerParamEncoder");
+class RequestTimeoutError extends Error {
+    constructor() {
+        super("Request timed out");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+    }
+}
+exports.RequestTimeoutError = RequestTimeoutError;
+class RequestParsingError extends Error {
+    constructor() {
+        super("Request cannot be parsed");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestParsingError.prototype);
+    }
+}
+exports.RequestParsingError = RequestParsingError;
+const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
+    let timeout;
+    res.responseStream = new ServerParamEncoder_1.ServerParamEncoder(res, 200, req);
+    if (req.headers['content-type'] !== "application/x-multiple-json") {
+        const dataBuffers = [];
+        req.on("data", (data) => {
+            dataBuffers.push(data);
+        });
+        req.on("end", () => {
+            try {
+                const body = JSON.parse(Buffer.concat(dataBuffers).toString());
+                const paramReader = {
+                    getParams: (schema) => {
+                        return Promise.resolve((0, SchemaVerifier_1.verifySchema)(body, schema));
+                    },
+                    getExistingParamsOrNull: (schema) => {
+                        return (0, SchemaVerifier_1.verifySchema)(body, schema);
+                    }
+                };
+                req.paramReader = paramReader;
+                next();
+            }
+            catch (e) {
+                console.error("ServerParamDecoder: error reading legacy (non-streaming) http request", e);
+                req.destroy(new RequestParsingError());
+                res.destroy(new RequestParsingError());
+            }
+            clearTimeout(timeout);
+        });
+        req.on("error", (e) => {
+            console.error("ServerParamDecoder: error reading legacy (non-streaming) http request", e);
+        });
+        timeout = setTimeout(() => {
+            req.destroy(new RequestTimeoutError());
+            res.destroy(new RequestTimeoutError());
+        }, timeoutMillis);
+        return;
+    }
+    const decoder = new ParamDecoder_1.ParamDecoder();
+    req.on("data", (data) => {
+        try {
+            decoder.onData(data);
+        }
+        catch (e) {
+            console.error("ServerParamDecoder: error reading streaming http request: on(\"data\")", e);
+            req.destroy(new RequestParsingError());
+            res.destroy(new RequestParsingError());
+        }
+    });
+    req.on("end", () => {
+        try {
+            decoder.onEnd();
+        }
+        catch (e) {
+            console.error("ServerParamDecoder: error reading streaming http request: on(\"end\")", e);
+            req.destroy(new RequestParsingError());
+            res.destroy(new RequestParsingError());
+        }
+        clearTimeout(timeout);
+    });
+    req.on("error", (e) => {
+        try {
+            decoder.onError(e);
+        }
+        catch (e) {
+            console.error("ServerParamDecoder: error reading streaming http request: on(\"error\")", e);
+        }
+    });
+    timeout = setTimeout(() => {
+        try {
+            decoder.onEnd();
+        }
+        catch (e) {
+            console.error("ServerParamDecoder: error reading streaming http request: timeout", e);
+        }
+        req.destroy(new RequestTimeoutError());
+        res.destroy(new RequestTimeoutError());
+    }, timeoutMillis);
+    req.paramReader = decoder;
+    next();
+    return;
+};
+exports.serverParamDecoder = serverParamDecoder;

package/dist/utils/paramcoders/server/ServerParamEncoder.d.ts

@@ -0,0 +1,11 @@
+import { Response, Request } from "express";
+export declare class ServerParamEncoder {
+    private response;
+    private controller;
+    private paramWriter;
+    constructor(response: Response, statusCode: number, request: Request);
+    writeParams(params: any): Promise<void>;
+    end(): Promise<void>;
+    writeParamsAndEnd(params: any): Promise<void>;
+    getAbortSignal(): AbortSignal;
+}

package/dist/utils/paramcoders/server/ServerParamEncoder.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerParamEncoder = void 0;
+const ParamEncoder_1 = require("../ParamEncoder");
+const LegacyParamEncoder_1 = require("../LegacyParamEncoder");
+class ServerParamEncoder {
+    constructor(response, statusCode, request) {
+        const legacy = !request.headers['accept'].includes("application/x-multiple-json");
+        let requestEnd = false;
+        let responseShouldEnd = false;
+        request.on("end", () => {
+            requestEnd = true;
+            if (responseShouldEnd && requestEnd)
+                response.end();
+        });
+        const onEnd = () => {
+            responseShouldEnd = true;
+            if (responseShouldEnd && requestEnd)
+                return new Promise(resolve => response.end(() => resolve()));
+            return Promise.resolve();
+        };
+        const onWrite = (data) => {
+            if (responseShouldEnd)
+                return Promise.resolve();
+            if (firstWrite) {
+                response.writeHead(statusCode);
+                firstWrite = false;
+            }
+            return new Promise((resolve, reject) => response.write(data, (error) => {
+                if (error != null) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            }));
+        };
+        let firstWrite = false;
+        if (legacy) {
+            response.header("Content-Type", "application/json");
+            this.paramWriter = new LegacyParamEncoder_1.LegacyParamEncoder(onWrite, onEnd);
+        }
+        else {
+            response.header("Content-Type", "application/x-multiple-json");
+            this.paramWriter = new ParamEncoder_1.ParamEncoder(onWrite, onEnd);
+        }
+        this.response = response;
+        this.controller = new AbortController();
+        this.response.on("close", () => this.controller.abort(new Error("Response stream closed!")));
+        this.response.on("error", (err) => this.controller.abort(err));
+    }
+    writeParams(params) {
+        return this.paramWriter.writeParams(params);
+    }
+    end() {
+        return this.paramWriter.end();
+    }
+    writeParamsAndEnd(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.writeParams(params);
+            yield this.end();
+        });
+    }
+    getAbortSignal() {
+        return this.controller.signal;
+    }
+}
+exports.ServerParamEncoder = ServerParamEncoder;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@atomiqlabs/lp-lib",
+  "version": "10.3.11",
+  "description": "Main functionality implementation for atomiq LP node",
+  "main": "./dist/index.js",
+  "types:": "./dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "/dist",
+    "/src"
+  ],
+  "keywords": [
+    "Solana",
+    "Bitcoin",
+    "Cross-chain",
+    "Cryptocurrency",
+    "Bridge",
+    "Trustless"
+  ],
+  "author": "adambor",
+  "license": "ISC",
+  "dependencies": {
+    "@atomiqlabs/base": "7.2.0",
+    "@atomiqlabs/bolt11": "1.5.1",
+    "@atomiqlabs/server-base": "1.0.4",
+    "@bitcoinerlab/secp256k1": "1.0.5",
+    "bitcoinjs-lib": "6.1.5",
+    "bn.js": "5.2.1",
+    "express": "4.18.2",
+    "lightning": "10.2.1",
+    "ln-service": "57.2.0",
+    "one-dollar-fee-estimator-failover": "0.1.1",
+    "promise-queue-ts": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/bn.js": "5.1.5",
+    "@types/express": "4.17.21",
+    "@types/node": "18.15.11",
+    "typescript": "4.9.5"
+  }
+}

package/src/fees/IBtcFeeEstimator.ts

@@ -0,0 +1,7 @@
+
+export interface IBtcFeeEstimator {
+
+    //Returns estimated fee in sats/vB
+    estimateFee(): Promise<number | null>;
+
+}