@atomiqlabs/sdk 8.6.2 → 8.7.1

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.ts

@@ -728,7 +728,7 @@ export class FromBTCLNAutoSwap<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;
     }
 
@@ -914,7 +914,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         const resp = await IntermediaryAPI.getInvoiceStatus(this.url, paymentHash.toString("hex"));
         switch(resp.code) {
             case InvoiceStatusResponseCodes.PAID:
-                const data = new this.wrapper._swapDataDeserializer(resp.data.data);
+                const data = new (this.wrapper._swapDataDeserializer(this._contractVersion))(resp.data.data);
                 if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) try {
                     await this._saveRealSwapData(data, save);
                     return true;
@@ -974,7 +974,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if (!data.isDepositToken(this.getSwapData().getDepositToken())) throw new IntermediaryError("Invalid deposit token used!");
         if (data.hasSuccessAction()) throw new IntermediaryError("Invalid has success action");
 
-        if (await this.wrapper._contract.isExpired(this._getInitiator(), data)) throw new IntermediaryError("Not enough time to claim!");
+        if (await this.wrapper._contract(this._contractVersion).isExpired(this._getInitiator(), data)) throw new IntermediaryError("Not enough time to claim!");
         if (this.wrapper._getHtlcTimeout(data) <= (Date.now()/1000)) throw new IntermediaryError("HTLC expires too soon!");
     }
 
@@ -1051,7 +1051,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
                 abortController.signal.throwIfAborted();
 
                 if(resp.code===InvoiceStatusResponseCodes.PAID) {
-                    const swapData = new this.wrapper._swapDataDeserializer(resp.data.data);
+                    const swapData = new (this.wrapper._swapDataDeserializer(this._contractVersion))(resp.data.data);
                     return await this._saveRealSwapData(swapData, true);
                 }
 
@@ -1164,7 +1164,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if(!this.isValidSecretPreimage(useSecret))
             throw new Error("Invalid swap secret pre-image provided!");
 
-        return await this.wrapper._contract.txsClaimWithSecret(
+        return await this._contract.txsClaimWithSecret(
             address ?? this._getInitiator(),
             this._data, useSecret, true, true
         );
@@ -1381,7 +1381,7 @@ export class FromBTCLNAutoSwap<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;
 
             if(this._state===FromBTCLNAutoSwapState.PR_PAID) {
@@ -1450,7 +1450,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if(await this.syncStateFromChain(quoteDefinitelyExpired, commitStatus)) changed = true;
 
         if(this._state===FromBTCLNAutoSwapState.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 = FromBTCLNAutoSwapState.EXPIRED;
                 changed = true;
@@ -1518,7 +1518,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             throw new Error("Invalid swap secret pre-image provided!");
 
         if(!noCheckExpiry) {
-            if(await this.wrapper._contract.isExpired(this._getInitiator(), this._data)) throw new Error("On-chain HTLC already expired!");
+            if(await this._contract.isExpired(this._getInitiator(), this._data)) throw new Error("On-chain HTLC already expired!");
         }
         await this.wrapper._messenger.broadcast(new SwapClaimWitnessMessage(this._data, useSecret));
     }
@@ -1545,7 +1545,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
                 break;
             case FromBTCLNAutoSwapState.PR_PAID:
             case FromBTCLNAutoSwapState.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 = FromBTCLNAutoSwapState.EXPIRED;
                     if(save) await this._saveAndEmit();

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper.ts

@@ -12,7 +12,7 @@ import {UserError} from "../../../../errors/UserError";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
 import {SwapType} from "../../../../enums/SwapType";
 import {
-    extendAbortController, parseHashValueExact32Bytes,
+    extendAbortController, mapArrayToObject, parseHashValueExact32Bytes,
     randomBytes,
     throwIfUndefined
 } from "../../../../utils/Utils";
@@ -148,10 +148,9 @@ export class FromBTCLNAutoWrapper<
      * @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 messenger
      * @param options
@@ -162,17 +161,21 @@ export class FromBTCLNAutoWrapper<
         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,
         messenger: Messenger,
         options?: AllOptional<FromBTCLNAutoWrapperOptions>,
         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,
@@ -255,30 +258,34 @@ export class FromBTCLNAutoWrapper<
      * @param options Options as passed to the swap creation function
      * @param abortController
      *
+     * @param contractVersions
      * @private
      */
-    private async preFetchClaimerBounty(
+    private preFetchClaimerBounty(
         signer: string,
         amountData: AmountData,
         options: {feeSafetyFactor: number, unsafeZeroWatchtowerFee: boolean},
-        abortController: AbortController
-    ): Promise<bigint | undefined> {
-        if(options.unsafeZeroWatchtowerFee) return 0n;
-
-        const dummyAmount = BigInt(Math.floor(Math.random()* 0x1000000));
-        const dummySwapData = await this._contract.createSwapData(
-            ChainSwapType.HTLC, this._chain.randomAddress(), signer, amountData.token,
-            dummyAmount, this._contract.getHashForHtlc(randomBytes(32)).toString("hex"),
-            this.getRandomSequence(), BigInt(Math.floor(Date.now()/1000)), false, true,
-            BigInt(Math.floor(Math.random() * 0x10000)), BigInt(Math.floor(Math.random() * 0x10000))
-        );
+        abortController: AbortController,
+        contractVersions: string[]
+    ): {[chainVersion: string]: Promise<bigint | undefined>} {
+        return mapArrayToObject(contractVersions, async (contractVersion) => {
+            if(options.unsafeZeroWatchtowerFee) return 0n;
+
+            const dummyAmount = BigInt(Math.floor(Math.random()* 0x1000000));
+            const dummySwapData = await this._contract(contractVersion).createSwapData(
+                ChainSwapType.HTLC, this._chain.randomAddress(), signer, amountData.token,
+                dummyAmount, this._contract(contractVersion).getHashForHtlc(randomBytes(32)).toString("hex"),
+                this.getRandomSequence(), BigInt(Math.floor(Date.now()/1000)), false, true,
+                BigInt(Math.floor(Math.random() * 0x10000)), BigInt(Math.floor(Math.random() * 0x10000))
+            );
 
-        try {
-            const result = await this._contract.getClaimFee(this._chain.randomAddress(), dummySwapData);
-            return result * BigInt(Math.floor(options.feeSafetyFactor*1000000)) / 1_000_000n
-        } catch (e) {
-            abortController.abort(e);
-        }
+            try {
+                const result = await this._contract(contractVersion).getClaimFee(this._chain.randomAddress(), dummySwapData);
+                return result * BigInt(Math.floor(options.feeSafetyFactor*1000000)) / 1_000_000n
+            } catch (e) {
+                abortController.abort(e);
+            }
+        });
     }
 
     /**
@@ -354,10 +361,10 @@ export class FromBTCLNAutoWrapper<
         additionalParams?: Record<string, any>,
         abortSignal?: AbortSignal,
         preFetches?: {
-            pricePrefetchPromise?: Promise<bigint | undefined>,
-            usdPricePrefetchPromise?: Promise<number | undefined>,
+            pricePrefetchPromise: Promise<bigint | undefined>,
+            usdPricePrefetchPromise: Promise<number | undefined>,
+            claimerBountyPrefetch: {[contractVersion: string]: Promise<bigint | undefined>},
             gasTokenPricePrefetchPromise?: Promise<bigint | undefined>,
-            claimerBountyPrefetch?: Promise<bigint | undefined>,
         }
     ): {
         quote: Promise<FromBTCLNAutoSwap<T>>,
@@ -381,6 +388,8 @@ export class FromBTCLNAutoWrapper<
         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) {
@@ -388,19 +397,20 @@ export class FromBTCLNAutoWrapper<
         } 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);
 
-        preFetches ??= {};
-        const _preFetches = {
-            pricePrefetchPromise: preFetches?.pricePrefetchPromise ?? this.preFetchPrice(amountData, _abortController.signal),
-            usdPricePrefetchPromise: preFetches?.usdPricePrefetchPromise ?? this.preFetchUsdPrice(_abortController.signal),
-            claimerBountyPrefetch: preFetches?.claimerBountyPrefetch ?? this.preFetchClaimerBounty(recipient, amountData, _options, _abortController),
+        const _preFetches = preFetches ?? {
+            pricePrefetchPromise: this.preFetchPrice(amountData, _abortController.signal),
+            usdPricePrefetchPromise: this.preFetchUsdPrice(_abortController.signal),
+            claimerBountyPrefetch: this.preFetchClaimerBounty(recipient, amountData, _options, _abortController, lpVersions),
             gasTokenPricePrefetchPromise: _options.gasAmount!==0n || !_options.unsafeZeroWatchtowerFee ?
-                (preFetches.gasTokenPricePrefetchPromise ??= this.preFetchPrice({token: nativeTokenAddress}, _abortController.signal)) :
+                this.preFetchPrice({token: nativeTokenAddress}, _abortController.signal) :
                 undefined
         };
 
@@ -409,10 +419,11 @@ export class FromBTCLNAutoWrapper<
                 intermediary: lp,
                 quote: (async () => {
                     if(lp.services[SwapType.FROM_BTCLN_AUTO]==null) throw new Error("LP service for processing from btcln auto 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.initFromBTCLNAuto(
@@ -428,7 +439,7 @@ export class FromBTCLNAutoWrapper<
                                 additionalParams,
                                 gasToken: this._chain.getNativeCurrencyAddress(),
                                 gasAmount: _options.gasAmount,
-                                claimerBounty: throwIfUndefined(_preFetches.claimerBountyPrefetch)
+                                claimerBounty: throwIfUndefined(_preFetches.claimerBountyPrefetch[version])
                             },
                             this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
                         );
@@ -448,7 +459,7 @@ export class FromBTCLNAutoWrapper<
                     if(decodedPr.millisatoshis==null) throw new IntermediaryError("Invalid returned swap invoice, no msat amount field");
                     if(decodedPr.timeExpireDate==null) throw new IntermediaryError("Invalid returned swap invoice, no expiry date field");
                     const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
-                    const claimerBounty = (await _preFetches.claimerBountyPrefetch)!;
+                    const claimerBounty = (await _preFetches.claimerBountyPrefetch[version])!;
 
                     try {
                         this.verifyReturnedData(resp, amountData, lp, _options, decodedPr, paymentHash, claimerBounty);
@@ -485,15 +496,16 @@ export class FromBTCLNAutoWrapper<
 
                             gasPricingInfo,
 
-                            initialSwapData: await this._contract.createSwapData(
+                            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,
                                 _options.gasAmount + resp.claimerBounty, resp.claimerBounty, nativeTokenAddress
                             ),
                             pr: resp.pr,
                             secret: secret?.toString("hex"),
-                            exactIn: amountData.exactIn ?? true
+                            exactIn: amountData.exactIn ?? true,
+                            contractVersion: version
                         };
                         const quote = new FromBTCLNAutoSwap<T>(this, swapInit);
                         return quote;
@@ -546,6 +558,8 @@ export class FromBTCLNAutoWrapper<
             descriptionHash: parseHashValueExact32Bytes(options?.descriptionHash, "description hash")
         };
 
+        const lpVersions = Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
+
         const abortController = extendAbortController(abortSignal);
         const preFetches = {
             pricePrefetchPromise: this.preFetchPrice(amountData, abortController.signal),
@@ -553,7 +567,7 @@ export class FromBTCLNAutoWrapper<
             gasTokenPricePrefetchPromise: _options.gasAmount!==0n || !_options.unsafeZeroWatchtowerFee ?
                 this.preFetchPrice({token: this._chain.getNativeCurrencyAddress()}, abortController.signal) :
                 undefined,
-            claimerBountyPrefetch: this.preFetchClaimerBounty(recipient, amountData, _options, abortController)
+            claimerBountyPrefetch: this.preFetchClaimerBounty(recipient, amountData, _options, abortController, lpVersions)
         };
 
         try {
@@ -615,7 +629,7 @@ export class FromBTCLNAutoWrapper<
         const changedSwapSet: Set<FromBTCLNAutoSwap<T>> = new Set();
 
         const swapExpiredStatus: {[id: string]: boolean} = {};
-        const checkStatusSwaps: (FromBTCLNAutoSwap<T> & {_data: T["Data"]})[] = [];
+        const checkStatusSwaps: {[contractVersion: string]: (FromBTCLNAutoSwap<T> & {_data: T["Data"]})[]} = {};
 
         await Promise.all(pastSwaps.map(async (pastSwap) => {
             if(pastSwap._shouldCheckIntermediary()) {
@@ -634,19 +648,27 @@ export class FromBTCLNAutoWrapper<
             }
             if(pastSwap._shouldFetchOnchainState()) {
                 //Add to swaps for which status should be checked
-                if(pastSwap._data!=null) checkStatusSwaps.push(pastSwap as FromBTCLNAutoSwap<T> & {_data: T["Data"]});
+                if(pastSwap._data!=null) (checkStatusSwaps[pastSwap._contractVersion ?? "v1"] ??= []).push(pastSwap as FromBTCLNAutoSwap<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;
+            }
 
-        for(let pastSwap of checkStatusSwaps) {
-            const shouldSave = await pastSwap._sync(
-                false, swapExpiredStatus[pastSwap.getId()],
-                swapStatuses[pastSwap.getEscrowHash()!], true
-            );
-            if(shouldSave) {
-                changedSwapSet.add(pastSwap);
+            const _checkStatusSwap = checkStatusSwaps[version];
+            const swapStatuses = await this._contract(version).getCommitStatuses(_checkStatusSwap.map(val => ({signer: val._getInitiator(), swapData: val._data})));
+
+            for(let pastSwap of _checkStatusSwap) {
+                const shouldSave = await pastSwap._sync(
+                    false, swapExpiredStatus[pastSwap.getId()],
+                    swapStatuses[pastSwap.getEscrowHash()!], true
+                );
+                if(shouldSave) {
+                    changedSwapSet.add(pastSwap);
+                }
             }
         }
 
@@ -672,6 +694,7 @@ export class FromBTCLNAutoWrapper<
     async recoverFromSwapDataAndState(
         init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
         state: SwapCommitState,
+        contractVersion: string,
         lp?: Intermediary
     ): Promise<FromBTCLNAutoSwap<T> | null> {
         const data = init.data;
@@ -702,7 +725,8 @@ export class FromBTCLNAutoWrapper<
             data,
             pr: paymentHash ?? undefined,
             secret,
-            exactIn: false
+            exactIn: false,
+            contractVersion
         }
         const swap = new FromBTCLNAutoSwap(this, swapInit);
         swap._commitTxId = await init.getInitTxId();

package/src/swaps/escrow_swaps/frombtc/onchain/FromBTCSwap.ts

@@ -385,7 +385,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     private inferRequiredConfirmationsCount(btcTx: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout: number): number | undefined {
         const txOut = btcTx.outs[vout];
         for(let i=1;i<=20;i++) {
-            const computedClaimHash = this.wrapper._contract.getHashForOnchain(
+            const computedClaimHash = this._contract.getHashForOnchain(
                 Buffer.from(txOut.scriptPubKey.hex, "hex"),
                 BigInt(txOut.value),
                 i
@@ -976,13 +976,13 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         if(tx.blockhash==null || tx.confirmations==null || tx.blockheight==null || tx.confirmations<this.requiredConfirmations)
             throw new Error("Bitcoin transaction not confirmed yet!");
 
-        return await this.wrapper._contract.txsClaimWithTxData(signer ?? this._getInitiator(), this._data, {
+        return await this._contract.txsClaimWithTxData(signer ?? this._getInitiator(), this._data, {
             blockhash: tx.blockhash,
             confirmations: tx.confirmations,
             txid: tx.txid,
             hex: tx.hex,
             height: tx.blockheight
-        }, this.requiredConfirmations, this.vout, undefined, this.wrapper._synchronizer, true);
+        }, this.requiredConfirmations, this.vout, undefined, this.wrapper._synchronizer(this._contractVersion), true);
     }
 
     /**
@@ -1017,7 +1017,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
                 this.logger.info("claim(): Transaction state is CLAIM_CLAIMED, swap was successfully claimed by the watchtower");
                 return this._claimTxId!;
             }
-            const status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+            const status = await this._contract.getCommitStatus(this._getInitiator(), this._data);
             if(status?.type===SwapCommitStateType.PAID) {
                 this.logger.info("claim(): Transaction commit status is PAID, swap was successfully claimed by the watchtower");
                 if(this._claimTxId==null) this._claimTxId = await status.getClaimTxId();
@@ -1149,7 +1149,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
                 quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired(); //Make sure we check for expiry here, to prevent race conditions
             }
 
-            const status = commitStatus ?? await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+            const status = commitStatus ?? await this._contract.getCommitStatus(this._getInitiator(), this._data);
             if(status!=null && await this._forciblySetOnchainState(status)) return true;
 
             if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {