@atomiqlabs/sdk 7.0.12 → 8.0.8

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IFromBTCSelfInitSwap = void 0;
+const base_1 = require("@atomiqlabs/base");
+const IEscrowSelfInitSwap_1 = require("../IEscrowSelfInitSwap");
+const FeeType_1 = require("../../../enums/FeeType");
+const PercentagePPM_1 = require("../../../types/fees/PercentagePPM");
+const TokenAmount_1 = require("../../../types/TokenAmount");
+class IFromBTCSelfInitSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
+    constructor(wrapper, initOrObj) {
+        super(wrapper, initOrObj);
+    }
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    tryRecomputeSwapPrice() {
+        if (this.swapFeeBtc == null) {
+            this.swapFeeBtc = this.swapFee * this.getInput().rawAmount / this.getOutAmountWithoutFee();
+        }
+        super.tryRecomputeSwapPrice();
+    }
+    _getInitiator() {
+        return this.getSwapData().getClaimer();
+    }
+    getOutputTxId() {
+        return this.claimTxId ?? null;
+    }
+    getOutputAddress() {
+        return this._getInitiator();
+    }
+    requiresAction() {
+        return this.isClaimable();
+    }
+    //////////////////////////////
+    //// Amounts & fees
+    getOutAmountWithoutFee() {
+        return this.getSwapData().getAmount() + this.swapFee;
+    }
+    getSwapFee() {
+        if (this.pricingInfo == null)
+            throw new Error("No pricing info known, cannot estimate fee!");
+        const feeWithoutBaseFee = this.swapFeeBtc - this.pricingInfo.satsBaseFee;
+        const swapFeePPM = feeWithoutBaseFee * 1000000n / this.getInputWithoutFee().rawAmount;
+        const amountInSrcToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc, this.inputToken, this.wrapper.prices, this.pricingInfo);
+        return {
+            amountInSrcToken,
+            amountInDstToken: (0, TokenAmount_1.toTokenAmount)(this.swapFee, this.wrapper.tokens[this.getSwapData().getToken()], this.wrapper.prices, this.pricingInfo),
+            currentUsdValue: amountInSrcToken.currentUsdValue,
+            usdValue: amountInSrcToken.usdValue,
+            pastUsdValue: amountInSrcToken.pastUsdValue,
+            composition: {
+                base: (0, TokenAmount_1.toTokenAmount)(this.pricingInfo.satsBaseFee, this.inputToken, this.wrapper.prices, this.pricingInfo),
+                percentage: (0, PercentagePPM_1.ppmToPercentage)(swapFeePPM)
+            }
+        };
+    }
+    getFee() {
+        return this.getSwapFee();
+    }
+    getFeeBreakdown() {
+        return [{
+                type: FeeType_1.FeeType.SWAP,
+                fee: this.getSwapFee()
+            }];
+    }
+    getOutputToken() {
+        return this.wrapper.tokens[this.getSwapData().getToken()];
+    }
+    getOutput() {
+        return (0, TokenAmount_1.toTokenAmount)(this.getSwapData().getAmount(), this.wrapper.tokens[this.getSwapData().getToken()], this.wrapper.prices, this.pricingInfo);
+    }
+    getInputWithoutFee() {
+        return (0, TokenAmount_1.toTokenAmount)(this.getInput().rawAmount - this.swapFeeBtc, this.inputToken, this.wrapper.prices, this.pricingInfo);
+    }
+    getSecurityDeposit() {
+        return (0, TokenAmount_1.toTokenAmount)(this.getSwapData().getSecurityDeposit(), this.wrapper.getNativeToken(), this.wrapper.prices, this.pricingInfo);
+    }
+    getTotalDeposit() {
+        return (0, TokenAmount_1.toTokenAmount)(this.getSwapData().getTotalDeposit(), this.wrapper.getNativeToken(), this.wrapper.prices, this.pricingInfo);
+    }
+    async hasEnoughForTxFees() {
+        const [balance, commitFee] = await Promise.all([
+            this.wrapper.contract.getBalance(this._getInitiator(), this.wrapper.chain.getNativeCurrencyAddress(), false),
+            this.getCommitFee()
+        ]);
+        const totalFee = commitFee + this.getSwapData().getTotalDeposit();
+        return {
+            enoughBalance: balance >= totalFee,
+            balance: (0, TokenAmount_1.toTokenAmount)(balance, this.wrapper.getNativeToken(), this.wrapper.prices, this.pricingInfo),
+            required: (0, TokenAmount_1.toTokenAmount)(totalFee, this.wrapper.getNativeToken(), this.wrapper.prices, this.pricingInfo)
+        };
+    }
+    //////////////////////////////
+    //// Commit
+    /**
+     * Returns the transactions required for committing the swap on-chain, locking the tokens from the intermediary
+     *  in an HTLC or PTLC
+     *
+     * @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
+     */
+    async txsCommit(skipChecks) {
+        if (!this.canCommit())
+            throw new Error("Must be in CREATED state!");
+        if (this.data == null || this.signatureData == null)
+            throw new Error("data or signature data is null, invalid state?");
+        if (!this.initiated) {
+            this.initiated = true;
+            await this._saveAndEmit();
+        }
+        return await this.wrapper.contract.txsInit(this._getInitiator(), this.data, this.signatureData, skipChecks, this.feeRate).catch(e => Promise.reject(e instanceof base_1.SignatureVerificationError ? new Error("Request timed out") : e));
+    }
+    //////////////////////////////
+    //// Claim
+    getClaimFee() {
+        return this.wrapper.contract.getClaimFee(this._getInitiator(), this.getSwapData());
+    }
+}
+exports.IFromBTCSelfInitSwap = IFromBTCSelfInitSwap;

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

@@ -0,0 +1,45 @@
+import { ISwapWrapperOptions } from "../../ISwapWrapper";
+import { Intermediary } from "../../../intermediaries/Intermediary";
+import { ChainType } from "@atomiqlabs/base";
+import { IEscrowSwapDefinition, IEscrowSwapWrapper } from "../IEscrowSwapWrapper";
+import { IEscrowSwap } from "../IEscrowSwap";
+import { AmountData } from "../../../types/AmountData";
+export type IFromBTCDefinition<T extends ChainType, W extends IFromBTCWrapper<T, any>, S extends IEscrowSwap<T>> = IEscrowSwapDefinition<T, W, S>;
+export declare abstract class IFromBTCWrapper<T extends ChainType, D extends IFromBTCDefinition<T, IFromBTCWrapper<T, D>, IEscrowSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends IEscrowSwapWrapper<T, D, O> {
+    /**
+     * Returns a random sequence to be used for swaps
+     *
+     * @protected
+     * @returns Random 64-bit sequence number
+     */
+    protected getRandomSequence(): bigint;
+    /**
+     * Pre-fetches feeRate for a given swap
+     *
+     * @param signer Address initiating the swap
+     * @param amountData
+     * @param claimHash optional claim hash of the swap or null
+     * @param abortController
+     * @protected
+     * @returns Fee rate
+     */
+    protected preFetchFeeRate(signer: string, amountData: AmountData, claimHash: string | undefined, abortController: AbortController): Promise<string | undefined>;
+    /**
+     * Pre-fetches intermediary's available SC on-chain liquidity
+     * @param amountData
+     * @param lp Intermediary
+     * @param abortController
+     * @protected
+     * @returns Intermediary's liquidity balance
+     */
+    protected preFetchIntermediaryLiquidity(amountData: AmountData, lp: Intermediary, abortController: AbortController): Promise<bigint | undefined>;
+    /**
+     * Verifies whether the intermediary has enough available liquidity such that we can initiate the swap
+     *
+     * @param amount Swap amount that we should receive
+     * @param liquidityPromise pre-fetched liquidity promise as obtained from preFetchIntermediaryLiquidity()
+     * @protected
+     * @throws {IntermediaryError} if intermediary's liquidity is lower than what's required for the swap
+     */
+    protected verifyIntermediaryLiquidity(amount: bigint, liquidityPromise: Promise<bigint>): Promise<void>;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IFromBTCWrapper = void 0;
+const IntermediaryError_1 = require("../../../errors/IntermediaryError");
+const Utils_1 = require("../../../utils/Utils");
+const base_1 = require("@atomiqlabs/base");
+const IEscrowSwapWrapper_1 = require("../IEscrowSwapWrapper");
+class IFromBTCWrapper extends IEscrowSwapWrapper_1.IEscrowSwapWrapper {
+    /**
+     * Returns a random sequence to be used for swaps
+     *
+     * @protected
+     * @returns Random 64-bit sequence number
+     */
+    getRandomSequence() {
+        return base_1.BigIntBufferUtils.fromBuffer((0, Utils_1.randomBytes)(8));
+    }
+    /**
+     * Pre-fetches feeRate for a given swap
+     *
+     * @param signer Address initiating the swap
+     * @param amountData
+     * @param claimHash optional claim hash of the swap or null
+     * @param abortController
+     * @protected
+     * @returns Fee rate
+     */
+    preFetchFeeRate(signer, amountData, claimHash, abortController) {
+        return this.contract.getInitFeeRate(this.chain.randomAddress(), signer, amountData.token, claimHash)
+            .catch(e => {
+            this.logger.warn("preFetchFeeRate(): Error: ", e);
+            abortController.abort(e);
+            return undefined;
+        });
+    }
+    /**
+     * Pre-fetches intermediary's available SC on-chain liquidity
+     * @param amountData
+     * @param lp Intermediary
+     * @param abortController
+     * @protected
+     * @returns Intermediary's liquidity balance
+     */
+    preFetchIntermediaryLiquidity(amountData, lp, abortController) {
+        return lp.getLiquidity(this.chainIdentifier, this.contract, amountData.token.toString(), abortController.signal).catch(e => {
+            this.logger.warn("preFetchIntermediaryLiquidity(): Error: ", e);
+            abortController.abort(e);
+            return undefined;
+        });
+    }
+    /**
+     * Verifies whether the intermediary has enough available liquidity such that we can initiate the swap
+     *
+     * @param amount Swap amount that we should receive
+     * @param liquidityPromise pre-fetched liquidity promise as obtained from preFetchIntermediaryLiquidity()
+     * @protected
+     * @throws {IntermediaryError} if intermediary's liquidity is lower than what's required for the swap
+     */
+    async verifyIntermediaryLiquidity(amount, liquidityPromise) {
+        const liquidity = await liquidityPromise;
+        if (liquidity < amount)
+            throw new IntermediaryError_1.IntermediaryError("Intermediary doesn't have enough liquidity");
+    }
+}
+exports.IFromBTCWrapper = IFromBTCWrapper;

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.d.ts

@@ -0,0 +1,263 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FromBTCLNDefinition, FromBTCLNWrapper } from "./FromBTCLNWrapper";
+import { IFromBTCSelfInitSwap } from "../IFromBTCSelfInitSwap";
+import { SwapType } from "../../../../enums/SwapType";
+import { ChainType, SignatureData, SwapCommitState, SwapData } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { MinimalLightningNetworkWalletInterface } from "../../../../bitcoin/wallet/MinimalLightningNetworkWalletInterface";
+import { IClaimableSwap } from "../../../IClaimableSwap";
+import { IAddressSwap } from "../../../IAddressSwap";
+import { IEscrowSelfInitSwapInit } from "../../IEscrowSelfInitSwap";
+import { TokenAmount } from "../../../../types/TokenAmount";
+import { BtcToken, SCToken } from "../../../../types/Token";
+import { LoggerType } from "../../../../utils/Logger";
+import { LNURLWithdraw } from "../../../../types/lnurl/LNURLWithdraw";
+/**
+ * State enum for FromBTCLN swaps
+ * @category Swaps
+ */
+export declare enum FromBTCLNSwapState {
+    FAILED = -4,
+    QUOTE_EXPIRED = -3,
+    QUOTE_SOFT_EXPIRED = -2,
+    EXPIRED = -1,
+    PR_CREATED = 0,
+    PR_PAID = 1,
+    CLAIM_COMMITED = 2,
+    CLAIM_CLAIMED = 3
+}
+export type FromBTCLNSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
+    pr: string;
+    secret: string;
+    initialSwapData: T;
+    lnurl?: string;
+    lnurlK1?: string;
+    lnurlCallback?: string;
+};
+export declare function isFromBTCLNSwapInit<T extends SwapData>(obj: any): obj is FromBTCLNSwapInit<T>;
+export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFromBTCSelfInitSwap<T, FromBTCLNDefinition<T>, FromBTCLNSwapState> implements IAddressSwap, IClaimableSwap<T, FromBTCLNDefinition<T>, FromBTCLNSwapState> {
+    protected readonly logger: LoggerType;
+    protected readonly inputToken: BtcToken<true>;
+    protected readonly TYPE = SwapType.FROM_BTCLN;
+    protected readonly lnurlFailSignal: AbortController;
+    protected readonly pr: string;
+    protected readonly secret: string;
+    protected initialSwapData: T["Data"];
+    lnurl?: string;
+    lnurlK1?: string;
+    lnurlCallback?: string;
+    prPosted?: boolean;
+    protected getSwapData(): T["Data"];
+    constructor(wrapper: FromBTCLNWrapper<T>, init: FromBTCLNSwapInit<T["Data"]>);
+    constructor(wrapper: FromBTCLNWrapper<T>, obj: any);
+    protected upgradeVersion(): void;
+    protected getIdentifierHash(): Buffer;
+    protected getPaymentHash(): Buffer;
+    protected canCommit(): boolean;
+    getInputAddress(): string | null;
+    getInputTxId(): string;
+    /**
+     * Returns the lightning network BOLT11 invoice that needs to be paid as an input to the swap
+     */
+    getAddress(): string;
+    getHyperlink(): string;
+    /**
+     * Returns the timeout time (in UNIX milliseconds) when the swap will definitelly be considered as expired
+     *  if the LP doesn't make it expired sooner
+     */
+    getDefinitiveExpiryTime(): number;
+    /**
+     * Returns timeout time (in UNIX milliseconds) when the LN invoice will expire
+     */
+    getTimeoutTime(): number;
+    /**
+     * Returns timeout time (in UNIX milliseconds) when the swap htlc will expire
+     */
+    getHtlcTimeoutTime(): number;
+    isFinished(): boolean;
+    isClaimable(): boolean;
+    isSuccessful(): boolean;
+    isFailed(): boolean;
+    isQuoteExpired(): boolean;
+    isQuoteSoftExpired(): boolean;
+    _verifyQuoteDefinitelyExpired(): Promise<boolean>;
+    verifyQuoteValid(): Promise<boolean>;
+    getInputToken(): BtcToken<true>;
+    getInput(): TokenAmount<T["ChainId"], BtcToken<true>>;
+    getSmartChainNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>>;
+    hasEnoughForTxFees(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount;
+        required: TokenAmount;
+    }>;
+    /**
+     * Executes the swap with the provided bitcoin lightning network wallet or LNURL
+     *
+     * @param dstSigner Signer on the destination network, needs to have the same address as the one specified when
+     *  quote was created, this is required for legacy swaps because the destination wallet needs to actively claim
+     *  the swap funds on the destination (this also means you need native token to cover gas costs)
+     * @param walletOrLnurlWithdraw Bitcoin lightning wallet to use to pay the lightning network invoice, or an LNURL-withdraw
+     *  link, wallet is not required and the LN invoice can be paid externally as well (just pass null or undefined here)
+     * @param callbacks Callbacks to track the progress of the swap
+     * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
+     */
+    execute(dstSigner: T["Signer"] | T["NativeSigner"], walletOrLnurlWithdraw?: MinimalLightningNetworkWalletInterface | LNURLWithdraw | string | null | undefined, callbacks?: {
+        onSourceTransactionReceived?: (sourceTxId: string) => void;
+        onDestinationCommitSent?: (destinationCommitTxId: string) => void;
+        onDestinationClaimSent?: (destinationClaimTxId: string) => void;
+        onSwapSettled?: (destinationTxId: string) => void;
+    }, options?: {
+        abortSignal?: AbortSignal;
+        lightningTxCheckIntervalSeconds?: number;
+        delayBetweenCommitAndClaimSeconds?: number;
+    }): Promise<void>;
+    txsExecute(options?: {
+        skipChecks?: boolean;
+    }): Promise<{
+        name: "Payment";
+        description: string;
+        chain: string;
+        txs: {
+            address: string;
+            hyperlink: string;
+        }[];
+    }[] | ({
+        name: "Commit";
+        description: string;
+        chain: T["ChainId"];
+        txs: T["TX"][];
+    } | {
+        name: "Claim";
+        description: string;
+        chain: T["ChainId"];
+        txs: T["TX"][];
+    })[]>;
+    /**
+     * Checks whether the LP received the LN payment and we can continue by committing & claiming the HTLC on-chain
+     *
+     * @param save If the new swap state should be saved
+     */
+    _checkIntermediaryPaymentReceived(save?: boolean): Promise<boolean | null>;
+    /**
+     * Checks the data returned by the intermediary in the payment auth request
+     *
+     * @param signer Smart chain signer's address initiating the swap
+     * @param data Parsed swap data as returned by the intermediary
+     * @param signature Signature data as returned by the intermediary
+     * @protected
+     * @throws {IntermediaryError} If the returned are not valid
+     * @throws {SignatureVerificationError} If the returned signature is not valid
+     * @throws {Error} If the swap is already committed on-chain
+     */
+    protected checkIntermediaryReturnedAuthData(signer: string, data: T["Data"], signature: SignatureData): Promise<void>;
+    /**
+     * Waits till an LN payment is received by the intermediary and client can continue commiting & claiming the HTLC
+     *
+     * @param onPaymentReceived Callback as for when the LP reports having received the ln payment
+     * @param abortSignal Abort signal to stop waiting for payment
+     * @param checkIntervalSeconds How often to poll the intermediary for answer
+     */
+    waitForPayment(onPaymentReceived?: (txId: string) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Commits the swap on-chain, locking the tokens from the intermediary in an HTLC
+     *
+     * @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)
+     * @param onBeforeTxSent
+     * @throws {Error} If invalid signer is provided that doesn't match the swap data
+     */
+    commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Unsafe txs claim getter without state checking!
+     *
+     * @param _signer
+     * @private
+     */
+    private _txsClaim;
+    /**
+     * Returns transactions required for claiming the HTLC and finishing the swap by revealing the HTLC secret
+     *  (hash preimage)
+     *
+     * @param _signer Optional signer address to use for claiming the swap, can also be different from the initializer
+     * @throws {Error} If in invalid state (must be CLAIM_COMMITED)
+     */
+    txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): 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
+     * @param onBeforeTxSent
+     */
+    claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void): 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 BTC_TX_CONFIRMED)
+     * @throws {Error} If the LP refunded sooner than we were able to claim
+     * @returns {boolean} whether the swap was claimed in time or not
+     */
+    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Estimated transaction fee for commit & claim txs combined
+     */
+    getCommitAndClaimFee(): Promise<bigint>;
+    canCommitAndClaimInOneShot(): boolean;
+    /**
+     * Returns transactions for both commit & claim operation together, such that they can be signed all at once by
+     *  the wallet. CAUTION: transactions must be sent sequentially, such that the claim (2nd) transaction is only
+     *  sent after the commit (1st) transaction confirms. Failure to do so can reveal the HTLC pre-image too soon,
+     *  opening a possibility for the LP to steal funds.
+     *
+     * @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 in invalid state (must be PR_PAID or CLAIM_COMMITED)
+     */
+    txsCommitAndClaim(skipChecks?: boolean): Promise<T["TX"][]>;
+    /**
+     * Commits and claims the swap, in a way that the transactions can be signed together by the underlying provider and
+     *  then sent sequentially
+     *
+     * @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)
+     * @param onBeforeCommitTxSent
+     * @param onBeforeClaimTxSent
+     * @throws {Error} If in invalid state (must be PR_PAID or CLAIM_COMMITED)
+     * @throws {Error} If invalid signer is provided that doesn't match the swap data
+     */
+    commitAndClaim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeCommitTxSent?: (txId: string) => void, onBeforeClaimTxSent?: (txId: string) => void): Promise<string[]>;
+    /**
+     * Is this an LNURL-withdraw swap?
+     */
+    isLNURL(): boolean;
+    /**
+     * Gets the used LNURL or null if this is not an LNURL-withdraw swap
+     */
+    getLNURL(): string | null;
+    /**
+     * Pay the generated lightning network invoice with LNURL-withdraw
+     */
+    settleWithLNURLWithdraw(lnurl: string | LNURLWithdraw): Promise<void>;
+    serialize(): any;
+    /**
+     * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
+     *  data
+     *
+     * @private
+     */
+    private syncStateFromChain;
+    _shouldFetchExpiryStatus(): boolean;
+    _shouldFetchCommitStatus(): boolean;
+    _shouldCheckIntermediary(): boolean;
+    _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState, skipLpCheck?: boolean): Promise<boolean>;
+    _tick(save?: boolean): Promise<boolean>;
+}