@atomiqlabs/sdk 8.6.3 → 8.7.1

package/dist/events/UnifiedSwapEventListener.js

@@ -47,9 +47,10 @@ class UnifiedSwapEventListener {
         const htlcCheckInitializeEvents = {};
         for (let event of events) {
             const escrowHash = chainEventToEscrowHash(event);
+            const eventVersion = event.contractVersion ?? "v1";
             if (escrowHash != null) {
                 const swap = swapsByEscrowHash[escrowHash];
-                if (swap != null) {
+                if (swap != null && (swap._contractVersion ?? "v1") === eventVersion) {
                     const obj = this.listeners[swap.getType()];
                     if (obj == null)
                         continue;
@@ -85,8 +86,9 @@ class UnifiedSwapEventListener {
         logger.debug("processEvents(): Additional HTLC swaps founds: ", swapsByClaimDataHash);
         for (let claimData in htlcCheckInitializeEvents) {
             const event = htlcCheckInitializeEvents[claimData];
+            const eventVersion = event.contractVersion ?? "v1";
             const swap = swapsByClaimDataHash[claimData];
-            if (swap != null) {
+            if (swap != null && (swap._contractVersion ?? "v1") === eventVersion) {
                 const obj = this.listeners[swap.getType()];
                 if (obj == null)
                     continue;

package/dist/intermediaries/Intermediary.d.ts

@@ -50,6 +50,12 @@ export declare class Intermediary {
     readonly addresses: {
         [chainIdentifier: string]: string;
     };
+    /**
+     * Contract versions of the intermediary on smart chains
+     */
+    readonly contractVersions: {
+        [chainIdentifier: string]: string;
+    };
     /**
      * Swap protocol services offered by the intermediary
      */
@@ -97,6 +103,8 @@ export declare class Intermediary {
         [chainIdentifier: string]: string;
     }, services: ServicesType, reputation?: {
         [chainIdentifier: string]: SingleChainReputationType;
+    }, contractVersions?: {
+        [chainIdentifier: string]: string;
     });
     /**
      * Returns the input/output swap limit for given swap type, chain and token
@@ -154,4 +162,17 @@ export declare class Intermediary {
      * @param chainIdentifier Chain identifier of the smart chain
      */
     getAddress(chainIdentifier: string): string;
+    /**
+     * Returns the contract version used by the intermediary for a given chain
+     *
+     * @param chainIdentifier
+     */
+    getContractVersion(chainIdentifier: string): string;
+    /**
+     * Returns the range of contract versions used by the LPs
+     *
+     * @param chainIdentifier
+     * @param lps
+     */
+    static getContractVersionsForLps(chainIdentifier: string, lps: Intermediary[]): string[];
 }

package/dist/intermediaries/Intermediary.js

@@ -9,7 +9,7 @@ const RetryUtils_1 = require("../utils/RetryUtils");
  * @category LPs
  */
 class Intermediary {
-    constructor(url, addresses, services, reputation = {}) {
+    constructor(url, addresses, services, reputation = {}, contractVersions = {}) {
         /**
          * Reputation of the intermediary on different smart chains, this is only fetched
          *  on-demand when creating a swap where reputation is checked
@@ -24,6 +24,7 @@ class Intermediary {
         this.addresses = addresses;
         this.services = services;
         this.reputation = reputation;
+        this.contractVersions = contractVersions;
         this.swapBounds = {};
         for (let _swapType in this.services) {
             const swapType = parseInt(_swapType);
@@ -138,5 +139,28 @@ class Intermediary {
     getAddress(chainIdentifier) {
         return this.addresses[chainIdentifier];
     }
+    /**
+     * Returns the contract version used by the intermediary for a given chain
+     *
+     * @param chainIdentifier
+     */
+    getContractVersion(chainIdentifier) {
+        return this.contractVersions[chainIdentifier] ?? "v1";
+    }
+    /**
+     * Returns the range of contract versions used by the LPs
+     *
+     * @param chainIdentifier
+     * @param lps
+     */
+    static getContractVersionsForLps(chainIdentifier, lps) {
+        const versions = [];
+        lps.forEach((lp) => {
+            const lpVersion = lp.getContractVersion(chainIdentifier);
+            if (!versions.includes(lpVersion))
+                versions.push(lpVersion);
+        });
+        return versions;
+    }
 }
 exports.Intermediary = Intermediary;

package/dist/intermediaries/IntermediaryDiscovery.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Intermediary } from "./Intermediary";
 import { SwapType } from "../enums/SwapType";
-import { SwapContract } from "@atomiqlabs/base";
+import { SpvVaultContract, SwapContract } from "@atomiqlabs/base";
 import { EventEmitter } from "events";
 /**
  * Swap handler type mapping for intermediary communication
@@ -83,7 +83,12 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      * Swap contracts for checking intermediary signatures
      */
     swapContracts: {
-        [key: string]: SwapContract;
+        [chainIdentifier: string]: {
+            [contractVersion: string]: {
+                swapContract: SwapContract;
+                spvVaultContract: SpvVaultContract;
+            };
+        };
     };
     /**
      * Registry URL used as a source for the list of intermediaries, this should be a link to a
@@ -105,7 +110,12 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      */
     private overrideNodeUrls?;
     constructor(swapContracts: {
-        [key: string]: SwapContract;
+        [chainIdentifier: string]: {
+            [contractVersion: string]: {
+                swapContract: SwapContract;
+                spvVaultContract: SpvVaultContract;
+            };
+        };
     }, registryUrl?: string, nodeUrls?: string[], httpRequestTimeout?: number, maxWaitForOthersTimeout?: number);
     /**
      * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
@@ -183,6 +193,8 @@ export declare class IntermediaryDiscovery extends EventEmitter {
     /**
      * Returns swap candidates for a specific swap type & token address
      *
+     * @remark Also filters the LPs based on supported swap versions
+     *
      * @param chainIdentifier Chain identifier of the smart chain
      * @param swapType Swap protocol type
      * @param tokenAddress Token address

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -133,13 +133,21 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         abortSignal?.throwIfAborted();
         const promises = [];
         const addresses = {};
+        const contractVersions = {};
         for (let chain in response.chains) {
             if (this.swapContracts[chain] != null) {
+                const { signature, address, contractVersion } = response.chains[chain];
+                const _contractVersion = contractVersion ?? "v1";
+                const contract = this.swapContracts[chain][_contractVersion];
+                if (contract == null) {
+                    logger.warn("getNodeInfo(): Unknown chain contract version " + _contractVersion + " for " + chain + " reported by intermediary: " + url);
+                    continue;
+                }
                 promises.push((async () => {
-                    const { signature, address } = response.chains[chain];
                     try {
-                        await this.swapContracts[chain].isValidDataSignature(buffer_1.Buffer.from(response.envelope), signature, address);
+                        await contract.swapContract.isValidDataSignature(buffer_1.Buffer.from(response.envelope), signature, address);
                         addresses[chain] = address;
+                        contractVersions[chain] = _contractVersion;
                     }
                     catch (e) {
                         logger.warn("getNodeInfo(): Failed to verify " + chain + " signature for intermediary: " + url);
@@ -171,6 +179,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         }
         return {
             addresses,
+            contractVersions,
             info
         };
     }
@@ -188,7 +197,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
             for (let key in nodeInfo.info.services) {
                 services[swapHandlerTypeToSwapType(key)] = nodeInfo.info.services[key];
             }
-            return new Intermediary_1.Intermediary(url, nodeInfo.addresses, services);
+            return new Intermediary_1.Intermediary(url, nodeInfo.addresses, services, undefined, nodeInfo.contractVersions);
         }
         catch (e) {
             logger.warn("fetchIntermediaries(): Intermediary " + url + ` is unreachable due to ${e.name ?? e.message} error, skipping...`);
@@ -356,6 +365,8 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
     /**
      * Returns swap candidates for a specific swap type & token address
      *
+     * @remark Also filters the LPs based on supported swap versions
+     *
      * @param chainIdentifier Chain identifier of the smart chain
      * @param swapType Swap protocol type
      * @param tokenAddress Token address
@@ -377,6 +388,13 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
                 return false;
             if (!swapService.chainTokens[chainIdentifier].includes(tokenAddress.toString()))
                 return false;
+            const contracts = this.swapContracts[chainIdentifier][e.getContractVersion(chainIdentifier) ?? "v1"];
+            if (contracts == null)
+                return false;
+            if (swapType === SwapType_1.SwapType.FROM_BTCLN_AUTO && !contracts.swapContract?.supportsInitWithoutClaimer)
+                return false;
+            if (swapType === SwapType_1.SwapType.SPV_VAULT_FROM_BTC && contracts.spvVaultContract == null)
+                return false;
             return true;
         });
         candidates.sort(getIntermediaryComparator(swapType, tokenAddress, amount));

package/dist/intermediaries/apis/IntermediaryAPI.d.ts

@@ -7,6 +7,7 @@ export type InfoHandlerResponse = {
         [chainIdentifier: string]: {
             address: string;
             signature: string;
+            contractVersion?: string;
         };
     };
 };

package/dist/swapper/Swapper.d.ts

@@ -159,14 +159,19 @@ type ChainSpecificData<T extends ChainType> = {
         [SwapType.FROM_BTCLN_AUTO]: FromBTCLNAutoWrapper<T>;
     };
     chainEvents: T["Events"];
-    swapContract: T["Contract"];
-    spvVaultContract: T["SpvVaultContract"];
     chainInterface: T["ChainInterface"];
-    btcRelay: BtcRelay<any, T["TX"], BtcBlock, T["Signer"]>;
-    synchronizer: RelaySynchronizer<any, T["TX"], BtcBlock>;
     unifiedChainEvents: UnifiedSwapEventListener<T>;
     unifiedSwapStorage: UnifiedSwapStorage<T>;
     reviver: (val: any) => ISwap<T>;
+    defaultVersion: string;
+    versionedContracts: {
+        [contractVersion: string]: {
+            swapContract: T["Contract"];
+            spvVaultContract: T["SpvVaultContract"];
+            btcRelay: BtcRelay<any, T["TX"], BtcBlock, T["Signer"]>;
+            synchronizer: RelaySynchronizer<any, T["TX"], BtcBlock>;
+        };
+    };
 };
 type MultiChainData<T extends MultiChain> = {
     [chainIdentifier in keyof T]: ChainSpecificData<T[chainIdentifier]>;

package/dist/swapper/Swapper.js

@@ -91,30 +91,50 @@ class Swapper extends events_1.EventEmitter {
             this.emit("swapState", swap);
         };
         this._chains = (0, Utils_1.objectMap)(chainsData, (chainData, key) => {
-            const { swapContract, chainEvents, btcRelay, chainInterface, spvVaultContract, spvVaultWithdrawalDataConstructor, chainId } = chainData;
-            const synchronizer = bitcoinSynchronizer(btcRelay);
+            let { chainInterface, chainEvents, chainId, btcRelay, swapContract, swapDataConstructor, spvVaultContract, spvVaultWithdrawalDataConstructor, spvVaultDataConstructor, defaultVersion, versions } = chainData;
+            defaultVersion ??= "v1";
+            if (versions == null) {
+                versions = {
+                    [defaultVersion]: {
+                        btcRelay,
+                        swapContract,
+                        swapDataConstructor,
+                        spvVaultContract,
+                        spvVaultDataConstructor,
+                        spvVaultWithdrawalDataConstructor
+                    }
+                };
+            }
+            const versionedContracts = (0, Utils_1.objectMap)(versions, (value, key) => {
+                return {
+                    swapContract: value.swapContract,
+                    spvVaultContract: value.spvVaultContract,
+                    btcRelay: value.btcRelay,
+                    synchronizer: bitcoinSynchronizer(value.btcRelay)
+                };
+            });
             const storageHandler = swapStorage(storagePrefix + chainId);
             const unifiedSwapStorage = new UnifiedSwapStorage_1.UnifiedSwapStorage(storageHandler, this.options.noSwapCache);
             const unifiedChainEvents = new UnifiedSwapEventListener_1.UnifiedSwapEventListener(unifiedSwapStorage, chainEvents);
             const wrappers = {};
-            wrappers[SwapType_1.SwapType.TO_BTCLN] = new ToBTCLNWrapper_1.ToBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, {
+            wrappers[SwapType_1.SwapType.TO_BTCLN] = new ToBTCLNWrapper_1.ToBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 saveUninitializedSwaps: this.options.saveUninitializedSwaps,
             });
-            wrappers[SwapType_1.SwapType.TO_BTC] = new ToBTCWrapper_1.ToBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, this._bitcoinRpc, {
+            wrappers[SwapType_1.SwapType.TO_BTC] = new ToBTCWrapper_1.ToBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 bitcoinNetwork: this._btcNetwork
             });
-            wrappers[SwapType_1.SwapType.FROM_BTCLN] = new FromBTCLNWrapper_1.FromBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, {
+            wrappers[SwapType_1.SwapType.FROM_BTCLN] = new FromBTCLNWrapper_1.FromBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, lightningApi, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 unsafeSkipLnNodeCheck: this.bitcoinNetwork === base_1.BitcoinNetwork.TESTNET4 || this.bitcoinNetwork === base_1.BitcoinNetwork.REGTEST
             });
-            wrappers[SwapType_1.SwapType.FROM_BTC] = new FromBTCWrapper_1.FromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, btcRelay, synchronizer, this._bitcoinRpc, {
+            wrappers[SwapType_1.SwapType.FROM_BTC] = new FromBTCWrapper_1.FromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, versionedContracts, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 saveUninitializedSwaps: this.options.saveUninitializedSwaps,
@@ -131,16 +151,18 @@ class Swapper extends events_1.EventEmitter {
                 saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 bitcoinNetwork: this._btcNetwork
             });
+            // This is gated on the default version of the contracts
             if (spvVaultContract != null) {
-                wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper_1.SpvFromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, spvVaultContract, pricing, this._tokens[chainId], spvVaultWithdrawalDataConstructor, btcRelay, synchronizer, bitcoinRpc, {
+                wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper_1.SpvFromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, versionedContracts, bitcoinRpc, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
                     saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     bitcoinNetwork: this._btcNetwork
                 });
             }
+            // This is gated on the default version of the contracts
             if (swapContract.supportsInitWithoutClaimer) {
-                wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, this.messenger, {
+                wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], versions, lightningApi, this.messenger, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
                     saveUninitializedSwaps: this.options.saveUninitializedSwaps,
@@ -156,18 +178,16 @@ class Swapper extends events_1.EventEmitter {
             };
             return {
                 chainEvents,
-                spvVaultContract,
-                swapContract,
                 chainInterface,
-                btcRelay,
-                synchronizer,
                 wrappers,
                 unifiedChainEvents,
                 unifiedSwapStorage,
-                reviver
+                defaultVersion,
+                reviver,
+                versionedContracts
             };
         });
-        const contracts = (0, Utils_1.objectMap)(chainsData, (data) => data.swapContract);
+        const contracts = (0, Utils_1.objectMap)(chainsData, (data) => data.versions ?? { [data.defaultVersion ?? "v1"]: { swapContract: data.swapContract, spvVaultContract: data.spvVaultContract } });
         if (options.intermediaryUrl != null) {
             this.intermediaryDiscovery = new IntermediaryDiscovery_1.IntermediaryDiscovery(contracts, options.registryUrl, Array.isArray(options.intermediaryUrl) ? options.intermediaryUrl : [options.intermediaryUrl], options.getRequestTimeout);
         }
@@ -218,13 +238,15 @@ class Swapper extends events_1.EventEmitter {
         const chainPromises = [];
         for (let chainIdentifier in this._chains) {
             chainPromises.push((async () => {
-                const { chainInterface, swapContract, unifiedChainEvents, unifiedSwapStorage, wrappers, reviver } = this._chains[chainIdentifier];
+                const { chainInterface, versionedContracts, unifiedChainEvents, unifiedSwapStorage, wrappers, reviver } = this._chains[chainIdentifier];
                 const _chainInterface = chainInterface;
                 if (_chainInterface.verifyNetwork != null) {
                     await _chainInterface.verifyNetwork(this.bitcoinNetwork);
                 }
-                await swapContract.start();
-                this.logger.debug("init(): Intialized swap contract: " + chainIdentifier);
+                for (let contractVersion in versionedContracts) {
+                    await versionedContracts[contractVersion].swapContract.start();
+                    this.logger.debug("init(): Intialized swap contract: " + chainIdentifier + ` version: ${contractVersion}`);
+                }
                 await unifiedSwapStorage.init();
                 if (unifiedSwapStorage.storage instanceof IndexedDBUnifiedStorage_1.IndexedDBUnifiedStorage) {
                     //Try to migrate the data here
@@ -1173,15 +1195,35 @@ class Swapper extends events_1.EventEmitter {
      *  initiated after this blockheight
      */
     async recoverSwaps(chainId, signer, startBlockheight) {
-        const { spvVaultContract, swapContract, unifiedSwapStorage, reviver, wrappers } = this._chains[chainId];
-        if (swapContract.getHistoricalSwaps == null ||
-            (spvVaultContract != null && spvVaultContract.getHistoricalWithdrawalStates == null))
+        //TODO: Recover swaps from all the known contract versions
+        const { versionedContracts, unifiedSwapStorage, reviver, wrappers } = this._chains[chainId];
+        const recoveredSwaps = [];
+        let someVersionSupportsRecovery = false;
+        const recoveredEscrowStates = {};
+        const recoveredSpvStates = {};
+        for (let contractVersion in versionedContracts) {
+            const { swapContract, spvVaultContract } = versionedContracts[contractVersion];
+            if (swapContract.getHistoricalSwaps == null ||
+                (spvVaultContract != null && spvVaultContract.getHistoricalWithdrawalStates == null)) {
+                this.logger.warn(`recoverSwaps(): Swap data recovery not supported on ${chainId}, with contract version ${contractVersion}`);
+                continue;
+            }
+            someVersionSupportsRecovery = true;
+            const { swaps } = await swapContract.getHistoricalSwaps(signer, startBlockheight);
+            const spvVaultData = wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] == null
+                ? undefined
+                : await spvVaultContract?.getHistoricalWithdrawalStates(signer, startBlockheight);
+            for (let key in swaps)
+                recoveredEscrowStates[key] = { ...swaps[key], contractVersion };
+            if (spvVaultData != null)
+                for (let key in spvVaultData.withdrawals)
+                    (recoveredSpvStates[contractVersion] ??= {})[key] = spvVaultData.withdrawals[key];
+        }
+        if (!someVersionSupportsRecovery)
             throw new Error(`Historical swap recovery is not supported for ${chainId}`);
-        const { swaps } = await swapContract.getHistoricalSwaps(signer, startBlockheight);
-        const spvVaultData = await spvVaultContract?.getHistoricalWithdrawalStates(signer, startBlockheight);
-        const escrowHashes = Object.keys(swaps);
-        if (spvVaultData != null)
-            Object.keys(spvVaultData.withdrawals).forEach(btcTxId => escrowHashes.push(btcTxId));
+        const escrowHashes = Object.keys(recoveredEscrowStates);
+        for (let contractVersion in recoveredSpvStates)
+            Object.keys(recoveredSpvStates[contractVersion]).forEach(btcTxId => escrowHashes.push(btcTxId));
         this.logger.debug(`recoverSwaps(): Loaded on-chain data for ${escrowHashes.length} swaps`);
         this.logger.debug(`recoverSwaps(): Fetching if swap escrowHashes are known: ${escrowHashes.join(", ")}`);
         const knownSwapsArray = await unifiedSwapStorage.query([[{ key: "escrowHash", value: escrowHashes }]], reviver);
@@ -1192,10 +1234,10 @@ class Swapper extends events_1.EventEmitter {
                 knownSwaps[escrowHash] = val;
         });
         this.logger.debug(`recoverSwaps(): Fetched known swaps escrowHashes: ${Object.keys(knownSwaps).join(", ")}`);
-        const recoveredSwaps = [];
-        for (let escrowHash in swaps) {
-            const { init, state } = swaps[escrowHash];
+        for (let escrowHash in recoveredEscrowStates) {
+            const { init, state, contractVersion } = recoveredEscrowStates[escrowHash];
             const knownSwap = knownSwaps[escrowHash];
+            const { swapContract } = versionedContracts[contractVersion];
             if (knownSwap == null) {
                 if (init == null) {
                     this.logger.warn(`recoverSwaps(escrow): Fetched ${escrowHash} swap state, but swap not found locally!`);
@@ -1204,6 +1246,10 @@ class Swapper extends events_1.EventEmitter {
             }
             else if (knownSwap instanceof IEscrowSwap_1.IEscrowSwap) {
                 this.logger.debug(`recoverSwaps(escrow): Forcibly updating ${escrowHash} swap: swap already known and in local storage!`);
+                if ((knownSwap._contractVersion ?? "v1") !== contractVersion) {
+                    this.logger.debug(`recoverSwaps(escrow): Skipping ${escrowHash} swap: swap uses contract version ${knownSwap._contractVersion ?? "v1"}, but state comes from ${contractVersion}!`);
+                    continue;
+                }
                 if (await knownSwap._forciblySetOnchainState(state)) {
                     await knownSwap._save();
                 }
@@ -1222,17 +1268,17 @@ class Swapper extends events_1.EventEmitter {
                     //To BTCLN
                     typeIdentified = true;
                     const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isClaimer(val.getAddress(chainId)));
-                    swap = await wrappers[SwapType_1.SwapType.TO_BTCLN].recoverFromSwapDataAndState(init, state, lp);
+                    swap = await wrappers[SwapType_1.SwapType.TO_BTCLN].recoverFromSwapDataAndState(init, state, contractVersion, lp);
                 }
                 else if (data.isClaimer(signer)) {
                     //From BTCLN
                     typeIdentified = true;
                     const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isOfferer(val.getAddress(chainId)));
-                    if (this.supportsSwapType(chainId, SwapType_1.SwapType.FROM_BTCLN_AUTO)) {
-                        swap = await wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO].recoverFromSwapDataAndState(init, state, lp);
+                    if (swapContract.supportsInitWithoutClaimer && wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] != null) {
+                        swap = await wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO].recoverFromSwapDataAndState(init, state, contractVersion, lp);
                     }
                     else {
-                        swap = await wrappers[SwapType_1.SwapType.FROM_BTCLN].recoverFromSwapDataAndState(init, state, lp);
+                        swap = await wrappers[SwapType_1.SwapType.FROM_BTCLN].recoverFromSwapDataAndState(init, state, contractVersion, lp);
                     }
                 }
             }
@@ -1240,13 +1286,13 @@ class Swapper extends events_1.EventEmitter {
                 //To BTC
                 typeIdentified = true;
                 const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isClaimer(val.getAddress(chainId)));
-                swap = await wrappers[SwapType_1.SwapType.TO_BTC].recoverFromSwapDataAndState(init, state, lp);
+                swap = await wrappers[SwapType_1.SwapType.TO_BTC].recoverFromSwapDataAndState(init, state, contractVersion, lp);
             }
             else if (data.getType() === base_1.ChainSwapType.CHAIN) {
                 //From BTC
                 typeIdentified = true;
                 const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isOfferer(val.getAddress(chainId)));
-                swap = await wrappers[SwapType_1.SwapType.FROM_BTC].recoverFromSwapDataAndState(init, state, lp);
+                swap = await wrappers[SwapType_1.SwapType.FROM_BTC].recoverFromSwapDataAndState(init, state, contractVersion, lp);
             }
             if (swap != null) {
                 recoveredSwaps.push(swap);
@@ -1256,14 +1302,16 @@ class Swapper extends events_1.EventEmitter {
                     this.logger.debug(`recoverSwaps(escrow): Swap data type correctly identified but swap returned is null for swap ${escrowHash}`);
             }
         }
-        if (spvVaultContract != null && spvVaultData != null) {
-            const vaultsData = await spvVaultContract.getMultipleVaultData(Object.keys(spvVaultData.withdrawals)
+        for (let contractVersion in recoveredSpvStates) {
+            const { spvVaultContract } = versionedContracts[contractVersion];
+            const spvVaultData = recoveredSpvStates[contractVersion];
+            const vaultsData = await spvVaultContract.getMultipleVaultData(Object.keys(spvVaultData)
                 .map(btcTxId => ({
-                owner: spvVaultData.withdrawals[btcTxId].owner,
-                vaultId: spvVaultData.withdrawals[btcTxId].vaultId
+                owner: spvVaultData[btcTxId].owner,
+                vaultId: spvVaultData[btcTxId].vaultId
             })));
-            for (let btcTxId in spvVaultData.withdrawals) {
-                const state = spvVaultData.withdrawals[btcTxId];
+            for (let btcTxId in spvVaultData) {
+                const state = spvVaultData[btcTxId];
                 const knownSwap = knownSwaps[btcTxId];
                 if (knownSwap != null) {
                     if (knownSwap instanceof SpvFromBTCSwap_1.SpvFromBTCSwap) {
@@ -1280,7 +1328,7 @@ class Swapper extends events_1.EventEmitter {
                     }
                 }
                 const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && state.owner.toLowerCase() === val.getAddress(chainId).toLowerCase());
-                const swap = await wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC].recoverFromState(state, vaultsData[state.owner]?.[state.vaultId.toString(10)], lp);
+                const swap = await wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC].recoverFromState(state, contractVersion, vaultsData[state.owner]?.[state.vaultId.toString(10)], lp);
                 if (swap != null) {
                     recoveredSwaps.push(swap);
                 }

package/dist/swapper/SwapperUtils.js

@@ -337,7 +337,8 @@ class SwapperUtils {
     async getSpendableBalance(wallet, token, options) {
         if (this.root._chains[token.chainId] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + token.chainId);
-        const { swapContract, chainInterface } = this.root._chains[token.chainId];
+        const { defaultVersion, versionedContracts, chainInterface } = this.root._chains[token.chainId];
+        const { swapContract } = versionedContracts[defaultVersion];
         let signer;
         if (typeof (wallet) === "string") {
             signer = wallet;

package/dist/swaps/ISwap.d.ts

@@ -25,6 +25,7 @@ export type ISwapInit = {
     swapFee: bigint;
     swapFeeBtc: bigint;
     exactIn: boolean;
+    contractVersion: string;
 };
 /**
  * Type guard to check if an object is an ISwapInit
@@ -119,6 +120,10 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * @internal
      */
     _persisted: boolean;
+    /**
+     * @internal
+     */
+    _contractVersion?: string;
     /**
      * Event emitter emitting `"swapState"` event when swap's state changes
      */

package/dist/swaps/ISwap.js

@@ -73,6 +73,7 @@ class ISwap {
             this.version = this.currentVersion;
             this.createdAt = Date.now();
             this._randomNonce = (0, Utils_1.randomBytes)(16).toString("hex");
+            this._contractVersion = swapInitOrObj.contractVersion;
         }
         else {
             this.expiry = swapInitOrObj.expiry;
@@ -97,6 +98,7 @@ class ISwap {
             this.exactIn = swapInitOrObj.exactIn;
             this.createdAt = swapInitOrObj.createdAt ?? swapInitOrObj.expiry;
             this._randomNonce = swapInitOrObj.randomNonce;
+            this._contractVersion = swapInitOrObj.contractVersion;
         }
         if (this.version !== this.currentVersion) {
             this.upgradeVersion();
@@ -323,7 +325,8 @@ class ISwap {
             initiated: this.initiated,
             exactIn: this.exactIn,
             createdAt: this.createdAt,
-            randomNonce: this._randomNonce
+            randomNonce: this._randomNonce,
+            contractVersion: this._contractVersion
         };
     }
     //////////////////////////////

package/dist/swaps/escrow_swaps/IEscrowSelfInitSwap.js

@@ -55,7 +55,7 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
         while (!expired) {
             await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
             try {
-                expired = await this.wrapper._contract.isInitAuthorizationExpired(this._data, this.signatureData);
+                expired = await this._contract.isInitAuthorizationExpired(this._data, this.signatureData);
             }
             catch (e) {
                 this.logger.error("watchdogWaitTillSignatureExpiry(): Error when checking signature expiry: ", e);
@@ -71,13 +71,13 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
      * @internal
      */
     getCommitFee() {
-        return this.wrapper._contract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate);
+        return this._contract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate);
     }
     /**
      * Returns the transaction fee paid on the smart chain side to initiate the escrow
      */
     async getSmartChainNetworkFee() {
-        const swapContract = this.wrapper._contract;
+        const swapContract = this._contract;
         return (0, TokenAmount_1.toTokenAmount)(await (swapContract.getRawCommitFee != null ?
             swapContract.getRawCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate) :
             swapContract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate)), this.wrapper._getNativeToken(), this.wrapper._prices);
@@ -90,7 +90,7 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
     async _verifyQuoteDefinitelyExpired() {
         if (this._data == null || this.signatureData == null)
             throw new Error("data or signature data are null!");
-        return this.wrapper._contract.isInitAuthorizationExpired(this._data, this.signatureData);
+        return this._contract.isInitAuthorizationExpired(this._data, this.signatureData);
     }
     /**
      * Checks if the swap's quote is still valid
@@ -99,7 +99,7 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
         if (this._data == null || this.signatureData == null)
             throw new Error("data or signature data are null!");
         try {
-            await this.wrapper._contract.isValidInitAuthorization(this._getInitiator(), this._data, this.signatureData, this.feeRate);
+            await this._contract.isValidInitAuthorization(this._getInitiator(), this._data, this.signatureData, this.feeRate);
             return true;
         }
         catch (e) {

package/dist/swaps/escrow_swaps/IEscrowSwap.d.ts

@@ -31,6 +31,10 @@ export declare abstract class IEscrowSwap<T extends ChainType = ChainType, D ext
      * @internal
      */
     _claimTxId?: string;
+    /**
+     * @internal
+     */
+    protected _contract: T["Contract"];
     protected constructor(wrapper: D["Wrapper"], obj: any);
     protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSwapInit<T["Data"]>);
     /**