@atomiqlabs/sdk 8.6.3 → 8.7.1

package/src/swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper.ts

@@ -9,7 +9,7 @@ import {ISwapPrice} from "../../../../prices/abstract/ISwapPrice";
 import {EventEmitter} from "events";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
 import {SwapType} from "../../../../enums/SwapType";
-import {extendAbortController, throwIfUndefined} from "../../../../utils/Utils";
+import {extendAbortController, mapArrayToObject, throwIfUndefined} from "../../../../utils/Utils";
 import {IntermediaryAPI, ToBTCLNResponseType} from "../../../../intermediaries/apis/IntermediaryAPI";
 import {RequestError} from "../../../../errors/RequestError";
 import {LNURL, LNURLPaySuccessAction} from "../../../../lnurl/LNURL";
@@ -102,21 +102,26 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
         unifiedStorage: UnifiedSwapStorage<T>,
         unifiedChainEvents: UnifiedSwapEventListener<T>,
         chain: T["ChainInterface"],
-        contract: T["Contract"],
         prices: ISwapPrice,
         tokens: WrapperCtorTokens,
-        swapDataDeserializer: new (data: any) => T["Data"],
+        versionedContracts: {
+            [version: string]: {
+                swapContract: T["Contract"],
+                swapDataConstructor: new (data: any) => T["Data"]
+            }
+        },
         options?: AllOptional<ToBTCLNWrapperOptions>,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
         super(
-            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer,
+            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens,
             {
                 ...options,
                 paymentTimeoutSeconds: options?.paymentTimeoutSeconds ?? 5*24*60*60,
                 lightningBaseFee: options?.lightningBaseFee ?? 10,
                 lightningFeePPM: options?.lightningFeePPM ?? 2000
             },
+            versionedContracts,
             events
         );
     }
@@ -221,7 +226,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             throw new IntermediaryError("Invalid data returned - total amount");
 
         if(parsedPr.tagsObject.payment_hash==null) throw new Error("Swap invoice doesn't contain payment hash field!");
-        const claimHash = this._contract.getHashForHtlc(Buffer.from(parsedPr.tagsObject.payment_hash, "hex"));
+        const claimHash = this._contract(lp.getContractVersion(this.chainIdentifier)).getHashForHtlc(Buffer.from(parsedPr.tagsObject.payment_hash, "hex"));
 
         if(
             data.getAmount() !== resp.total ||
@@ -265,18 +270,19 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             expiryTimestamp: bigint
         },
         preFetches: {
-            feeRatePromise: Promise<string | undefined>,
+            feeRatePromise: {[contractVersion: string]: Promise<string | undefined>},
             pricePreFetchPromise: Promise<bigint | undefined>,
             usdPricePrefetchPromise: Promise<number | undefined>,
-            signDataPrefetchPromise?: Promise<T["PreFetchVerification"] | undefined>
+            signDataPrefetchPromise?: {[contractVersion: string]: Promise<T["PreFetchVerification"] | undefined> | undefined}
         },
         abort: AbortSignal | AbortController,
         additionalParams?: Record<string, any>,
     ) {
         if(lp.services[SwapType.TO_BTCLN]==null) throw new Error("LP service for processing to btcln swaps not found!");
+        const version = lp.getContractVersion(this.chainIdentifier);
 
         const abortController = abort instanceof AbortController ? abort : extendAbortController(abort);
-        const reputationPromise = this.preFetchIntermediaryReputation(amountData, lp, abortController);
+        const reputationPromise = this.preFetchIntermediaryReputation(amountData, lp, abortController, version);
 
         try {
             const {signDataPromise, resp} = await tryWithRetries(async(retryCount: number) => {
@@ -286,13 +292,13 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                     maxFee: await calculatedOptions.maxFee,
                     expiryTimestamp: calculatedOptions.expiryTimestamp,
                     token: amountData.token,
-                    feeRate: throwIfUndefined(preFetches.feeRatePromise),
+                    feeRate: throwIfUndefined(preFetches.feeRatePromise[version]),
                     additionalParams
                 }, this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
 
-                let signDataPromise = preFetches.signDataPrefetchPromise;
+                let signDataPromise = preFetches.signDataPrefetchPromise?.[version];
                 if(signDataPromise==null) {
-                    signDataPromise = this.preFetchSignData(signDataPrefetch);
+                    signDataPromise = this.preFetchSignData(signDataPrefetch, version);
                 } else signDataPrefetch.catch(() => {});
 
                 return {
@@ -304,7 +310,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             if(parsedPr.millisatoshis==null) throw new Error("Swap invoice doesn't have msat amount field!");
             const amountOut: bigint = (BigInt(parsedPr.millisatoshis) + 999n) / 1000n;
             const totalFee: bigint = resp.swapFee + resp.maxFee;
-            const data: T["Data"] = new this._swapDataDeserializer(resp.data);
+            const data: T["Data"] = new (this._swapDataDeserializer(version))(resp.data);
             data.setOfferer(signer);
 
             await this.verifyReturnedData(signer, resp, parsedPr, amountData.token, lp, calculatedOptions, data);
@@ -316,7 +322,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                     preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortController.signal
                 ),
                 this.verifyReturnedSignature(
-                    signer, data, resp, preFetches.feeRatePromise, signDataPromise, abortController.signal
+                    signer, data, resp, preFetches.feeRatePromise[version], signDataPromise, version, abortController.signal
                 ),
                 reputationPromise
             ]);
@@ -332,14 +338,15 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                 expiry: signatureExpiry,
                 swapFee: resp.swapFee,
                 swapFeeBtc,
-                feeRate: (await preFetches.feeRatePromise)!,
+                feeRate: (await preFetches.feeRatePromise[version])!,
                 signatureData: resp,
                 data,
                 networkFee: resp.maxFee,
                 networkFeeBtc: resp.routingFeeSats,
                 confidence: resp.confidence,
                 pr,
-                exactIn: false
+                exactIn: false,
+                contractVersion: version
             } as IToBTCSwapInit<T["Data"]>);
             return quote;
         } catch (e) {
@@ -370,10 +377,10 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
         additionalParams?: Record<string, any>,
         abortSignal?: AbortSignal,
         preFetches?: {
-            feeRatePromise: Promise<string | undefined>,
+            feeRatePromise: {[contractVersion: string]: Promise<string | undefined>},
             pricePreFetchPromise: Promise<bigint | undefined>,
             usdPricePrefetchPromise: Promise<number | undefined>,
-            signDataPrefetchPromise?: Promise<T["PreFetchVerification"] | undefined>
+            signDataPrefetchPromise?: {[contractVersion: string]: Promise<T["PreFetchVerification"] | undefined> | undefined}
         }
     ): Promise<{
         quote: Promise<ToBTCLNSwap<T>>,
@@ -383,19 +390,27 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
         if(parsedPr.millisatoshis==null) throw new UserError("Must be an invoice with amount");
         const amountOut: bigint = (BigInt(parsedPr.millisatoshis) + 999n) / 1000n;
 
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
+
         const _options = this.toRequiredSwapOptions({...amountData, amount: amountOut}, options);
 
         if(parsedPr.tagsObject.payment_hash==null) throw new Error("Provided lightning invoice doesn't contain payment hash field!");
         await this.checkPaymentHashWasPaid(parsedPr.tagsObject.payment_hash);
 
-        const claimHash = this._contract.getHashForHtlc(Buffer.from(parsedPr.tagsObject.payment_hash, "hex"));
+        const _hash = mapArrayToObject(lpVersions, (contractVersion: string) => {
+            return this._contract(contractVersion).getHashForHtlc(Buffer.from(parsedPr.tagsObject.payment_hash!, "hex")).toString("hex");
+        });
 
         const _abortController = extendAbortController(abortSignal);
         const _preFetches = preFetches ?? {
             pricePreFetchPromise: this.preFetchPrice(amountData, _abortController.signal),
-            feeRatePromise: this.preFetchFeeRate(signer, amountData, claimHash.toString("hex"), _abortController),
+            feeRatePromise: this.preFetchFeeRate(signer, amountData, _hash, _abortController, lpVersions),
             usdPricePrefetchPromise: this.preFetchUsdPrice(_abortController.signal),
-            signDataPrefetchPromise: this._contract.preFetchBlockDataForSignatures==null ? this.preFetchSignData(Promise.resolve(true)) : undefined
+            signDataPrefetchPromise: mapArrayToObject(lpVersions, (contractVersion: string) => {
+                return this._contract(contractVersion).preFetchBlockDataForSignatures==null ?
+                    this.preFetchSignData(Promise.resolve(true), contractVersion) :
+                    undefined;
+            })
         };
 
         return lps.map(lp => {
@@ -451,7 +466,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             expiryTimestamp: bigint
         },
         preFetches: {
-            feeRatePromise: Promise<string | undefined>,
+            feeRatePromise: {[contractVersion: string]: Promise<string | undefined>},
             pricePreFetchPromise: Promise<bigint | undefined>,
             usdPricePrefetchPromise: Promise<number | undefined>
         },
@@ -459,9 +474,10 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
         additionalParams?: Record<string, any>,
     ) {
         if(lp.services[SwapType.TO_BTCLN]==null) throw new Error("LP service for processing to btcln swaps not found!");
+        const version = lp.getContractVersion(this.chainIdentifier);
 
         const abortController = extendAbortController(abortSignal);
-        const reputationPromise = this.preFetchIntermediaryReputation(amountData, lp, abortController);
+        const reputationPromise = this.preFetchIntermediaryReputation(amountData, lp, abortController, version);
 
         try {
             const {signDataPromise, prepareResp} = await tryWithRetries(async(retryCount: number) => {
@@ -476,7 +492,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                 }, this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
 
                 return {
-                    signDataPromise: this.preFetchSignData(signDataPrefetch),
+                    signDataPromise: this.preFetchSignData(signDataPrefetch, version),
                     prepareResp: await response
                 };
             }, undefined, e => e instanceof RequestError, abortController.signal);
@@ -498,7 +514,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                 (retryCount: number) => IntermediaryAPI.initToBTCLNExactIn(lp.url, {
                     pr: invoice,
                     reqId: prepareResp.reqId,
-                    feeRate: throwIfUndefined(preFetches.feeRatePromise),
+                    feeRate: throwIfUndefined(preFetches.feeRatePromise[version]),
                     additionalParams
                 }, this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined),
                 undefined, RequestError, abortController.signal
@@ -507,7 +523,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             if(parsedInvoice.millisatoshis==null) throw new Error("Swap invoice doesn't have msat amount field!");
             const amountOut: bigint = (BigInt(parsedInvoice.millisatoshis) + 999n) / 1000n;
             const totalFee: bigint = resp.swapFee + resp.maxFee;
-            const data: T["Data"] = new this._swapDataDeserializer(resp.data);
+            const data: T["Data"] = new (this._swapDataDeserializer(version))(resp.data);
             data.setOfferer(signer);
 
             await this.verifyReturnedData(signer, resp, parsedInvoice, amountData.token, lp, calculatedOptions, data, amountData.amount);
@@ -519,7 +535,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                     preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortSignal
                 ),
                 this.verifyReturnedSignature(
-                    signer, data, resp, preFetches.feeRatePromise, signDataPromise, abortController.signal
+                    signer, data, resp, preFetches.feeRatePromise[version], signDataPromise, version, abortController.signal
                 ),
                 reputationPromise
             ]);
@@ -535,14 +551,15 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
                 expiry: signatureExpiry,
                 swapFee: resp.swapFee,
                 swapFeeBtc,
-                feeRate: (await preFetches.feeRatePromise)!,
+                feeRate: (await preFetches.feeRatePromise[version])!,
                 signatureData: resp,
                 data,
                 networkFee: resp.maxFee,
                 networkFeeBtc: resp.routingFeeSats,
                 confidence: resp.confidence,
                 pr: invoice,
-                exactIn: true
+                exactIn: true,
+                contractVersion: version
             } as IToBTCSwapInit<T["Data"]>);
             return quote;
         } catch (e) {
@@ -578,13 +595,17 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
     }[]> {
         if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
 
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
+
         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, undefined, _abortController);
-        const signDataPrefetchPromise: Promise<T["PreFetchVerification"] | undefined> | undefined = this._contract.preFetchBlockDataForSignatures==null ?
-            this.preFetchSignData(Promise.resolve(true)) :
-            undefined;
+        const feeRatePromise = this.preFetchFeeRate(signer, amountData, undefined, _abortController, lpVersions);
+        const signDataPrefetchPromise = mapArrayToObject(lpVersions, (contractVersion: string) => {
+            return this._contract(contractVersion).preFetchBlockDataForSignatures==null ?
+                this.preFetchSignData(Promise.resolve(true), contractVersion) :
+                undefined;
+        });
 
         const _options = this.toRequiredSwapOptions(amountData, options, pricePreFetchPromise, _abortController.signal);
 
@@ -716,6 +737,7 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
     async recoverFromSwapDataAndState(
         init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
         state: SwapCommitState,
+        contractVersion: string,
         lp?: Intermediary
     ): Promise<ToBTCLNSwap<T> | null> {
         const data = init.data;
@@ -747,7 +769,8 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
             networkFeeBtc: 0n,
             confidence: 0,
             pr: paymentHash ?? undefined,
-            exactIn: false
+            exactIn: false,
+            contractVersion
         };
         const swap = new ToBTCLNSwap(this, swapInit);
         swap._commitTxId = await init.getInitTxId();

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

@@ -102,7 +102,7 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
 
             const foundVout = btcTx.outs.find(vout => {
                 if(requiredConfirmations!=null) {
-                    return this._data.getClaimHash()===this.wrapper._contract.getHashForOnchain(
+                    return this._data.getClaimHash()===this._contract.getHashForOnchain(
                         Buffer.from(vout.scriptPubKey.hex, "hex"),
                         BigInt(vout.value),
                         requiredConfirmations,
@@ -111,7 +111,7 @@ export class ToBTCSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, To
                 } else {
                     for(let i=1;i<=20;i++) {
                         if(
-                            this._data.getClaimHash()===this.wrapper._contract.getHashForOnchain(
+                            this._data.getClaimHash()===this._contract.getHashForOnchain(
                                 Buffer.from(vout.scriptPubKey.hex, "hex"),
                                 BigInt(vout.value),
                                 i,

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

@@ -15,7 +15,12 @@ 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 {
+    extendAbortController,
+    mapArrayToObject,
+    randomBytes,
+    throwIfUndefined
+} from "../../../../utils/Utils";
 import {toOutputScript} from "../../../../utils/BitcoinUtils";
 import {IntermediaryAPI, ToBTCResponseType} from "../../../../intermediaries/apis/IntermediaryAPI";
 import {RequestError} from "../../../../errors/RequestError";
@@ -73,10 +78,9 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
      * @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 versionedContracts Chain specific versioned contracts
      * @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
@@ -86,16 +90,20 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
         unifiedStorage: UnifiedSwapStorage<T>,
         unifiedChainEvents: UnifiedSwapEventListener<T>,
         chain: T["ChainInterface"],
-        contract: T["Contract"],
         prices: ISwapPrice,
         tokens: WrapperCtorTokens,
-        swapDataDeserializer: new (data: any) => T["Data"],
+        versionedContracts: {
+            [version: string]: {
+                swapContract: T["Contract"],
+                swapDataConstructor: new (data: any) => T["Data"]
+            }
+        },
         btcRpc: BitcoinRpc<any>,
         options?: AllOptional<ToBTCWrapperOptions>,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
         super(
-            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer,
+            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens,
             {
                 ...options,
                 bitcoinNetwork: options?.bitcoinNetwork ?? TEST_NETWORK,
@@ -105,6 +113,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                 maxExpectedOnchainSendSafetyFactor: options?.maxExpectedOnchainSendSafetyFactor ?? 4,
                 maxExpectedOnchainSendGracePeriodBlocks: options?.maxExpectedOnchainSendGracePeriodBlocks ?? 12,
             },
+            versionedContracts,
             events
         );
         this._btcRpc = btcRpc;
@@ -234,29 +243,35 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
             confirmationTarget: options?.confirmationTarget ?? 3,
             confirmations: options?.confirmations ?? 2
         };
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
 
         const nonce: bigint = this.getRandomNonce();
         const outputScript: Buffer = this.btcAddressToOutputScript(recipient);
-        const _hash: string | undefined = !amountData.exactIn ?
-            this._contract.getHashForOnchain(outputScript, amountData.amount, _options.confirmations, nonce).toString("hex") :
+        const _hash = !amountData.exactIn ?
+            mapArrayToObject(lpVersions, (contractVersion: string) => {
+                return this._contract(contractVersion).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;
+        const feeRatePromise = this.preFetchFeeRate(signer, amountData, _hash, _abortController, lpVersions);
+        const _signDataPromise = mapArrayToObject(lpVersions, (contractVersion: string) => {
+            return this._contract(contractVersion).preFetchBlockDataForSignatures==null ?
+                this.preFetchSignData(Promise.resolve(true), contractVersion) :
+                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 version = lp.getContractVersion(this.chainIdentifier);
 
                     const abortController = extendAbortController(_abortController.signal);
-                    const reputationPromise: Promise<SingleChainReputationType | undefined> = this.preFetchIntermediaryReputation(amountData, lp, abortController);
+                    const reputationPromise: Promise<SingleChainReputationType | undefined> = this.preFetchIntermediaryReputation(amountData, lp, abortController, version);
 
                     try {
                         const {signDataPromise, resp} = await tryWithRetries(async(retryCount) => {
@@ -269,13 +284,13 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                                 token: amountData.token,
                                 offerer: signer,
                                 exactIn: amountData.exactIn,
-                                feeRate: throwIfUndefined(feeRatePromise),
+                                feeRate: throwIfUndefined(feeRatePromise[version]),
                                 additionalParams
                             }, this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined);
 
-                            let signDataPromise = _signDataPromise;
+                            let signDataPromise = _signDataPromise[version];
                             if(signDataPromise==null) {
-                                signDataPromise = this.preFetchSignData(signDataPrefetch);
+                                signDataPromise = this.preFetchSignData(signDataPrefetch, version);
                             } else signDataPrefetch.catch(() => {});
 
                             return {
@@ -284,9 +299,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?.[version] ?? this._contract(version).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(version))(resp.data);
                         data.setOfferer(signer);
 
                         this.verifyReturnedData(signer, resp, amountData, lp, _options, data, hash);
@@ -295,7 +310,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                                 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),
+                            this.verifyReturnedSignature(signer, data, resp, feeRatePromise[version], signDataPromise, version, abortController.signal),
                             reputationPromise
                         ]);
                         abortController.signal.throwIfAborted();
@@ -312,7 +327,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                             expiry: signatureExpiry,
                             swapFee: resp.swapFee,
                             swapFeeBtc,
-                            feeRate: (await feeRatePromise)!,
+                            feeRate: (await feeRatePromise[version])!,
                             signatureData: resp,
                             data,
                             networkFee: resp.networkFee,
@@ -323,7 +338,8 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                             satsPerVByte: Number(resp.satsPervByte),
                             exactIn: amountData.exactIn,
                             requiredConfirmations: _options.confirmations,
-                            nonce
+                            nonce,
+                            contractVersion: version
                         } as ToBTCSwapInit<T["Data"]>);
                         return quote;
                     } catch (e) {
@@ -341,6 +357,7 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
     async recoverFromSwapDataAndState(
         init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
         state: SwapCommitState,
+        contractVersion: string,
         lp?: Intermediary
     ): Promise<ToBTCSwap<T> | null> {
         const data = init.data;
@@ -367,7 +384,8 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
             data,
             networkFee: 0n,
             networkFeeBtc: 0n,
-            exactIn: true
+            exactIn: true,
+            contractVersion
         };
         const swap = new ToBTCSwap(this, swapInit);
         swap._commitTxId = await init.getInitTxId();

package/src/swaps/spv_swaps/SpvFromBTCSwap.ts

@@ -276,6 +276,8 @@ export class SpvFromBTCSwap<T extends ChainType>
      */
     private btcTxConfirmedAt?: number;
 
+    private _contract: T["SpvVaultContract"];
+
     constructor(wrapper: SpvFromBTCWrapper<T>, init: SpvFromBTCSwapInit);
     constructor(wrapper: SpvFromBTCWrapper<T>, obj: any);
     constructor(wrapper: SpvFromBTCWrapper<T>, initOrObject: SpvFromBTCSwapInit | any) {
@@ -342,10 +344,12 @@ export class SpvFromBTCSwap<T extends ChainType>
             this.gasPricingInfo = deserializePriceInfoType(initOrObject.gasPricingInfo);
             this.btcTxConfirmedAt = initOrObject.btcTxConfirmedAt;
             this.posted = initOrObject.posted;
-            if(initOrObject.data!=null) this._data = new this.wrapper._spvWithdrawalDataDeserializer(initOrObject.data);
+            if(initOrObject.data!=null) this._data = new (this.wrapper._spvWithdrawalDataDeserializer(this._contractVersion))(initOrObject.data);
         }
         this.tryCalculateSwapFee();
         this.logger = getLogger("SPVFromBTC("+this.getId()+"): ");
+
+        this._contract = wrapper._contract(this._contractVersion);
     }
 
     /**
@@ -779,7 +783,7 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         const out2script = toOutputScript(this.wrapper._options.bitcoinNetwork, this.btcDestinationAddress);
 
-        const opReturnData = this.wrapper._contract.toOpReturnData(
+        const opReturnData = this._contract.toOpReturnData(
             this.recipient,
             [
                 this.outputTotalSwap / this.vaultTokenMultipliers[0],
@@ -934,7 +938,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             psbt.finalizeIdx(i);
         }
         const btcTx = await this.wrapper._btcRpc.parseTransaction(Buffer.from(psbt.toBytes(true)).toString("hex"));
-        const data = await this.wrapper._contract.getWithdrawalData(btcTx);
+        const data = await this._contract.getWithdrawalData(btcTx);
 
         this.logger.debug("submitPsbt(): parsed withdrawal data: ", data);
 
@@ -971,7 +975,7 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         //Verify tx is parsable by the contract
         try {
-            await this.wrapper._contract.checkWithdrawalTx(data);
+            await this._contract.checkWithdrawalTx(data);
         } catch (e: any) {
             throw new Error("Transaction not parsable by the contract: "+(e.message ?? e.toString()));
         }
@@ -1273,7 +1277,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(!this.isClaimable()) throw new Error("Must be in BTC_TX_CONFIRMED state!");
         if(this._data==null) throw new Error("Expected swap to have withdrawal data filled!");
 
-        const vaultData = await this.wrapper._contract.getVaultData(this.vaultOwner, this.vaultId);
+        const vaultData = await this._contract.getVaultData(this.vaultOwner, this.vaultId);
         if(vaultData==null) throw new Error(`Vault data for ${this.vaultOwner}:${this.vaultId.toString(10)} not found (already closed???)!`);
 
         const btcTx = await this.wrapper._btcRpc.getTransaction(this._data.btcTx.txid);
@@ -1291,13 +1295,13 @@ export class SpvFromBTCSwap<T extends ChainType>
         //Parse transactions to withdrawal data
         const withdrawalData: T["SpvVaultWithdrawalData"][] = [];
         for(let tx of txs) {
-            withdrawalData.push(await this.wrapper._contract.getWithdrawalData(tx));
+            withdrawalData.push(await this._contract.getWithdrawalData(tx));
         }
 
-        return await this.wrapper._contract.txsClaim(
+        return await this._contract.txsClaim(
             address ?? this._getInitiator(), vaultData,
             withdrawalData.map(tx => {return {tx}}),
-            this.wrapper._synchronizer, true
+            this.wrapper._synchronizer(this._contractVersion), true
         );
     }
 
@@ -1335,7 +1339,7 @@ export class SpvFromBTCSwap<T extends ChainType>
                 this.logger.info("claim(): Transaction state is CLAIMED, swap was successfully claimed by the watchtower");
                 return this._claimTxId!;
             }
-            const withdrawalState = await this.wrapper._contract.getWithdrawalState(this._data, this._genesisSmartChainBlockHeight);
+            const withdrawalState = await this._contract.getWithdrawalState(this._data, this._genesisSmartChainBlockHeight);
             if(withdrawalState!=null && withdrawalState.type===SpvWithdrawalStateType.CLAIMED) {
                 this.logger.info("claim(): Transaction status is CLAIMED, swap was successfully claimed by the watchtower");
                 this._claimTxId = withdrawalState.txId;
@@ -1374,7 +1378,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             try {
                 //Be smart about checking withdrawal state
                 if(await this._shouldCheckWithdrawalState()) {
-                    status = await this.wrapper._contract.getWithdrawalState(
+                    status = await this._contract.getWithdrawalState(
                         this._data, this._genesisSmartChainBlockHeight
                     ) ?? {type: SpvWithdrawalStateType.NOT_FOUND};
                 }
@@ -1654,7 +1658,7 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         if(this._state===SpvFromBTCSwapState.BROADCASTED || this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
             if(await this._shouldCheckWithdrawalState()) {
-                const status = await this.wrapper._contract.getWithdrawalState(this._data!, this._genesisSmartChainBlockHeight);
+                const status = await this._contract.getWithdrawalState(this._data!, this._genesisSmartChainBlockHeight);
                 this.logger.debug("syncStateFromChain(): status of "+this._data!.btcTx.txid, status);
                 switch(status?.type) {
                     case SpvWithdrawalStateType.FRONTED:
@@ -1750,8 +1754,8 @@ export class SpvFromBTCSwap<T extends ChainType>
      * @internal
      */
     async _shouldCheckWithdrawalState(frontingAddress?: string | null, vaultDataUtxo?: string | null) {
-        if(frontingAddress===undefined) frontingAddress = await this.wrapper._contract.getFronterAddress(this.vaultOwner, this.vaultId, this._data!);
-        if(vaultDataUtxo===undefined) vaultDataUtxo = await this.wrapper._contract.getVaultLatestUtxo(this.vaultOwner, this.vaultId);
+        if(frontingAddress===undefined) frontingAddress = await this._contract.getFronterAddress(this.vaultOwner, this.vaultId, this._data!);
+        if(vaultDataUtxo===undefined) vaultDataUtxo = await this._contract.getVaultLatestUtxo(this.vaultOwner, this.vaultId);
 
         if(frontingAddress != null) return true; //In case the swap is fronted there will for sure be a fronted event
         if(vaultDataUtxo == null) return true; //Vault UTXO is null (the vault closed)