@atomiqlabs/sdk 8.1.8 → 8.3.1

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

@@ -10,9 +10,24 @@ export type IEscrowSelfInitSwapInit<T extends SwapData> = IEscrowSwapInit<T> & {
 };
 export declare function isIEscrowSelfInitSwapInit<T extends SwapData>(obj: any): obj is IEscrowSelfInitSwapInit<T>;
 export type IEscrowSelfInitSwapDefinition<T extends ChainType, W extends IEscrowSwapWrapper<T, any>, S extends IEscrowSelfInitSwap<T>> = SwapTypeDefinition<T, W, S>;
+/**
+ * Base class for escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives) where the
+ *  user needs to initiate the escrow on the smart chain side
+ *
+ * @category Swaps
+ */
 export declare abstract class IEscrowSelfInitSwap<T extends ChainType = ChainType, D extends IEscrowSelfInitSwapDefinition<T, IEscrowSwapWrapper<T, D>, IEscrowSelfInitSwap<T, D, S>> = IEscrowSwapDefinition<T, IEscrowSwapWrapper<T, any>, IEscrowSelfInitSwap<T, any, any>>, S extends number = number> extends IEscrowSwap<T, D, S> {
-    feeRate: string;
-    signatureData?: SignatureData;
+    /**
+     * Fee rate to be used for the escrow initiation transaction
+     * @internal
+     */
+    protected readonly feeRate: string;
+    /**
+     * Signature data received from the intermediary (LP) allowing the user
+     *  to initiate the swap escrow
+     * @internal
+     */
+    protected signatureData?: SignatureData;
     protected constructor(wrapper: D["Wrapper"], obj: any);
     protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSelfInitSwapInit<T["Data"]>);
     /**
@@ -20,27 +35,52 @@ export declare abstract class IEscrowSelfInitSwap<T extends ChainType = ChainTyp
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     protected watchdogWaitTillSignatureExpiry(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<void>;
     /**
      * Get the estimated smart chain fee of the commit transaction
+     * @internal
      */
     protected getCommitFee(): Promise<bigint>;
     /**
-     * Returns the transaction fee paid on the smart chain
+     * Returns the transaction fee paid on the smart chain side to initiate the escrow
      */
     getSmartChainNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>>;
     /**
-     * Checks if the initiator/sender has enough balance to cover the transaction fee for processing the swap
+     * Checks if the initiator/sender has enough balance on the smart chain side
+     *  to cover the transaction fee for processing the swap
      */
     abstract hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean;
         balance: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
         required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
     }>;
+    /**
+     * Returns transactions for initiating (committing) the escrow on the smart chain side
+     *
+     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
+     *  (this is handled on swap creation, if you commit right after quoting, you can use `skipChecks=true`)
+     */
     abstract txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
+    /**
+     * Initiates (commits) the escrow on the smart chain side
+     *
+     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
+     * @param abortSignal Abort signal
+     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
+     *  (this is handled on swap creation, if you commit right after quoting, you can use `skipChecks=true`)
+     * @param onBeforeTxSent Callback called before the transactions are broadcasted
+     */
     abstract commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    /**
+     * Waits till a swap is initiated (committed) on-chain, should be called after sending the commit
+     *  transactions ({@link txsCommit}) manually to wait till the SDK processes the escrow
+     *  initialization and updates the swap state accordingly
+     *
+     * @param abortSignal AbortSignal
+     */
+    abstract waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
     /**
      * Checks if the swap's quote is expired for good (i.e. the swap strictly cannot be committed on-chain anymore)
      */
@@ -48,6 +88,9 @@ export declare abstract class IEscrowSelfInitSwap<T extends ChainType = ChainTyp
     /**
      * Checks if the swap's quote is still valid
      */
-    verifyQuoteValid(): Promise<boolean>;
+    _verifyQuoteValid(): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
     serialize(): any;
 }

package/dist/swaps/escrow_swaps/IEscrowSelfInitSwap.js

@@ -15,6 +15,12 @@ function isIEscrowSelfInitSwapInit(obj) {
         (0, IEscrowSwap_1.isIEscrowSwapInit)(obj);
 }
 exports.isIEscrowSelfInitSwapInit = isIEscrowSelfInitSwapInit;
+/**
+ * Base class for escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives) where the
+ *  user needs to initiate the escrow on the smart chain side
+ *
+ * @category Swaps
+ */
 class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
     constructor(wrapper, swapInitOrObj) {
         super(wrapper, swapInitOrObj);
@@ -39,17 +45,17 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     async watchdogWaitTillSignatureExpiry(intervalSeconds, abortSignal) {
-        if (this.data == null || this.signatureData == null)
+        if (this._data == null || this.signatureData == null)
             throw new Error("Tried to await signature expiry but data or signature is null, invalid state?");
         intervalSeconds ??= 5;
         let expired = false;
         while (!expired) {
             await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
             try {
-                expired = await this.wrapper.contract.isInitAuthorizationExpired(this.data, this.signatureData);
+                expired = await this.wrapper._contract.isInitAuthorizationExpired(this._data, this.signatureData);
             }
             catch (e) {
                 this.logger.error("watchdogWaitTillSignatureExpiry(): Error when checking signature expiry: ", e);
@@ -62,18 +68,19 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
     //// Amounts & fees
     /**
      * Get the estimated smart chain fee of the commit transaction
+     * @internal
      */
     getCommitFee() {
-        return this.wrapper.contract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate);
+        return this.wrapper._contract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate);
     }
     /**
-     * Returns the transaction fee paid on the smart chain
+     * Returns the transaction fee paid on the smart chain side to initiate the escrow
      */
     async getSmartChainNetworkFee() {
-        const swapContract = this.wrapper.contract;
+        const swapContract = this.wrapper._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);
+            swapContract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate)), this.wrapper._getNativeToken(), this.wrapper._prices);
     }
     //////////////////////////////
     //// Quote verification
@@ -81,18 +88,18 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
      * Checks if the swap's quote is expired for good (i.e. the swap strictly cannot be committed on-chain anymore)
      */
     async _verifyQuoteDefinitelyExpired() {
-        if (this.data == null || this.signatureData == null)
+        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.wrapper._contract.isInitAuthorizationExpired(this._data, this.signatureData);
     }
     /**
      * Checks if the swap's quote is still valid
      */
-    async verifyQuoteValid() {
-        if (this.data == null || this.signatureData == null)
+    async _verifyQuoteValid() {
+        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.wrapper._contract.isValidInitAuthorization(this._getInitiator(), this._data, this.signatureData, this.feeRate);
             return true;
         }
         catch (e) {
@@ -102,6 +109,9 @@ class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
             throw e;
         }
     }
+    /**
+     * @inheritDoc
+     */
     serialize() {
         return {
             ...super.serialize(),

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

@@ -8,43 +8,74 @@ export type IEscrowSwapInit<T extends SwapData> = ISwapInit & {
     data?: T;
 };
 export declare function isIEscrowSwapInit<T extends SwapData>(obj: any): obj is IEscrowSwapInit<T>;
+/**
+ * Base class for escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives)
+ *
+ * @category Swaps
+ */
 export declare abstract class IEscrowSwap<T extends ChainType = ChainType, D extends IEscrowSwapDefinition<T, IEscrowSwapWrapper<T, D>, IEscrowSwap<T, D, S>> = IEscrowSwapDefinition<T, IEscrowSwapWrapper<T, any>, IEscrowSwap<T, any, any>>, S extends number = number> extends ISwap<T, D, S> {
-    data?: T["Data"];
+    /**
+     * @internal
+     */
+    _data?: T["Data"];
     /**
      * Transaction IDs for the swap on the smart chain side
+     * @internal
+     */
+    _commitTxId?: string;
+    /**
+     * @internal
      */
-    commitTxId?: string;
-    refundTxId?: string;
-    claimTxId?: string;
+    _refundTxId?: string;
+    /**
+     * @internal
+     */
+    _claimTxId?: string;
     protected constructor(wrapper: D["Wrapper"], obj: any);
     protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSwapInit<T["Data"]>);
+    /**
+     * Returns the swap escrow data for this swap
+     *
+     * @internal
+     */
     protected abstract getSwapData(): T["Data"];
     /**
      * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
      *  lightning swaps the identifier hash is used instead of claim data hash
+     *
+     * @internal
      */
     protected getIdentifierHash(): Buffer;
     /**
      * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
      *  lightning swaps the identifier hash is used instead of claim data hash
+     *
+     * @internal
      */
     protected getIdentifierHashString(): string;
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getEscrowHash(): string | null;
     /**
      * Returns the escrow hash - i.e. hash of the escrow data
      */
     getEscrowHash(): string | null;
     /**
-     * Returns the claim data hash - i.e. hash passed to the claim handler
+     * Returns the claim data hash specifying the claim path of the escrow - i.e. hash passed to the claim handler
      */
     getClaimHash(): string;
+    /**
+     * @inheritDoc
+     */
     getId(): string;
     /**
      * Periodically checks the chain to see whether the swap is committed
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     protected watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
     /**
@@ -52,19 +83,41 @@ export declare abstract class IEscrowSwap<T extends ChainType = ChainType, D ext
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     protected watchdogWaitTillResult(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<SwapPaidState | SwapExpiredState | SwapNotCommitedState>;
     /**
-     * Checks if the swap's quote is expired for good (i.e. the swap strictly cannot be committed on-chain anymore)
+     * Whether on-chain state should be fetched for this swap
+     * @internal
      */
-    abstract _verifyQuoteDefinitelyExpired(): Promise<boolean>;
+    abstract _shouldFetchOnchainState(): boolean;
     /**
-     * Checks if the swap's quote is still valid
+     * Whether expiration status of the swap quote should be checked for this swap
+     * @internal
      */
-    abstract verifyQuoteValid(): Promise<boolean>;
-    abstract _shouldFetchCommitStatus(): boolean;
     abstract _shouldFetchExpiryStatus(): boolean;
+    /**
+     * @inheritDoc
+     *
+     * @param save Whether to save the new swap state or not
+     * @param quoteDefinitelyExpired Optionally pass whether the quote is definitely expired from a batch pre-fetch,
+     *  fetched on-demand if not provided
+     * @param commitStatus Optionally pass the quote on-chain state from a batch pre-fetch, fetched on-demand if
+     *  not provided
+     *
+     * @internal
+     */
     abstract _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean>;
+    /**
+     * Forcibly overrides current swap state from fetched on-chain swap state
+     *
+     * @param commitStatus Swap state fetched from the smart chain
+     *
+     * @internal
+     */
+    abstract _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
     serialize(): any;
 }

package/dist/swaps/escrow_swaps/IEscrowSwap.js

@@ -11,18 +11,23 @@ function isIEscrowSwapInit(obj) {
         (0, ISwap_1.isISwapInit)(obj);
 }
 exports.isIEscrowSwapInit = isIEscrowSwapInit;
+/**
+ * Base class for escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives)
+ *
+ * @category Swaps
+ */
 class IEscrowSwap extends ISwap_1.ISwap {
     constructor(wrapper, swapInitOrObj) {
         super(wrapper, swapInitOrObj);
         if (isIEscrowSwapInit(swapInitOrObj)) {
-            this.data = swapInitOrObj.data;
+            this._data = swapInitOrObj.data;
         }
         else {
             if (swapInitOrObj.data != null)
-                this.data = new wrapper.swapDataDeserializer(swapInitOrObj.data);
-            this.commitTxId = swapInitOrObj.commitTxId;
-            this.claimTxId = swapInitOrObj.claimTxId;
-            this.refundTxId = swapInitOrObj.refundTxId;
+                this._data = new wrapper._swapDataDeserializer(swapInitOrObj.data);
+            this._commitTxId = swapInitOrObj.commitTxId;
+            this._claimTxId = swapInitOrObj.claimTxId;
+            this._refundTxId = swapInitOrObj.refundTxId;
         }
     }
     //////////////////////////////
@@ -30,23 +35,31 @@ class IEscrowSwap extends ISwap_1.ISwap {
     /**
      * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
      *  lightning swaps the identifier hash is used instead of claim data hash
+     *
+     * @internal
      */
     getIdentifierHash() {
         const claimHashBuffer = buffer_1.Buffer.from(this.getClaimHash(), "hex");
-        if (this.randomNonce == null)
+        if (this._randomNonce == null)
             return claimHashBuffer;
-        return buffer_1.Buffer.concat([claimHashBuffer, buffer_1.Buffer.from(this.randomNonce, "hex")]);
+        return buffer_1.Buffer.concat([claimHashBuffer, buffer_1.Buffer.from(this._randomNonce, "hex")]);
     }
     /**
      * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
      *  lightning swaps the identifier hash is used instead of claim data hash
+     *
+     * @internal
      */
     getIdentifierHashString() {
         const identifierHash = this.getIdentifierHash();
         return identifierHash.toString("hex");
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getEscrowHash() {
-        return this.data?.getEscrowHash() ?? null;
+        return this._data?.getEscrowHash() ?? null;
     }
     /**
      * Returns the escrow hash - i.e. hash of the escrow data
@@ -55,11 +68,14 @@ class IEscrowSwap extends ISwap_1.ISwap {
         return this._getEscrowHash();
     }
     /**
-     * Returns the claim data hash - i.e. hash passed to the claim handler
+     * Returns the claim data hash specifying the claim path of the escrow - i.e. hash passed to the claim handler
      */
     getClaimHash() {
         return this.getSwapData().getClaimHash();
     }
+    /**
+     * @inheritDoc
+     */
     getId() {
         return this.getIdentifierHashString();
     }
@@ -70,17 +86,17 @@ class IEscrowSwap extends ISwap_1.ISwap {
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     async watchdogWaitTillCommited(intervalSeconds, abortSignal) {
-        if (this.data == null)
+        if (this._data == null)
             throw new Error("Tried to await commitment but data is null, invalid state?");
         intervalSeconds ??= 5;
         let status = { type: base_1.SwapCommitStateType.NOT_COMMITED };
         while (status?.type === base_1.SwapCommitStateType.NOT_COMMITED) {
             await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
             try {
-                status = await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
+                status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
                 if (status?.type === base_1.SwapCommitStateType.NOT_COMMITED &&
                     await this._verifyQuoteDefinitelyExpired())
                     return false;
@@ -98,17 +114,17 @@ class IEscrowSwap extends ISwap_1.ISwap {
      *
      * @param intervalSeconds How often to check (in seconds), default to 5s
      * @param abortSignal
-     * @protected
+     * @internal
      */
     async watchdogWaitTillResult(intervalSeconds, abortSignal) {
-        if (this.data == null)
+        if (this._data == null)
             throw new Error("Tried to await result but data is null, invalid state?");
         intervalSeconds ??= 5;
         let status = { type: base_1.SwapCommitStateType.COMMITED };
         while (status?.type === base_1.SwapCommitStateType.COMMITED || status?.type === base_1.SwapCommitStateType.REFUNDABLE) {
             await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
             try {
-                status = await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
+                status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
             }
             catch (e) {
                 this.logger.error("watchdogWaitTillResult(): Error when fetching commit status: ", e);
@@ -118,13 +134,16 @@ class IEscrowSwap extends ISwap_1.ISwap {
             abortSignal.throwIfAborted();
         return status;
     }
+    /**
+     * @inheritDoc
+     */
     serialize() {
         return {
             ...super.serialize(),
-            data: this.data != null ? this.data.serialize() : null,
-            commitTxId: this.commitTxId,
-            claimTxId: this.claimTxId,
-            refundTxId: this.refundTxId
+            data: this._data != null ? this._data.serialize() : null,
+            commitTxId: this._commitTxId,
+            claimTxId: this._claimTxId,
+            refundTxId: this._refundTxId
         };
     }
     ;

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

@@ -10,10 +10,21 @@ import { SwapType } from "../../enums/SwapType";
 import { IEscrowSwap } from "./IEscrowSwap";
 import { Intermediary } from "../../intermediaries/Intermediary";
 export type IEscrowSwapDefinition<T extends ChainType, W extends IEscrowSwapWrapper<T, any>, S extends IEscrowSwap<T>> = SwapTypeDefinition<T, W, S>;
+/**
+ * Base class for wrappers of escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives)
+ *
+ * @category Swaps
+ */
 export declare abstract class IEscrowSwapWrapper<T extends ChainType, D extends IEscrowSwapDefinition<T, IEscrowSwapWrapper<T, D>, IEscrowSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends ISwapWrapper<T, D, O> {
     readonly abstract TYPE: SwapType;
-    readonly contract: T["Contract"];
-    readonly swapDataDeserializer: new (data: any) => T["Data"];
+    /**
+     * @internal
+     */
+    readonly _contract: T["Contract"];
+    /**
+     * @internal
+     */
+    readonly _swapDataDeserializer: new (data: any) => T["Data"];
     constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], contract: T["Contract"], prices: ISwapPrice, tokens: WrapperCtorTokens, swapDataDeserializer: new (data: any) => T["Data"], options: O, events?: EventEmitter<{
         swapState: [ISwap];
     }>);
@@ -21,8 +32,9 @@ export declare abstract class IEscrowSwapWrapper<T extends ChainType, D extends
      * 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
      */
     protected preFetchSignData(signDataPrefetch: Promise<any | null>): Promise<T["PreFetchVerification"] | undefined>;
     /**
@@ -34,47 +46,65 @@ export declare abstract class IEscrowSwapWrapper<T extends ChainType, D extends
      * @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
      */
     protected verifyReturnedSignature(initiator: string, data: T["Data"], signature: SignatureData, feeRatePromise: Promise<any>, preFetchSignatureVerificationData: Promise<any>, abortSignal?: AbortSignal): Promise<number>;
     /**
      * Processes InitializeEvent for a given swap
      * @param swap
      * @param event
-     * @protected
      * @returns Whether the swap was updated/changed
+     *
+     * @internal
      */
     protected abstract processEventInitialize(swap: D["Swap"], event: InitializeEvent<T["Data"]>): Promise<boolean>;
     /**
      * Processes ClaimEvent for a given swap
      * @param swap
      * @param event
-     * @protected
      * @returns Whether the swap was updated/changed
+     *
+     * @internal
      */
     protected abstract processEventClaim(swap: D["Swap"], event: ClaimEvent<T["Data"]>): Promise<boolean>;
     /**
      * Processes RefundEvent for a given swap
      * @param swap
      * @param event
-     * @protected
      * @returns Whether the swap was updated/changed
+     *
+     * @internal
      */
     protected abstract processEventRefund(swap: D["Swap"], event: RefundEvent<T["Data"]>): Promise<boolean>;
     /**
      * Processes a single SC on-chain event
-     * @private
      * @param event
      * @param swap
+     *
+     * @internal
      */
     protected processEvent(event: SwapEvent<T["Data"]>, swap: D["Swap"]): Promise<void>;
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{
         changedSwaps: D["Swap"][];
         removeSwaps: D["Swap"][];
     }>;
-    recoverFromSwapDataAndState(init: {
+    /**
+     * Recovers a swap from smart chain on-chain data, please note that not all values for the recovered
+     *  swaps might be populated, as some data is purely off-chain and can never be recovered purely
+     *  from on-chain data.
+     *
+     * @param init Swap escrow initialization transaction and swap data
+     * @param state Current on-chain state of the swap
+     * @param lp Intermediary (LP) used as a counterparty for the swap
+     */
+    abstract recoverFromSwapDataAndState(init: {
         data: T["Data"];
         getInitTxId: () => Promise<string>;
         getTxBlock: () => Promise<{