@atomiqlabs/sdk 8.9.1 → 8.9.3

package/src/swaps/escrow_swaps/IEscrowSwapWrapper.ts

@@ -1,285 +1,285 @@
-import {ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens} from "../ISwapWrapper";
-import {
-    ChainType,
-    ClaimEvent,
-    InitializeEvent,
-    RefundEvent,
-    SignatureData,
-    SwapCommitState,
-    SwapEvent
-} from "@atomiqlabs/base";
-import {ISwap} from "../ISwap";
-import {UnifiedSwapStorage} from "../../storage/UnifiedSwapStorage";
-import {UnifiedSwapEventListener} from "../../events/UnifiedSwapEventListener";
-import {ISwapPrice} from "../../prices/abstract/ISwapPrice";
-import {EventEmitter} from "events";
-import {SwapType} from "../../enums/SwapType";
-import {IEscrowSwap} from "./IEscrowSwap";
-import {Intermediary} from "../../intermediaries/Intermediary";
-import {IntermediaryAPI} from "../../intermediaries/apis/IntermediaryAPI";
-
-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/Abstract
- */
-export 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;
-
-    /**
-     * @internal
-     */
-    readonly _contract: (version?: string) => T["Contract"] = (version?: string) => {
-        const _version = version ?? "v1";
-        const data = this._versionedContracts[_version];
-        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
-        return data.swapContract;
-    };
-    /**
-     * @internal
-     */
-    readonly _swapDataDeserializer: (version?: string) => new (data: any) => T["Data"] = (version?: string) => {
-        const _version = version ?? "v1";
-        const data = this._versionedContracts[_version];
-        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
-        return data.swapDataConstructor;
-    };
-
-    //TODO: Properly populate in constructor
-    readonly _versionedContracts: {
-        [version: string]: {
-            swapContract: T["Contract"],
-            swapDataConstructor: new (data: any) => T["Data"]
-        }
-    } = {};
-
-    constructor(
-        chainIdentifier: string,
-        unifiedStorage: UnifiedSwapStorage<T>,
-        unifiedChainEvents: UnifiedSwapEventListener<T>,
-        chain: T["ChainInterface"],
-        prices: ISwapPrice,
-        tokens: WrapperCtorTokens,
-        lpApi: IntermediaryAPI,
-        options: O,
-        versionedContracts: {
-            [version: string]: {
-                swapContract: T["Contract"],
-                swapDataConstructor: new (data: any) => T["Data"]
-            }
-        },
-        events?: EventEmitter<{swapState: [ISwap]}>
-    ) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
-        this._versionedContracts = versionedContracts;
-    }
-
-    /**
-     * 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
-     * @param contractVersion
-     * @returns Pre-fetched signature verification data or null if failed
-     *
-     * @internal
-     */
-    protected preFetchSignData(signDataPrefetch: Promise<any | null>, contractVersion: string): Promise<T["PreFetchVerification"] | undefined> {
-        if(this._contract(contractVersion).preFetchForInitSignatureVerification==null) {
-            // Catch promise rejections, should they happen
-            signDataPrefetch.catch(() => {});
-            return Promise.resolve(undefined);
-        }
-        return signDataPrefetch.then(obj => {
-            if(obj==null) return undefined;
-            return this._contract(contractVersion).preFetchForInitSignatureVerification!(obj);
-        }).catch(e => {
-            this.logger.error("preFetchSignData(): Error: ", e);
-        });
-    }
-
-    /**
-     * Verifies swap initialization signature returned by the intermediary
-     *
-     * @param initiator A smart chain account initiating the swap
-     * @param data Parsed swap data from the intermediary
-     * @param signature Response of the intermediary
-     * @param feeRatePromise Pre-fetched fee rate promise
-     * @param preFetchSignatureVerificationData Pre-fetched signature verification data
-     * @param contractVersion
-     * @param abortSignal
-     * @returns Swap initialization signature expiry
-     * @throws {SignatureVerificationError} when swap init signature is invalid
-     *
-     * @internal
-     */
-    protected async verifyReturnedSignature(
-        initiator: string,
-        data: T["Data"],
-        signature: SignatureData,
-        feeRatePromise: Promise<any>,
-        preFetchSignatureVerificationData: Promise<any>,
-        contractVersion: string,
-        abortSignal?: AbortSignal,
-    ): Promise<number> {
-        const [feeRate, preFetchedSignatureData] = await Promise.all([feeRatePromise, preFetchSignatureVerificationData]);
-        await this._contract(contractVersion).isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
-        return await this._contract(contractVersion).getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
-    }
-
-    /**
-     * Processes InitializeEvent for a given swap
-     * @param swap
-     * @param event
-     * @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
-     * @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
-     * @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
-     * @param event
-     * @param swap
-     *
-     * @internal
-     */
-    protected async processEvent(event: SwapEvent<T["Data"]>, swap: D["Swap"]): Promise<void> {
-        if(swap==null) return;
-
-        let swapChanged: boolean = false;
-        if(event instanceof InitializeEvent) {
-            swapChanged = await this.processEventInitialize(swap, event);
-            if(event.meta?.txId!=null && swap._commitTxId!==event.meta.txId) {
-                swap._commitTxId = event.meta.txId;
-                swapChanged ||= true;
-            }
-        }
-        if(event instanceof ClaimEvent) {
-            swapChanged = await this.processEventClaim(swap, event);
-            if(event.meta?.txId!=null && swap._claimTxId!==event.meta.txId) {
-                swap._claimTxId = event.meta.txId;
-                swapChanged ||= true;
-            }
-        }
-        if(event instanceof RefundEvent) {
-            swapChanged = await this.processEventRefund(swap, event);
-            if(event.meta?.txId!=null && swap._refundTxId!==event.meta.txId) {
-                swap._refundTxId = event.meta.txId;
-                swapChanged ||= true;
-            }
-        }
-
-        this.logger.info("processEvents(): "+event.constructor.name+" processed for "+swap.getId()+" swap: ", swap);
-
-        if(swapChanged) {
-            await swap._saveAndEmit();
-        }
-    }
-
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    protected async _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{ changedSwaps: D["Swap"][]; removeSwaps: D["Swap"][] }> {
-        const changedSwaps: D["Swap"][] = [];
-        const removeSwaps: D["Swap"][] = [];
-
-        const swapExpiredStatus: {[id: string]: boolean} = {};
-
-        const checkStatusSwaps: {[contractVersion: string]: (D["Swap"] & {_data: T["Data"]})[]} = {};
-
-        for(let pastSwap of pastSwaps) {
-            if(pastSwap._shouldFetchExpiryStatus()) {
-                //Check expiry
-                swapExpiredStatus[pastSwap.getId()] = await pastSwap._verifyQuoteDefinitelyExpired();
-            }
-            if(pastSwap._shouldFetchOnchainState()) {
-                //Add to swaps for which status should be checked
-                if(pastSwap._data!=null) (checkStatusSwaps[pastSwap._contractVersion ?? "v1"] ??= []).push(pastSwap as (D["Swap"] & {_data: T["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;
-            }
-
-            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 escrowHash = pastSwap.getEscrowHash();
-                const shouldSave = await pastSwap._sync(
-                    false,
-                    swapExpiredStatus[pastSwap.getId()],
-                    escrowHash==null ? undefined : swapStatuses[escrowHash]
-                );
-                if(shouldSave) {
-                    if(pastSwap.isQuoteExpired()) {
-                        removeSwaps.push(pastSwap);
-                    } else {
-                        changedSwaps.push(pastSwap);
-                    }
-                }
-            }
-        }
-
-        return {
-            changedSwaps,
-            removeSwaps
-        };
-    }
-
-    /**
-     * 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
-     */
-    public abstract recoverFromSwapDataAndState(
-        init: {
-            data: T["Data"],
-            getInitTxId: () => Promise<string>,
-            getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>
-        },
-        state: SwapCommitState,
-        contractVersion: string,
-        lp?: Intermediary
-    ): Promise<D["Swap"] | null>;
-
+import {ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens} from "../ISwapWrapper";
+import {
+    ChainType,
+    ClaimEvent,
+    InitializeEvent,
+    RefundEvent,
+    SignatureData,
+    SwapCommitState,
+    SwapEvent
+} from "@atomiqlabs/base";
+import {ISwap} from "../ISwap";
+import {UnifiedSwapStorage} from "../../storage/UnifiedSwapStorage";
+import {UnifiedSwapEventListener} from "../../events/UnifiedSwapEventListener";
+import {ISwapPrice} from "../../prices/abstract/ISwapPrice";
+import {EventEmitter} from "events";
+import {SwapType} from "../../enums/SwapType";
+import {IEscrowSwap} from "./IEscrowSwap";
+import {Intermediary} from "../../intermediaries/Intermediary";
+import {IntermediaryAPI} from "../../intermediaries/apis/IntermediaryAPI";
+
+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/Abstract
+ */
+export 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;
+
+    /**
+     * @internal
+     */
+    readonly _contract: (version?: string) => T["Contract"] = (version?: string) => {
+        const _version = version ?? "v1";
+        const data = this._versionedContracts[_version];
+        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
+        return data.swapContract;
+    };
+    /**
+     * @internal
+     */
+    readonly _swapDataDeserializer: (version?: string) => new (data: any) => T["Data"] = (version?: string) => {
+        const _version = version ?? "v1";
+        const data = this._versionedContracts[_version];
+        if(data==null) throw new Error(`Invalid contract version ${_version} requested`);
+        return data.swapDataConstructor;
+    };
+
+    //TODO: Properly populate in constructor
+    readonly _versionedContracts: {
+        [version: string]: {
+            swapContract: T["Contract"],
+            swapDataConstructor: new (data: any) => T["Data"]
+        }
+    } = {};
+
+    constructor(
+        chainIdentifier: string,
+        unifiedStorage: UnifiedSwapStorage<T>,
+        unifiedChainEvents: UnifiedSwapEventListener<T>,
+        chain: T["ChainInterface"],
+        prices: ISwapPrice,
+        tokens: WrapperCtorTokens,
+        lpApi: IntermediaryAPI,
+        options: O,
+        versionedContracts: {
+            [version: string]: {
+                swapContract: T["Contract"],
+                swapDataConstructor: new (data: any) => T["Data"]
+            }
+        },
+        events?: EventEmitter<{swapState: [ISwap]}>
+    ) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
+        this._versionedContracts = versionedContracts;
+    }
+
+    /**
+     * 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
+     * @param contractVersion
+     * @returns Pre-fetched signature verification data or null if failed
+     *
+     * @internal
+     */
+    protected preFetchSignData(signDataPrefetch: Promise<any | null>, contractVersion: string): Promise<T["PreFetchVerification"] | undefined> {
+        if(this._contract(contractVersion).preFetchForInitSignatureVerification==null) {
+            // Catch promise rejections, should they happen
+            signDataPrefetch.catch(() => {});
+            return Promise.resolve(undefined);
+        }
+        return signDataPrefetch.then(obj => {
+            if(obj==null) return undefined;
+            return this._contract(contractVersion).preFetchForInitSignatureVerification!(obj);
+        }).catch(e => {
+            this.logger.error("preFetchSignData(): Error: ", e);
+        });
+    }
+
+    /**
+     * Verifies swap initialization signature returned by the intermediary
+     *
+     * @param initiator A smart chain account initiating the swap
+     * @param data Parsed swap data from the intermediary
+     * @param signature Response of the intermediary
+     * @param feeRatePromise Pre-fetched fee rate promise
+     * @param preFetchSignatureVerificationData Pre-fetched signature verification data
+     * @param contractVersion
+     * @param abortSignal
+     * @returns Swap initialization signature expiry
+     * @throws {SignatureVerificationError} when swap init signature is invalid
+     *
+     * @internal
+     */
+    protected async verifyReturnedSignature(
+        initiator: string,
+        data: T["Data"],
+        signature: SignatureData,
+        feeRatePromise: Promise<any>,
+        preFetchSignatureVerificationData: Promise<any>,
+        contractVersion: string,
+        abortSignal?: AbortSignal,
+    ): Promise<number> {
+        const [feeRate, preFetchedSignatureData] = await Promise.all([feeRatePromise, preFetchSignatureVerificationData]);
+        await this._contract(contractVersion).isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
+        return await this._contract(contractVersion).getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
+    }
+
+    /**
+     * Processes InitializeEvent for a given swap
+     * @param swap
+     * @param event
+     * @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
+     * @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
+     * @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
+     * @param event
+     * @param swap
+     *
+     * @internal
+     */
+    protected async processEvent(event: SwapEvent<T["Data"]>, swap: D["Swap"]): Promise<void> {
+        if(swap==null) return;
+
+        let swapChanged: boolean = false;
+        if(event instanceof InitializeEvent) {
+            swapChanged = await this.processEventInitialize(swap, event);
+            if(event.meta?.txId!=null && swap._commitTxId!==event.meta.txId) {
+                swap._commitTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+        if(event instanceof ClaimEvent) {
+            swapChanged = await this.processEventClaim(swap, event);
+            if(event.meta?.txId!=null && swap._claimTxId!==event.meta.txId) {
+                swap._claimTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+        if(event instanceof RefundEvent) {
+            swapChanged = await this.processEventRefund(swap, event);
+            if(event.meta?.txId!=null && swap._refundTxId!==event.meta.txId) {
+                swap._refundTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+
+        this.logger.info("processEvents(): "+event.constructor.name+" processed for "+swap.getId()+" swap: ", swap);
+
+        if(swapChanged) {
+            await swap._saveAndEmit();
+        }
+    }
+
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    protected async _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{ changedSwaps: D["Swap"][]; removeSwaps: D["Swap"][] }> {
+        const changedSwaps: D["Swap"][] = [];
+        const removeSwaps: D["Swap"][] = [];
+
+        const swapExpiredStatus: {[id: string]: boolean} = {};
+
+        const checkStatusSwaps: {[contractVersion: string]: (D["Swap"] & {_data: T["Data"]})[]} = {};
+
+        for(let pastSwap of pastSwaps) {
+            if(pastSwap._shouldFetchExpiryStatus()) {
+                //Check expiry
+                swapExpiredStatus[pastSwap.getId()] = await pastSwap._verifyQuoteDefinitelyExpired();
+            }
+            if(pastSwap._shouldFetchOnchainState()) {
+                //Add to swaps for which status should be checked
+                if(pastSwap._data!=null) (checkStatusSwaps[pastSwap._contractVersion ?? "v1"] ??= []).push(pastSwap as (D["Swap"] & {_data: T["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;
+            }
+
+            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 escrowHash = pastSwap.getEscrowHash();
+                const shouldSave = await pastSwap._sync(
+                    false,
+                    swapExpiredStatus[pastSwap.getId()],
+                    escrowHash==null ? undefined : swapStatuses[escrowHash]
+                );
+                if(shouldSave) {
+                    if(pastSwap.isQuoteExpired()) {
+                        removeSwaps.push(pastSwap);
+                    } else {
+                        changedSwaps.push(pastSwap);
+                    }
+                }
+            }
+        }
+
+        return {
+            changedSwaps,
+            removeSwaps
+        };
+    }
+
+    /**
+     * 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
+     */
+    public abstract recoverFromSwapDataAndState(
+        init: {
+            data: T["Data"],
+            getInitTxId: () => Promise<string>,
+            getTxBlock: () => Promise<{blockTime: number, blockHeight: number}>
+        },
+        state: SwapCommitState,
+        contractVersion: string,
+        lp?: Intermediary
+    ): Promise<D["Swap"] | null>;
+
 }