@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/http/paramcoders/SchemaVerifier.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySchema = exports.verifyField = exports.isOptionalField = exports.FieldTypeEnum = exports.parseBigInt = void 0;
+function parseBigInt(str) {
+    if (str == null)
+        return null;
+    if (typeof (str) !== "string" && typeof (str) !== "number")
+        return null;
+    try {
+        return BigInt(str);
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.parseBigInt = parseBigInt;
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum[FieldTypeEnum["String"] = 0] = "String";
+    FieldTypeEnum[FieldTypeEnum["Boolean"] = 1] = "Boolean";
+    FieldTypeEnum[FieldTypeEnum["Number"] = 2] = "Number";
+    FieldTypeEnum[FieldTypeEnum["BigInt"] = 3] = "BigInt";
+    FieldTypeEnum[FieldTypeEnum["Any"] = 4] = "Any";
+    FieldTypeEnum[FieldTypeEnum["StringOptional"] = 100] = "StringOptional";
+    FieldTypeEnum[FieldTypeEnum["BooleanOptional"] = 101] = "BooleanOptional";
+    FieldTypeEnum[FieldTypeEnum["NumberOptional"] = 102] = "NumberOptional";
+    FieldTypeEnum[FieldTypeEnum["BigIntOptional"] = 103] = "BigIntOptional";
+    FieldTypeEnum[FieldTypeEnum["AnyOptional"] = 104] = "AnyOptional";
+})(FieldTypeEnum = exports.FieldTypeEnum || (exports.FieldTypeEnum = {}));
+function isAllOptional(schema) {
+    for (let key in schema) {
+        if (!isOptionalField(schema[key]))
+            return false;
+    }
+    return true;
+}
+function isOptionalField(type) {
+    if (typeof (type) === "function")
+        return type(undefined) != null;
+    if (typeof (type) === "object")
+        return isAllOptional(type);
+    return type >= 100;
+}
+exports.isOptionalField = isOptionalField;
+function verifyField(fieldType, val) {
+    const type = fieldType;
+    if (typeof (type) === "function") {
+        const result = type(val);
+        if (result == null)
+            return;
+        return result;
+    }
+    if (val == null && isOptionalField(type)) {
+        return null;
+    }
+    if (type === FieldTypeEnum.Any || type === FieldTypeEnum.AnyOptional) {
+        return val;
+    }
+    else if (type === FieldTypeEnum.Boolean || type === FieldTypeEnum.BooleanOptional) {
+        if (typeof (val) !== "boolean")
+            return;
+        return val;
+    }
+    else if (type === FieldTypeEnum.Number || type === FieldTypeEnum.NumberOptional) {
+        if (typeof (val) !== "number")
+            return;
+        if (isNaN(val))
+            return;
+        return val;
+    }
+    else if (type === FieldTypeEnum.BigInt || type === FieldTypeEnum.BigIntOptional) {
+        const result = parseBigInt(val);
+        if (result == null)
+            return;
+        return result;
+    }
+    else if (type === FieldTypeEnum.String || type === FieldTypeEnum.StringOptional) {
+        if (typeof (val) !== "string")
+            return;
+        return val;
+    }
+    else {
+        //Probably another request schema
+        const result = verifySchema(val, type);
+        if (result == null)
+            return;
+        return result;
+    }
+}
+exports.verifyField = verifyField;
+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 && isOptionalField(type)) {
+            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.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);
+            if (result == null)
+                return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}
+exports.verifySchema = verifySchema;

package/dist/http/paramcoders/client/ResponseParamDecoder.d.ts

@@ -0,0 +1,11 @@
+import { ParamDecoder } from "../ParamDecoder";
+export declare class ResponseParamDecoder extends ParamDecoder {
+    private readonly reader?;
+    private readonly abortSignal?;
+    constructor(resp: Response, abortSignal?: AbortSignal);
+    /**
+     * Keeps reading the response until the reader closes
+     * @private
+     */
+    private readResponse;
+}

package/dist/http/paramcoders/client/ResponseParamDecoder.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseParamDecoder = void 0;
+const ParamDecoder_1 = require("../ParamDecoder");
+const buffer_1 = require("buffer");
+const Logger_1 = require("../../../utils/Logger");
+const logger = (0, Logger_1.getLogger)("ResponseParamDecoder: ");
+class ResponseParamDecoder extends ParamDecoder_1.ParamDecoder {
+    constructor(resp, abortSignal) {
+        super();
+        this.abortSignal = abortSignal;
+        try {
+            //Read from stream
+            if (resp.body == null)
+                throw new Error("Response has no body field!");
+            this.reader = resp.body.getReader();
+            this.readResponse();
+        }
+        catch (e) {
+            //Read in one piece
+            resp.arrayBuffer().then(respBuffer => {
+                super.onData(buffer_1.Buffer.from(respBuffer));
+                super.onEnd();
+            }).catch(e => {
+                super.onError(e);
+            });
+        }
+        if (abortSignal != null)
+            abortSignal.addEventListener("abort", () => {
+                super.onError(abortSignal.reason);
+                if (this.reader != null && !this.reader.closed)
+                    this.reader.cancel(abortSignal.reason);
+            });
+    }
+    /**
+     * Keeps reading the response until the reader closes
+     * @private
+     */
+    async readResponse() {
+        if (this.reader == null)
+            return;
+        while (true) {
+            const readResp = await this.reader.read().catch(e => {
+                logger.error("readResponse(): Error reading response: ", e);
+                return null;
+            });
+            if (this.abortSignal != null && this.abortSignal.aborted)
+                return;
+            if (readResp == null || readResp.done) {
+                super.onEnd();
+                return;
+            }
+            super.onData(buffer_1.Buffer.from(readResp.value));
+        }
+    }
+}
+exports.ResponseParamDecoder = ResponseParamDecoder;

package/dist/http/paramcoders/client/StreamParamEncoder.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ParamEncoder } from "../ParamEncoder";
+import { Buffer } from "buffer";
+export declare class StreamParamEncoder extends ParamEncoder {
+    private readonly stream;
+    private closed;
+    constructor();
+    /**
+     * Returns the readable stream to be passed to the fetch API
+     */
+    getReadableStream(): ReadableStream<Buffer>;
+}

package/dist/http/paramcoders/client/StreamParamEncoder.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamParamEncoder = void 0;
+const ParamEncoder_1 = require("../ParamEncoder");
+class StreamParamEncoder extends ParamEncoder_1.ParamEncoder {
+    constructor() {
+        let stream = new TransformStream();
+        let writeStream = stream.writable.getWriter();
+        writeStream.closed.then(() => this.closed = true);
+        super(writeStream.write.bind(writeStream), () => {
+            if (this.closed)
+                return Promise.resolve();
+            this.closed = true;
+            return writeStream.close();
+        });
+        this.closed = false;
+        this.stream = stream;
+    }
+    /**
+     * Returns the readable stream to be passed to the fetch API
+     */
+    getReadableStream() {
+        return this.stream.readable;
+    }
+}
+exports.StreamParamEncoder = StreamParamEncoder;

package/dist/http/paramcoders/client/StreamingFetchPromise.d.ts

@@ -0,0 +1,16 @@
+import { RequestSchema, RequestSchemaResultPromise } from "../SchemaVerifier";
+export type RequestBody = {
+    [key: string]: Promise<any> | any;
+};
+/**
+ * Sends a POST request to the specified URL in a streaming request/response mode
+ *
+ * @param url URL to send the request to
+ * @param body An object containing properties that should be sent to the server, can be Promise or any
+ * @param schema Schema of the response that should be received from the server
+ * @param timeout Timeout in millseconds for the request to succeed & all its response properties to resolve
+ * @param signal Abort signal
+ * @param streamRequest Whether the request should be streamed or not
+ * @throws {RequestError} When the response code is not 200
+ */
+export declare function streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean): Promise<RequestSchemaResultPromise<T>>;

package/dist/http/paramcoders/client/StreamingFetchPromise.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamingFetchPromise = void 0;
+const SchemaVerifier_1 = require("../SchemaVerifier");
+const RequestError_1 = require("../../../errors/RequestError");
+const Utils_1 = require("../../../utils/Utils");
+const StreamParamEncoder_1 = require("./StreamParamEncoder");
+const ResponseParamDecoder_1 = require("./ResponseParamDecoder");
+const Logger_1 = require("../../../utils/Logger");
+const TimeoutUtils_1 = require("../../../utils/TimeoutUtils");
+const logger = (0, Logger_1.getLogger)("StreamingFetch: ");
+//https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#feature_detection
+const supportsRequestStreams = (() => {
+    try {
+        let duplexAccessed = false;
+        const request = new Request('https://example.com/', {
+            body: new ReadableStream(),
+            method: 'POST',
+            get duplex() {
+                duplexAccessed = true;
+                return 'half';
+            },
+        });
+        const hasContentType = request.headers.has('Content-Type');
+        return duplexAccessed && !hasContentType;
+    }
+    catch (e) {
+        logger.error("supportsRequestStreams: Error checking environment support for HTTP request stream", e);
+        return false;
+    }
+})();
+logger.info("Environment supports request stream: " + supportsRequestStreams);
+/**
+ * Sends a POST request to the specified URL in a streaming request/response mode
+ *
+ * @param url URL to send the request to
+ * @param body An object containing properties that should be sent to the server, can be Promise or any
+ * @param schema Schema of the response that should be received from the server
+ * @param timeout Timeout in millseconds for the request to succeed & all its response properties to resolve
+ * @param signal Abort signal
+ * @param streamRequest Whether the request should be streamed or not
+ * @throws {RequestError} When the response code is not 200
+ */
+async function streamingFetchPromise(url, body, schema, timeout, signal, streamRequest) {
+    if (streamRequest == null)
+        streamRequest = supportsRequestStreams;
+    if (timeout != null)
+        signal = (0, TimeoutUtils_1.timeoutSignal)(timeout, new Error("Network request timed out"), signal);
+    const headers = {};
+    const init = {
+        method: "POST",
+        headers
+    };
+    const startTime = Date.now();
+    const immediateValues = {};
+    const promises = [];
+    if (!streamRequest) {
+        for (let key in body) {
+            if (body[key] instanceof Promise) {
+                promises.push(body[key].then((val) => {
+                    immediateValues[key] = val;
+                }));
+            }
+            else {
+                immediateValues[key] = body[key];
+            }
+        }
+        try {
+            await Promise.all(promises);
+        }
+        catch (e) {
+            e._inputPromiseError = true;
+            throw e;
+        }
+        if (signal != null)
+            signal.throwIfAborted();
+        logger.debug(url + ": Sending request (" + (Date.now() - startTime) + "ms) (non-streaming): ", immediateValues);
+        init.body = JSON.stringify(immediateValues);
+        headers['content-type'] = "application/json";
+    }
+    else {
+        const outputStream = new StreamParamEncoder_1.StreamParamEncoder();
+        let hasPromiseInBody = false;
+        for (let key in body) {
+            if (body[key] instanceof Promise) {
+                promises.push(body[key].then((val) => {
+                    logger.debug(url + ": Send param (" + (Date.now() - startTime) + "ms) (streaming): ", { [key]: val });
+                    return outputStream.writeParams({
+                        [key]: val
+                    });
+                }));
+                hasPromiseInBody = true;
+            }
+            else {
+                immediateValues[key] = body[key];
+            }
+        }
+        if (hasPromiseInBody) {
+            init.body = outputStream.getReadableStream();
+            headers['content-type'] = "application/x-multiple-json";
+            init.duplex = "half";
+            logger.debug(url + ": Sending request (" + (Date.now() - startTime) + "ms) (streaming): ", immediateValues);
+            promises.push(outputStream.writeParams(immediateValues));
+            const abortController = (0, Utils_1.extendAbortController)(signal);
+            signal = abortController.signal;
+            Promise.all(promises).then(() => outputStream.end()).catch(e => {
+                e._inputPromiseError = true;
+                abortController.abort(e);
+            });
+            signal.addEventListener("abort", () => outputStream.end());
+        }
+        else {
+            logger.debug(url + ": Sending request (" + (Date.now() - startTime) + "ms) (non-streaming): ", immediateValues);
+            init.body = JSON.stringify(immediateValues);
+            headers['content-type'] = "application/json";
+        }
+    }
+    if (signal != null)
+        init.signal = signal;
+    headers['accept'] = "application/x-multiple-json";
+    const resp = await fetch(url, init).catch(e => {
+        if (init.signal != null && e.name === "AbortError") {
+            throw init.signal.reason;
+        }
+        else {
+            if (e.message != null)
+                e.message += streamRequest ? " (streaming req)" : " (non streaming req)";
+            throw e;
+        }
+    });
+    logger.debug(url + ": Response status (" + (Date.now() - startTime) + "ms) " + (streamRequest ? "(streaming req)" : "(non streaming req)") + ": ", resp.status);
+    if (resp.status !== 200) {
+        let respTxt;
+        try {
+            respTxt = await resp.text();
+        }
+        catch (e) {
+            throw new RequestError_1.RequestError(resp.statusText, resp.status);
+        }
+        throw new RequestError_1.RequestError(respTxt, resp.status);
+    }
+    if (resp.headers.get("content-type") !== "application/x-multiple-json") {
+        const respBody = await resp.json();
+        logger.debug(url + ": Response read (" + (Date.now() - startTime) + "ms) (non streaming resp): ", respBody);
+        return (0, Utils_1.objectMap)(schema, (schemaValue, key) => {
+            const value = respBody[key];
+            const result = (0, SchemaVerifier_1.verifyField)(schemaValue, value);
+            if (result === undefined) {
+                return Promise.reject(new Error("Invalid field value"));
+            }
+            else {
+                return Promise.resolve(result);
+            }
+        });
+    }
+    else {
+        const decoder = new ResponseParamDecoder_1.ResponseParamDecoder(resp, init.signal ?? undefined);
+        return (0, Utils_1.objectMap)(schema, (schemaValue, key) => decoder.getParam(key).catch(e => {
+            if ((0, SchemaVerifier_1.isOptionalField)(schemaValue))
+                return undefined;
+            throw e;
+        }).then(value => {
+            logger.debug(url + ": Response frame read (" + (Date.now() - startTime) + "ms) (streaming resp): ", { [key]: value });
+            const result = (0, SchemaVerifier_1.verifyField)(schemaValue, value);
+            if (result === undefined) {
+                return Promise.reject(new Error("Invalid field value"));
+            }
+            else {
+                return result;
+            }
+        }));
+    }
+}
+exports.streamingFetchPromise = streamingFetchPromise;

package/dist/index.d.ts

@@ -1,5 +1,83 @@
 export * from "@atomiqlabs/base";
-export * from "@atomiqlabs/sdk-lib";
-export * from "./SwapperFactory";
-export * from "./Utils";
-export * from "./storage/LocalStorageManager";
+export { MempoolApi } from "./bitcoin/mempool/MempoolApi";
+export * from "./bitcoin/mempool/MempoolBitcoinRpc";
+export * from "./bitcoin/wallet/BitcoinWallet";
+export * from "./bitcoin/wallet/IBitcoinWallet";
+export * from "./bitcoin/wallet/MinimalBitcoinWalletInterface";
+export * from "./bitcoin/wallet/MinimalLightningNetworkWalletInterface";
+export * from "./bitcoin/wallet/SingleAddressBitcoinWallet";
+export * from "./enums/FeeType";
+export * from "./enums/SwapAmountType";
+export * from "./enums/SwapDirection";
+export * from "./enums/SwapType";
+export * from "./errors/IntermediaryError";
+export * from "./errors/PaymentAuthError";
+export * from "./errors/RequestError";
+export * from "./errors/UserError";
+export { Intermediary } from "./intermediaries/Intermediary";
+export { IntermediaryDiscovery } from "./intermediaries/IntermediaryDiscovery";
+export * from "./prices/abstract/ISwapPrice";
+export { RedundantSwapPrice } from "./prices/RedundantSwapPrice";
+export * from "./prices/SingleSwapPrice";
+export * from "./prices/SwapPriceWithChain";
+export { BinancePriceProvider } from "./prices/providers/BinancePriceProvider";
+export { CoinGeckoPriceProvider } from "./prices/providers/CoinGeckoPriceProvider";
+export { CoinPaprikaPriceProvider } from "./prices/providers/CoinPaprikaPriceProvider";
+export { KrakenPriceProvider } from "./prices/providers/KrakenPriceProvider";
+export { OKXPriceProvider } from "./prices/providers/OKXPriceProvider";
+export { CustomPriceProvider } from "./prices/providers/CustomPriceProvider";
+export * from "./storage/IUnifiedStorage";
+export * from "./storage/UnifiedSwapStorage";
+export { IndexedDBUnifiedStorage } from "./storage-browser/IndexedDBUnifiedStorage";
+export * from "./storage-browser/LocalStorageManager";
+export { Swapper } from "./swapper/Swapper";
+export * from "./swapper/SwapperFactory";
+export * from "./swapper/SwapperUtils";
+export * from "./swapper/SwapperWithChain";
+export * from "./swapper/SwapperWithSigner";
+export { FromBTCLNSwap, FromBTCLNSwapState } from "./swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap";
+export { FromBTCLNWrapper } from "./swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper";
+export { FromBTCLNAutoSwap, FromBTCLNAutoSwapState } from "./swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap";
+export { FromBTCLNAutoWrapper } from "./swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper";
+export { FromBTCSwap, FromBTCSwapState } from "./swaps/escrow_swaps/frombtc/onchain/FromBTCSwap";
+export { FromBTCWrapper } from "./swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper";
+export { IFromBTCLNWrapper } from "./swaps/escrow_swaps/frombtc/IFromBTCLNWrapper";
+export { IFromBTCSelfInitSwap } from "./swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap";
+export { IFromBTCWrapper } from "./swaps/escrow_swaps/frombtc/IFromBTCWrapper";
+export { ToBTCLNSwap } from "./swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap";
+export { ToBTCLNWrapper } from "./swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper";
+export { ToBTCSwap } from "./swaps/escrow_swaps/tobtc/onchain/ToBTCSwap";
+export { ToBTCWrapper } from "./swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper";
+export { IToBTCSwap, ToBTCSwapState } from "./swaps/escrow_swaps/tobtc/IToBTCSwap";
+export { IToBTCWrapper } from "./swaps/escrow_swaps/tobtc/IToBTCWrapper";
+export { IEscrowSelfInitSwap } from "./swaps/escrow_swaps/IEscrowSelfInitSwap";
+export { IEscrowSwap } from "./swaps/escrow_swaps/IEscrowSwap";
+export { IEscrowSwapWrapper } from "./swaps/escrow_swaps/IEscrowSwapWrapper";
+export { SpvFromBTCSwap, SpvFromBTCSwapState } from "./swaps/spv_swaps/SpvFromBTCSwap";
+export { SpvFromBTCWrapper } from "./swaps/spv_swaps/SpvFromBTCWrapper";
+export { LnForGasSwap, LnForGasSwapState } from "./swaps/trusted/ln/LnForGasSwap";
+export { LnForGasWrapper } from "./swaps/trusted/ln/LnForGasWrapper";
+export { OnchainForGasSwap, OnchainForGasSwapState } from "./swaps/trusted/onchain/OnchainForGasSwap";
+export { OnchainForGasWrapper } from "./swaps/trusted/onchain/OnchainForGasWrapper";
+export * from "./swaps/IAddressSwap";
+export * from "./swaps/IBTCWalletSwap";
+export * from "./swaps/IClaimableSwap";
+export * from "./swaps/IRefundableSwap";
+export * from "./swaps/IAddressSwap";
+export { ISwap } from "./swaps/ISwap";
+export * from "./swaps/ISwapWithGasDrop";
+export { ISwapWrapper } from "./swaps/ISwapWrapper";
+export * from "./types/fees/Fee";
+export * from "./types/fees/FeeBreakdown";
+export * from "./types/fees/PercentagePPM";
+export * from "./types/lnurl/LNURLPay";
+export * from "./types/lnurl/LNURLWithdraw";
+export * from "./types/AmountData";
+export * from "./types/CustomPriceFunction";
+export * from "./types/PriceInfoType";
+export * from "./types/SwapExecutionAction";
+export * from "./types/SwapWithSigner";
+export * from "./types/Token";
+export * from "./types/TokenAmount";
+export * from "./utils/TokenUtils";
+export * from "./utils/SwapUtils";