@atomiqlabs/lp-lib 10.3.11

package/src/utils/coinselect2/utils.ts

@@ -0,0 +1,183 @@
+// baseline estimates, used to improve performance
+const TX_EMPTY_SIZE = 4 + 1 + 1 + 4;
+const TX_INPUT_BASE = 32 + 4 + 1 + 4;
+
+const WITNESS_OVERHEAD = 2/4;
+
+const P2WPKH_WITNESS = (1+1+72+1+33)/4;
+const P2TR_WITNESS = (1+1+65)/4;
+
+const TX_INPUT_PUBKEYHASH = 107;
+const TX_INPUT_P2SH_P2WPKH = 23 + P2WPKH_WITNESS + 1;
+const TX_INPUT_P2WPKH = 0 + P2WPKH_WITNESS;
+const TX_INPUT_P2WSH = 0 + (1+1+64)/4;
+const TX_INPUT_P2TR = 0 + P2TR_WITNESS;
+
+const TX_OUTPUT_BASE = 8 + 1;
+
+const TX_OUTPUT_PUBKEYHASH = 25;
+const TX_OUTPUT_P2SH_P2WPKH = 23;
+const TX_OUTPUT_P2WPKH = 22;
+const TX_OUTPUT_P2WSH = 34;
+const TX_OUTPUT_P2TR = 34;
+
+export type CoinselectAddressTypes = "p2sh-p2wpkh" | "p2wpkh" | "p2wsh" | "p2tr" | "p2pkh";
+
+export type CoinselectTxInput = {
+    script?: Buffer,
+    witness?: Buffer,
+    txId: string,
+    vout: number,
+    type?: CoinselectAddressTypes,
+    value: number,
+    outputScript?: Buffer,
+    address?: string
+};
+
+export type CoinselectTxOutput = {
+    script?: Buffer,
+    address?: string,
+    type?: CoinselectAddressTypes,
+    value: number
+};
+
+
+const INPUT_BYTES = {
+    "p2sh-p2wpkh": TX_INPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_INPUT_P2WPKH,
+    "p2tr": TX_INPUT_P2TR,
+    "p2pkh": TX_INPUT_PUBKEYHASH,
+    "p2wsh": TX_INPUT_P2WSH
+};
+
+function inputBytes (input: {
+    script?: Buffer,
+    witness?: Buffer,
+    type?: CoinselectAddressTypes
+}) {
+    if(input.script==null && input.witness==null) {
+        return {length: TX_INPUT_BASE + INPUT_BYTES[input.type], isWitness: input.type!=="p2pkh"};
+    }
+    return {
+        length: TX_INPUT_BASE + (input.script?.length || 0) + ((input.witness?.length || 0)/4),
+        isWitness: input.witness!=null
+    };
+}
+
+const OUTPUT_BYTES = {
+    "p2sh-p2wpkh": TX_OUTPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_OUTPUT_P2WPKH,
+    "p2tr": TX_OUTPUT_P2TR,
+    "p2pkh": TX_OUTPUT_PUBKEYHASH,
+    "p2wsh": TX_OUTPUT_P2WSH
+};
+
+function outputBytes (output: {
+    script?: Buffer,
+    type?: CoinselectAddressTypes
+}): number {
+  return TX_OUTPUT_BASE + (output.script ? output.script.length : OUTPUT_BYTES[output.type]);
+}
+
+const DUST_THRESHOLDS = {
+    "p2sh-p2wpkh": 540,
+    "p2wpkh": 294,
+    "p2tr": 330,
+    "p2pkh": 546,
+    "p2wsh": 330
+};
+
+function dustThreshold (output: {
+    script?: Buffer,
+    type: CoinselectAddressTypes
+}): number {
+  return DUST_THRESHOLDS[output.type];
+}
+
+function transactionBytes (
+    inputs: {
+        script?: Buffer,
+        type?: CoinselectAddressTypes
+    }[],
+    outputs: {
+        script?: Buffer,
+        type?: CoinselectAddressTypes
+    }[],
+    changeType: CoinselectAddressTypes
+): number {
+    let size = TX_EMPTY_SIZE;
+    let isSegwit = false;
+    if(changeType!=="p2pkh") {
+        size += WITNESS_OVERHEAD;
+        let isSegwit = true;
+    }
+    for(let input of inputs) {
+        const {length, isWitness} = inputBytes(input);
+        size += length;
+        if(!isSegwit && isWitness) {
+            isSegwit = true;
+            size += WITNESS_OVERHEAD;
+        }
+    }
+    for(let output of outputs) {
+        size += outputBytes(output);
+    }
+    return Math.ceil(size);
+}
+
+function uintOrNaN(v: number): number {
+  if (typeof v !== 'number') return NaN;
+  if (!isFinite(v)) return NaN;
+  if (Math.floor(v) !== v) return NaN;
+  if (v < 0) return NaN;
+  return v;
+}
+
+function sumForgiving(range: {value: number}[]): number {
+  return range.reduce((a, x) => a + (isFinite(x.value) ? x.value : 0), 0);
+}
+
+function sumOrNaN(range: {value: number}[]): number {
+  return range.reduce((a, x)  => a + uintOrNaN(x.value), 0);
+}
+
+function finalize(
+    inputs: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    changeType: CoinselectAddressTypes
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+  const bytesAccum = transactionBytes(inputs, outputs, changeType);
+
+  const feeAfterExtraOutput = feeRate * (bytesAccum + outputBytes({type: changeType}))
+  const remainderAfterExtraOutput = sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput)
+
+  // is it worth a change output?
+  if (remainderAfterExtraOutput >= dustThreshold({type: changeType})) {
+    outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType })
+  }
+
+  const fee = sumOrNaN(inputs) - sumOrNaN(outputs)
+  if (!isFinite(fee)) return { fee: feeRate * bytesAccum }
+
+  return {
+    inputs: inputs,
+    outputs: outputs,
+    fee: fee
+  }
+}
+
+export const utils = {
+  dustThreshold: dustThreshold,
+  finalize: finalize,
+  inputBytes: inputBytes,
+  outputBytes: outputBytes,
+  sumOrNaN: sumOrNaN,
+  sumForgiving: sumForgiving,
+  transactionBytes: transactionBytes,
+  uintOrNaN: uintOrNaN
+};

package/src/utils/paramcoders/IParamReader.ts

@@ -0,0 +1,8 @@
+import {RequestSchema, RequestSchemaResult} from "./SchemaVerifier";
+
+export interface IParamReader {
+
+    getParams<T extends RequestSchema>(schema: T): Promise<RequestSchemaResult<T>>;
+    getExistingParamsOrNull<T extends RequestSchema>(schema: T): RequestSchemaResult<T>;
+
+}

package/src/utils/paramcoders/IParamWriter.ts

@@ -0,0 +1,8 @@
+
+export interface IParamWriter {
+
+    end(): Promise<void>;
+    writeParams(data: any): Promise<void>;
+
+}
+

package/src/utils/paramcoders/LegacyParamEncoder.ts

@@ -0,0 +1,28 @@
+import {IParamWriter} from "./IParamWriter";
+
+
+export class LegacyParamEncoder implements IParamWriter {
+
+    private readonly writeFN: (data: Buffer) => Promise<void>;
+    private readonly endFN: () => Promise<void>;
+
+    private obj = {};
+
+    constructor(write: (data: Buffer) => Promise<void>, end: () => Promise<void>) {
+        this.writeFN = write;
+        this.endFN = end;
+    }
+
+    writeParams(data: any): Promise<void> {
+        for(let key in data) {
+            if(this.obj[key]==null) this.obj[key] = data[key];
+        }
+        return Promise.resolve();
+    }
+
+    async end(): Promise<void> {
+        await this.writeFN(Buffer.from(JSON.stringify(this.obj)));
+        await this.endFN();
+    }
+
+}

package/src/utils/paramcoders/ParamDecoder.ts

@@ -0,0 +1,219 @@
+import {FieldTypeEnum, parseBN, RequestSchema, RequestSchemaResult, verifySchema} from "./SchemaVerifier";
+import {IParamReader} from "./IParamReader";
+
+
+export class ParamDecoder implements IParamReader {
+
+    frameHeader: Buffer = null;
+    frameData: Buffer[] = [];
+    frameDataLength: number = 0;
+
+    closed: boolean = false;
+
+    params: {
+        [key: string]: {
+            promise: Promise<any>,
+            resolve: (data: any) => void,
+            reject: (err: any) => void,
+            value: any
+        }
+    } = {};
+
+    constructor() {
+
+    }
+
+    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]),
+                    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: Buffer): void {
+        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(): void {
+        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: any): void {
+        for(let key in this.params) {
+            if(this.params[key].reject!=null) {
+                this.params[key].reject(e);
+            }
+        }
+        this.closed = true;
+    }
+
+    getParam(key: string): Promise<any> {
+        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,
+                reject,
+                promise,
+                value: null
+            }
+        }
+        return this.params[key].promise;
+    }
+
+    async getParams<T extends RequestSchema>(schema: T): Promise<RequestSchemaResult<T>> {
+        const resultSchema: any = {};
+        for(let fieldName in schema) {
+            const val: any = await this.getParam(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 && (type as number)>=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 as number)) 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 as RequestSchema);
+                if(result==null) return null;
+                resultSchema[fieldName] = result;
+            }
+        }
+        return resultSchema;
+    }
+
+    getExistingParamsOrNull<T extends RequestSchema>(schema: T): RequestSchemaResult<T> {
+        const resultSchema: any = {};
+        for(let fieldName in schema) {
+            const val: any = this.params[fieldName]?.value;
+
+            if(val==null) {
+                resultSchema[fieldName] = null;
+                continue;
+            }
+
+            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(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.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 as RequestSchema);
+                if(result==null) return null;
+                resultSchema[fieldName] = result;
+            }
+        }
+        return resultSchema;
+    }
+
+}

package/src/utils/paramcoders/ParamEncoder.ts

@@ -0,0 +1,30 @@
+import {IParamWriter} from "./IParamWriter";
+
+
+export class ParamEncoder implements IParamWriter {
+
+    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;
+    }
+
+    writeParams(data: 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
+        ]));
+    }
+
+    end(): Promise<void> {
+        return this.endFN();
+    }
+
+}

package/src/utils/paramcoders/SchemaVerifier.ts

@@ -0,0 +1,97 @@
+import * as BN from "bn.js";
+
+export function parseBN(str: string | number): BN | null {
+    if(str==null) return null;
+    if(typeof(str)!=="string" && typeof(str)!=="number") return null;
+    try {
+        return new BN(str);
+    } catch (e) {
+        return null;
+    }
+}
+
+export 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 function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> {
+    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 && (type as number)>=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 as number)) 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 as RequestSchema);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}

package/src/utils/paramcoders/server/ServerParamDecoder.ts

@@ -0,0 +1,115 @@
+import {Request, Response} from "express";
+import {RequestSchema, verifySchema} from "../SchemaVerifier";
+import {ParamDecoder} from "../ParamDecoder";
+import {ServerParamEncoder} from "./ServerParamEncoder";
+import {IParamReader} from "../IParamReader";
+
+export class RequestTimeoutError extends Error {
+
+    constructor() {
+        super("Request timed out");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+    }
+
+}
+
+export class RequestParsingError extends Error {
+
+    constructor() {
+        super("Request cannot be parsed");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestParsingError.prototype);
+    }
+
+}
+
+export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => {
+
+    let timeout;
+
+    (res as any).responseStream = new ServerParamEncoder(res, 200, req);
+
+    if(req.headers['content-type']!=="application/x-multiple-json") {
+
+        const dataBuffers: Buffer[] = [];
+        req.on("data", (data: Buffer) => {
+            dataBuffers.push(data)
+        });
+        req.on("end", () => {
+            try {
+                const body = JSON.parse(Buffer.concat(dataBuffers).toString());
+                const paramReader: IParamReader = {
+                    getParams: <T extends RequestSchema>(schema: T) => {
+                        return Promise.resolve(verifySchema(body, schema));
+                    },
+                    getExistingParamsOrNull: <T extends RequestSchema>(schema: T) => {
+                        return verifySchema(body, schema);
+                    }
+                };
+                (req as any).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();
+    req.on("data", (data: Buffer) => {
+        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 as any).paramReader = decoder;
+
+    next();
+    return;
+
+}