@atomiqlabs/sdk 8.1.8 → 8.3.1

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

@@ -6,45 +6,68 @@ import { TokenAmount } from "../../../../types/TokenAmount";
 import { BtcToken } from "../../../../types/Token";
 import { LoggerType } from "../../../../utils/Logger";
 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 declare function isToBTCSwapInit<T extends SwapData>(obj: any): obj is ToBTCSwapInit<T>;
 /**
- * Smart Chain to on-chain BTC swap
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
  * @category Swaps
  */
 export declare class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, ToBTCDefinition<T>> {
+    protected readonly TYPE: SwapType.TO_BTC;
+    /**
+     * @internal
+     */
     protected readonly outputToken: BtcToken<false>;
-    protected readonly TYPE = SwapType.TO_BTC;
+    /**
+     * @internal
+     */
     protected readonly logger: LoggerType;
-    private readonly address;
-    private readonly amount;
+    private address?;
+    private amount?;
     private readonly confirmationTarget;
     private readonly satsPerVByte;
-    private readonly requiredConfirmations;
-    private readonly nonce;
+    private requiredConfirmations?;
+    private nonce?;
     private txId?;
     constructor(wrapper: ToBTCWrapper<T>, serializedObject: any);
     constructor(wrapper: ToBTCWrapper<T>, init: ToBTCSwapInit<T["Data"]>);
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _setPaymentResult(result: {
         secret?: string;
         txId?: string;
     }, check?: boolean): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
     getOutputToken(): BtcToken<false>;
+    /**
+     * @inheritDoc
+     */
     getOutput(): TokenAmount<T["ChainId"], BtcToken<false>>;
     /**
-     * Returns the bitcoin address where the BTC will be sent to
+     * @inheritDoc
+     */
+    getOutputAddress(): string | null;
+    /**
+     * @inheritDoc
      */
-    getOutputAddress(): string;
     getOutputTxId(): string | 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;
+    /**
+     * @inheritDoc
+     */
     serialize(): any;
 }

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

@@ -9,18 +9,20 @@ const Utils_1 = require("../../../../utils/Utils");
 const TokenAmount_1 = require("../../../../types/TokenAmount");
 const Token_1 = require("../../../../types/Token");
 const Logger_1 = require("../../../../utils/Logger");
+const BitcoinUtils_1 = require("../../../../utils/BitcoinUtils");
 function isToBTCSwapInit(obj) {
-    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") &&
         (0, IToBTCSwap_1.isIToBTCSwapInit)(obj);
 }
 exports.isToBTCSwapInit = isToBTCSwapInit;
 /**
- * Smart Chain to on-chain BTC swap
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
  * @category Swaps
  */
 class ToBTCSwap extends IToBTCSwap_1.IToBTCSwap {
@@ -28,8 +30,11 @@ class ToBTCSwap extends IToBTCSwap_1.IToBTCSwap {
         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;
+        /**
+         * @internal
+         */
+        this.outputToken = Token_1.BitcoinTokens.BTC;
         if (isToBTCSwapInit(initOrObject)) {
             this.address = initOrObject.address;
             this.amount = initOrObject.amount;
@@ -40,64 +45,105 @@ class ToBTCSwap extends IToBTCSwap_1.IToBTCSwap {
         }
         else {
             this.address = initOrObject.address;
-            this.amount = BigInt(initOrObject.amount);
+            this.amount = (0, Utils_1.toBigInt)(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.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();
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     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 (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_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");
+            //Extract nonce from tx
+            const nonce = this.nonce ?? (BigInt(btcTx.ins[0].sequence) & 0x00ffffffn) | (BigInt(btcTx.locktime - 500000000) << 24n);
+            let requiredConfirmations = this.requiredConfirmations;
+            const foundVout = btcTx.outs.find(vout => {
+                if (requiredConfirmations != null) {
+                    return this._data.getClaimHash() === this.wrapper._contract.getHashForOnchain(buffer_1.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_1.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 = (0, BitcoinUtils_1.fromOutputScript)(this.wrapper._options.bitcoinNetwork, foundVout.scriptPubKey.hex);
+                this.amount = BigInt(foundVout.value);
+                this.requiredConfirmations = requiredConfirmations;
+            }
+            else {
+                if (check)
+                    throw new IntermediaryError_1.IntermediaryError("Invalid btc txId returned");
+            }
         }
         this.txId = result.txId;
         return true;
     }
     //////////////////////////////
     //// Amounts & fees
+    /**
+     * @inheritDoc
+     */
     getOutputToken() {
         return Token_1.BitcoinTokens.BTC;
     }
+    /**
+     * @inheritDoc
+     */
     getOutput() {
-        return (0, TokenAmount_1.toTokenAmount)(this.amount, this.outputToken, this.wrapper.prices, this.pricingInfo);
+        return (0, TokenAmount_1.toTokenAmount)(this.amount ?? null, this.outputToken, this.wrapper._prices, this.pricingInfo);
     }
     //////////////////////////////
     //// Getters & utils
     /**
-     * Returns the bitcoin address where the BTC will be sent to
+     * @inheritDoc
      */
     getOutputAddress() {
-        return this.address;
+        return this.address ?? null;
     }
+    /**
+     * @inheritDoc
+     */
     getOutputTxId() {
         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() {
         return this.satsPerVByte;
     }
     //////////////////////////////
     //// Storage
+    /**
+     * @inheritDoc
+     */
     serialize() {
         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/dist/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { ToBTCSwap } from "./ToBTCSwap";
 import { IToBTCDefinition, IToBTCWrapper } from "../IToBTCWrapper";
-import { BitcoinRpc, ChainType } from "@atomiqlabs/base";
+import { BitcoinRpc, ChainType, SwapCommitState } from "@atomiqlabs/base";
 import { Intermediary } from "../../../../intermediaries/Intermediary";
 import { ISwapPrice } from "../../../../prices/abstract/ISwapPrice";
 import { EventEmitter } from "events";
@@ -26,10 +26,21 @@ export type ToBTCWrapperOptions = ISwapWrapperOptions & {
     maxExpectedOnchainSendGracePeriodBlocks: number;
 };
 export type ToBTCDefinition<T extends ChainType> = IToBTCDefinition<T, ToBTCWrapper<T>, ToBTCSwap<T>>;
+/**
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
+ * @category Swaps
+ */
 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>;
+    readonly TYPE: SwapType.TO_BTC;
+    /**
+     * @internal
+     */
+    readonly _swapDeserializer: typeof ToBTCSwap;
+    /**
+     * @internal
+     */
+    readonly _btcRpc: BitcoinRpc<any>;
     /**
      * @param chainIdentifier
      * @param unifiedStorage Storage interface for the current environment
@@ -47,18 +58,22 @@ export declare class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T,
         swapState: [ISwap];
     }>);
     /**
-     * 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;
     /**
      * 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;
     /**
@@ -71,23 +86,37 @@ export declare class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T,
      * @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;
     /**
-     * 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, amountData: AmountData, lps: Intermediary[], options?: ToBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
+    create(signer: string, recipient: string, amountData: AmountData, lps: Intermediary[], options?: ToBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
         quote: Promise<ToBTCSwap<T>>;
         intermediary: Intermediary;
     }[];
+    /**
+     * @inheritDoc
+     */
+    recoverFromSwapDataAndState(init: {
+        data: T["Data"];
+        getInitTxId: () => Promise<string>;
+        getTxBlock: () => Promise<{
+            blockTime: number;
+            blockHeight: number;
+        }>;
+    }, state: SwapCommitState, lp?: Intermediary): Promise<ToBTCSwap<T> | null>;
 }

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

@@ -13,6 +13,12 @@ const IntermediaryAPI_1 = require("../../../../intermediaries/apis/IntermediaryA
 const RequestError_1 = require("../../../../errors/RequestError");
 const utils_1 = require("@scure/btc-signer/utils");
 const RetryUtils_1 = require("../../../../utils/RetryUtils");
+const IToBTCSwap_1 = require("../IToBTCSwap");
+/**
+ * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+ *
+ * @category Swaps
+ */
 class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
     /**
      * @param chainIdentifier
@@ -37,13 +43,18 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
             maxExpectedOnchainSendGracePeriodBlocks: options?.maxExpectedOnchainSendGracePeriodBlocks ?? 12,
         }, events);
         this.TYPE = SwapType_1.SwapType.TO_BTC;
-        this.swapDeserializer = ToBTCSwap_1.ToBTCSwap;
-        this.btcRpc = btcRpc;
+        /**
+         * @internal
+         */
+        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 randomly generated random bitcoin transaction nonce to be used for BTC on-chain swaps
+     *
      * @returns Escrow nonce
+     *
+     * @private
      */
     getRandomNonce() {
         const firstPart = BigInt(Math.floor((Date.now() / 1000)) - 700000000);
@@ -53,13 +64,15 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
      * 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) {
         try {
-            return (0, BitcoinUtils_1.toOutputScript)(this.options.bitcoinNetwork, addr);
+            return (0, BitcoinUtils_1.toOutputScript)(this._options.bitcoinNetwork, addr);
         }
         catch (e) {
             throw new UserError_1.UserError("Invalid address specified");
@@ -75,8 +88,10 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
      * @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, resp, amountData, lp, options, data, hash) {
         if (resp.totalFee !== (resp.swapFee + resp.networkFee))
@@ -91,10 +106,10 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
         }
         const maxAllowedBlockDelta = BigInt(options.confirmations +
             options.confirmationTarget +
-            this.options.maxExpectedOnchainSendGracePeriodBlocks);
+            this._options.maxExpectedOnchainSendGracePeriodBlocks);
         const maxAllowedExpiryDelta = maxAllowedBlockDelta
-            * BigInt(this.options.maxExpectedOnchainSendSafetyFactor)
-            * BigInt(this.options.bitcoinBlocktime);
+            * BigInt(this._options.maxExpectedOnchainSendSafetyFactor)
+            * BigInt(this._options.bitcoinBlocktime);
         const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
         const maxAllowedExpiryTimestamp = currentTimestamp + maxAllowedExpiryDelta;
         if (data.getExpiry() > maxAllowedExpiryTimestamp) {
@@ -112,17 +127,18 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
         }
     }
     /**
-     * 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, address, amountData, lps, options, additionalParams, abortSignal) {
+    create(signer, recipient, amountData, lps, options, additionalParams, abortSignal) {
         if (!this.isInitialized)
             throw new Error("Not initialized, call init() first!");
         const _options = {
@@ -130,15 +146,15 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
             confirmations: options?.confirmations ?? 2
         };
         const nonce = this.getRandomNonce();
-        const outputScript = this.btcAddressToOutputScript(address);
+        const outputScript = this.btcAddressToOutputScript(recipient);
         const _hash = !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 = (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 ?
+        const _signDataPromise = this._contract.preFetchBlockDataForSignatures == null ?
             this.preFetchSignData(Promise.resolve(true)) :
             undefined;
         return lps.map(lp => {
@@ -152,7 +168,7 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
                     try {
                         const { signDataPromise, resp } = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
                             const { signDataPrefetch, response } = IntermediaryAPI_1.IntermediaryAPI.initToBTC(this.chainIdentifier, lp.url, {
-                                btcAddress: address,
+                                btcAddress: recipient,
                                 amount: amountData.amount,
                                 confirmationTarget: _options.confirmationTarget,
                                 confirmations: _options.confirmations,
@@ -162,14 +178,14 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
                                 exactIn: amountData.exactIn,
                                 feeRate: (0, Utils_1.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),
                                 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);
+                        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([
@@ -194,7 +210,7 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
                             data,
                             networkFee: resp.networkFee,
                             networkFeeBtc,
-                            address,
+                            address: recipient,
                             amount: resp.amount,
                             confirmationTarget: _options.confirmationTarget,
                             satsPerVByte: Number(resp.satsPervByte),
@@ -213,5 +229,44 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
             };
         });
     }
+    /**
+     * @inheritDoc
+     */
+    async recoverFromSwapDataAndState(init, state, lp) {
+        const data = init.data;
+        const swapInit = {
+            pricingInfo: {
+                isValid: true,
+                satsBaseFee: 0n,
+                swapPriceUSatPerToken: 100000000000000n,
+                realPriceUSatPerToken: 100000000000000n,
+                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_1.ToBTCSwap(this, swapInit);
+        swap._commitTxId = await init.getInitTxId();
+        const blockData = await init.getTxBlock();
+        swap.createdAt = blockData.blockTime * 1000;
+        swap._setInitiated();
+        swap._state = IToBTCSwap_1.ToBTCSwapState.COMMITED;
+        await swap._sync(false, false, state);
+        await swap._save();
+        return swap;
+    }
 }
 exports.ToBTCWrapper = ToBTCWrapper;