@atomiqlabs/sdk 8.1.7 → 8.3.1

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

@@ -8,43 +8,51 @@ import {toBigInt} from "../../../../utils/Utils";
 import {TokenAmount, toTokenAmount} from "../../../../types/TokenAmount";
 import {BitcoinTokens, BtcToken} from "../../../../types/Token";
 import {getLogger, LoggerType} from "../../../../utils/Logger";
+import {fromOutputScript} from "../../../../utils/BitcoinUtils";
 
 
 export type ToBTCSwapInit<T extends SwapData> = IToBTCSwapInit<T> & {
-    address: string;
-    amount: bigint;
+    address?: string;
+    amount?: bigint;
     confirmationTarget: number;
     satsPerVByte: number;
-    requiredConfirmations: number;
-    nonce: bigint;
+    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" &&
+    return (obj.address==null || typeof (obj.address) === "string") &&
+        (obj.amount==null || typeof(obj.amount) === "bigint") &&
         typeof (obj.confirmationTarget) === "number" &&
         typeof (obj.satsPerVByte) === "number" &&
-        typeof (obj.requiredConfirmations) === "number" &&
-        typeof (obj.nonce) === "bigint" &&
+        (obj.requiredConfirmations==null || typeof (obj.requiredConfirmations) === "number") &&
+        (obj.nonce==null || typeof (obj.nonce) === "bigint") &&
         isIToBTCSwapInit<T>(obj);
 }
 
 /**
- * Smart Chain to on-chain BTC swap
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
  * @category Swaps
  */
 export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, ToBTCDefinition<T>> {
+    protected readonly TYPE: SwapType.TO_BTC = SwapType.TO_BTC;
+    /**
+     * @internal
+     */
     protected readonly outputToken: BtcToken<false> = BitcoinTokens.BTC;
-    protected readonly TYPE = SwapType.TO_BTC;
+    /**
+     * @internal
+     */
     protected readonly logger: LoggerType;
 
-    private readonly address: string;
-    private readonly amount: bigint;
+    private address?: string;
+    private amount?: bigint;
     private readonly confirmationTarget: number;
     private readonly satsPerVByte: number;
 
-    private readonly requiredConfirmations: number;
-    private readonly nonce: bigint;
+    private requiredConfirmations?: number;
+    private nonce?: bigint;
 
     private txId?: string;
 
@@ -65,33 +73,68 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
             this.nonce = initOrObject.nonce;
         } else {
             this.address = initOrObject.address;
-            this.amount = BigInt(initOrObject.amount);
+            this.amount = toBigInt(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.requiredConfirmations = initOrObject.requiredConfirmations ?? this._data.getConfirmationsHint();
+            this.nonce = toBigInt(initOrObject.nonce) ?? this._data.getNonceHint();
         }
         this.logger = getLogger("ToBTC("+this.getIdentifierHashString()+"): ");
         this.tryRecomputeSwapPrice();
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     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(check || this.address==null || this.amount==null || this.nonce==null || this.requiredConfirmations==null) {
+            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");
+            //Extract nonce from tx
+            const nonce = this.nonce ?? (BigInt(btcTx.ins[0].sequence) & 0x00FFFFFFn) | (BigInt(btcTx.locktime - 500_000_000) << 24n);
+            let requiredConfirmations = this.requiredConfirmations;
+
+            const foundVout = btcTx.outs.find(vout => {
+                if(requiredConfirmations!=null) {
+                    return this._data.getClaimHash()===this.wrapper._contract.getHashForOnchain(
+                        Buffer.from(vout.scriptPubKey.hex, "hex"),
+                        BigInt(vout.value),
+                        requiredConfirmations,
+                        nonce
+                    ).toString("hex");
+                } else {
+                    for(let i=1;i<=20;i++) {
+                        if(
+                            this._data.getClaimHash()===this.wrapper._contract.getHashForOnchain(
+                                Buffer.from(vout.scriptPubKey.hex, "hex"),
+                                BigInt(vout.value),
+                                i,
+                                nonce
+                            ).toString("hex")
+                        ) {
+                            requiredConfirmations = i;
+                            return true;
+                        }
+                    }
+                }
+            });
+
+            if(requiredConfirmations==null) this.logger.warn(`_setPaymentResult(): Tried to recover data from bitcoin transaction ${result.txId} data, but wasn't able to!`);
+
+            if(foundVout!=null) {
+                this.nonce = nonce;
+                this.address = fromOutputScript(this.wrapper._options.bitcoinNetwork, foundVout.scriptPubKey.hex);
+                this.amount = BigInt(foundVout.value);
+                this.requiredConfirmations = requiredConfirmations;
+            } else {
+                if(check) throw new IntermediaryError("Invalid btc txId returned");
+            }
         }
         this.txId = result.txId;
         return true;
@@ -101,12 +144,18 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
     //////////////////////////////
     //// Amounts & fees
 
+    /**
+     * @inheritDoc
+     */
     getOutputToken(): BtcToken<false> {
         return BitcoinTokens.BTC;
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutput(): TokenAmount<T["ChainId"], BtcToken<false>> {
-        return toTokenAmount(this.amount, this.outputToken, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.amount ?? null, this.outputToken, this.wrapper._prices, this.pricingInfo);
     }
 
 
@@ -114,18 +163,21 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
     //// Getters & utils
 
     /**
-     * Returns the bitcoin address where the BTC will be sent to
+     * @inheritDoc
      */
-    getOutputAddress(): string {
-        return this.address;
+    getOutputAddress(): string | null {
+        return this.address ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputTxId(): string | null {
         return this.txId ?? null;
     }
 
     /**
-     * Returns fee rate of the bitcoin transaction in sats/vB
+     * Returns fee rate of the output bitcoin transaction in sats/vB as reported by the intermediary (LP)
      */
     getBitcoinFeeRate(): number {
         return this.satsPerVByte;
@@ -135,11 +187,14 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
     //////////////////////////////
     //// Storage
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         return {
             ...super.serialize(),
             address: this.address,
-            amount: this.amount.toString(10),
+            amount: this.amount==null ? null : this.amount.toString(10),
             confirmationTarget: this.confirmationTarget,
             satsPerVByte: this.satsPerVByte,
             nonce: this.nonce==null ? null : this.nonce.toString(10),

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

@@ -1,6 +1,12 @@
 import {ToBTCSwap, ToBTCSwapInit} from "./ToBTCSwap";
 import {IToBTCDefinition, IToBTCWrapper} from "../IToBTCWrapper";
-import {BigIntBufferUtils, BitcoinRpc, ChainSwapType, ChainType} from "@atomiqlabs/base";
+import {
+    BigIntBufferUtils,
+    BitcoinRpc,
+    ChainSwapType,
+    ChainType,
+    SwapCommitState
+} from "@atomiqlabs/base";
 import {Intermediary, SingleChainReputationType} from "../../../../intermediaries/Intermediary";
 import {ISwapPrice} from "../../../../prices/abstract/ISwapPrice";
 import {EventEmitter} from "events";
@@ -20,6 +26,7 @@ import {ISwap} from "../../../ISwap";
 import {AmountData} from "../../../../types/AmountData";
 import {tryWithRetries} from "../../../../utils/RetryUtils";
 import {AllOptional, AllRequired} from "../../../../utils/TypeUtils";
+import {ToBTCSwapState} from "../IToBTCSwap";
 
 export type ToBTCOptions = {
     confirmationTarget?: number,
@@ -39,11 +46,21 @@ export type ToBTCWrapperOptions = ISwapWrapperOptions & {
 
 export type ToBTCDefinition<T extends ChainType> = IToBTCDefinition<T, ToBTCWrapper<T>, ToBTCSwap<T>>;
 
+/**
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
+ * @category Swaps
+ */
 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>;
+    public readonly TYPE: SwapType.TO_BTC = SwapType.TO_BTC;
+    /**
+     * @internal
+     */
+    readonly _swapDeserializer = ToBTCSwap;
+    /**
+     * @internal
+     */
+    readonly _btcRpc: BitcoinRpc<any>;
 
     /**
      * @param chainIdentifier
@@ -83,13 +100,15 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
             },
             events
         );
-        this.btcRpc = btcRpc;
+        this._btcRpc = btcRpc;
     }
 
     /**
-     * Returns randomly generated random escrow nonce to be used for to BTC on-chain swaps
-     * @private
+     * Returns randomly generated random bitcoin transaction nonce to be used for BTC on-chain swaps
+     *
      * @returns Escrow nonce
+     *
+     * @private
      */
     private getRandomNonce(): bigint {
         const firstPart = BigInt(Math.floor((Date.now()/1000)) - 700000000);
@@ -101,13 +120,15 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
      * 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
      */
     private btcAddressToOutputScript(addr: string): Buffer {
         try {
-            return toOutputScript(this.options.bitcoinNetwork, addr);
+            return toOutputScript(this._options.bitcoinNetwork, addr);
         } catch (e) {
             throw new UserError("Invalid address specified");
         }
@@ -123,8 +144,10 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
      * @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
      */
     private verifyReturnedData(
         signer: string,
@@ -146,11 +169,11 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
         const maxAllowedBlockDelta: bigint = BigInt(
             options.confirmations +
             options.confirmationTarget +
-            this.options.maxExpectedOnchainSendGracePeriodBlocks
+            this._options.maxExpectedOnchainSendGracePeriodBlocks
         );
         const maxAllowedExpiryDelta: bigint = maxAllowedBlockDelta
-            * BigInt(this.options.maxExpectedOnchainSendSafetyFactor)
-            * BigInt(this.options.bitcoinBlocktime);
+            * BigInt(this._options.maxExpectedOnchainSendSafetyFactor)
+            * BigInt(this._options.bitcoinBlocktime);
         const currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
         const maxAllowedExpiryTimestamp: bigint = currentTimestamp + maxAllowedExpiryDelta;
 
@@ -173,19 +196,20 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
     }
 
     /**
-     * Returns quotes fetched from LPs, paying to an 'address' - a bitcoin address
+     * Returns a newly created Smart chain -> Bitcoin swap using the PrTLC based escrow swap protocol,
+     *  with the passed amount.
      *
-     * @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
+     * @param signer Source chain signer address initiating the swap
+     * @param recipient Recipient bitcoin on-chain address
+     * @param amountData Amount, token and exact input/output data for to swap
+     * @param lps An array of intermediaries (LPs) to get the quotes from
+     * @param options Optional additional quote options
+     * @param additionalParams Optional additional parameters sent to the LP when creating the swap
+     * @param abortSignal Abort signal
      */
     create(
         signer: string,
-        address: string,
+        recipient: string,
         amountData: AmountData,
         lps: Intermediary[],
         options?: ToBTCOptions,
@@ -202,16 +226,16 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
         };
 
         const nonce: bigint = this.getRandomNonce();
-        const outputScript: Buffer = this.btcAddressToOutputScript(address);
+        const outputScript: Buffer = this.btcAddressToOutputScript(recipient);
         const _hash: string | undefined = !amountData.exactIn ?
-            this.contract.getHashForOnchain(outputScript, amountData.amount, _options.confirmations, nonce).toString("hex") :
+            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 ?
+        const _signDataPromise: Promise<T["PreFetchVerification"] | undefined> | undefined = this._contract.preFetchBlockDataForSignatures==null ?
             this.preFetchSignData(Promise.resolve(true)) :
             undefined;
 
@@ -227,7 +251,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                     try {
                         const {signDataPromise, resp} = await tryWithRetries(async(retryCount) => {
                             const {signDataPrefetch, response} = IntermediaryAPI.initToBTC(this.chainIdentifier, lp.url, {
-                                btcAddress: address,
+                                btcAddress: recipient,
                                 amount: amountData.amount,
                                 confirmationTarget: _options.confirmationTarget,
                                 confirmations: _options.confirmations,
@@ -237,7 +261,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                                 exactIn: amountData.exactIn,
                                 feeRate: throwIfUndefined(feeRatePromise),
                                 additionalParams
-                            }, this.options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
+                            }, this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
 
                             return {
                                 signDataPromise: _signDataPromise ?? this.preFetchSignData(signDataPrefetch),
@@ -245,9 +269,9 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                             };
                         }, undefined, RequestError, abortController.signal);
 
-                        let hash: string = _hash ?? this.contract.getHashForOnchain(outputScript, resp.amount, _options.confirmations, nonce).toString("hex");
+                        let hash: string = _hash ?? this._contract.getHashForOnchain(outputScript, resp.amount, _options.confirmations, nonce).toString("hex");
 
-                        const data: T["Data"] = new this.swapDataDeserializer(resp.data);
+                        const data: T["Data"] = new this._swapDataDeserializer(resp.data);
                         data.setOfferer(signer);
 
                         this.verifyReturnedData(signer, resp, amountData, lp, _options, data, hash);
@@ -278,7 +302,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                             data,
                             networkFee: resp.networkFee,
                             networkFeeBtc,
-                            address,
+                            address: recipient,
                             amount: resp.amount,
                             confirmationTarget: _options.confirmationTarget,
                             satsPerVByte: Number(resp.satsPervByte),
@@ -296,4 +320,50 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
             }
         });
     }
+
+    /**
+     * @inheritDoc
+     */
+    async recoverFromSwapDataAndState(
+        init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
+        state: SwapCommitState,
+        lp?: Intermediary
+    ): Promise<ToBTCSwap<T> | null> {
+        const data = init.data;
+
+        const swapInit: ToBTCSwapInit<T["Data"]> = {
+            pricingInfo: {
+                isValid: true,
+                satsBaseFee: 0n,
+                swapPriceUSatPerToken: 100_000_000_000_000n,
+                realPriceUSatPerToken: 100_000_000_000_000n,
+                differencePPM: 0n,
+                feePPM: 0n,
+            },
+            url: lp?.url,
+            expiry: 0,
+            swapFee: 0n,
+            swapFeeBtc: 0n,
+            confirmationTarget: 1,
+            satsPerVByte: 0,
+            feeRate: "",
+            signatureData: undefined,
+            nonce: data.getNonceHint() ?? undefined,
+            requiredConfirmations: data.getConfirmationsHint() ?? undefined,
+            data,
+            networkFee: 0n,
+            networkFeeBtc: 0n,
+            exactIn: true
+        };
+        const swap = new ToBTCSwap(this, swapInit);
+        swap._commitTxId = await init.getInitTxId();
+        const blockData = await init.getTxBlock();
+        swap.createdAt = blockData.blockTime * 1000;
+        swap._setInitiated();
+        swap._state = ToBTCSwapState.COMMITED;
+        await swap._sync(false, false, state);
+        await swap._save();
+        return swap;
+    }
+
 }