@atomiqlabs/sdk 8.6.2 → 8.7.1

package/src/swaps/escrow_swaps/IEscrowSwapWrapper.ts

@@ -34,46 +34,68 @@ export abstract class IEscrowSwapWrapper<
     /**
      * @internal
      */
-    readonly _contract: T["Contract"];
+    readonly _contract: (version?: string) => T["Contract"] = (version?: string) => {
+        const _version = version ?? "v1";
+        const data = this._versionedContracts[_version];
+        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
+        return data.swapContract;
+    };
     /**
      * @internal
      */
-    readonly _swapDataDeserializer: new (data: any) => T["Data"];
+    readonly _swapDataDeserializer: (version?: string) => new (data: any) => T["Data"] = (version?: string) => {
+        const _version = version ?? "v1";
+        const data = this._versionedContracts[_version];
+        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
+        return data.swapDataConstructor;
+    };
+
+    //TODO: Properly populate in constructor
+    readonly _versionedContracts: {
+        [version: string]: {
+            swapContract: T["Contract"],
+            swapDataConstructor: new (data: any) => T["Data"]
+        }
+    } = {};
 
     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"],
         options: O,
+        versionedContracts: {
+            [version: string]: {
+                swapContract: T["Contract"],
+                swapDataConstructor: new (data: any) => T["Data"]
+            }
+        },
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
         super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
-        this._swapDataDeserializer = swapDataDeserializer;
-        this._contract = contract;
+        this._versionedContracts = versionedContracts;
     }
 
     /**
      * Pre-fetches signature verification data from the server's pre-sent promise, doesn't throw, instead returns null
      *
      * @param signDataPrefetch Promise that resolves when we receive "signDataPrefetch" from the LP in streaming mode
+     * @param contractVersion
      * @returns Pre-fetched signature verification data or null if failed
      *
      * @internal
      */
-    protected preFetchSignData(signDataPrefetch: Promise<any | null>): Promise<T["PreFetchVerification"] | undefined> {
-        if(this._contract.preFetchForInitSignatureVerification==null) {
+    protected preFetchSignData(signDataPrefetch: Promise<any | null>, contractVersion: string): Promise<T["PreFetchVerification"] | undefined> {
+        if(this._contract(contractVersion).preFetchForInitSignatureVerification==null) {
             // Catch promise rejections, should they happen
             signDataPrefetch.catch(() => {});
             return Promise.resolve(undefined);
         }
         return signDataPrefetch.then(obj => {
             if(obj==null) return undefined;
-            return this._contract.preFetchForInitSignatureVerification!(obj);
+            return this._contract(contractVersion).preFetchForInitSignatureVerification!(obj);
         }).catch(e => {
             this.logger.error("preFetchSignData(): Error: ", e);
         });
@@ -87,6 +109,7 @@ export abstract class IEscrowSwapWrapper<
      * @param signature Response of the intermediary
      * @param feeRatePromise Pre-fetched fee rate promise
      * @param preFetchSignatureVerificationData Pre-fetched signature verification data
+     * @param contractVersion
      * @param abortSignal
      * @returns Swap initialization signature expiry
      * @throws {SignatureVerificationError} when swap init signature is invalid
@@ -99,11 +122,12 @@ export abstract class IEscrowSwapWrapper<
         signature: SignatureData,
         feeRatePromise: Promise<any>,
         preFetchSignatureVerificationData: Promise<any>,
-        abortSignal?: AbortSignal
+        contractVersion: string,
+        abortSignal?: AbortSignal,
     ): Promise<number> {
         const [feeRate, preFetchedSignatureData] = await Promise.all([feeRatePromise, preFetchSignatureVerificationData]);
-        await this._contract.isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
-        return await this._contract.getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
+        await this._contract(contractVersion).isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
+        return await this._contract(contractVersion).getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
     }
 
     /**
@@ -186,7 +210,7 @@ export abstract class IEscrowSwapWrapper<
 
         const swapExpiredStatus: {[id: string]: boolean} = {};
 
-        const checkStatusSwaps: (D["Swap"] & {_data: T["Data"]})[] = [];
+        const checkStatusSwaps: {[contractVersion: string]: (D["Swap"] & {_data: T["Data"]})[]} = {};
 
         for(let pastSwap of pastSwaps) {
             if(pastSwap._shouldFetchExpiryStatus()) {
@@ -195,24 +219,37 @@ export abstract class IEscrowSwapWrapper<
             }
             if(pastSwap._shouldFetchOnchainState()) {
                 //Add to swaps for which status should be checked
-                if(pastSwap._data!=null) checkStatusSwaps.push(pastSwap as (D["Swap"] & {_data: T["Data"]}));
+                if(pastSwap._data!=null) (checkStatusSwaps[pastSwap._contractVersion ?? "v1"] ??= []).push(pastSwap as (D["Swap"] & {_data: T["Data"]}));
             }
         }
 
-        const swapStatuses = await this._contract.getCommitStatuses(checkStatusSwaps.map(val => ({signer: val._getInitiator(), swapData: val._data})));
+        for(let version in checkStatusSwaps) {
+            if(this._versionedContracts[version]==null) {
+                this.logger.warn(`_checkPastSwaps(): No contract was found for ${this.chainIdentifier} version ${version}! Skipping these swaps!`);
+                continue;
+            }
 
-        for(let pastSwap of checkStatusSwaps) {
-            const escrowHash = pastSwap.getEscrowHash();
-            const shouldSave = await pastSwap._sync(
-                false,
-                swapExpiredStatus[pastSwap.getId()],
-                escrowHash==null ? undefined : swapStatuses[escrowHash]
+            const _checkStatusSwap = checkStatusSwaps[version];
+            const swapStatuses = await this._contract(version).getCommitStatuses(
+                _checkStatusSwap.map(val => ({
+                    signer: val._getInitiator(),
+                    swapData: val._data
+                }))
             );
-            if(shouldSave) {
-                if(pastSwap.isQuoteExpired()) {
-                    removeSwaps.push(pastSwap);
-                } else {
-                    changedSwaps.push(pastSwap);
+
+            for(let pastSwap of _checkStatusSwap) {
+                const escrowHash = pastSwap.getEscrowHash();
+                const shouldSave = await pastSwap._sync(
+                    false,
+                    swapExpiredStatus[pastSwap.getId()],
+                    escrowHash==null ? undefined : swapStatuses[escrowHash]
+                );
+                if(shouldSave) {
+                    if(pastSwap.isQuoteExpired()) {
+                        removeSwaps.push(pastSwap);
+                    } else {
+                        changedSwaps.push(pastSwap);
+                    }
                 }
             }
         }
@@ -239,6 +276,7 @@ export abstract class IEscrowSwapWrapper<
             getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>
         },
         state: SwapCommitState,
+        contractVersion: string,
         lp?: Intermediary
     ): Promise<D["Swap"] | null>;
 

package/src/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.ts

@@ -38,10 +38,9 @@ export abstract class IFromBTCLNWrapper<
      * @param unifiedStorage Storage interface for the current environment
      * @param unifiedChainEvents On-chain event listener
      * @param chain
-     * @param contract Underlying contract handling the swaps
      * @param prices Swap pricing handler
      * @param tokens
-     * @param swapDataDeserializer Deserializer for SwapData
+     * @param versionedContracts
      * @param lnApi
      * @param options
      * @param events Instance to use for emitting events
@@ -51,15 +50,19 @@ export abstract class IFromBTCLNWrapper<
         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"]
+            }
+        },
         lnApi: LightningNetworkApi,
         options: O,
         events?: EventEmitter<{swapState: [IEscrowSwap]}>
     ) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, options, events);
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, versionedContracts, events);
         this.lnApi = lnApi;
     }
 

package/src/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.ts

@@ -196,7 +196,7 @@ export abstract class IFromBTCSelfInitSwap<
         required: TokenAmount<SCToken<T["ChainId"]>, true>
     }> {
         const [balance, commitFee] = await Promise.all([
-            this.wrapper._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
+            this._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
             this.getCommitFee()
         ]);
         const totalFee = commitFee + this.getSwapData().getTotalDeposit();
@@ -247,7 +247,7 @@ export abstract class IFromBTCSelfInitSwap<
             await this._saveAndEmit();
         }
 
-        return await this.wrapper._contract.txsInit(
+        return await this._contract.txsInit(
             this._getInitiator(), this._data, this.signatureData, skipChecks, this.feeRate
         ).catch(e => Promise.reject(e instanceof SignatureVerificationError ? new Error("Request timed out") : e));
     }
@@ -274,7 +274,7 @@ export abstract class IFromBTCSelfInitSwap<
      *  smart chain
      */
     async getClaimNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
-        const swapContract: T["Contract"] = this.wrapper._contract;
+        const swapContract: T["Contract"] = this._contract;
         return toTokenAmount(
             await swapContract.getClaimFee(this._getInitiator(), this.getSwapData()),
             this.wrapper._getNativeToken(),

package/src/swaps/escrow_swaps/frombtc/IFromBTCWrapper.ts

@@ -1,7 +1,7 @@
 import {ISwapWrapperOptions} from "../../ISwapWrapper";
 import {Intermediary} from "../../../intermediaries/Intermediary";
 import {IntermediaryError} from "../../../errors/IntermediaryError";
-import {randomBytes} from "../../../utils/Utils";
+import {mapArrayToObject, randomBytes} from "../../../utils/Utils";
 import {BigIntBufferUtils, ChainType} from "@atomiqlabs/base";
 import {IEscrowSwapDefinition, IEscrowSwapWrapper} from "../IEscrowSwapWrapper";
 import {IEscrowSwap} from "../IEscrowSwap";
@@ -39,6 +39,7 @@ export abstract class IFromBTCWrapper<
      * @param claimHash optional claim hash of the swap or null
      * @param abortController
      *
+     * @param contractVersions
      * @returns Fee rate
      *
      * @internal
@@ -46,15 +47,18 @@ export abstract class IFromBTCWrapper<
     protected preFetchFeeRate(
         signer: string,
         amountData: AmountData,
-        claimHash: string | undefined,
-        abortController: AbortController
-    ): Promise<string | undefined> {
-        return this._contract.getInitFeeRate(this._chain.randomAddress(), signer, amountData.token, claimHash)
-            .catch(e => {
-                this.logger.warn("preFetchFeeRate(): Error: ", e);
-                abortController.abort(e);
-                return undefined;
-            });
+        claimHash: {[contractVersion: string]: string} | undefined,
+        abortController: AbortController,
+        contractVersions: string[]
+    ): {[contractVersion: string]: Promise<string | undefined>} {
+        return mapArrayToObject(contractVersions, (contractVersion) => {
+            return this._contract(contractVersion).getInitFeeRate(this._chain.randomAddress(), signer, amountData.token, claimHash?.[contractVersion])
+                .catch(e => {
+                    this.logger.warn("preFetchFeeRate(): Error: ", e);
+                    abortController.abort(e);
+                    return undefined;
+                });
+        });
     }
 
     /**
@@ -64,12 +68,18 @@ export abstract class IFromBTCWrapper<
      * @param lp Intermediary
      * @param abortController
      *
+     * @param contractVersion
      * @returns Intermediary's liquidity balance
      *
      * @internal
      */
-    protected preFetchIntermediaryLiquidity(amountData: AmountData, lp: Intermediary, abortController: AbortController): Promise<bigint | undefined> {
-        return lp.getLiquidity(this.chainIdentifier, this._contract, amountData.token.toString(), abortController.signal).catch(e => {
+    protected preFetchIntermediaryLiquidity(
+        amountData: AmountData,
+        lp: Intermediary,
+        abortController: AbortController,
+        contractVersion: string
+    ): Promise<bigint | undefined> {
+        return lp.getLiquidity(this.chainIdentifier, this._contract(contractVersion), amountData.token.toString(), abortController.signal).catch(e => {
             this.logger.warn("preFetchIntermediaryLiquidity(): Error: ", e);
             abortController.abort(e);
             return undefined;

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.ts

@@ -474,16 +474,16 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         required: TokenAmount<SCToken<T["ChainId"]>, true>
     }> {
         const [balance, feeRate] = await Promise.all([
-            this.wrapper._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
-            this.feeRate!=null ? Promise.resolve<string>(this.feeRate) : this.wrapper._contract.getInitFeeRate(
+            this._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
+            this.feeRate!=null ? Promise.resolve<string>(this.feeRate) : this._contract.getInitFeeRate(
                 this.getSwapData().getOfferer(),
                 this.getSwapData().getClaimer(),
                 this.getSwapData().getToken(),
                 this.getSwapData().getClaimHash()
             )
         ]);
-        const commitFee = await this.wrapper._contract.getCommitFee(this._getInitiator(), this.getSwapData(), feeRate);
-        const claimFee = await this.wrapper._contract.getClaimFee(this._getInitiator(), this.getSwapData(), feeRate);
+        const commitFee = await this._contract.getCommitFee(this._getInitiator(), this.getSwapData(), feeRate);
+        const claimFee = await this._contract.getClaimFee(this._getInitiator(), this.getSwapData(), feeRate);
         const totalFee = commitFee + claimFee + this.getSwapData().getTotalDeposit();
         return {
             enoughBalance: balance >= totalFee,
@@ -494,7 +494,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
 
     private isValidSecretPreimage(secret: string) {
         const paymentHash = Buffer.from(sha256(Buffer.from(secret, "hex")));
-        const claimHash = this.wrapper._contract.getHashForHtlc(paymentHash).toString("hex");
+        const claimHash = this._contract.getHashForHtlc(paymentHash).toString("hex");
         return this.getSwapData().getClaimHash()===claimHash;
     }
 
@@ -716,10 +716,10 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         const resp = await IntermediaryAPI.getPaymentAuthorization(this.url, paymentHash.toString("hex"));
         switch(resp.code) {
             case PaymentAuthorizationResponseCodes.AUTH_DATA:
-                const data = new this.wrapper._swapDataDeserializer(resp.data.data);
+                const data = new (this.wrapper._swapDataDeserializer(this._contractVersion))(resp.data.data);
                 try {
                     await this.checkIntermediaryReturnedAuthData(this._getInitiator(), data, resp.data);
-                    this.expiry = await this.wrapper._contract.getInitAuthorizationExpiry(
+                    this.expiry = await this._contract.getInitAuthorizationExpiry(
                         data,
                         resp.data
                     );
@@ -773,8 +773,8 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         if (data.hasSuccessAction()) throw new IntermediaryError("Invalid has success action");
 
         await Promise.all([
-            this.wrapper._contract.isValidInitAuthorization(this._getInitiator(), data, signature, this.feeRate),
-            this.wrapper._contract.getCommitStatus(data.getClaimer(), data)
+            this._contract.isValidInitAuthorization(this._getInitiator(), data, signature, this.feeRate),
+            this._contract.getCommitStatus(data.getClaimer(), data)
                 .then(status => {
                     if (status?.type !== SwapCommitStateType.NOT_COMMITED)
                         throw new Error("Swap already committed on-chain!");
@@ -846,9 +846,9 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
 
         if(resp.code===PaymentAuthorizationResponseCodes.AUTH_DATA) {
             const sigData = resp.data;
-            const swapData = new this.wrapper._swapDataDeserializer(resp.data.data);
+            const swapData = new (this.wrapper._swapDataDeserializer(this._contractVersion))(resp.data.data);
             await this.checkIntermediaryReturnedAuthData(this._getInitiator(), swapData, sigData);
-            this.expiry = await this.wrapper._contract.getInitAuthorizationExpiry(
+            this.expiry = await this._contract.getInitAuthorizationExpiry(
                 swapData,
                 sigData
             );
@@ -972,7 +972,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         if(!this.isValidSecretPreimage(useSecret))
             throw new Error("Invalid swap secret pre-image provided!");
 
-        return this.wrapper._contract.txsClaimWithSecret(
+        return this._contract.txsClaimWithSecret(
             address ?? this._getInitiator(),
             this._data, useSecret, true, true
         );
@@ -1092,7 +1092,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      *  to settle the swap on the smart chain destination side.
      */
     async getCommitAndClaimNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
-        const swapContract: T["Contract"] = this.wrapper._contract;
+        const swapContract: T["Contract"] = this._contract;
         const feeRate = this.feeRate ?? await swapContract.getInitFeeRate(
             this.getSwapData().getOfferer(),
             this.getSwapData().getClaimer(),
@@ -1123,7 +1123,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      *  call {@link commit} first and then {@link claim}.
      */
     canCommitAndClaimInOneShot(): boolean {
-        return this.wrapper._contract.initAndClaimWithSecret!=null;
+        return this._contract.initAndClaimWithSecret!=null;
     }
 
     /**
@@ -1154,7 +1154,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
             throw new Error("Invalid swap secret pre-image provided!");
 
         const initTxs = await this.txsCommit(skipChecks);
-        const claimTxs = await this.wrapper._contract.txsClaimWithSecret(
+        const claimTxs = await this._contract.txsClaimWithSecret(
             this._getInitiator(), this._data, useSecret,
             true, true, undefined,
             true
@@ -1311,7 +1311,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
             }
 
             //Check if it's already successfully paid
-            commitStatus ??= await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data!);
+            commitStatus ??= await this._contract.getCommitStatus(this._getInitiator(), this._data!);
             if(commitStatus!=null && await this._forciblySetOnchainState(commitStatus)) return true;
 
             //Set the state on expiry here
@@ -1382,7 +1382,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         if(await this.syncStateFromChain(quoteDefinitelyExpired, commitStatus)) changed = true;
 
         if(this._state===FromBTCLNSwapState.CLAIM_COMMITED) {
-            const expired = await this.wrapper._contract.isExpired(this._getInitiator(), this._data!);
+            const expired = await this._contract.isExpired(this._getInitiator(), this._data!);
             if(expired) {
                 this._state = FromBTCLNSwapState.EXPIRED;
                 changed = true;
@@ -1447,7 +1447,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
                 }
                 break;
             case FromBTCLNSwapState.CLAIM_COMMITED:
-                const expired = await this.wrapper._contract.isExpired(this._getInitiator(), this._data!);
+                const expired = await this._contract.isExpired(this._getInitiator(), this._data!);
                 if(expired) {
                     this._state = FromBTCLNSwapState.EXPIRED;
                     if(save) await this._saveAndEmit();

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.ts

@@ -13,7 +13,7 @@ import {UserError} from "../../../../errors/UserError";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
 import {SwapType} from "../../../../enums/SwapType";
 import {
-    extendAbortController, parseHashValueExact32Bytes,
+    extendAbortController, mapArrayToObject, parseHashValueExact32Bytes,
     throwIfUndefined
 } from "../../../../utils/Utils";
 import {FromBTCLNResponseType, IntermediaryAPI} from "../../../../intermediaries/apis/IntermediaryAPI";
@@ -113,10 +113,9 @@ export class FromBTCLNWrapper<
      * @param unifiedStorage Storage interface for the current environment
      * @param unifiedChainEvents On-chain event listener
      * @param chain
-     * @param contract Underlying contract handling the swaps
      * @param prices Swap pricing handler
      * @param tokens
-     * @param swapDataDeserializer Deserializer for SwapData
+     * @param versionedContracts
      * @param lnApi
      * @param options
      * @param events Instance to use for emitting events
@@ -126,16 +125,20 @@ export class FromBTCLNWrapper<
         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"]
+            }
+        },
         lnApi: LightningNetworkApi,
         options?: AllOptional<FromBTCLNWrapperOptions>,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
         super(
-            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, lnApi,
+            chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, versionedContracts, lnApi,
             {
                 ...options,
                 safetyFactor: options?.safetyFactor ?? 2,
@@ -254,8 +257,8 @@ export class FromBTCLNWrapper<
         abortSignal?: AbortSignal,
         preFetches?: {
             usdPricePrefetchPromise: Promise<number | undefined>,
-            pricePrefetchPromise?: Promise<bigint | undefined>,
-            feeRatePromise?: Promise<string | undefined>
+            pricePrefetchPromise: Promise<bigint | undefined>,
+            feeRatePromise: {[contractVersion: string]: Promise<string | undefined>},
         }
     ): {
         quote: Promise<FromBTCLNSwap<T>>,
@@ -273,6 +276,8 @@ export class FromBTCLNWrapper<
         if(_options.description!=null && Buffer.byteLength(_options.description, "utf8") > 500)
             throw new UserError("Invalid description length");
 
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
+
         let secret: Buffer | undefined;
         let paymentHash: Buffer;
         if(_options.paymentHash!=null) {
@@ -280,15 +285,17 @@ export class FromBTCLNWrapper<
         } else {
             ({secret, paymentHash} = this.getSecretAndHash());
         }
-        const claimHash = this._contract.getHashForHtlc(paymentHash);
+        const _hash = mapArrayToObject(lpVersions, (contractVersion: string) => {
+            return this._contract(contractVersion).getHashForHtlc(paymentHash).toString("hex");
+        });
 
         const nativeTokenAddress = this._chain.getNativeCurrencyAddress();
 
         const _abortController = extendAbortController(abortSignal);
-        const _preFetches = {
-            pricePrefetchPromise: preFetches?.pricePrefetchPromise ?? this.preFetchPrice(amountData, _abortController.signal),
-            feeRatePromise: preFetches?.feeRatePromise ?? this.preFetchFeeRate(recipient, amountData, claimHash.toString("hex"), _abortController),
-            usdPricePrefetchPromise: preFetches?.usdPricePrefetchPromise ?? this.preFetchUsdPrice(_abortController.signal),
+        const _preFetches = preFetches ?? {
+            pricePrefetchPromise: this.preFetchPrice(amountData, _abortController.signal),
+            feeRatePromise: this.preFetchFeeRate(recipient, amountData, _hash, _abortController, lpVersions),
+            usdPricePrefetchPromise: this.preFetchUsdPrice(_abortController.signal),
         }
 
         return lps.map(lp => {
@@ -296,10 +303,11 @@ export class FromBTCLNWrapper<
                 intermediary: lp,
                 quote: (async () => {
                     if(lp.services[SwapType.FROM_BTCLN]==null) throw new Error("LP service for processing from btcln swaps not found!");
+                    const version = lp.getContractVersion(this.chainIdentifier);
 
                     const abortController = extendAbortController(_abortController.signal);
 
-                    const liquidityPromise: Promise<bigint | undefined> = this.preFetchIntermediaryLiquidity(amountData, lp, abortController);
+                    const liquidityPromise: Promise<bigint | undefined> = this.preFetchIntermediaryLiquidity(amountData, lp, abortController, version);
 
                     const {lnCapacityPromise, resp} = await tryWithRetries(async(retryCount: number) => {
                         const {lnPublicKey, response} = IntermediaryAPI.initFromBTCLN(
@@ -312,7 +320,7 @@ export class FromBTCLNWrapper<
                                 description: _options.description,
                                 descriptionHash: _options.descriptionHash,
                                 exactOut: !amountData.exactIn,
-                                feeRate: throwIfUndefined(_preFetches.feeRatePromise),
+                                feeRate: throwIfUndefined(_preFetches.feeRatePromise[version]),
                                 additionalParams
                             },
                             this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
@@ -351,16 +359,17 @@ export class FromBTCLNWrapper<
                             expiry: decodedPr.timeExpireDate*1000,
                             swapFee: resp.swapFee,
                             swapFeeBtc: resp.swapFee * amountIn / (resp.total - resp.swapFee),
-                            feeRate: (await _preFetches.feeRatePromise)!,
-                            initialSwapData: await this._contract.createSwapData(
+                            feeRate: (await _preFetches.feeRatePromise[version])!,
+                            initialSwapData: await this._contract(version).createSwapData(
                                 ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), recipient, amountData.token,
-                                resp.total, claimHash.toString("hex"),
+                                resp.total, _hash[version],
                                 this.getRandomSequence(), BigInt(Math.floor(Date.now()/1000)), false, true,
                                 resp.securityDeposit, 0n, nativeTokenAddress
                             ),
                             pr: resp.pr,
                             secret: secret?.toString("hex"),
-                            exactIn: amountData.exactIn ?? true
+                            exactIn: amountData.exactIn ?? true,
+                            contractVersion: version
                         } as FromBTCLNSwapInit<T["Data"]>);
                         return quote;
                     } catch (e) {
@@ -408,11 +417,13 @@ export class FromBTCLNWrapper<
             unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? this._options.unsafeSkipLnNodeCheck
         };
 
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
+
         const abortController = extendAbortController(abortSignal);
         const preFetches = {
             pricePrefetchPromise: this.preFetchPrice(amountData, abortController.signal),
             usdPricePrefetchPromise: this.preFetchUsdPrice(abortController.signal),
-            feeRatePromise: this.preFetchFeeRate(recipient, amountData, undefined, abortController)
+            feeRatePromise: this.preFetchFeeRate(recipient, amountData, undefined, abortController, lpVersions)
         };
 
         try {
@@ -474,7 +485,7 @@ export class FromBTCLNWrapper<
         const changedSwapSet: Set<FromBTCLNSwap<T>> = new Set();
 
         const swapExpiredStatus: {[id: string]: boolean} = {};
-        const checkStatusSwaps: (FromBTCLNSwap<T> & {_data: T["Data"]})[] = [];
+        const checkStatusSwaps: {[contractVersion: string]: (FromBTCLNSwap<T> & {_data: T["Data"]})[]} = {};
 
         await Promise.all(pastSwaps.map(async (pastSwap) => {
             if(pastSwap._shouldCheckIntermediary()) {
@@ -493,19 +504,27 @@ export class FromBTCLNWrapper<
             }
             if(pastSwap._shouldFetchOnchainState()) {
                 //Add to swaps for which status should be checked
-                if(pastSwap._data!=null) checkStatusSwaps.push(pastSwap as (FromBTCLNSwap<T> & {_data: T["Data"]}));
+                if(pastSwap._data!=null) (checkStatusSwaps[pastSwap._contractVersion ?? "v1"] ??= []).push(pastSwap as (FromBTCLNSwap<T> & {_data: T["Data"]}));
             }
         }));
 
-        const swapStatuses = await this._contract.getCommitStatuses(checkStatusSwaps.map(val => ({signer: val._getInitiator(), swapData: val._data})));
+        for(let version in checkStatusSwaps) {
+            if(this._versionedContracts[version]==null) {
+                this.logger.warn(`_checkPastSwaps(): No contract was found for ${this.chainIdentifier} version ${version}! Skipping these swaps!`);
+                continue;
+            }
+
+            const _checkStatusSwap = checkStatusSwaps[version];
+            const swapStatuses = await this._contract(version).getCommitStatuses(_checkStatusSwap.map(val => ({signer: val._getInitiator(), swapData: val._data})));
 
-        for(let pastSwap of checkStatusSwaps) {
-            const shouldSave = await pastSwap._sync(
-                false, swapExpiredStatus[pastSwap.getId()],
-                swapStatuses[pastSwap.getEscrowHash()!], true
-            );
-            if(shouldSave) {
-                changedSwapSet.add(pastSwap);
+            for(let pastSwap of _checkStatusSwap) {
+                const shouldSave = await pastSwap._sync(
+                    false, swapExpiredStatus[pastSwap.getId()],
+                    swapStatuses[pastSwap.getEscrowHash()!], true
+                );
+                if(shouldSave) {
+                    changedSwapSet.add(pastSwap);
+                }
             }
         }
 
@@ -532,6 +551,7 @@ export class FromBTCLNWrapper<
     async recoverFromSwapDataAndState(
         init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
         state: SwapCommitState,
+        contractVersion: string,
         lp?: Intermediary
     ): Promise<FromBTCLNSwap<T> | null> {
         const data = init.data;
@@ -562,7 +582,8 @@ export class FromBTCLNWrapper<
             data,
             pr: paymentHash ?? undefined,
             secret,
-            exactIn: false
+            exactIn: false,
+            contractVersion
         }
         const swap = new FromBTCLNSwap(this, swapInit);
         swap._commitTxId = await init.getInitTxId();