@atomiqlabs/sdk 8.1.8 → 8.3.1

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.js

@@ -3,26 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IEscrowSwapWrapper = void 0;
 const ISwapWrapper_1 = require("../ISwapWrapper");
 const base_1 = require("@atomiqlabs/base");
+/**
+ * Base class for wrappers of escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives)
+ *
+ * @category Swaps
+ */
 class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
     constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, options, events) {
         super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
-        this.swapDataDeserializer = swapDataDeserializer;
-        this.contract = contract;
+        this._swapDataDeserializer = swapDataDeserializer;
+        this._contract = contract;
     }
     /**
      * Pre-fetches signature verification data from the server's pre-sent promise, doesn't throw, instead returns null
      *
      * @param signDataPrefetch Promise that resolves when we receive "signDataPrefetch" from the LP in streaming mode
-     * @protected
      * @returns Pre-fetched signature verification data or null if failed
+     *
+     * @internal
      */
     preFetchSignData(signDataPrefetch) {
-        if (this.contract.preFetchForInitSignatureVerification == null)
+        if (this._contract.preFetchForInitSignatureVerification == null)
             return Promise.resolve(undefined);
         return signDataPrefetch.then(obj => {
             if (obj == null)
                 return undefined;
-            return this.contract.preFetchForInitSignatureVerification(obj);
+            return this._contract.preFetchForInitSignatureVerification(obj);
         }).catch(e => {
             this.logger.error("preFetchSignData(): Error: ", e);
         });
@@ -36,20 +42,22 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
      * @param feeRatePromise Pre-fetched fee rate promise
      * @param preFetchSignatureVerificationData Pre-fetched signature verification data
      * @param abortSignal
-     * @protected
      * @returns Swap initialization signature expiry
      * @throws {SignatureVerificationError} when swap init signature is invalid
+     *
+     * @internal
      */
     async verifyReturnedSignature(initiator, data, signature, feeRatePromise, preFetchSignatureVerificationData, abortSignal) {
         const [feeRate, preFetchedSignatureData] = await Promise.all([feeRatePromise, preFetchSignatureVerificationData]);
-        await this.contract.isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
-        return await this.contract.getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
+        await this._contract.isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
+        return await this._contract.getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
     }
     /**
      * Processes a single SC on-chain event
-     * @private
      * @param event
      * @param swap
+     *
+     * @internal
      */
     async processEvent(event, swap) {
         if (swap == null)
@@ -57,22 +65,22 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
         let swapChanged = false;
         if (event instanceof base_1.InitializeEvent) {
             swapChanged = await this.processEventInitialize(swap, event);
-            if (event.meta?.txId != null && swap.commitTxId !== event.meta.txId) {
-                swap.commitTxId = event.meta.txId;
+            if (event.meta?.txId != null && swap._commitTxId !== event.meta.txId) {
+                swap._commitTxId = event.meta.txId;
                 swapChanged ||= true;
             }
         }
         if (event instanceof base_1.ClaimEvent) {
             swapChanged = await this.processEventClaim(swap, event);
-            if (event.meta?.txId != null && swap.claimTxId !== event.meta.txId) {
-                swap.claimTxId = event.meta.txId;
+            if (event.meta?.txId != null && swap._claimTxId !== event.meta.txId) {
+                swap._claimTxId = event.meta.txId;
                 swapChanged ||= true;
             }
         }
         if (event instanceof base_1.RefundEvent) {
             swapChanged = await this.processEventRefund(swap, event);
-            if (event.meta?.txId != null && swap.refundTxId !== event.meta.txId) {
-                swap.refundTxId = event.meta.txId;
+            if (event.meta?.txId != null && swap._refundTxId !== event.meta.txId) {
+                swap._refundTxId = event.meta.txId;
                 swapChanged ||= true;
             }
         }
@@ -81,6 +89,10 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
             await swap._saveAndEmit();
         }
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _checkPastSwaps(pastSwaps) {
         const changedSwaps = [];
         const removeSwaps = [];
@@ -91,13 +103,13 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
                 //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)
+                if (pastSwap._data != null)
                     checkStatusSwaps.push(pastSwap);
             }
         }
-        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 escrowHash = pastSwap.getEscrowHash();
             const shouldSave = await pastSwap._sync(false, swapExpiredStatus[pastSwap.getId()], escrowHash == null ? undefined : swapStatuses[escrowHash]);
@@ -115,8 +127,5 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
             removeSwaps
         };
     }
-    recoverFromSwapDataAndState(init, state, lp) {
-        return Promise.resolve(null);
-    }
 }
 exports.IEscrowSwapWrapper = IEscrowSwapWrapper;

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.d.ts

@@ -14,7 +14,15 @@ import { PaymentRequestObject, TagsObject } from "@atomiqlabs/bolt11";
 import { IEscrowSwap } from "../IEscrowSwap";
 import { LNURLWithdrawParamsWithUrl } from "../../../types/lnurl/LNURLWithdraw";
 export type IFromBTCLNDefinition<T extends ChainType, W extends IFromBTCLNWrapper<T, any>, S extends IEscrowSwap<T>> = IFromBTCDefinition<T, W, S>;
+/**
+ * Base class for wrappers of escrow-based Lightning -> Smart chain swaps
+ *
+ * @category Swaps
+ */
 export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends IFromBTCLNDefinition<T, IFromBTCLNWrapper<T, D>, IEscrowSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends IFromBTCWrapper<T, D, O> {
+    /**
+     * @internal
+     */
     protected readonly lnApi: LightningNetworkApi;
     /**
      * @param chainIdentifier
@@ -33,16 +41,11 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
         swapState: [IEscrowSwap];
     }>);
     /**
-     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
-     *
-     * @param data Parsed swap data
-     */
-    getHtlcTimeout(data: SwapData): bigint;
-    /**
-     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap\
+     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap
      *
-     * @private
      * @returns Hash pre-image & payment hash
+     *
+     * @internal
      */
     protected getSecretAndHash(): {
         secret: Buffer;
@@ -51,10 +54,12 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
     /**
      * Pre-fetches intermediary's LN node capacity, doesn't throw, instead returns null
      *
-     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary thorugh
+     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary through
      *  streaming
-     * @private
+     *
      * @returns LN Node liquidity
+     *
+     * @internal
      */
     protected preFetchLnCapacity(pubkeyPromise: Promise<string | null>): Promise<LNNodeLiquidity | null>;
     /**
@@ -62,13 +67,14 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
      *
      * @param lp Intermediary
      * @param decodedPr Decoded bolt11 lightning network invoice
-     * @param amountIn Amount to be paid for the swap in sats
      * @param lnCapacityPrefetchPromise Pre-fetch for LN node capacity, preFetchLnCapacity()
-     * @param abortSignal
-     * @private
+     * @param abortSignal Abort signal
+     *
      * @throws {IntermediaryError} if the lightning network node doesn't have enough inbound liquidity
      * @throws {Error} if the lightning network node's inbound liquidity might be enough, but the swap would
      *  deplete more than half of the liquidity
+     *
+     * @internal
      */
     protected verifyLnNodeCapacity(lp: Intermediary, decodedPr: PaymentRequestObject & {
         tagsObject: TagsObject;
@@ -77,9 +83,19 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
      * Parses and fetches lnurl withdraw params from the specified lnurl
      *
      * @param lnurl LNURL to be parsed and fetched
-     * @param abortSignal
-     * @private
+     * @param abortSignal Abort signal
+     *
      * @throws {UserError} if the LNURL is invalid or if it's not a LNURL-withdraw
+     *
+     * @internal
      */
     protected getLNURLWithdraw(lnurl: string | LNURLWithdrawParamsWithUrl, abortSignal: AbortSignal): Promise<LNURLWithdrawParamsWithUrl>;
+    /**
+     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
+     *
+     * @param data Parsed swap data
+     *
+     * @internal
+     */
+    _getHtlcTimeout(data: SwapData): bigint;
 }

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.js

@@ -8,6 +8,11 @@ const IntermediaryError_1 = require("../../../errors/IntermediaryError");
 const LNURL_1 = require("../../../lnurl/LNURL");
 const UserError_1 = require("../../../errors/UserError");
 const sha256_1 = require("@noble/hashes/sha256");
+/**
+ * Base class for wrappers of escrow-based Lightning -> Smart chain swaps
+ *
+ * @category Swaps
+ */
 class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
     /**
      * @param chainIdentifier
@@ -27,18 +32,11 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
         this.lnApi = lnApi;
     }
     /**
-     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
+     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap
      *
-     * @param data Parsed swap data
-     */
-    getHtlcTimeout(data) {
-        return data.getExpiry() - 600n;
-    }
-    /**
-     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap\
-     *
-     * @private
      * @returns Hash pre-image & payment hash
+     *
+     * @internal
      */
     getSecretAndHash() {
         const secret = (0, Utils_1.randomBytes)(32);
@@ -48,10 +46,12 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
     /**
      * Pre-fetches intermediary's LN node capacity, doesn't throw, instead returns null
      *
-     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary thorugh
+     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary through
      *  streaming
-     * @private
+     *
      * @returns LN Node liquidity
+     *
+     * @internal
      */
     preFetchLnCapacity(pubkeyPromise) {
         return pubkeyPromise.then(pubkey => {
@@ -68,13 +68,14 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
      *
      * @param lp Intermediary
      * @param decodedPr Decoded bolt11 lightning network invoice
-     * @param amountIn Amount to be paid for the swap in sats
      * @param lnCapacityPrefetchPromise Pre-fetch for LN node capacity, preFetchLnCapacity()
-     * @param abortSignal
-     * @private
+     * @param abortSignal Abort signal
+     *
      * @throws {IntermediaryError} if the lightning network node doesn't have enough inbound liquidity
      * @throws {Error} if the lightning network node's inbound liquidity might be enough, but the swap would
      *  deplete more than half of the liquidity
+     *
+     * @internal
      */
     async verifyLnNodeCapacity(lp, decodedPr, lnCapacityPrefetchPromise, abortSignal) {
         if (decodedPr.payeeNodeKey == null)
@@ -84,6 +85,8 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
         const _result = await lnCapacityPrefetchPromise ?? await this.lnApi.getLNNodeLiquidity(decodedPr.payeeNodeKey);
         if (_result === null)
             throw new IntermediaryError_1.IntermediaryError("LP's lightning node not found in the lightning network graph!");
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
         lp.lnData = _result;
         if (decodedPr.payeeNodeKey !== _result.publicKey)
             throw new IntermediaryError_1.IntermediaryError("Invalid pr returned - payee pubkey");
@@ -97,19 +100,31 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
      * Parses and fetches lnurl withdraw params from the specified lnurl
      *
      * @param lnurl LNURL to be parsed and fetched
-     * @param abortSignal
-     * @private
+     * @param abortSignal Abort signal
+     *
      * @throws {UserError} if the LNURL is invalid or if it's not a LNURL-withdraw
+     *
+     * @internal
      */
     async getLNURLWithdraw(lnurl, abortSignal) {
         if (typeof (lnurl) !== "string")
             return lnurl;
-        const res = await LNURL_1.LNURL.getLNURL(lnurl, true, this.options.getRequestTimeout, abortSignal);
+        const res = await LNURL_1.LNURL.getLNURL(lnurl, true, this._options.getRequestTimeout, abortSignal);
         if (res == null)
             throw new UserError_1.UserError("Invalid LNURL");
         if (res.tag !== "withdrawRequest")
             throw new UserError_1.UserError("Not a LNURL-withdrawal");
         return res;
     }
+    /**
+     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
+     *
+     * @param data Parsed swap data
+     *
+     * @internal
+     */
+    _getHtlcTimeout(data) {
+        return data.getExpiry() - 600n;
+    }
 }
 exports.IFromBTCLNWrapper = IFromBTCLNWrapper;

package/dist/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.d.ts

@@ -6,88 +6,153 @@ import { IEscrowSelfInitSwap, IEscrowSelfInitSwapDefinition, IEscrowSelfInitSwap
 import { FeeType } from "../../../enums/FeeType";
 import { TokenAmount } from "../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../types/Token";
+import { IClaimableSwap } from "../../IClaimableSwap";
 export type IFromBTCSelfInitDefinition<T extends ChainType, W extends IFromBTCWrapper<T, any>, S extends IFromBTCSelfInitSwap<T>> = IEscrowSelfInitSwapDefinition<T, W, S>;
-export declare abstract class IFromBTCSelfInitSwap<T extends ChainType = ChainType, D extends IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, D>, IFromBTCSelfInitSwap<T, D, S>> = IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, any>, IFromBTCSelfInitSwap<T, any, any>>, S extends number = number> extends IEscrowSelfInitSwap<T, D, S> implements IAddressSwap {
+/**
+ * Base class for legacy escrow-based Bitcoin (on-chain & lightning) -> Smart chain swaps,
+ *  which require the user to manually initiate the escrow on the destination smart chain
+ *
+ * @category Swaps
+ */
+export declare abstract class IFromBTCSelfInitSwap<T extends ChainType = ChainType, D extends IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, D>, IFromBTCSelfInitSwap<T, D, S>> = IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, any>, IFromBTCSelfInitSwap<T, any, any>>, S extends number = number> extends IEscrowSelfInitSwap<T, D, S> implements IAddressSwap, IClaimableSwap<T, D, S> {
+    /**
+     * @internal
+     */
     protected abstract readonly inputToken: BtcToken;
     protected constructor(wrapper: D["Wrapper"], init: IEscrowSelfInitSwapInit<T["Data"]>);
     protected constructor(wrapper: D["Wrapper"], obj: any);
     /**
-     * In case swapFee in BTC is not supplied it recalculates it based on swap price
-     * @protected
+     * @inheritDoc
+     * @internal
      */
     protected tryRecomputeSwapPrice(): void;
     /**
-     * Returns the bitcoin address or lightning invoice to be paid for the swap
+     * @inheritDoc
      */
     abstract getAddress(): string;
     /**
-     * Returns a string that can be displayed as QR code representation of the address or lightning invoice
-     *  (with bitcoin: or lightning: prefix)
+     * @inheritDoc
      */
     abstract getHyperlink(): string;
+    /**
+     * @inheritDoc
+     */
     abstract isClaimable(): boolean;
     /**
      * Returns if the swap can be committed
+     * @internal
      */
     protected abstract canCommit(): boolean;
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getInitiator(): string;
+    /**
+     * @inheritDoc
+     */
     getOutputTxId(): string | null;
+    /**
+     * @inheritDoc
+     */
     getOutputAddress(): string | null;
+    /**
+     * @inheritDoc
+     */
     requiresAction(): boolean;
+    /**
+     * Returns the swap output amount in destination token based units without any fees, this
+     *  value is therefore always higher than the actual received output.
+     *
+     * @internal
+     */
     protected getOutAmountWithoutFee(): bigint;
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
     protected getSwapFee(): Fee<T["ChainId"], BtcToken, SCToken<T["ChainId"]>>;
+    /**
+     * @inheritDoc
+     */
     getFee(): Fee;
+    /**
+     * @inheritDoc
+     */
     getFeeBreakdown(): [{
         type: FeeType.SWAP;
         fee: Fee<T["ChainId"], BtcToken, SCToken<T["ChainId"]>>;
     }];
+    /**
+     * @inheritDoc
+     */
     getOutputToken(): SCToken<T["ChainId"]>;
+    /**
+     * @inheritDoc
+     */
     getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
+    /**
+     * @inheritDoc
+     */
     abstract getInput(): TokenAmount<T["ChainId"], BtcToken>;
+    /**
+     * @inheritDoc
+     */
     getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken>;
-    getSecurityDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
-    getTotalDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
+    /**
+     * @inheritDoc
+     */
     hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean;
         balance: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
         required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
     }>;
     /**
-     * Returns the transactions required for committing the swap on-chain, locking the tokens from the intermediary
-     *  in an HTLC or PTLC
+     * Returns the amount of native token of the destination chain locked up during initialization of the escrow
+     *  to act as a security deposit that can be taken by the intermediary (LP) if the user doesn't go through
+     *  with the swap
+     */
+    getSecurityDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
+    /**
+     * Returns the total amount of native token of the destination chain locked up during initialization of the escrow.
+     *  This covers the security deposit and the watchtower fee (if applicable), it is calculated a maximum of those
+     *  two values.
+     */
+    getTotalDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
+    /**
+     * Creates the escrow on the destination smart chain side, pre-locking the tokens from the intermediary (LP)
+     *  into an escrow.
+     *
+     * @inheritDoc
      *
-     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
-     *  (this is handled when swap is created (quoted), if you commit right after quoting, you can use skipChecks=true)
      * @throws {Error} When in invalid state to commit the swap
      */
     txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
     /**
-     * Commits the swap on-chain, locking the tokens from the intermediary in an HTLC or PTLC
+     * Creates the escrow on the destination smart chain side, pre-locking the tokens from the intermediary (LP)
+     *  into an escrow.
+     *
+     * @inheritDoc
      *
-     * @param signer Signer to sign the transactions with, must be the same as used in the initialization
-     * @param abortSignal Abort signal to stop waiting for the transaction confirmation and abort
-     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
-     *  (this is handled when swap is created (quoted), if you commit right after quoting, you can use skipChecks=true)
      * @throws {Error} If invalid signer is provided that doesn't match the swap data
      */
     abstract commit(signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean): Promise<string>;
-    abstract waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
-    getClaimFee(): Promise<bigint>;
+    /**
+     * Returns the transaction fee required for the claim transaction to settle the escrow on the destination
+     *  smart chain
+     */
+    getClaimNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>>;
+    /**
+     * @inheritDoc
+     */
     abstract txsClaim(signer?: T["Signer"]): Promise<T["TX"][]>;
     /**
-     * Claims and finishes the swap
-     *
-     * @param signer Signer to sign the transactions with, can also be different to the initializer
-     * @param abortSignal Abort signal to stop waiting for transaction confirmation
+     * @inheritDoc
      */
     abstract claim(signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
     /**
-     * Waits till the swap is successfully claimed
-     *
-     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
-     * @param abortSignal AbortSignal
-     * @throws {Error} If swap is in invalid state (must be COMMIT)
-     * @returns {boolean} whether the swap was claimed in time or not
+     * @inheritDoc
      */
     abstract waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
 }