@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/swaps/escrow_swaps/tobtc/onchain/ToBTCSwap.ts

@@ -0,0 +1,151 @@
+import {ToBTCDefinition, ToBTCWrapper} from "./ToBTCWrapper";
+import {isIToBTCSwapInit, IToBTCSwap, IToBTCSwapInit} from "../IToBTCSwap";
+import {SwapType} from "../../../../enums/SwapType";
+import {ChainType, SwapData} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {IntermediaryError} from "../../../../errors/IntermediaryError";
+import {toBigInt} from "../../../../utils/Utils";
+import {TokenAmount, toTokenAmount} from "../../../../types/TokenAmount";
+import {BitcoinTokens, BtcToken} from "../../../../types/Token";
+import {getLogger, LoggerType} from "../../../../utils/Logger";
+
+
+export type ToBTCSwapInit<T extends SwapData> = IToBTCSwapInit<T> & {
+    address: string;
+    amount: bigint;
+    confirmationTarget: number;
+    satsPerVByte: number;
+    requiredConfirmations: number;
+    nonce: bigint;
+};
+
+export function isToBTCSwapInit<T extends SwapData>(obj: any): obj is ToBTCSwapInit<T> {
+    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" &&
+        isIToBTCSwapInit<T>(obj);
+}
+
+/**
+ * Smart Chain to on-chain BTC swap
+ * @category Swaps
+ */
+export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, ToBTCDefinition<T>> {
+    protected readonly outputToken: BtcToken<false> = BitcoinTokens.BTC;
+    protected readonly TYPE = SwapType.TO_BTC;
+    protected readonly logger: LoggerType;
+
+    private readonly address: string;
+    private readonly amount: bigint;
+    private readonly confirmationTarget: number;
+    private readonly satsPerVByte: number;
+
+    private readonly requiredConfirmations: number;
+    private readonly nonce: bigint;
+
+    private txId?: string;
+
+    constructor(wrapper: ToBTCWrapper<T>, serializedObject: any);
+    constructor(wrapper: ToBTCWrapper<T>, init: ToBTCSwapInit<T["Data"]>);
+    constructor(
+        wrapper: ToBTCWrapper<T>,
+        initOrObject: ToBTCSwapInit<T["Data"]> | any
+    ) {
+        if(isToBTCSwapInit(initOrObject) && initOrObject.url!=null) initOrObject.url += "/tobtc";
+        super(wrapper, initOrObject);
+        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 = toBigInt(initOrObject.nonce) ?? this.data.getNonceHint();
+        }
+        this.logger = getLogger("ToBTC("+this.getIdentifierHashString()+"): ");
+        this.tryRecomputeSwapPrice();
+    }
+
+    async _setPaymentResult(result: { secret?: string; txId?: string }, check: boolean = false): Promise<boolean> {
+        if(result==null) return false;
+        if(result.txId==null) throw new 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.from(vout.scriptPubKey.hex, "hex"),
+                BigInt(vout.value),
+                this.requiredConfirmations,
+                this.nonce
+            ).toString("hex"));
+
+            if(foundVout==null) throw new IntermediaryError("Invalid btc txId returned");
+        }
+        this.txId = result.txId;
+        return true;
+    }
+
+
+    //////////////////////////////
+    //// Amounts & fees
+
+    getOutputToken(): BtcToken<false> {
+        return BitcoinTokens.BTC;
+    }
+
+    getOutput(): TokenAmount<T["ChainId"], BtcToken<false>> {
+        return toTokenAmount(this.amount, this.outputToken, this.wrapper.prices, this.pricingInfo);
+    }
+
+
+    //////////////////////////////
+    //// Getters & utils
+
+    /**
+     * Returns the bitcoin address where the BTC will be sent to
+     */
+    getOutputAddress(): string {
+        return this.address;
+    }
+
+    getOutputTxId(): string | null {
+        return this.txId ?? null;
+    }
+
+    /**
+     * Returns fee rate of the bitcoin transaction in sats/vB
+     */
+    getBitcoinFeeRate(): number {
+        return this.satsPerVByte;
+    }
+
+
+    //////////////////////////////
+    //// Storage
+
+    serialize(): any {
+        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
+        };
+    }
+
+}

package/src/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.ts

@@ -0,0 +1,299 @@
+import {ToBTCSwap, ToBTCSwapInit} from "./ToBTCSwap";
+import {IToBTCDefinition, IToBTCWrapper} from "../IToBTCWrapper";
+import {BigIntBufferUtils, BitcoinRpc, ChainSwapType, ChainType} from "@atomiqlabs/base";
+import {Intermediary, SingleChainReputationType} from "../../../../intermediaries/Intermediary";
+import {ISwapPrice} from "../../../../prices/abstract/ISwapPrice";
+import {EventEmitter} from "events";
+import {ISwapWrapperOptions, WrapperCtorTokens} from "../../../ISwapWrapper";
+import {Buffer} from "buffer";
+import {UserError} from "../../../../errors/UserError";
+import {IntermediaryError} from "../../../../errors/IntermediaryError";
+import {SwapType} from "../../../../enums/SwapType";
+import {extendAbortController, randomBytes, throwIfUndefined} from "../../../../utils/Utils";
+import {toOutputScript} from "../../../../utils/BitcoinUtils";
+import {IntermediaryAPI, ToBTCResponseType} from "../../../../intermediaries/apis/IntermediaryAPI";
+import {RequestError} from "../../../../errors/RequestError";
+import {BTC_NETWORK, TEST_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 {tryWithRetries} from "../../../../utils/RetryUtils";
+import {AllOptional, AllRequired} 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 class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDefinition<T>, ToBTCWrapperOptions> {
+    public readonly TYPE = SwapType.TO_BTC;
+    public readonly swapDeserializer = 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]}>
+    ) {
+        super(
+            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer,
+            {
+                bitcoinNetwork: options?.bitcoinNetwork ?? 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.btcRpc = btcRpc;
+    }
+
+    /**
+     * Returns randomly generated random escrow nonce to be used for to BTC on-chain swaps
+     * @private
+     * @returns Escrow nonce
+     */
+    private getRandomNonce(): bigint {
+        const firstPart = BigInt(Math.floor((Date.now()/1000)) - 700000000);
+
+        return (firstPart << 24n) | BigIntBufferUtils.fromBuffer(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
+     */
+    private btcAddressToOutputScript(addr: string): Buffer {
+        try {
+            return toOutputScript(this.options.bitcoinNetwork, addr);
+        } catch (e) {
+            throw new 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
+     */
+    private verifyReturnedData(
+        signer: string,
+        resp: ToBTCResponseType,
+        amountData: AmountData,
+        lp: Intermediary,
+        options: AllRequired<ToBTCOptions>,
+        data: T["Data"],
+        hash: string
+    ): void {
+        if(resp.totalFee !== (resp.swapFee + resp.networkFee)) throw new IntermediaryError("Invalid totalFee returned");
+
+        if(amountData.exactIn) {
+            if(resp.total !== amountData.amount) throw new IntermediaryError("Invalid total returned");
+        } else {
+            if(resp.amount !== amountData.amount) throw new IntermediaryError("Invalid amount returned");
+        }
+
+        const maxAllowedBlockDelta: bigint = BigInt(
+            options.confirmations +
+            options.confirmationTarget +
+            this.options.maxExpectedOnchainSendGracePeriodBlocks
+        );
+        const maxAllowedExpiryDelta: bigint = maxAllowedBlockDelta
+            * BigInt(this.options.maxExpectedOnchainSendSafetyFactor)
+            * BigInt(this.options.bitcoinBlocktime);
+        const currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
+        const maxAllowedExpiryTimestamp: bigint = currentTimestamp + maxAllowedExpiryDelta;
+
+        if(data.getExpiry() > maxAllowedExpiryTimestamp) {
+            throw new IntermediaryError("Expiry time returned too high!");
+        }
+
+        if(
+            data.getAmount() !== resp.total ||
+            data.getClaimHash()!==hash ||
+            data.getType()!==ChainSwapType.CHAIN_NONCED ||
+            !data.isPayIn() ||
+            !data.isToken(amountData.token) ||
+            !data.isClaimer(lp.getAddress(this.chainIdentifier)) ||
+            !data.isOfferer(signer) ||
+            data.getTotalDeposit() !== 0n
+        ) {
+            throw new 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: string,
+        address: string,
+        amountData: AmountData,
+        lps: Intermediary[],
+        options?: ToBTCOptions,
+        additionalParams?: Record<string, any>,
+        abortSignal?: AbortSignal
+    ): {
+        quote: Promise<ToBTCSwap<T>>,
+        intermediary: Intermediary
+    }[] {
+        if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
+        const _options: AllRequired<ToBTCOptions> = {
+            confirmationTarget: options?.confirmationTarget ?? 3,
+            confirmations: options?.confirmations ?? 2
+        };
+
+        const nonce: bigint = this.getRandomNonce();
+        const outputScript: Buffer = this.btcAddressToOutputScript(address);
+        const _hash: string | undefined = !amountData.exactIn ?
+            this.contract.getHashForOnchain(outputScript, amountData.amount, _options.confirmations, nonce).toString("hex") :
+            undefined;
+
+        const _abortController = extendAbortController(abortSignal);
+        const pricePreFetchPromise: Promise<bigint | undefined> = this.preFetchPrice(amountData, _abortController.signal);
+        const usdPricePrefetchPromise: Promise<number | undefined> = this.preFetchUsdPrice(_abortController.signal);
+        const feeRatePromise: Promise<string | undefined> = this.preFetchFeeRate(signer, amountData, _hash, _abortController);
+        const _signDataPromise: Promise<T["PreFetchVerification"] | undefined> | undefined = this.contract.preFetchBlockDataForSignatures==null ?
+            this.preFetchSignData(Promise.resolve(true)) :
+            undefined;
+
+        return lps.map(lp => {
+            return {
+                intermediary: lp,
+                quote: (async () => {
+                    if(lp.services[SwapType.TO_BTC]==null) throw new Error("LP service for processing to btc swaps not found!");
+
+                    const abortController = extendAbortController(_abortController.signal);
+                    const reputationPromise: Promise<SingleChainReputationType | undefined> = this.preFetchIntermediaryReputation(amountData, lp, abortController);
+
+                    try {
+                        const {signDataPromise, resp} = await tryWithRetries(async(retryCount) => {
+                            const {signDataPrefetch, response} = 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: throwIfUndefined(feeRatePromise),
+                                additionalParams
+                            }, this.options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
+
+                            return {
+                                signDataPromise: _signDataPromise ?? this.preFetchSignData(signDataPrefetch),
+                                resp: await response
+                            };
+                        }, undefined, RequestError, abortController.signal);
+
+                        let hash: string = _hash ?? this.contract.getHashForOnchain(outputScript, resp.amount, _options.confirmations, nonce).toString("hex");
+
+                        const data: T["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.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<T>(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
+                        } as ToBTCSwapInit<T["Data"]>);
+                        await quote._save();
+                        return quote;
+                    } catch (e) {
+                        abortController.abort(e);
+                        throw e;
+                    }
+                })()
+            }
+        });
+    }
+}