@atomiqlabs/sdk 8.6.3 → 8.7.1

package/src/swapper/Swapper.ts

@@ -6,7 +6,7 @@ import {
     ChainSwapType,
     ChainType, LightningNetworkApi,
     Messenger,
-    RelaySynchronizer
+    RelaySynchronizer, SpvWithdrawalClaimedState, SpvWithdrawalFrontedState, SwapCommitState, SwapContract, SwapData
 } from "@atomiqlabs/base";
 import {
     ToBTCLNOptions,
@@ -190,14 +190,20 @@ 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>
+    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> = {
@@ -358,12 +364,37 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         };
 
         this._chains = objectMap<CtorMultiChainData<T>, MultiChainData<T>>(chainsData, <InputKey extends keyof CtorMultiChainData<T>>(chainData: CtorMultiChainData<T>[InputKey], key: string) => {
-            const {
-                swapContract, chainEvents, btcRelay,
-                chainInterface, spvVaultContract, spvVaultWithdrawalDataConstructor,
-                chainId
+            let {
+                chainInterface, chainEvents, chainId,
+                btcRelay,
+                swapContract, swapDataConstructor,
+                spvVaultContract, spvVaultWithdrawalDataConstructor, spvVaultDataConstructor,
+                defaultVersion, versions
             } = chainData;
-            const synchronizer = bitcoinSynchronizer(btcRelay);
+
+            defaultVersion ??= "v1";
+
+            if(versions==null) {
+                versions = {
+                    [defaultVersion]: {
+                        btcRelay,
+                        swapContract,
+                        swapDataConstructor,
+                        spvVaultContract,
+                        spvVaultDataConstructor,
+                        spvVaultWithdrawalDataConstructor
+                    }
+                }
+            }
+
+            const versionedContracts = 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<T[InputKey]>(storageHandler, this.options.noSwapCache);
@@ -376,10 +407,9 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 unifiedSwapStorage,
                 unifiedChainEvents,
                 chainInterface,
-                swapContract,
                 pricing,
                 this._tokens[chainId],
-                chainData.swapDataConstructor,
+                versions,
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
@@ -391,10 +421,9 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 unifiedSwapStorage,
                 unifiedChainEvents,
                 chainInterface,
-                swapContract,
                 pricing,
                 this._tokens[chainId],
-                chainData.swapDataConstructor,
+                versions,
                 this._bitcoinRpc,
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
@@ -408,10 +437,9 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 unifiedSwapStorage,
                 unifiedChainEvents,
                 chainInterface,
-                swapContract,
                 pricing,
                 this._tokens[chainId],
-                chainData.swapDataConstructor,
+                versions,
                 lightningApi,
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
@@ -425,12 +453,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 unifiedSwapStorage,
                 unifiedChainEvents,
                 chainInterface,
-                swapContract,
                 pricing,
                 this._tokens[chainId],
-                chainData.swapDataConstructor,
-                btcRelay,
-                synchronizer,
+                versions,
+                versionedContracts,
                 this._bitcoinRpc,
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
@@ -468,18 +494,17 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 }
             );
 
+            // This is gated on the default version of the contracts
             if(spvVaultContract!=null) {
                 wrappers[SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper<T[InputKey]>(
                     key,
                     unifiedSwapStorage,
                     unifiedChainEvents,
                     chainInterface,
-                    spvVaultContract,
                     pricing,
                     this._tokens[chainId],
-                    spvVaultWithdrawalDataConstructor,
-                    btcRelay,
-                    synchronizer,
+                    versions,
+                    versionedContracts,
                     bitcoinRpc,
                     {
                         getRequestTimeout: this.options.getRequestTimeout,
@@ -490,16 +515,16 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 );
             }
 
+            // This is gated on the default version of the contracts
             if(swapContract.supportsInitWithoutClaimer) {
                 wrappers[SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper<T[InputKey]>(
                     key,
                     unifiedSwapStorage,
                     unifiedChainEvents,
                     chainInterface,
-                    swapContract,
                     pricing,
                     this._tokens[chainId],
-                    chainData.swapDataConstructor,
+                    versions,
                     lightningApi,
                     this.messenger,
                     {
@@ -521,22 +546,22 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
 
             return {
                 chainEvents,
-                spvVaultContract,
-                swapContract,
                 chainInterface,
-                btcRelay,
-                synchronizer,
 
                 wrappers,
 
                 unifiedChainEvents,
                 unifiedSwapStorage,
 
-                reviver
+                defaultVersion,
+
+                reviver,
+
+                versionedContracts
             }
         });
 
-        const contracts = objectMap(chainsData, (data) => data.swapContract);
+        const contracts = objectMap(chainsData, (data) => data.versions ?? {[data.defaultVersion ?? "v1"]: {swapContract: data.swapContract, spvVaultContract: data.spvVaultContract}});
         if(options.intermediaryUrl!=null) {
             this.intermediaryDiscovery = new IntermediaryDiscovery(contracts, options.registryUrl, Array.isArray(options.intermediaryUrl) ? options.intermediaryUrl : [options.intermediaryUrl], options.getRequestTimeout);
         } else {
@@ -595,7 +620,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
             chainPromises.push((async() => {
                 const {
                     chainInterface,
-                    swapContract,
+                    versionedContracts,
                     unifiedChainEvents,
                     unifiedSwapStorage,
                     wrappers,
@@ -607,8 +632,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                     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) {
@@ -1872,18 +1899,56 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
      *  initiated after this blockheight
      */
     async recoverSwaps<C extends ChainIds<T>>(chainId: C, signer: string, startBlockheight?: number): Promise<ISwap<T[C]>[]> {
-        const {spvVaultContract, swapContract, unifiedSwapStorage, reviver, wrappers} = this._chains[chainId];
+        //TODO: Recover swaps from all the known contract versions
+        const {versionedContracts, unifiedSwapStorage, reviver, wrappers} = this._chains[chainId];
 
-        if(
-            swapContract.getHistoricalSwaps==null ||
-            (spvVaultContract!=null && spvVaultContract.getHistoricalWithdrawalStates==null)
-        ) throw new Error(`Historical swap recovery is not supported for ${chainId}`);
+        const recoveredSwaps: ISwap<T[C]>[] = [];
+        let someVersionSupportsRecovery = false;
+        const recoveredEscrowStates: {
+            [p: string]: {
+                init?: {
+                    data: SwapData
+                    getInitTxId: () => Promise<string>
+                    getTxBlock: () => Promise<{
+                        blockTime: number
+                        blockHeight: number
+                    }>
+                },
+                state: SwapCommitState
+                contractVersion: string
+            }
+        } = {};
+        const recoveredSpvStates: {
+            [contractVersion: string]: {
+                [escrowHash: string]: SpvWithdrawalClaimedState | SpvWithdrawalFrontedState
+            }
+        } = {};
+
+        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 = await spvVaultContract?.getHistoricalWithdrawalStates!(signer, startBlockheight);
+            const {swaps} = await swapContract.getHistoricalSwaps(signer, startBlockheight);
+            const spvVaultData = wrappers[SwapType.SPV_VAULT_FROM_BTC]==null
+                ? undefined
+                : await spvVaultContract?.getHistoricalWithdrawalStates!(signer, startBlockheight);
 
-        const escrowHashes = Object.keys(swaps);
-        if(spvVaultData!=null) Object.keys(spvVaultData.withdrawals).forEach(btcTxId => escrowHashes.push(btcTxId));
+            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 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);
@@ -1894,11 +1959,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         });
         this.logger.debug(`recoverSwaps(): Fetched known swaps escrowHashes: ${Object.keys(knownSwaps).join(", ")}`);
 
-        const recoveredSwaps: ISwap<T[C]>[] = [];
-
-        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) {
@@ -1907,6 +1971,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 }
             } else if(knownSwap instanceof 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();
                 }
@@ -1926,27 +1994,27 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                     //To BTCLN
                     typeIdentified = true;
                     const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isClaimer(val.getAddress(chainId)));
-                    swap = await wrappers[SwapType.TO_BTCLN].recoverFromSwapDataAndState(init, state, lp);
+                    swap = await wrappers[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.FROM_BTCLN_AUTO)) {
-                        swap = await wrappers[SwapType.FROM_BTCLN_AUTO].recoverFromSwapDataAndState(init, state, lp);
+                    if(swapContract.supportsInitWithoutClaimer && wrappers[SwapType.FROM_BTCLN_AUTO]!=null) {
+                        swap = await wrappers[SwapType.FROM_BTCLN_AUTO].recoverFromSwapDataAndState(init, state, contractVersion, lp);
                     } else {
-                        swap = await wrappers[SwapType.FROM_BTCLN].recoverFromSwapDataAndState(init, state, lp);
+                        swap = await wrappers[SwapType.FROM_BTCLN].recoverFromSwapDataAndState(init, state, contractVersion, lp);
                     }
                 }
             } else if(data.getType()===ChainSwapType.CHAIN_NONCED) {
                 //To BTC
                 typeIdentified = true;
                 const lp = this.intermediaryDiscovery.intermediaries.find(val => val.supportsChain(chainId) && data.isClaimer(val.getAddress(chainId)));
-                swap = await wrappers[SwapType.TO_BTC].recoverFromSwapDataAndState(init, state, lp);
+                swap = await wrappers[SwapType.TO_BTC].recoverFromSwapDataAndState(init, state, contractVersion, lp);
             } else if(data.getType()===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.FROM_BTC].recoverFromSwapDataAndState(init, state, lp);
+                swap = await wrappers[SwapType.FROM_BTC].recoverFromSwapDataAndState(init, state, contractVersion, lp);
             }
 
             if(swap!=null) {
@@ -1956,17 +2024,20 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
             }
         }
 
-        if(spvVaultContract!=null && spvVaultData!=null) {
+        for(let contractVersion in recoveredSpvStates) {
+            const { spvVaultContract } = versionedContracts[contractVersion];
+            const spvVaultData = recoveredSpvStates[contractVersion];
+
             const vaultsData = await spvVaultContract.getMultipleVaultData(
-                Object.keys(spvVaultData.withdrawals)
+                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) {
@@ -1988,6 +2059,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 );
                 const swap = await wrappers[SwapType.SPV_VAULT_FROM_BTC].recoverFromState(
                     state,
+                    contractVersion,
                     vaultsData[state.owner]?.[state.vaultId.toString(10)],
                     lp
                 );

package/src/swapper/SwapperUtils.ts

@@ -404,7 +404,9 @@ export class SwapperUtils<T extends MultiChain> {
         feeRate?: any
     }): Promise<TokenAmount> {
         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: string;
         if(typeof(wallet)==="string") {

package/src/swaps/ISwap.ts

@@ -25,7 +25,8 @@ export type ISwapInit = {
     expiry: number,
     swapFee: bigint,
     swapFeeBtc: bigint,
-    exactIn: boolean
+    exactIn: boolean,
+    contractVersion: string
 };
 
 /**
@@ -140,6 +141,10 @@ export abstract class ISwap<
      * @internal
      */
     _persisted: boolean = false;
+    /**
+     * @internal
+     */
+    _contractVersion?: string;
 
 
     /**
@@ -181,6 +186,7 @@ export abstract class ISwap<
             this.version = this.currentVersion;
             this.createdAt = Date.now();
             this._randomNonce = randomBytes(16).toString("hex");
+            this._contractVersion = swapInitOrObj.contractVersion;
         } else {
             this.expiry = swapInitOrObj.expiry;
             this.url = swapInitOrObj.url;
@@ -211,6 +217,7 @@ export abstract class ISwap<
             this.createdAt = swapInitOrObj.createdAt ?? swapInitOrObj.expiry;
 
             this._randomNonce = swapInitOrObj.randomNonce;
+            this._contractVersion = swapInitOrObj.contractVersion;
         }
         if(this.version!==this.currentVersion) {
             this.upgradeVersion();
@@ -637,7 +644,8 @@ export abstract class ISwap<
             initiated: this.initiated,
             exactIn: this.exactIn,
             createdAt: this.createdAt,
-            randomNonce: this._randomNonce
+            randomNonce: this._randomNonce,
+            contractVersion: this._contractVersion
         }
     }
 

package/src/swaps/escrow_swaps/IEscrowSelfInitSwap.ts

@@ -89,7 +89,7 @@ export abstract class IEscrowSelfInitSwap<
         while(!expired) {
             await 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);
             }
@@ -106,14 +106,14 @@ export abstract class IEscrowSelfInitSwap<
      * @internal
      */
     protected getCommitFee(): Promise<bigint> {
-        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(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
-        const swapContract: T["Contract"] = this.wrapper._contract;
+        const swapContract: T["Contract"] = this._contract;
         return toTokenAmount(
             await (
                 swapContract.getRawCommitFee!=null ?
@@ -178,7 +178,7 @@ export abstract class IEscrowSelfInitSwap<
     async _verifyQuoteDefinitelyExpired(): Promise<boolean> {
         if(this._data==null || this.signatureData==null) throw new Error("data or signature data are null!");
 
-        return this.wrapper._contract.isInitAuthorizationExpired(
+        return this._contract.isInitAuthorizationExpired(
             this._data!, this.signatureData!
         );
     }
@@ -190,7 +190,7 @@ export abstract class IEscrowSelfInitSwap<
         if(this._data==null || this.signatureData==null) throw new Error("data or signature data are null!");
 
         try {
-            await this.wrapper._contract.isValidInitAuthorization(
+            await this._contract.isValidInitAuthorization(
                 this._getInitiator(), this._data!, this.signatureData!, this.feeRate
             );
             return true;

package/src/swaps/escrow_swaps/IEscrowSwap.ts

@@ -50,6 +50,11 @@ export abstract class IEscrowSwap<
      */
     _claimTxId?: string;
 
+    /**
+     * @internal
+     */
+    protected _contract: T["Contract"];
+
     protected constructor(wrapper: D["Wrapper"], obj: any);
     protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSwapInit<T["Data"]>);
     protected constructor(
@@ -61,12 +66,14 @@ export abstract class IEscrowSwap<
         if(isIEscrowSwapInit(swapInitOrObj)) {
             this._data = swapInitOrObj.data;
         } else {
-            if(swapInitOrObj.data!=null) this._data = new wrapper._swapDataDeserializer(swapInitOrObj.data);
+            if(swapInitOrObj.data!=null) this._data = new (wrapper._swapDataDeserializer(this._contractVersion))(swapInitOrObj.data);
 
             this._commitTxId = swapInitOrObj.commitTxId;
             this._claimTxId = swapInitOrObj.claimTxId;
             this._refundTxId = swapInitOrObj.refundTxId;
         }
+
+        this._contract = wrapper._contract(this._contractVersion);
     }
 
     /**
@@ -170,7 +177,7 @@ export abstract class IEscrowSwap<
         while(status?.type===SwapCommitStateType.NOT_COMMITED) {
             await timeoutPromise(intervalSeconds*1000, abortSignal);
             try {
-                status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+                status = await this._contract.getCommitStatus(this._getInitiator(), this._data);
                 if(
                     status?.type===SwapCommitStateType.NOT_COMMITED &&
                     await this._verifyQuoteDefinitelyExpired()
@@ -200,7 +207,7 @@ export abstract class IEscrowSwap<
         while(status?.type===SwapCommitStateType.COMMITED || status?.type===SwapCommitStateType.REFUNDABLE) {
             await timeoutPromise(intervalSeconds*1000, abortSignal);
             try {
-                status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+                status = await this._contract.getCommitStatus(this._getInitiator(), this._data);
             } catch (e) {
                 this.logger.error("watchdogWaitTillResult(): Error when fetching commit status: ", e);
             }