@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/http/paramcoders/client/ResponseParamDecoder.ts

@@ -0,0 +1,58 @@
+import {ParamDecoder} from "../ParamDecoder";
+import {Buffer} from "buffer";
+
+import {getLogger} from "../../../utils/Logger";
+
+const logger = getLogger("ResponseParamDecoder: ");
+
+export class ResponseParamDecoder extends ParamDecoder {
+
+    private readonly reader?: ReadableStreamDefaultReader<Uint8Array>;
+    private readonly abortSignal?: AbortSignal;
+
+    constructor(resp: Response, abortSignal?: 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.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
+     */
+    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.from(readResp.value));
+        }
+    }
+}

package/src/http/paramcoders/client/StreamParamEncoder.ts

@@ -0,0 +1,29 @@
+import {ParamEncoder} from "../ParamEncoder";
+import {Buffer} from "buffer";
+
+
+export class StreamParamEncoder extends ParamEncoder {
+
+    private readonly stream: TransformStream<Buffer>;
+    private closed: boolean = false;
+
+    constructor() {
+        let stream = new TransformStream<Buffer>();
+        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.stream = stream;
+    }
+
+    /**
+     * Returns the readable stream to be passed to the fetch API
+     */
+    getReadableStream(): ReadableStream<Buffer> {
+        return this.stream.readable;
+    }
+
+}

package/src/http/paramcoders/client/StreamingFetchPromise.ts

@@ -0,0 +1,193 @@
+import {isOptionalField, RequestSchema, RequestSchemaResultPromise, verifyField} from "../SchemaVerifier";
+import {RequestError} from "../../../errors/RequestError";
+import {extendAbortController, objectMap} from "../../../utils/Utils";
+import {StreamParamEncoder} from "./StreamParamEncoder";
+import {ResponseParamDecoder} from "./ResponseParamDecoder";
+import {getLogger} from "../../../utils/Logger";
+import {timeoutSignal} from "../../../utils/TimeoutUtils";
+
+
+export type RequestBody = {
+    [key: string]: Promise<any> | any
+}
+
+const logger = getLogger("StreamingFetch: ");
+
+//https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#feature_detection
+const supportsRequestStreams: boolean = (() => {
+    try {
+        let duplexAccessed = false;
+
+        const request = new Request('https://example.com/', {
+            body: new ReadableStream(),
+            method: 'POST',
+            get duplex() {
+                duplexAccessed = true;
+                return 'half';
+            },
+        } as any);
+        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
+ */
+export async function streamingFetchPromise<T extends RequestSchema>(
+    url: string,
+    body: RequestBody,
+    schema: T,
+    timeout?: number,
+    signal?: AbortSignal,
+    streamRequest?: boolean
+): Promise<RequestSchemaResultPromise<T>> {
+    if(streamRequest==null) streamRequest = supportsRequestStreams;
+    if(timeout!=null) signal = timeoutSignal(timeout, new Error("Network request timed out"), signal);
+
+    const headers: Record<string, string> = {};
+    const init: RequestInit = {
+        method: "POST",
+        headers
+    };
+
+    const startTime = Date.now();
+
+    const immediateValues: any = {};
+    const promises: Promise<any>[] = [];
+
+    if(!streamRequest) {
+        for(let key in body) {
+            if(body[key] instanceof Promise) {
+                promises.push(body[key].then((val: any) => {
+                    immediateValues[key] = val;
+                }));
+            } else {
+                immediateValues[key] = body[key];
+            }
+        }
+
+        try {
+            await Promise.all(promises);
+        } catch (e: any) {
+            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();
+
+        let hasPromiseInBody = false;
+        for(let key in body) {
+            if(body[key] instanceof Promise) {
+                promises.push(body[key].then((val: any) => {
+                    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 as any).duplex = "half";
+
+            logger.debug(url+": Sending request ("+(Date.now()-startTime)+"ms) (streaming): ", immediateValues);
+            promises.push(outputStream.writeParams(immediateValues));
+
+            const abortController = 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: string;
+        try {
+            respTxt = await resp.text();
+        } catch (e) {
+            throw new RequestError(resp.statusText, resp.status);
+        }
+        throw new 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 objectMap(schema, (schemaValue, key) => {
+            const value = respBody[key];
+
+            const result = verifyField(schemaValue, value);
+            if(result===undefined) {
+                return Promise.reject(new Error("Invalid field value"));
+            } else {
+                return Promise.resolve(result);
+            }
+        }) as any;
+    } else {
+        const decoder = new ResponseParamDecoder(resp, init.signal ?? undefined);
+
+        return objectMap(schema, (schemaValue, key) => decoder.getParam(key).catch(e => {
+            if(isOptionalField(schemaValue)) return undefined;
+            throw e;
+        }).then(value => {
+            logger.debug(url+": Response frame read ("+(Date.now()-startTime)+"ms) (streaming resp): ", {[key]: value});
+            const result = verifyField(schemaValue, value);
+            if(result===undefined) {
+                return Promise.reject(new Error("Invalid field value"));
+            } else {
+                return result;
+            }
+        })) as any;
+    }
+}

package/src/index.ts

@@ -1,5 +1,103 @@
 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";

package/src/intermediaries/Intermediary.ts

@@ -0,0 +1,204 @@
+import {SwapType} from "../enums/SwapType";
+import {SwapHandlerInfoType} from "./IntermediaryDiscovery";
+import {ChainSwapType, SwapContract} from "@atomiqlabs/base";
+import {LNNodeLiquidity} from "../bitcoin/LightningNetworkApi";
+
+import {tryWithRetries} from "../utils/RetryUtils";
+
+/**
+ * Services offered by an intermediary
+ * @category Pricing and LPs
+ */
+export type ServicesType = {
+    [key in SwapType]?: SwapHandlerInfoType
+};
+
+/**
+ * Reputation data for an intermediary on a single chain
+ * @category Pricing and LPs
+ */
+export type SingleChainReputationType = {
+    [token: string]: {
+        [key in ChainSwapType]: {
+            successVolume: bigint,
+            successCount: bigint,
+            failVolume: bigint,
+            failCount: bigint,
+            coopCloseVolume: bigint,
+            coopCloseCount: bigint,
+        }
+    }
+};
+
+/**
+ * Smart chain liquidity data
+ * @category Pricing and LPs
+ */
+export type SCLiquidity = {
+    [token: string]: bigint
+};
+
+/**
+ * Represents a liquidity provider/intermediary
+ * @category Pricing and LPs
+ */
+export class Intermediary {
+
+    readonly url: string;
+    readonly addresses: {[chainIdentifier: string]: string};
+    readonly services: ServicesType;
+    readonly swapBounds: {
+        [swapType in SwapType]?: {
+            [chainIdentifier: string]: {
+                [tokenAddress: string]: {
+                    input: {
+                        min?: bigint,
+                        max?: bigint
+                    },
+                    output: {
+                        min?: bigint,
+                        max?: bigint
+                    }
+                }
+            }
+        }
+    }
+    reputation: { [chainIdentifier: string]: SingleChainReputationType } = {};
+    liquidity: { [chainIdentifier: string]: SCLiquidity } = {};
+    lnData?: LNNodeLiquidity;
+
+    constructor(
+        url: string,
+        addresses: {[chainIdentifier: string]: string},
+        services: ServicesType,
+        reputation: { [chainIdentifier: string]: SingleChainReputationType } = {}
+    ) {
+        this.url = url;
+        this.addresses = addresses;
+        this.services = services;
+        this.reputation = reputation;
+
+        this.swapBounds = {};
+        for(let _swapType in this.services) {
+            const swapType: SwapType = parseInt(_swapType);
+            const serviceInfo = this.services[swapType]!;
+            const btcBounds = {min: BigInt(serviceInfo.min), max: BigInt(serviceInfo.max)};
+            const isSend = swapType===SwapType.TO_BTC || swapType===SwapType.TO_BTCLN;
+            this.swapBounds[swapType] = {};
+            for(let chainIdentifier in serviceInfo.chainTokens) {
+                this.swapBounds[swapType]![chainIdentifier] = {};
+                for(let tokenAddress of serviceInfo.chainTokens[chainIdentifier]) {
+                    this.swapBounds[swapType]![chainIdentifier][tokenAddress] = {
+                        input: isSend ? {} : btcBounds,
+                        output: !isSend ? {} : btcBounds,
+                    };
+                }
+            }
+        }
+    }
+
+    getSwapLimits(swapType: SwapType, chainId: string, tokenAddress: string): {input: {min?: bigint, max?: bigint}, output: {min?: bigint, max?: bigint}} | undefined {
+        return this.swapBounds[swapType]?.[chainId]?.[tokenAddress];
+    }
+
+    /**
+     * Returns tokens supported by the intermediary, optionally constrained to the specific swap types
+     *
+     * @param chainIdentifier
+     * @param swapTypesArr
+     * @private
+     */
+    private getSupportedTokens(chainIdentifier: string, swapTypesArr: SwapType[] = [
+        SwapType.TO_BTC,
+        SwapType.TO_BTCLN,
+        SwapType.FROM_BTC,
+        SwapType.FROM_BTCLN,
+        SwapType.SPV_VAULT_FROM_BTC,
+        SwapType.FROM_BTCLN_AUTO
+    ]): Set<string> {
+        const swapTypes = new Set(swapTypesArr);
+        let tokens: Set<string> = new Set<string>();
+        swapTypes.forEach((swapType) => {
+            const supportedTokens = this.services[swapType]?.chainTokens?.[chainIdentifier];
+            if(supportedTokens!=null) supportedTokens.forEach(token => tokens.add(token));
+        });
+        return tokens;
+    }
+
+    /**
+     * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param tokens
+     * @param abortSignal
+     */
+    async getReputation(
+        chainIdentifier: string,
+        swapContract: SwapContract<any>,
+        tokens?: string[],
+        abortSignal?: AbortSignal
+    ): Promise<SingleChainReputationType> {
+        const checkReputationTokens: Set<string> = tokens==null ?
+            this.getSupportedTokens(chainIdentifier, [SwapType.TO_BTC, SwapType.TO_BTCLN]) :
+            new Set<string>(tokens);
+
+        const promises: Promise<void>[] = [];
+        const reputation: SingleChainReputationType = {};
+        for(let token of checkReputationTokens) {
+            promises.push(
+                tryWithRetries(() =>
+                    swapContract.getIntermediaryReputation(this.getAddress(chainIdentifier), token),
+                    undefined, undefined, abortSignal
+                ).then(result => {
+                    if(result!=null) reputation[token] = result;
+                })
+            );
+        }
+        await Promise.all(promises);
+
+        this.reputation ??= {};
+        this.reputation[chainIdentifier] ??= {};
+        for(let key in reputation) {
+            this.reputation[chainIdentifier][key] = reputation[key];
+        }
+
+        return reputation;
+    }
+
+    /**
+     * Fetches, returns and saves the liquidity of the intermediaryfor a specific token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param token
+     * @param abortSignal
+     */
+    async getLiquidity(
+        chainIdentifier: string,
+        swapContract: SwapContract<any>,
+        token: string,
+        abortSignal?: AbortSignal
+    ): Promise<bigint> {
+        const result = await tryWithRetries(
+            () => swapContract.getBalance(this.getAddress(chainIdentifier), token, true),
+            undefined, undefined, abortSignal
+        );
+
+        this.liquidity ??= {};
+        this.liquidity[chainIdentifier] ??= {};
+        this.liquidity[chainIdentifier][token] = result;
+
+        return result;
+    }
+
+    supportsChain(chainIdentifier: string): boolean {
+        if(this.addresses[chainIdentifier]==null) return false;
+        return this.getSupportedTokens(chainIdentifier).size!==0;
+    }
+
+    getAddress(chainIdentifier: string) {
+        return this.addresses[chainIdentifier];
+    }
+
+}