@atomiqlabs/sdk 8.1.7 → 8.3.1

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

@@ -5,7 +5,7 @@ import {
     ChainType,
     ClaimEvent,
     InitializeEvent, LightningNetworkApi,
-    RefundEvent
+    RefundEvent, SwapCommitState, SwapCommitStateType
 } from "@atomiqlabs/base";
 import {Intermediary} from "../../../../intermediaries/Intermediary";
 import {Buffer} from "buffer";
@@ -29,7 +29,8 @@ import {IClaimableSwapWrapper} from "../../../IClaimableSwapWrapper";
 import {AmountData} from "../../../../types/AmountData";
 import {LNURLWithdrawParamsWithUrl} from "../../../../types/lnurl/LNURLWithdraw";
 import {tryWithRetries} from "../../../../utils/RetryUtils";
-import {AllOptional, AllRequired} from "../../../../utils/TypeUtils";
+import {AllOptional} from "../../../../utils/TypeUtils";
+import {sha256} from "@noble/hashes/sha2";
 
 export type FromBTCLNOptions = {
     descriptionHash?: Buffer,
@@ -45,16 +46,44 @@ export type FromBTCLNWrapperOptions = ISwapWrapperOptions & {
 export type FromBTCLNDefinition<T extends ChainType> = IFromBTCLNDefinition<T, FromBTCLNWrapper<T>, FromBTCLNSwap<T>>;
 
 /**
- * Factory wrapper for creating Lightning BTC to Smart Chain swaps
+ * Legacy escrow (HTLC) based swap for Bitcoin Lightning -> Smart chains, requires manual settlement
+ *  of the swap on the destination network once the lightning network payment is received by the LP.
+ *
  * @category Swaps
  */
 export class FromBTCLNWrapper<
     T extends ChainType
 > extends IFromBTCLNWrapper<T, FromBTCLNDefinition<T>, FromBTCLNWrapperOptions> implements IClaimableSwapWrapper<FromBTCLNSwap<T>> {
 
-    public readonly claimableSwapStates = [FromBTCLNSwapState.CLAIM_COMMITED];
-    public readonly TYPE = SwapType.FROM_BTCLN;
-    public readonly swapDeserializer = FromBTCLNSwap;
+    public readonly TYPE: SwapType.FROM_BTCLN = SwapType.FROM_BTCLN;
+
+    /**
+     * @internal
+     */
+    protected readonly tickSwapState = [
+        FromBTCLNSwapState.PR_CREATED,
+        FromBTCLNSwapState.PR_PAID,
+        FromBTCLNSwapState.CLAIM_COMMITED
+    ];
+
+    /**
+     * @internal
+     */
+    readonly _pendingSwapStates = [
+        FromBTCLNSwapState.PR_CREATED,
+        FromBTCLNSwapState.QUOTE_SOFT_EXPIRED,
+        FromBTCLNSwapState.PR_PAID,
+        FromBTCLNSwapState.CLAIM_COMMITED,
+        FromBTCLNSwapState.EXPIRED
+    ];
+    /**
+     * @internal
+     */
+    readonly _claimableSwapStates = [FromBTCLNSwapState.CLAIM_COMMITED];
+    /**
+     * @internal
+     */
+    readonly _swapDeserializer = FromBTCLNSwap;
 
     /**
      * @param chainIdentifier
@@ -93,38 +122,38 @@ export class FromBTCLNWrapper<
         );
     }
 
-    public readonly pendingSwapStates = [
-        FromBTCLNSwapState.PR_CREATED,
-        FromBTCLNSwapState.QUOTE_SOFT_EXPIRED,
-        FromBTCLNSwapState.PR_PAID,
-        FromBTCLNSwapState.CLAIM_COMMITED,
-        FromBTCLNSwapState.EXPIRED
-    ];
-    public readonly tickSwapState = [
-        FromBTCLNSwapState.PR_CREATED,
-        FromBTCLNSwapState.PR_PAID,
-        FromBTCLNSwapState.CLAIM_COMMITED
-    ];
-
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected processEventInitialize(swap: FromBTCLNSwap<T>, event: InitializeEvent<T["Data"]>): Promise<boolean> {
-        if(swap.state===FromBTCLNSwapState.PR_PAID || swap.state===FromBTCLNSwapState.QUOTE_SOFT_EXPIRED) {
-            swap.state = FromBTCLNSwapState.CLAIM_COMMITED;
+        if(swap._state===FromBTCLNSwapState.PR_PAID || swap._state===FromBTCLNSwapState.QUOTE_SOFT_EXPIRED) {
+            swap._state = FromBTCLNSwapState.CLAIM_COMMITED;
             return Promise.resolve(true);
         }
         return Promise.resolve(false);
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected processEventClaim(swap: FromBTCLNSwap<T>, event: ClaimEvent<T["Data"]>): Promise<boolean> {
-        if(swap.state!==FromBTCLNSwapState.FAILED && swap.state!==FromBTCLNSwapState.CLAIM_CLAIMED) {
-            swap.state = FromBTCLNSwapState.CLAIM_CLAIMED;
+        if(swap._state!==FromBTCLNSwapState.FAILED && swap._state!==FromBTCLNSwapState.CLAIM_CLAIMED) {
+            swap._state = FromBTCLNSwapState.CLAIM_CLAIMED;
+            swap._setSwapSecret(event.result);
             return Promise.resolve(true);
         }
         return Promise.resolve(false);
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected processEventRefund(swap: FromBTCLNSwap<T>, event: RefundEvent<T["Data"]>): Promise<boolean> {
-        if(swap.state!==FromBTCLNSwapState.CLAIM_CLAIMED && swap.state!==FromBTCLNSwapState.FAILED) {
-            swap.state = FromBTCLNSwapState.FAILED;
+        if(swap._state!==FromBTCLNSwapState.CLAIM_CLAIMED && swap._state!==FromBTCLNSwapState.FAILED) {
+            swap._state = FromBTCLNSwapState.FAILED;
             return Promise.resolve(true);
         }
         return Promise.resolve(false);
@@ -139,8 +168,10 @@ export class FromBTCLNWrapper<
      * @param options Options as passed to the swap creation function
      * @param decodedPr Decoded bolt11 lightning network invoice
      * @param paymentHash Expected payment hash of the bolt11 lightning network invoice
-     * @private
+     *
      * @throws {IntermediaryError} in case the response is invalid
+     *
+     * @private
      */
     private verifyReturnedData(
         resp: FromBTCLNResponseType,
@@ -171,18 +202,21 @@ export class FromBTCLNWrapper<
     }
 
     /**
-     * Returns a newly created swap, receiving 'amount' on lightning network
+     * Returns a newly created legacy Lightning -> Smart chain swap using the HTLC based escrow swap protocol,
+     *  where the user needs to manually settle swap on the destination smart chain. The user has to pay
+     *  a bolt11 invoice on the input lightning network side.
      *
-     * @param signer                Smart chain signer's address intiating the swap
-     * @param amountData            Amount of token & amount to swap
-     * @param lps                   LPs (liquidity providers) to get the quotes from
-     * @param options               Quote options
-     * @param additionalParams      Additional parameters sent to the LP when creating the swap
-     * @param abortSignal           Abort signal for aborting the process
-     * @param preFetches
+     * @param recipient Smart chain signer's address on the destination chain, that will have to manually
+     *  settle the swap.
+     * @param amountData Amount, token and exact input/output data for to swap
+     * @param lps An array of intermediaries (LPs) to get the quotes from
+     * @param options Optional additional quote options
+     * @param additionalParams Optional additional parameters sent to the LP when creating the swap
+     * @param abortSignal Abort signal
+     * @param preFetches Optional pre-fetches for speeding up the quoting process (mainly used internally)
      */
     create(
-        signer: string,
+        recipient: string,
         amountData: AmountData,
         lps: Intermediary[],
         options?: FromBTCLNOptions,
@@ -198,20 +232,20 @@ export class FromBTCLNWrapper<
         intermediary: Intermediary
     }[] {
         if(options==null) options = {};
-        options.unsafeSkipLnNodeCheck ??= this.options.unsafeSkipLnNodeCheck;
+        options.unsafeSkipLnNodeCheck ??= this._options.unsafeSkipLnNodeCheck;
 
         if(options.descriptionHash!=null && options.descriptionHash.length!==32)
             throw new UserError("Invalid description hash length");
 
         const {secret, paymentHash} = this.getSecretAndHash();
-        const claimHash = this.contract.getHashForHtlc(paymentHash);
+        const claimHash = this._contract.getHashForHtlc(paymentHash);
 
-        const nativeTokenAddress = this.chain.getNativeCurrencyAddress();
+        const nativeTokenAddress = this._chain.getNativeCurrencyAddress();
 
         const _abortController = extendAbortController(abortSignal);
         const _preFetches = {
             pricePrefetchPromise: preFetches?.pricePrefetchPromise ?? this.preFetchPrice(amountData, _abortController.signal),
-            feeRatePromise: preFetches?.feeRatePromise ?? this.preFetchFeeRate(signer, amountData, claimHash.toString("hex"), _abortController),
+            feeRatePromise: preFetches?.feeRatePromise ?? this.preFetchFeeRate(recipient, amountData, claimHash.toString("hex"), _abortController),
             usdPricePrefetchPromise: preFetches?.usdPricePrefetchPromise ?? this.preFetchUsdPrice(_abortController.signal),
         }
 
@@ -231,14 +265,14 @@ export class FromBTCLNWrapper<
                             {
                                 paymentHash,
                                 amount: amountData.amount,
-                                claimer: signer,
+                                claimer: recipient,
                                 token: amountData.token.toString(),
                                 descriptionHash: options?.descriptionHash,
                                 exactOut: !amountData.exactIn,
                                 feeRate: throwIfUndefined(_preFetches.feeRatePromise),
                                 additionalParams
                             },
-                            this.options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
+                            this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
                         );
 
                         return {
@@ -270,8 +304,8 @@ export class FromBTCLNWrapper<
                             swapFee: resp.swapFee,
                             swapFeeBtc: resp.swapFee * amountIn / (resp.total - resp.swapFee),
                             feeRate: (await _preFetches.feeRatePromise)!,
-                            initialSwapData: await this.contract.createSwapData(
-                                ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), signer, amountData.token,
+                            initialSwapData: await this._contract.createSwapData(
+                                ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), recipient, amountData.token,
                                 resp.total, claimHash.toString("hex"),
                                 this.getRandomSequence(), BigInt(Math.floor(Date.now()/1000)), false, true,
                                 resp.securityDeposit, 0n, nativeTokenAddress
@@ -292,17 +326,21 @@ export class FromBTCLNWrapper<
     }
 
     /**
-     * Returns a newly created swap, receiving 'amount' from the lnurl-withdraw
+     * Returns a newly created legacy Lightning -> Smart chain swap using the HTLC based escrow swap protocol,
+     *  where the user needs to manually settle swap on the destination smart chain. The swap is created
+     *  with an LNURL-withdraw link which will be used to pay the generated bolt11 invoice automatically
+     *  when {@link FromBTCLNSwap.waitForPayment} is called on the swap.
      *
-     * @param signer                Smart chains signer's address intiating the swap
-     * @param lnurl                 LNURL-withdraw to withdraw funds from
-     * @param amountData            Amount of token & amount to swap
-     * @param lps                   LPs (liquidity providers) to get the quotes from
-     * @param additionalParams      Additional parameters sent to the LP when creating the swap
-     * @param abortSignal           Abort signal for aborting the process
+     * @param recipient Smart chain signer's address on the destination chain, that will have to manually
+     *  settle the swap.
+     * @param lnurl LNURL-withdraw link to pull the funds from
+     * @param amountData Amount, token and exact input/output data for to swap
+     * @param lps An array of intermediaries (LPs) to get the quotes from
+     * @param additionalParams Optional additional parameters sent to the LP when creating the swap
+     * @param abortSignal Abort signal
      */
     async createViaLNURL(
-        signer: string,
+        recipient: string,
         lnurl: string | LNURLWithdrawParamsWithUrl,
         amountData: AmountData,
         lps: Intermediary[],
@@ -318,12 +356,12 @@ export class FromBTCLNWrapper<
         const preFetches = {
             pricePrefetchPromise: this.preFetchPrice(amountData, abortController.signal),
             usdPricePrefetchPromise: this.preFetchUsdPrice(abortController.signal),
-            feeRatePromise: this.preFetchFeeRate(signer, amountData, undefined, abortController)
+            feeRatePromise: this.preFetchFeeRate(recipient, amountData, undefined, abortController)
         };
 
         try {
             const exactOutAmountPromise: Promise<bigint | undefined> | undefined = !amountData.exactIn ? preFetches.pricePrefetchPromise.then(price =>
-                this.prices.getToBtcSwapAmount(this.chainIdentifier, amountData.amount, amountData.token, abortController.signal, price)
+                this._prices.getToBtcSwapAmount(this.chainIdentifier, amountData.amount, amountData.token, abortController.signal, price)
             ).catch(e => {
                 abortController.abort(e);
                 return undefined;
@@ -345,12 +383,14 @@ export class FromBTCLNWrapper<
                 if((amount * 105n / 100n) > max) throw new UserError("Amount more than LNURL-withdraw maximum");
             }
 
-            return this.create(signer, amountData, lps, undefined, additionalParams, abortSignal, preFetches).map(data => {
+            return this.create(recipient, amountData, lps, undefined, additionalParams, abortSignal, preFetches).map(data => {
                 return {
                     quote: data.quote.then(quote => {
-                        quote.lnurl = withdrawRequest.url;
-                        quote.lnurlK1 = withdrawRequest.k1;
-                        quote.lnurlCallback = withdrawRequest.callback;
+                        quote._setLNURLData(
+                            withdrawRequest.url,
+                            withdrawRequest.k1,
+                            withdrawRequest.callback
+                        )
 
                         const amountIn = quote.getInput().rawAmount!;
                         if(amountIn < min) throw new UserError("Amount less than LNURL-withdraw minimum");
@@ -367,6 +407,10 @@ export class FromBTCLNWrapper<
         }
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected async _checkPastSwaps(pastSwaps: FromBTCLNSwap<T>[]): Promise<{
         changedSwaps: FromBTCLNSwap<T>[];
         removeSwaps: FromBTCLNSwap<T>[]
@@ -374,7 +418,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: (FromBTCLNSwap<T> & {_data: T["Data"]})[] = [];
 
         await Promise.all(pastSwaps.map(async (pastSwap) => {
             if(pastSwap._shouldCheckIntermediary()) {
@@ -391,13 +435,13 @@ export class FromBTCLNWrapper<
                 //Check expiry
                 swapExpiredStatus[pastSwap.getId()] = await pastSwap._verifyQuoteDefinitelyExpired();
             }
-            if(pastSwap._shouldFetchCommitStatus()) {
+            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.push(pastSwap as (FromBTCLNSwap<T> & {_data: T["Data"]}));
             }
         }));
 
-        const swapStatuses = await this.contract.getCommitStatuses(checkStatusSwaps.map(val => ({signer: val._getInitiator(), swapData: val.data})));
+        const swapStatuses = await this._contract.getCommitStatuses(checkStatusSwaps.map(val => ({signer: val._getInitiator(), swapData: val._data})));
 
         for(let pastSwap of checkStatusSwaps) {
             const shouldSave = await pastSwap._sync(
@@ -425,4 +469,54 @@ export class FromBTCLNWrapper<
         };
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async recoverFromSwapDataAndState(
+        init: {data: T["Data"], getInitTxId: () => Promise<string>, getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>},
+        state: SwapCommitState,
+        lp?: Intermediary
+    ): Promise<FromBTCLNSwap<T> | null> {
+        const data = init.data;
+
+        let paymentHash = data.getHTLCHashHint();
+        let secret: string | undefined;
+        if(state.type===SwapCommitStateType.PAID) {
+            secret = await state.getClaimResult();
+            paymentHash = Buffer.from(sha256(Buffer.from(secret, "hex"))).toString("hex");
+        }
+
+        const swapInit: FromBTCLNSwapInit<T["Data"]> = {
+            pricingInfo: {
+                isValid: true,
+                satsBaseFee: 0n,
+                swapPriceUSatPerToken: 100_000_000_000_000n,
+                realPriceUSatPerToken: 100_000_000_000_000n,
+                differencePPM: 0n,
+                feePPM: 0n,
+            },
+            url: lp?.url,
+            expiry: 0,
+            swapFee: 0n,
+            swapFeeBtc: 0n,
+            feeRate: "",
+            signatureData: undefined,
+            initialSwapData: data,
+            data,
+            pr: paymentHash ?? undefined,
+            secret,
+            exactIn: false
+        }
+        const swap = new FromBTCLNSwap(this, swapInit);
+        swap._commitTxId = await init.getInitTxId();
+        const blockData = await init.getTxBlock();
+        swap.createdAt = blockData.blockTime * 1000;
+        swap._setInitiated();
+        swap._state = FromBTCLNSwapState.CLAIM_COMMITED;
+        await swap._sync(false, false, state);
+        await swap._save();
+        return swap;
+    }
+
 }