@atomiqlabs/sdk 7.0.11 → 8.0.7

package/dist/swaps/ISwapWithGasDrop.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSwapWithGasDrop = void 0;
+/**
+ * Type guard to check if a swap has gas drop functionality
+ * @category Swaps
+ */
+function isSwapWithGasDrop(swap) {
+    return swap != null && typeof (swap.getGasDropOutput) === "function";
+}
+exports.isSwapWithGasDrop = isSwapWithGasDrop;

package/dist/swaps/ISwapWrapper.d.ts

@@ -0,0 +1,153 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainEvent, ChainType } from "@atomiqlabs/base";
+import { EventEmitter } from "events";
+import { ISwap } from "./ISwap";
+import { ISwapPrice } from "../prices/abstract/ISwapPrice";
+import { ChainIds, MultiChain } from "../swapper/Swapper";
+import { UnifiedSwapEventListener } from "../events/UnifiedSwapEventListener";
+import { SwapType } from "../enums/SwapType";
+import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
+import { SCToken } from "../types/Token";
+import { PriceInfoType } from "../types/PriceInfoType";
+/**
+ * Options for swap wrapper configuration
+ * @category Swaps
+ */
+export type ISwapWrapperOptions = {
+    getRequestTimeout?: number;
+    postRequestTimeout?: number;
+};
+/**
+ * Token configuration for wrapper constructors
+ * @category Swaps
+ */
+export type WrapperCtorTokens<T extends MultiChain = MultiChain> = {
+    ticker: string;
+    name: string;
+    chains: {
+        [chainId in ChainIds<T>]?: {
+            address: string;
+            decimals: number;
+            displayDecimals?: number;
+        };
+    };
+}[];
+/**
+ * Type definition linking wrapper and swap types
+ * @category Swaps
+ */
+export type SwapTypeDefinition<T extends ChainType, W extends ISwapWrapper<T, any>, S extends ISwap<T>> = {
+    Wrapper: W;
+    Swap: S;
+};
+/**
+ * Base abstract class for swap wrapper implementations
+ * @category Swaps
+ */
+export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, ISwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> {
+    abstract readonly TYPE: SwapType;
+    protected readonly logger: import("../utils/Logger").LoggerType;
+    abstract readonly swapDeserializer: new (wrapper: D["Wrapper"], data: any) => D["Swap"];
+    readonly unifiedStorage: UnifiedSwapStorage<T>;
+    readonly unifiedChainEvents: UnifiedSwapEventListener<T>;
+    readonly chainIdentifier: T["ChainId"];
+    readonly chain: T["ChainInterface"];
+    readonly prices: ISwapPrice;
+    readonly events: EventEmitter<{
+        swapState: [D["Swap"]];
+    }>;
+    readonly options: O;
+    readonly tokens: {
+        [tokenAddress: string]: SCToken<T["ChainId"]>;
+    };
+    readonly pendingSwaps: Map<string, WeakRef<D["Swap"]>>;
+    isInitialized: boolean;
+    tickInterval?: NodeJS.Timeout;
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage
+     * @param unifiedChainEvents
+     * @param chain
+     * @param prices Swap pricing handler
+     * @param tokens Chain specific token data
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier: T["ChainId"], unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, options: O, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    /**
+     * Pre-fetches swap price for a given swap
+     *
+     * @param amountData
+     * @param abortSignal
+     * @protected
+     * @returns Price of the token in uSats (micro sats)
+     */
+    protected preFetchPrice(amountData: {
+        token: string;
+    }, abortSignal?: AbortSignal): Promise<bigint | undefined>;
+    /**
+     * Pre-fetches bitcoin's USD price
+     *
+     * @param abortSignal
+     * @protected
+     */
+    protected preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number | undefined>;
+    /**
+     * Verifies returned  price for swaps
+     *
+     * @param lpServiceData Service data for the service in question (TO_BTCLN, TO_BTC, etc.) of the given intermediary
+     * @param send Whether this is a send (SOL -> SC) or receive (BTC -> SC) swap
+     * @param amountSats Amount in BTC
+     * @param amountToken Amount in token
+     * @param token Token used in the swap
+     * @param feeData Fee data as returned by the intermediary
+     * @param pricePrefetchPromise Price pre-fetch promise
+     * @param usdPricePrefetchPromise
+     * @param abortSignal
+     * @protected
+     * @returns Price info object
+     * @throws {IntermediaryError} if the calculated fee is too high
+     */
+    protected verifyReturnedPrice(lpServiceData: {
+        swapBaseFee: number;
+        swapFeePPM: number;
+    }, send: boolean, amountSats: bigint, amountToken: bigint, token: string, feeData: {
+        networkFee?: bigint;
+    }, pricePrefetchPromise?: Promise<bigint | undefined>, usdPricePrefetchPromise?: Promise<number | undefined>, abortSignal?: AbortSignal): Promise<PriceInfoType>;
+    abstract readonly pendingSwapStates: Array<D["Swap"]["state"]>;
+    abstract readonly tickSwapState?: Array<D["Swap"]["state"]>;
+    /**
+     * Processes a single SC on-chain event
+     * @private
+     * @param event
+     * @param swap
+     */
+    protected abstract processEvent?(event: ChainEvent<T["Data"]>, swap: D["Swap"]): Promise<void>;
+    /**
+     * Initializes the swap wrapper, needs to be called before any other action can be taken
+     */
+    init(noTimers?: boolean, noCheckPastSwaps?: boolean): Promise<void>;
+    protected startTickInterval(): void;
+    protected _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{
+        changedSwaps: D["Swap"][];
+        removeSwaps: D["Swap"][];
+    }>;
+    checkPastSwaps(pastSwaps?: D["Swap"][], noSave?: boolean): Promise<{
+        removeSwaps: D["Swap"][];
+        changedSwaps: D["Swap"][];
+    }>;
+    tick(swaps?: D["Swap"][]): Promise<void>;
+    saveSwapData(swap: D["Swap"]): Promise<void>;
+    removeSwapData(swap: D["Swap"]): Promise<void>;
+    /**
+     * Un-subscribes from event listeners on Solana
+     */
+    stop(): Promise<void>;
+    /**
+     * Returns the smart chain's native token used to pay for fees
+     */
+    getNativeToken(): SCToken<T["ChainId"]>;
+}

package/dist/swaps/ISwapWrapper.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwapWrapper = void 0;
+const events_1 = require("events");
+const IntermediaryError_1 = require("../errors/IntermediaryError");
+const Logger_1 = require("../utils/Logger");
+/**
+ * Base abstract class for swap wrapper implementations
+ * @category Swaps
+ */
+class ISwapWrapper {
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage
+     * @param unifiedChainEvents
+     * @param chain
+     * @param prices Swap pricing handler
+     * @param tokens Chain specific token data
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events) {
+        this.logger = (0, Logger_1.getLogger)(this.constructor.name + ": ");
+        this.pendingSwaps = new Map();
+        this.isInitialized = false;
+        this.unifiedStorage = unifiedStorage;
+        this.unifiedChainEvents = unifiedChainEvents;
+        this.chainIdentifier = chainIdentifier;
+        this.chain = chain;
+        this.prices = prices;
+        this.events = events || new events_1.EventEmitter();
+        this.options = options;
+        this.tokens = {};
+        for (let tokenData of tokens) {
+            const chainData = tokenData.chains[chainIdentifier];
+            if (chainData == null)
+                continue;
+            this.tokens[chainData.address] = {
+                chain: "SC",
+                chainId: this.chainIdentifier,
+                address: chainData.address,
+                decimals: chainData.decimals,
+                ticker: tokenData.ticker,
+                name: tokenData.name,
+                displayDecimals: chainData.displayDecimals
+            };
+        }
+    }
+    /**
+     * Pre-fetches swap price for a given swap
+     *
+     * @param amountData
+     * @param abortSignal
+     * @protected
+     * @returns Price of the token in uSats (micro sats)
+     */
+    preFetchPrice(amountData, abortSignal) {
+        return this.prices.preFetchPrice(this.chainIdentifier, amountData.token, abortSignal).catch(e => {
+            this.logger.error("preFetchPrice.token(): Error: ", e);
+            return undefined;
+        });
+    }
+    /**
+     * Pre-fetches bitcoin's USD price
+     *
+     * @param abortSignal
+     * @protected
+     */
+    preFetchUsdPrice(abortSignal) {
+        return this.prices.preFetchUsdPrice(abortSignal).catch(e => {
+            this.logger.error("preFetchPrice.usd(): Error: ", e);
+            return undefined;
+        });
+    }
+    /**
+     * Verifies returned  price for swaps
+     *
+     * @param lpServiceData Service data for the service in question (TO_BTCLN, TO_BTC, etc.) of the given intermediary
+     * @param send Whether this is a send (SOL -> SC) or receive (BTC -> SC) swap
+     * @param amountSats Amount in BTC
+     * @param amountToken Amount in token
+     * @param token Token used in the swap
+     * @param feeData Fee data as returned by the intermediary
+     * @param pricePrefetchPromise Price pre-fetch promise
+     * @param usdPricePrefetchPromise
+     * @param abortSignal
+     * @protected
+     * @returns Price info object
+     * @throws {IntermediaryError} if the calculated fee is too high
+     */
+    async verifyReturnedPrice(lpServiceData, send, amountSats, amountToken, token, feeData, pricePrefetchPromise = Promise.resolve(undefined), usdPricePrefetchPromise = Promise.resolve(undefined), abortSignal) {
+        const swapBaseFee = BigInt(lpServiceData.swapBaseFee);
+        const swapFeePPM = BigInt(lpServiceData.swapFeePPM);
+        if (send && feeData.networkFee != null)
+            amountToken = amountToken - feeData.networkFee;
+        const [isValidAmount, usdPrice] = await Promise.all([
+            send ?
+                this.prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise) :
+                this.prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise),
+            usdPricePrefetchPromise.then(value => {
+                if (value != null)
+                    return value;
+                return this.prices.preFetchUsdPrice(abortSignal);
+            })
+        ]);
+        if (!isValidAmount.isValid)
+            throw new IntermediaryError_1.IntermediaryError("Fee too high");
+        isValidAmount.realPriceUsdPerBitcoin = usdPrice;
+        return isValidAmount;
+    }
+    /**
+     * Initializes the swap wrapper, needs to be called before any other action can be taken
+     */
+    async init(noTimers = false, noCheckPastSwaps = false) {
+        if (this.isInitialized)
+            return;
+        if (!noCheckPastSwaps) {
+            //Save events received in the meantime into the event queue and process them only after we've checked and
+            // processed all the past swaps
+            let eventQueue = [];
+            const initListener = (event, swap) => {
+                eventQueue.push({ event, swap });
+                return Promise.resolve();
+            };
+            if (this.processEvent != null)
+                this.unifiedChainEvents.registerListener(this.TYPE, initListener, this.swapDeserializer.bind(null, this));
+            await this.checkPastSwaps();
+            if (this.processEvent != null) {
+                //Process accumulated event queue
+                for (let event of eventQueue) {
+                    await this.processEvent(event.event, event.swap);
+                }
+                //Unregister the temporary event handler
+                this.unifiedChainEvents.unregisterListener(this.TYPE);
+            }
+        }
+        if (this.processEvent != null)
+            this.unifiedChainEvents.registerListener(this.TYPE, this.processEvent.bind(this), this.swapDeserializer.bind(null, this));
+        if (!noTimers)
+            this.startTickInterval();
+        // this.logger.info("init(): Swap wrapper initialized");
+        this.isInitialized = true;
+    }
+    startTickInterval() {
+        if (this.tickSwapState == null || this.tickSwapState.length === 0)
+            return;
+        this.tickInterval = setInterval(() => {
+            this.tick();
+        }, 1000);
+    }
+    async _checkPastSwaps(pastSwaps) {
+        const changedSwaps = [];
+        const removeSwaps = [];
+        await Promise.all(pastSwaps.map((swap) => swap._sync(false).then(changed => {
+            if (swap.isQuoteExpired()) {
+                removeSwaps.push(swap);
+                this.logger.debug("_checkPastSwaps(): Removing expired swap: " + swap.getId());
+            }
+            else {
+                if (changed)
+                    changedSwaps.push(swap);
+            }
+        }).catch(e => this.logger.error("_checkPastSwaps(): Error when checking swap " + swap.getId() + ": ", e))));
+        return { changedSwaps, removeSwaps };
+    }
+    async checkPastSwaps(pastSwaps, noSave) {
+        if (pastSwaps == null)
+            pastSwaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this.pendingSwapStates }]], (val) => new this.swapDeserializer(this, val));
+        const { removeSwaps, changedSwaps } = await this._checkPastSwaps(pastSwaps);
+        if (!noSave) {
+            await this.unifiedStorage.removeAll(removeSwaps);
+            await this.unifiedStorage.saveAll(changedSwaps);
+            changedSwaps.forEach(swap => swap._emitEvent());
+            removeSwaps.forEach(swap => swap._emitEvent());
+        }
+        return {
+            removeSwaps,
+            changedSwaps
+        };
+    }
+    async tick(swaps) {
+        if (swaps == null)
+            swaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this.tickSwapState }]], (val) => new this.swapDeserializer(this, val));
+        for (let pendingSwap of this.pendingSwaps.values()) {
+            const value = pendingSwap.deref();
+            if (value != null)
+                value._tick(true);
+        }
+        swaps.forEach(value => {
+            value._tick(true);
+        });
+    }
+    saveSwapData(swap) {
+        if (!swap.isInitiated()) {
+            this.logger.debug("saveSwapData(): Swap " + swap.getId() + " not initiated, saving to pending swaps");
+            this.pendingSwaps.set(swap.getId(), new WeakRef(swap));
+            return Promise.resolve();
+        }
+        else {
+            this.pendingSwaps.delete(swap.getId());
+        }
+        return this.unifiedStorage.save(swap);
+    }
+    removeSwapData(swap) {
+        this.pendingSwaps.delete(swap.getId());
+        if (!swap.isInitiated())
+            return Promise.resolve();
+        return this.unifiedStorage.remove(swap);
+    }
+    /**
+     * Un-subscribes from event listeners on Solana
+     */
+    async stop() {
+        this.isInitialized = false;
+        this.unifiedChainEvents.unregisterListener(this.TYPE);
+        this.logger.info("stop(): Swap wrapper stopped");
+        if (this.tickInterval != null)
+            clearInterval(this.tickInterval);
+    }
+    /**
+     * Returns the smart chain's native token used to pay for fees
+     */
+    getNativeToken() {
+        return this.tokens[this.chain.getNativeCurrencyAddress()];
+    }
+}
+exports.ISwapWrapper = ISwapWrapper;

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

@@ -0,0 +1,53 @@
+import { IEscrowSwap, IEscrowSwapInit } from "./IEscrowSwap";
+import { ChainType, SignatureData, SwapData } from "@atomiqlabs/base";
+import { IEscrowSwapDefinition, IEscrowSwapWrapper } from "./IEscrowSwapWrapper";
+import { SwapTypeDefinition } from "../ISwapWrapper";
+import { TokenAmount } from "../../types/TokenAmount";
+import { SCToken } from "../../types/Token";
+export type IEscrowSelfInitSwapInit<T extends SwapData> = IEscrowSwapInit<T> & {
+    feeRate: string;
+    signatureData?: SignatureData;
+};
+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>;
+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;
+    protected constructor(wrapper: D["Wrapper"], obj: any);
+    protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSelfInitSwapInit<T["Data"]>);
+    /**
+     * Periodically checks for init signature's expiry
+     *
+     * @param intervalSeconds How often to check (in seconds), default to 5s
+     * @param abortSignal
+     * @protected
+     */
+    protected watchdogWaitTillSignatureExpiry(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Get the estimated smart chain fee of the commit transaction
+     */
+    protected getCommitFee(): Promise<bigint>;
+    /**
+     * Returns the transaction fee paid on the smart chain
+     */
+    getSmartChainNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>>;
+    /**
+     * Checks if the initiator/sender has enough balance to cover the transaction fee for processing the swap
+     */
+    abstract hasEnoughForTxFees(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount;
+        required: TokenAmount;
+    }>;
+    abstract txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
+    abstract commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    /**
+     * Checks if the swap's quote is expired for good (i.e. the swap strictly cannot be committed on-chain anymore)
+     */
+    _verifyQuoteDefinitelyExpired(): Promise<boolean>;
+    /**
+     * Checks if the swap's quote is still valid
+     */
+    verifyQuoteValid(): Promise<boolean>;
+    serialize(): any;
+}

package/dist/swaps/escrow_swaps/IEscrowSelfInitSwap.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IEscrowSelfInitSwap = exports.isIEscrowSelfInitSwapInit = void 0;
+const IEscrowSwap_1 = require("./IEscrowSwap");
+const base_1 = require("@atomiqlabs/base");
+const TokenAmount_1 = require("../../types/TokenAmount");
+const TimeoutUtils_1 = require("../../utils/TimeoutUtils");
+function isIEscrowSelfInitSwapInit(obj) {
+    return typeof obj === "object" &&
+        typeof (obj.feeRate) === "string" &&
+        (obj.signatureData == null || (typeof (obj.signatureData) === "object" &&
+            typeof (obj.signatureData.prefix) === "string" &&
+            typeof (obj.signatureData.timeout) === "string" &&
+            typeof (obj.signatureData.signature) === "string")) &&
+        (0, IEscrowSwap_1.isIEscrowSwapInit)(obj);
+}
+exports.isIEscrowSelfInitSwapInit = isIEscrowSelfInitSwapInit;
+class IEscrowSelfInitSwap extends IEscrowSwap_1.IEscrowSwap {
+    constructor(wrapper, swapInitOrObj) {
+        super(wrapper, swapInitOrObj);
+        if (isIEscrowSelfInitSwapInit(swapInitOrObj)) {
+            this.feeRate = swapInitOrObj.feeRate;
+            this.signatureData = swapInitOrObj.signatureData;
+        }
+        else {
+            if (swapInitOrObj.signature != null)
+                this.signatureData = {
+                    prefix: swapInitOrObj.prefix,
+                    timeout: swapInitOrObj.timeout,
+                    signature: swapInitOrObj.signature
+                };
+            this.feeRate = swapInitOrObj.feeRate;
+        }
+    }
+    //////////////////////////////
+    //// Watchdogs
+    /**
+     * Periodically checks for init signature's expiry
+     *
+     * @param intervalSeconds How often to check (in seconds), default to 5s
+     * @param abortSignal
+     * @protected
+     */
+    async watchdogWaitTillSignatureExpiry(intervalSeconds, abortSignal) {
+        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);
+            }
+            catch (e) {
+                this.logger.error("watchdogWaitTillSignatureExpiry(): Error when checking signature expiry: ", e);
+            }
+        }
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+    }
+    //////////////////////////////
+    //// Amounts & fees
+    /**
+     * Get the estimated smart chain fee of the commit transaction
+     */
+    getCommitFee() {
+        return this.wrapper.contract.getCommitFee(this._getInitiator(), this.getSwapData(), this.feeRate);
+    }
+    /**
+     * Returns the transaction fee paid on the smart chain
+     */
+    async getSmartChainNetworkFee() {
+        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);
+    }
+    //////////////////////////////
+    //// Quote verification
+    /**
+     * 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)
+            throw new Error("data or signature data are null!");
+        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)
+            throw new Error("data or signature data are null!");
+        try {
+            await this.wrapper.contract.isValidInitAuthorization(this._getInitiator(), this.data, this.signatureData, this.feeRate);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof base_1.SignatureVerificationError) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            prefix: this.signatureData?.prefix,
+            timeout: this.signatureData?.timeout,
+            signature: this.signatureData?.signature,
+            feeRate: this.feeRate == null ? null : this.feeRate.toString(),
+        };
+    }
+    ;
+}
+exports.IEscrowSelfInitSwap = IEscrowSelfInitSwap;

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

@@ -0,0 +1,70 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ISwap, ISwapInit } from "../ISwap";
+import { ChainType, SwapCommitState, SwapData, SwapExpiredState, SwapNotCommitedState, SwapPaidState } from "@atomiqlabs/base";
+import { IEscrowSwapDefinition, IEscrowSwapWrapper } from "./IEscrowSwapWrapper";
+import { Buffer } from "buffer";
+export type IEscrowSwapInit<T extends SwapData> = ISwapInit & {
+    data?: T;
+};
+export declare function isIEscrowSwapInit<T extends SwapData>(obj: any): obj is IEscrowSwapInit<T>;
+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"];
+    /**
+     * Transaction IDs for the swap on the smart chain side
+     */
+    commitTxId?: string;
+    refundTxId?: string;
+    claimTxId?: string;
+    protected constructor(wrapper: D["Wrapper"], obj: any);
+    protected constructor(wrapper: D["Wrapper"], swapInit: IEscrowSwapInit<T["Data"]>);
+    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
+     */
+    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
+     */
+    protected getIdentifierHashString(): string;
+    _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
+     */
+    getClaimHash(): string;
+    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
+     */
+    protected watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Periodically checks the chain to see whether the swap was finished (claimed or refunded)
+     *
+     * @param intervalSeconds How often to check (in seconds), default to 5s
+     * @param abortSignal
+     * @protected
+     */
+    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)
+     */
+    abstract _verifyQuoteDefinitelyExpired(): Promise<boolean>;
+    /**
+     * Checks if the swap's quote is still valid
+     */
+    abstract verifyQuoteValid(): Promise<boolean>;
+    abstract _shouldFetchCommitStatus(): boolean;
+    abstract _shouldFetchExpiryStatus(): boolean;
+    abstract _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean>;
+    serialize(): any;
+}