@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swaps/escrow_swaps/tobtc/onchain/ToBTCSwap.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBTCSwap = exports.isToBTCSwapInit = void 0;
+const IToBTCSwap_1 = require("../IToBTCSwap");
+const SwapType_1 = require("../../../../enums/SwapType");
+const buffer_1 = require("buffer");
+const IntermediaryError_1 = require("../../../../errors/IntermediaryError");
+const Utils_1 = require("../../../../utils/Utils");
+const TokenAmount_1 = require("../../../../types/TokenAmount");
+const Token_1 = require("../../../../types/Token");
+const Logger_1 = require("../../../../utils/Logger");
+function isToBTCSwapInit(obj) {
+    return typeof (obj.address) === "string" &&
+        typeof (obj.amount) === "bigint" &&
+        typeof (obj.confirmationTarget) === "number" &&
+        typeof (obj.satsPerVByte) === "number" &&
+        typeof (obj.requiredConfirmations) === "number" &&
+        typeof (obj.nonce) === "bigint" &&
+        (0, IToBTCSwap_1.isIToBTCSwapInit)(obj);
+}
+exports.isToBTCSwapInit = isToBTCSwapInit;
+/**
+ * Smart Chain to on-chain BTC swap
+ * @category Swaps
+ */
+class ToBTCSwap extends IToBTCSwap_1.IToBTCSwap {
+    constructor(wrapper, initOrObject) {
+        if (isToBTCSwapInit(initOrObject) && initOrObject.url != null)
+            initOrObject.url += "/tobtc";
+        super(wrapper, initOrObject);
+        this.outputToken = Token_1.BitcoinTokens.BTC;
+        this.TYPE = SwapType_1.SwapType.TO_BTC;
+        if (isToBTCSwapInit(initOrObject)) {
+            this.address = initOrObject.address;
+            this.amount = initOrObject.amount;
+            this.confirmationTarget = initOrObject.confirmationTarget;
+            this.satsPerVByte = initOrObject.satsPerVByte;
+            this.requiredConfirmations = initOrObject.requiredConfirmations;
+            this.nonce = initOrObject.nonce;
+        }
+        else {
+            this.address = initOrObject.address;
+            this.amount = BigInt(initOrObject.amount);
+            this.confirmationTarget = initOrObject.confirmationTarget;
+            this.satsPerVByte = initOrObject.satsPerVByte;
+            this.txId = initOrObject.txId;
+            this.requiredConfirmations = initOrObject.requiredConfirmations ?? this.data.getConfirmationsHint();
+            this.nonce = (0, Utils_1.toBigInt)(initOrObject.nonce) ?? this.data.getNonceHint();
+        }
+        this.logger = (0, Logger_1.getLogger)("ToBTC(" + this.getIdentifierHashString() + "): ");
+        this.tryRecomputeSwapPrice();
+    }
+    async _setPaymentResult(result, check = false) {
+        if (result == null)
+            return false;
+        if (result.txId == null)
+            throw new IntermediaryError_1.IntermediaryError("No btc txId returned!");
+        if (check) {
+            const btcTx = await this.wrapper.btcRpc.getTransaction(result.txId);
+            if (btcTx == null)
+                return false;
+            const foundVout = btcTx.outs.find(vout => this.data.getClaimHash() === this.wrapper.contract.getHashForOnchain(buffer_1.Buffer.from(vout.scriptPubKey.hex, "hex"), BigInt(vout.value), this.requiredConfirmations, this.nonce).toString("hex"));
+            if (foundVout == null)
+                throw new IntermediaryError_1.IntermediaryError("Invalid btc txId returned");
+        }
+        this.txId = result.txId;
+        return true;
+    }
+    //////////////////////////////
+    //// Amounts & fees
+    getOutputToken() {
+        return Token_1.BitcoinTokens.BTC;
+    }
+    getOutput() {
+        return (0, TokenAmount_1.toTokenAmount)(this.amount, this.outputToken, this.wrapper.prices, this.pricingInfo);
+    }
+    //////////////////////////////
+    //// Getters & utils
+    /**
+     * Returns the bitcoin address where the BTC will be sent to
+     */
+    getOutputAddress() {
+        return this.address;
+    }
+    getOutputTxId() {
+        return this.txId ?? null;
+    }
+    /**
+     * Returns fee rate of the bitcoin transaction in sats/vB
+     */
+    getBitcoinFeeRate() {
+        return this.satsPerVByte;
+    }
+    //////////////////////////////
+    //// Storage
+    serialize() {
+        return {
+            ...super.serialize(),
+            address: this.address,
+            amount: this.amount.toString(10),
+            confirmationTarget: this.confirmationTarget,
+            satsPerVByte: this.satsPerVByte,
+            nonce: this.nonce == null ? null : this.nonce.toString(10),
+            requiredConfirmations: this.requiredConfirmations,
+            txId: this.txId
+        };
+    }
+}
+exports.ToBTCSwap = ToBTCSwap;

package/dist/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.d.ts

@@ -0,0 +1,93 @@
+/// <reference types="node" />
+import { ToBTCSwap } from "./ToBTCSwap";
+import { IToBTCDefinition, IToBTCWrapper } from "../IToBTCWrapper";
+import { BitcoinRpc, ChainType } from "@atomiqlabs/base";
+import { Intermediary } from "../../../../intermediaries/Intermediary";
+import { ISwapPrice } from "../../../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { ISwapWrapperOptions, WrapperCtorTokens } from "../../../ISwapWrapper";
+import { SwapType } from "../../../../enums/SwapType";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { UnifiedSwapEventListener } from "../../../../events/UnifiedSwapEventListener";
+import { UnifiedSwapStorage } from "../../../../storage/UnifiedSwapStorage";
+import { ISwap } from "../../../ISwap";
+import { AmountData } from "../../../../types/AmountData";
+import { AllOptional } from "../../../../utils/TypeUtils";
+export type ToBTCOptions = {
+    confirmationTarget?: number;
+    confirmations?: number;
+};
+export type ToBTCWrapperOptions = ISwapWrapperOptions & {
+    safetyFactor: number;
+    maxConfirmations: number;
+    bitcoinNetwork: BTC_NETWORK;
+    bitcoinBlocktime: number;
+    maxExpectedOnchainSendSafetyFactor: number;
+    maxExpectedOnchainSendGracePeriodBlocks: number;
+};
+export type ToBTCDefinition<T extends ChainType> = IToBTCDefinition<T, ToBTCWrapper<T>, ToBTCSwap<T>>;
+export declare class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDefinition<T>, ToBTCWrapperOptions> {
+    readonly TYPE = SwapType.TO_BTC;
+    readonly swapDeserializer: typeof ToBTCSwap;
+    readonly btcRpc: BitcoinRpc<any>;
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents Smart chain on-chain event listener
+     * @param chain
+     * @param contract Chain specific swap contract
+     * @param prices Swap pricing handler
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for chain specific SwapData
+     * @param btcRpc Bitcoin RPC api
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], contract: T["Contract"], prices: ISwapPrice, tokens: WrapperCtorTokens, swapDataDeserializer: new (data: any) => T["Data"], btcRpc: BitcoinRpc<any>, options?: AllOptional<ToBTCWrapperOptions>, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    /**
+     * Returns randomly generated random escrow nonce to be used for to BTC on-chain swaps
+     * @private
+     * @returns Escrow nonce
+     */
+    private getRandomNonce;
+    /**
+     * Converts bitcoin address to its corresponding output script
+     *
+     * @param addr Bitcoin address to get the output script for
+     * @private
+     * @returns Output script as Buffer
+     * @throws {UserError} if invalid address is specified
+     */
+    private btcAddressToOutputScript;
+    /**
+     * Verifies returned LP data
+     *
+     * @param signer
+     * @param resp LP's response
+     * @param amountData
+     * @param lp
+     * @param options Options as passed to the swap create function
+     * @param data LP's returned parsed swap data
+     * @param hash Payment hash of the swap
+     * @private
+     * @throws {IntermediaryError} if returned data are not correct
+     */
+    private verifyReturnedData;
+    /**
+     * Returns quotes fetched from LPs, paying to an 'address' - a bitcoin address
+     *
+     * @param signer                Smart-chain signer address initiating the swap
+     * @param address               Bitcoin on-chain address you wish to pay to
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    create(signer: string, address: string, amountData: AmountData, lps: Intermediary[], options?: ToBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
+        quote: Promise<ToBTCSwap<T>>;
+        intermediary: Intermediary;
+    }[];
+}

package/dist/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBTCWrapper = void 0;
+const ToBTCSwap_1 = require("./ToBTCSwap");
+const IToBTCWrapper_1 = require("../IToBTCWrapper");
+const base_1 = require("@atomiqlabs/base");
+const UserError_1 = require("../../../../errors/UserError");
+const IntermediaryError_1 = require("../../../../errors/IntermediaryError");
+const SwapType_1 = require("../../../../enums/SwapType");
+const Utils_1 = require("../../../../utils/Utils");
+const BitcoinUtils_1 = require("../../../../utils/BitcoinUtils");
+const IntermediaryAPI_1 = require("../../../../intermediaries/apis/IntermediaryAPI");
+const RequestError_1 = require("../../../../errors/RequestError");
+const utils_1 = require("@scure/btc-signer/utils");
+const RetryUtils_1 = require("../../../../utils/RetryUtils");
+class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents Smart chain on-chain event listener
+     * @param chain
+     * @param contract Chain specific swap contract
+     * @param prices Swap pricing handler
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for chain specific SwapData
+     * @param btcRpc Bitcoin RPC api
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, btcRpc, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, {
+            bitcoinNetwork: options?.bitcoinNetwork ?? utils_1.TEST_NETWORK,
+            safetyFactor: options?.safetyFactor ?? 2,
+            maxConfirmations: options?.maxConfirmations ?? 6,
+            bitcoinBlocktime: options?.bitcoinBlocktime ?? (60 * 10),
+            maxExpectedOnchainSendSafetyFactor: options?.maxExpectedOnchainSendSafetyFactor ?? 4,
+            maxExpectedOnchainSendGracePeriodBlocks: options?.maxExpectedOnchainSendGracePeriodBlocks ?? 12,
+        }, events);
+        this.TYPE = SwapType_1.SwapType.TO_BTC;
+        this.swapDeserializer = ToBTCSwap_1.ToBTCSwap;
+        this.btcRpc = btcRpc;
+    }
+    /**
+     * Returns randomly generated random escrow nonce to be used for to BTC on-chain swaps
+     * @private
+     * @returns Escrow nonce
+     */
+    getRandomNonce() {
+        const firstPart = BigInt(Math.floor((Date.now() / 1000)) - 700000000);
+        return (firstPart << 24n) | base_1.BigIntBufferUtils.fromBuffer((0, Utils_1.randomBytes)(3));
+    }
+    /**
+     * Converts bitcoin address to its corresponding output script
+     *
+     * @param addr Bitcoin address to get the output script for
+     * @private
+     * @returns Output script as Buffer
+     * @throws {UserError} if invalid address is specified
+     */
+    btcAddressToOutputScript(addr) {
+        try {
+            return (0, BitcoinUtils_1.toOutputScript)(this.options.bitcoinNetwork, addr);
+        }
+        catch (e) {
+            throw new UserError_1.UserError("Invalid address specified");
+        }
+    }
+    /**
+     * Verifies returned LP data
+     *
+     * @param signer
+     * @param resp LP's response
+     * @param amountData
+     * @param lp
+     * @param options Options as passed to the swap create function
+     * @param data LP's returned parsed swap data
+     * @param hash Payment hash of the swap
+     * @private
+     * @throws {IntermediaryError} if returned data are not correct
+     */
+    verifyReturnedData(signer, resp, amountData, lp, options, data, hash) {
+        if (resp.totalFee !== (resp.swapFee + resp.networkFee))
+            throw new IntermediaryError_1.IntermediaryError("Invalid totalFee returned");
+        if (amountData.exactIn) {
+            if (resp.total !== amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid total returned");
+        }
+        else {
+            if (resp.amount !== amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid amount returned");
+        }
+        const maxAllowedBlockDelta = BigInt(options.confirmations +
+            options.confirmationTarget +
+            this.options.maxExpectedOnchainSendGracePeriodBlocks);
+        const maxAllowedExpiryDelta = maxAllowedBlockDelta
+            * BigInt(this.options.maxExpectedOnchainSendSafetyFactor)
+            * BigInt(this.options.bitcoinBlocktime);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const maxAllowedExpiryTimestamp = currentTimestamp + maxAllowedExpiryDelta;
+        if (data.getExpiry() > maxAllowedExpiryTimestamp) {
+            throw new IntermediaryError_1.IntermediaryError("Expiry time returned too high!");
+        }
+        if (data.getAmount() !== resp.total ||
+            data.getClaimHash() !== hash ||
+            data.getType() !== base_1.ChainSwapType.CHAIN_NONCED ||
+            !data.isPayIn() ||
+            !data.isToken(amountData.token) ||
+            !data.isClaimer(lp.getAddress(this.chainIdentifier)) ||
+            !data.isOfferer(signer) ||
+            data.getTotalDeposit() !== 0n) {
+            throw new IntermediaryError_1.IntermediaryError("Invalid data returned");
+        }
+    }
+    /**
+     * Returns quotes fetched from LPs, paying to an 'address' - a bitcoin address
+     *
+     * @param signer                Smart-chain signer address initiating the swap
+     * @param address               Bitcoin on-chain address you wish to pay to
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    create(signer, address, amountData, lps, options, additionalParams, abortSignal) {
+        if (!this.isInitialized)
+            throw new Error("Not initialized, call init() first!");
+        const _options = {
+            confirmationTarget: options?.confirmationTarget ?? 3,
+            confirmations: options?.confirmations ?? 2
+        };
+        const nonce = this.getRandomNonce();
+        const outputScript = this.btcAddressToOutputScript(address);
+        const _hash = !amountData.exactIn ?
+            this.contract.getHashForOnchain(outputScript, amountData.amount, _options.confirmations, nonce).toString("hex") :
+            undefined;
+        const _abortController = (0, Utils_1.extendAbortController)(abortSignal);
+        const pricePreFetchPromise = this.preFetchPrice(amountData, _abortController.signal);
+        const usdPricePrefetchPromise = this.preFetchUsdPrice(_abortController.signal);
+        const feeRatePromise = this.preFetchFeeRate(signer, amountData, _hash, _abortController);
+        const _signDataPromise = this.contract.preFetchBlockDataForSignatures == null ?
+            this.preFetchSignData(Promise.resolve(true)) :
+            undefined;
+        return lps.map(lp => {
+            return {
+                intermediary: lp,
+                quote: (async () => {
+                    if (lp.services[SwapType_1.SwapType.TO_BTC] == null)
+                        throw new Error("LP service for processing to btc swaps not found!");
+                    const abortController = (0, Utils_1.extendAbortController)(_abortController.signal);
+                    const reputationPromise = this.preFetchIntermediaryReputation(amountData, lp, abortController);
+                    try {
+                        const { signDataPromise, resp } = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
+                            const { signDataPrefetch, response } = IntermediaryAPI_1.IntermediaryAPI.initToBTC(this.chainIdentifier, lp.url, {
+                                btcAddress: address,
+                                amount: amountData.amount,
+                                confirmationTarget: _options.confirmationTarget,
+                                confirmations: _options.confirmations,
+                                nonce: nonce,
+                                token: amountData.token,
+                                offerer: signer,
+                                exactIn: amountData.exactIn,
+                                feeRate: (0, Utils_1.throwIfUndefined)(feeRatePromise),
+                                additionalParams
+                            }, this.options.postRequestTimeout, abortController.signal, retryCount > 0 ? false : undefined);
+                            return {
+                                signDataPromise: _signDataPromise ?? this.preFetchSignData(signDataPrefetch),
+                                resp: await response
+                            };
+                        }, undefined, RequestError_1.RequestError, abortController.signal);
+                        let hash = _hash ?? this.contract.getHashForOnchain(outputScript, resp.amount, _options.confirmations, nonce).toString("hex");
+                        const data = new this.swapDataDeserializer(resp.data);
+                        data.setOfferer(signer);
+                        this.verifyReturnedData(signer, resp, amountData, lp, _options, data, hash);
+                        const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTC], true, resp.amount, data.getAmount(), amountData.token, resp, pricePreFetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedSignature(signer, data, resp, feeRatePromise, signDataPromise, abortController.signal),
+                            reputationPromise
+                        ]);
+                        abortController.signal.throwIfAborted();
+                        if (reputation != null)
+                            lp.reputation[amountData.token.toString()] = reputation;
+                        const inputWithoutFees = data.getAmount() - resp.swapFee - resp.networkFee;
+                        const swapFeeBtc = resp.swapFee * resp.amount / inputWithoutFees;
+                        const networkFeeBtc = resp.networkFee * resp.amount / inputWithoutFees;
+                        const quote = new ToBTCSwap_1.ToBTCSwap(this, {
+                            pricingInfo,
+                            url: lp.url,
+                            expiry: signatureExpiry,
+                            swapFee: resp.swapFee,
+                            swapFeeBtc,
+                            feeRate: (await feeRatePromise),
+                            signatureData: resp,
+                            data,
+                            networkFee: resp.networkFee,
+                            networkFeeBtc,
+                            address,
+                            amount: resp.amount,
+                            confirmationTarget: _options.confirmationTarget,
+                            satsPerVByte: Number(resp.satsPervByte),
+                            exactIn: amountData.exactIn,
+                            requiredConfirmations: _options.confirmations,
+                            nonce
+                        });
+                        await quote._save();
+                        return quote;
+                    }
+                    catch (e) {
+                        abortController.abort(e);
+                        throw e;
+                    }
+                })()
+            };
+        });
+    }
+}
+exports.ToBTCWrapper = ToBTCWrapper;