@atomiqlabs/sdk 7.0.11 → 8.0.7

package/dist/swaps/IAddressSwap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type guard to check if an object is an IAddressSwap
+ * @category Swaps
+ */
+export declare function isIAddressSwap(obj: any): obj is IAddressSwap;
+/**
+ * Interface for swaps which require a user to send funds to a specific address
+ * @category Swaps
+ */
+export interface IAddressSwap {
+    getAddress(): string;
+    getHyperlink(): string;
+}

package/dist/swaps/IAddressSwap.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIAddressSwap = void 0;
+/**
+ * Type guard to check if an object is an IAddressSwap
+ * @category Swaps
+ */
+function isIAddressSwap(obj) {
+    return obj != null &&
+        typeof (obj.getAddress) === "function" &&
+        typeof (obj.getHyperlink) === "function";
+}
+exports.isIAddressSwap = isIAddressSwap;

package/dist/swaps/IBTCWalletSwap.d.ts

@@ -0,0 +1,55 @@
+import { IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
+import { Transaction } from "@scure/btc-signer";
+import { MinimalBitcoinWalletInterface, MinimalBitcoinWalletInterfaceWithSigner } from "../bitcoin/wallet/MinimalBitcoinWalletInterface";
+import { TokenAmount } from "../types/TokenAmount";
+import { BtcToken } from "../types/Token";
+/**
+ * Type guard to check if an object is an IBTCWalletSwap
+ * @category Swaps
+ */
+export declare function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap;
+/**
+ * Interface for swaps requiring Bitcoin wallet interaction
+ * @category Swaps
+ */
+export interface IBTCWalletSwap {
+    /**
+     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
+     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
+     *  `swap.submitPsbt()`
+     *
+     * @param _bitcoinWallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
+     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     */
+    getFundedPsbt(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number, additionalOutputs?: ({
+        amount: bigint;
+        outputScript: Uint8Array;
+    } | {
+        amount: bigint;
+        address: string;
+    })[]): Promise<{
+        psbt: Transaction;
+        psbtHex: string;
+        psbtBase64: string;
+        signInputs: number[];
+    }>;
+    /**
+     * Submits a PSBT signed by the wallet back to the SDK
+     *
+     * @param psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     */
+    submitPsbt(psbt: Transaction | string): Promise<string>;
+    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>> | null>;
+    sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string>;
+    /**
+     * Waits till the bitcoin transaction confirms
+     *
+     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
+     * @param checkIntervalSeconds How often to check the bitcoin transaction
+     * @param abortSignal Abort signal
+     * @throws {Error} if in invalid state (must be CLAIM_COMMITED)
+     */
+    waitForBitcoinTransaction(updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<string>;
+    getRequiredConfirmationsCount(): number;
+}

package/dist/swaps/IBTCWalletSwap.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIBTCWalletSwap = void 0;
+/**
+ * Type guard to check if an object is an IBTCWalletSwap
+ * @category Swaps
+ */
+function isIBTCWalletSwap(obj) {
+    return obj != null &&
+        typeof (obj.getFundedPsbt) === "function" &&
+        typeof (obj.submitPsbt) === "function" &&
+        typeof (obj.estimateBitcoinFee) === "function" &&
+        typeof (obj.sendBitcoinTransaction) === "function" &&
+        typeof (obj.waitForBitcoinTransaction) === "function" &&
+        typeof (obj.getRequiredConfirmationsCount) === "function";
+}
+exports.isIBTCWalletSwap = isIBTCWalletSwap;

package/dist/swaps/IClaimableSwap.d.ts

@@ -0,0 +1,17 @@
+import { ChainType } from "@atomiqlabs/base";
+import { ISwap } from "./ISwap";
+import { ISwapWrapper, SwapTypeDefinition } from "./ISwapWrapper";
+/**
+ * Type guard to check if an object is an IClaimableSwap
+ * @category Swaps
+ */
+export declare function isIClaimableSwap(obj: any): obj is IClaimableSwap;
+/**
+ * Interface for swaps that can be claimed
+ * @category Swaps
+ */
+export interface IClaimableSwap<T extends ChainType = ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IClaimableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IClaimableSwap<T, any, any>>, S extends number = number> extends ISwap<T, D, S> {
+    isClaimable(): boolean;
+    txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+}

package/dist/swaps/IClaimableSwap.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIClaimableSwap = void 0;
+/**
+ * Type guard to check if an object is an IClaimableSwap
+ * @category Swaps
+ */
+function isIClaimableSwap(obj) {
+    return obj != null &&
+        typeof (obj.isClaimable) === "function" &&
+        typeof (obj.txsClaim) === "function" &&
+        typeof (obj.claim) === "function";
+}
+exports.isIClaimableSwap = isIClaimableSwap;

package/dist/swaps/IClaimableSwapWrapper.d.ts

@@ -0,0 +1,5 @@
+import { ISwap } from "./ISwap";
+import { IClaimableSwap } from "./IClaimableSwap";
+export interface IClaimableSwapWrapper<T extends ISwap & IClaimableSwap = ISwap & IClaimableSwap> {
+    claimableSwapStates: T["state"][];
+}

package/dist/swaps/IClaimableSwapWrapper.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/swaps/IRefundableSwap.d.ts

@@ -0,0 +1,17 @@
+import { ChainType } from "@atomiqlabs/base";
+import { ISwap } from "./ISwap";
+import { ISwapWrapper, SwapTypeDefinition } from "./ISwapWrapper";
+/**
+ * Type guard to check if an object is an IRefundableSwap
+ * @category Swaps
+ */
+export declare function isIRefundableSwap(obj: any): obj is IRefundableSwap;
+/**
+ * Interface for swaps that can be refunded
+ * @category Swaps
+ */
+export interface IRefundableSwap<T extends ChainType = ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IRefundableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IRefundableSwap<T, any, any>>, S extends number = number> extends ISwap<T, D, S> {
+    isRefundable(): boolean;
+    txsRefund(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    refund(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+}

package/dist/swaps/IRefundableSwap.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIRefundableSwap = void 0;
+/**
+ * Type guard to check if an object is an IRefundableSwap
+ * @category Swaps
+ */
+function isIRefundableSwap(obj) {
+    return typeof (obj.isRefundable) === "function" &&
+        typeof (obj.txsRefund) === "function" &&
+        typeof (obj.refund) === "function";
+}
+exports.isIRefundableSwap = isIRefundableSwap;

package/dist/swaps/ISwap.d.ts

@@ -0,0 +1,207 @@
+/// <reference types="node" />
+import { SwapType } from "../enums/SwapType";
+import { EventEmitter } from "events";
+import { ISwapWrapper, SwapTypeDefinition } from "./ISwapWrapper";
+import { ChainType } from "@atomiqlabs/base";
+import { SwapDirection } from "../enums/SwapDirection";
+import { Fee } from "../types/fees/Fee";
+import { FeeBreakdown } from "../types/fees/FeeBreakdown";
+import { PercentagePPM } from "../types/fees/PercentagePPM";
+import { TokenAmount } from "../types/TokenAmount";
+import { Token } from "../types/Token";
+import { SwapExecutionAction } from "../types/SwapExecutionAction";
+import { LoggerType } from "../utils/Logger";
+import { PriceInfoType } from "../types/PriceInfoType";
+/**
+ * Initialization data for creating a swap
+ * @category Swaps
+ */
+export type ISwapInit = {
+    pricingInfo: PriceInfoType;
+    url?: string;
+    expiry: number;
+    swapFee: bigint;
+    swapFeeBtc: bigint;
+    exactIn: boolean;
+};
+/**
+ * Type guard to check if an object is an ISwapInit
+ * @category Swaps
+ */
+export declare function isISwapInit(obj: any): obj is ISwapInit;
+/**
+ * Base abstract class for all swap types
+ * @category Swaps
+ */
+export declare abstract class ISwap<T extends ChainType = ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, ISwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, ISwap<T, any, any>>, S extends number = number> {
+    protected readonly abstract TYPE: SwapType;
+    protected readonly abstract logger: LoggerType;
+    protected readonly currentVersion: number;
+    protected readonly wrapper: D["Wrapper"];
+    readonly url?: string;
+    readonly chainIdentifier: T["ChainId"];
+    readonly exactIn: boolean;
+    createdAt: number;
+    protected version: number;
+    protected initiated: boolean;
+    state: S;
+    expiry: number;
+    pricingInfo?: PriceInfoType;
+    protected swapFee: bigint;
+    protected swapFeeBtc: bigint;
+    /**
+     * Random nonce to differentiate the swap from others with the same identifier hash (i.e. when quoting the same swap
+     *  from multiple LPs)
+     */
+    randomNonce: string;
+    /**
+     * Event emitter emitting "swapState" event when swap's state changes
+     */
+    events: EventEmitter<{
+        swapState: [D["Swap"]];
+    }>;
+    protected constructor(wrapper: D["Wrapper"], obj: any);
+    protected constructor(wrapper: D["Wrapper"], swapInit: ISwapInit);
+    protected abstract upgradeVersion(): void;
+    /**
+     * Waits till the swap reaches a specific state
+     *
+     * @param targetState The state to wait for
+     * @param type Whether to wait for the state exactly or also to a state with a higher number
+     * @param abortSignal
+     * @protected
+     */
+    protected waitTillState(targetState: S, type?: "eq" | "gte" | "neq", abortSignal?: AbortSignal): Promise<void>;
+    abstract txsExecute(options?: any): Promise<SwapExecutionAction<T>[]>;
+    protected tryRecomputeSwapPrice(): void;
+    /**
+     * Re-fetches & revalidates the price data
+     */
+    refreshPriceData(): Promise<void>;
+    /**
+     * Checks if the pricing for the swap is valid, according to max allowed price difference set in the ISwapPrice
+     */
+    hasValidPrice(): boolean;
+    /**
+     * Returns pricing info about the swap
+     */
+    getPriceInfo(): {
+        marketPrice?: number;
+        swapPrice: number;
+        difference: PercentagePPM;
+    };
+    abstract _getEscrowHash(): string | null;
+    /**
+     * @param signer Signer to check with this swap's initiator
+     * @throws {Error} When signer's address doesn't match with the swap's initiator one
+     */
+    protected checkSigner(signer: T["Signer"] | string): void;
+    /**
+     * Checks if the swap's quote is still valid
+     */
+    abstract verifyQuoteValid(): Promise<boolean>;
+    abstract getInputAddress(): string | null;
+    abstract getOutputAddress(): string | null;
+    abstract getInputTxId(): string | null;
+    abstract getOutputTxId(): string | null;
+    /**
+     * Returns the ID of the swap, as used in the storage and getSwapById function
+     */
+    abstract getId(): string;
+    /**
+     * Checks whether there is some action required from the user for this swap - can mean either refundable or claimable
+     */
+    abstract requiresAction(): boolean;
+    /**
+     * Returns whether the swap is finished and in its terminal state (this can mean successful, refunded or failed)
+     */
+    abstract isFinished(): boolean;
+    /**
+     * Checks whether the swap's quote has definitely expired and cannot be committed anymore, we can remove such swap
+     */
+    abstract isQuoteExpired(): boolean;
+    /**
+     * Checks whether the swap's quote is soft expired (this means there is not enough time buffer for it to commit,
+     *  but it still can happen)
+     */
+    abstract isQuoteSoftExpired(): boolean;
+    /**
+     * Returns whether the swap finished successful
+     */
+    abstract isSuccessful(): boolean;
+    /**
+     * Returns whether the swap failed (e.g. was refunded)
+     */
+    abstract isFailed(): boolean;
+    /**
+     * Returns the intiator address of the swap - address that created this swap
+     */
+    abstract _getInitiator(): string;
+    isInitiated(): boolean;
+    _setInitiated(): void;
+    /**
+     * Returns quote expiry in UNIX millis
+     */
+    getQuoteExpiry(): number;
+    /**
+     * Returns the type of the swap
+     */
+    getType(): SwapType;
+    /**
+     * Returns the direction of the swap
+     */
+    getDirection(): SwapDirection;
+    /**
+     * Returns the current state of the swap
+     */
+    getState(): S;
+    /**
+     * Returns output amount of the swap, user receives this much
+     */
+    abstract getOutput(): TokenAmount | null;
+    /**
+     * Returns the output token of the swap
+     */
+    abstract getOutputToken(): Token<T["ChainId"]>;
+    /**
+     * Returns input amount of the swap, user needs to pay this much
+     */
+    abstract getInput(): TokenAmount | null;
+    /**
+     * Returns the input token of the swap
+     */
+    abstract getInputToken(): Token<T["ChainId"]>;
+    /**
+     * Returns input amount if the swap without the fees (swap fee, network fee)
+     */
+    abstract getInputWithoutFee(): TokenAmount | null;
+    /**
+     * Returns total fee for the swap, the fee is represented in source currency & destination currency, but is
+     *  paid only once
+     */
+    abstract getFee(): Fee;
+    /**
+     * Returns the breakdown of all the fees paid
+     */
+    abstract getFeeBreakdown(): FeeBreakdown<T["ChainId"]>;
+    serialize(): any;
+    _save(): Promise<void>;
+    _saveAndEmit(state?: S): Promise<void>;
+    _emitEvent(): void;
+    /**
+     * Synchronizes swap state from chain and/or LP node, usually ran on startup
+     *
+     * @param save whether to save the new swap state or not
+     *
+     * @returns {boolean} true if the swap changed, false if the swap hasn't changed
+     */
+    abstract _sync(save?: boolean): Promise<boolean>;
+    /**
+     * Runs quick checks on the swap, such as checking the expiry, usually ran periodically every few seconds
+     *
+     * @param save whether to save the new swap state or not
+     *
+     * @returns {boolean} true if the swap changed, false if the swap hasn't changed
+     */
+    abstract _tick(save?: boolean): Promise<boolean>;
+}

package/dist/swaps/ISwap.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwap = exports.isISwapInit = void 0;
+const SwapType_1 = require("../enums/SwapType");
+const events_1 = require("events");
+const Utils_1 = require("../utils/Utils");
+const SwapDirection_1 = require("../enums/SwapDirection");
+const PercentagePPM_1 = require("../types/fees/PercentagePPM");
+const Token_1 = require("../types/Token");
+const PriceInfoType_1 = require("../types/PriceInfoType");
+/**
+ * Type guard to check if an object is an ISwapInit
+ * @category Swaps
+ */
+function isISwapInit(obj) {
+    return typeof obj === 'object' &&
+        obj != null &&
+        (0, PriceInfoType_1.isPriceInfoType)(obj.pricingInfo) &&
+        (obj.url == null || typeof obj.url === 'string') &&
+        typeof obj.expiry === 'number' &&
+        typeof (obj.swapFee) === "bigint" &&
+        typeof (obj.swapFeeBtc) === "bigint" &&
+        (typeof obj.exactIn === 'boolean');
+}
+exports.isISwapInit = isISwapInit;
+/**
+ * Base abstract class for all swap types
+ * @category Swaps
+ */
+class ISwap {
+    constructor(wrapper, swapInitOrObj) {
+        this.currentVersion = 1;
+        this.initiated = false;
+        this.state = 0;
+        /**
+         * Event emitter emitting "swapState" event when swap's state changes
+         */
+        this.events = new events_1.EventEmitter();
+        this.chainIdentifier = wrapper.chainIdentifier;
+        this.wrapper = wrapper;
+        if (isISwapInit(swapInitOrObj)) {
+            this.pricingInfo = swapInitOrObj.pricingInfo;
+            this.url = swapInitOrObj.url;
+            this.expiry = swapInitOrObj.expiry;
+            this.swapFee = swapInitOrObj.swapFee;
+            this.swapFeeBtc = swapInitOrObj.swapFeeBtc;
+            this.exactIn = swapInitOrObj.exactIn;
+            this.version = this.currentVersion;
+            this.createdAt = Date.now();
+            this.randomNonce = (0, Utils_1.randomBytes)(16).toString("hex");
+        }
+        else {
+            this.expiry = swapInitOrObj.expiry;
+            this.url = swapInitOrObj.url;
+            this.state = swapInitOrObj.state;
+            if (swapInitOrObj._isValid != null && swapInitOrObj._differencePPM != null && swapInitOrObj._satsBaseFee != null &&
+                swapInitOrObj._feePPM != null && swapInitOrObj._swapPriceUSatPerToken != null) {
+                this.pricingInfo = {
+                    isValid: swapInitOrObj._isValid,
+                    differencePPM: BigInt(swapInitOrObj._differencePPM),
+                    satsBaseFee: BigInt(swapInitOrObj._satsBaseFee),
+                    feePPM: BigInt(swapInitOrObj._feePPM),
+                    realPriceUSatPerToken: (0, Utils_1.toBigInt)(swapInitOrObj._realPriceUSatPerToken),
+                    realPriceUsdPerBitcoin: swapInitOrObj._realPriceUsdPerBitcoin,
+                    swapPriceUSatPerToken: BigInt(swapInitOrObj._swapPriceUSatPerToken),
+                };
+            }
+            this.swapFee = (0, Utils_1.toBigInt)(swapInitOrObj.swapFee);
+            this.swapFeeBtc = (0, Utils_1.toBigInt)(swapInitOrObj.swapFeeBtc);
+            this.version = swapInitOrObj.version;
+            this.initiated = swapInitOrObj.initiated;
+            this.exactIn = swapInitOrObj.exactIn;
+            this.createdAt = swapInitOrObj.createdAt ?? swapInitOrObj.expiry;
+            this.randomNonce = swapInitOrObj.randomNonce;
+        }
+        if (this.version !== this.currentVersion) {
+            this.upgradeVersion();
+        }
+        if (this.initiated == null)
+            this.initiated = true;
+    }
+    /**
+     * Waits till the swap reaches a specific state
+     *
+     * @param targetState The state to wait for
+     * @param type Whether to wait for the state exactly or also to a state with a higher number
+     * @param abortSignal
+     * @protected
+     */
+    waitTillState(targetState, type = "eq", abortSignal) {
+        return new Promise((resolve, reject) => {
+            let listener;
+            listener = (swap) => {
+                if (type === "eq" ? swap.state === targetState : type === "gte" ? swap.state >= targetState : swap.state != targetState) {
+                    resolve();
+                    this.events.removeListener("swapState", listener);
+                }
+            };
+            this.events.on("swapState", listener);
+            if (abortSignal != null)
+                abortSignal.addEventListener("abort", () => {
+                    this.events.removeListener("swapState", listener);
+                    reject(abortSignal.reason);
+                });
+        });
+    }
+    //////////////////////////////
+    //// Pricing
+    tryRecomputeSwapPrice() {
+        if (this.pricingInfo == null)
+            return;
+        if (this.pricingInfo.swapPriceUSatPerToken == null) {
+            const priceUsdPerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
+            const input = this.getInput();
+            const output = this.getOutput();
+            if (input == null || output == null)
+                return;
+            if ((0, Token_1.isSCToken)(input.token) && this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC) {
+                this.pricingInfo = this.wrapper.prices.recomputePriceInfoSend(this.chainIdentifier, output.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, input.rawAmount, input.token.address);
+                this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
+            }
+            else if ((0, Token_1.isSCToken)(output.token) && this.getDirection() === SwapDirection_1.SwapDirection.FROM_BTC) {
+                this.pricingInfo = this.wrapper.prices.recomputePriceInfoReceive(this.chainIdentifier, input.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, output.rawAmount, output.token.address);
+                this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
+            }
+        }
+    }
+    /**
+     * Re-fetches & revalidates the price data
+     */
+    async refreshPriceData() {
+        if (this.pricingInfo == null)
+            return;
+        const priceUsdPerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
+        const input = this.getInput();
+        const output = this.getOutput();
+        if (input == null || output == null)
+            return;
+        if ((0, Token_1.isSCToken)(input.token) && this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC) {
+            this.pricingInfo = await this.wrapper.prices.isValidAmountSend(this.chainIdentifier, output.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, input.rawAmount, input.token.address);
+            this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
+        }
+        else if ((0, Token_1.isSCToken)(output.token) && this.getDirection() === SwapDirection_1.SwapDirection.FROM_BTC) {
+            this.pricingInfo = await this.wrapper.prices.isValidAmountReceive(this.chainIdentifier, input.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, output.rawAmount, output.token.address);
+            this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
+        }
+    }
+    /**
+     * Checks if the pricing for the swap is valid, according to max allowed price difference set in the ISwapPrice
+     */
+    hasValidPrice() {
+        if (this.pricingInfo == null)
+            throw new Error("Pricing info not found, cannot check price validity!");
+        return this.pricingInfo.isValid;
+    }
+    /**
+     * Returns pricing info about the swap
+     */
+    getPriceInfo() {
+        if (this.pricingInfo == null)
+            throw new Error("Pricing info not provided and not known!");
+        const swapPrice = this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC ?
+            100000000000000 / Number(this.pricingInfo.swapPriceUSatPerToken) :
+            Number(this.pricingInfo.swapPriceUSatPerToken) / 100000000000000;
+        let marketPrice;
+        if (this.pricingInfo.realPriceUSatPerToken != null)
+            marketPrice = this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC ?
+                100000000000000 / Number(this.pricingInfo.realPriceUSatPerToken) :
+                Number(this.pricingInfo.realPriceUSatPerToken) / 100000000000000;
+        return {
+            marketPrice,
+            swapPrice,
+            difference: (0, PercentagePPM_1.ppmToPercentage)(this.pricingInfo.differencePPM)
+        };
+    }
+    /**
+     * @param signer Signer to check with this swap's initiator
+     * @throws {Error} When signer's address doesn't match with the swap's initiator one
+     */
+    checkSigner(signer) {
+        if ((typeof (signer) === "string" ? signer : signer.getAddress()) !== this._getInitiator())
+            throw new Error("Invalid signer provided!");
+    }
+    isInitiated() {
+        return this.initiated;
+    }
+    _setInitiated() {
+        this.initiated = true;
+    }
+    /**
+     * Returns quote expiry in UNIX millis
+     */
+    getQuoteExpiry() {
+        return this.expiry;
+    }
+    /**
+     * Returns the type of the swap
+     */
+    getType() {
+        return this.TYPE;
+    }
+    /**
+     * Returns the direction of the swap
+     */
+    getDirection() {
+        return this.TYPE === SwapType_1.SwapType.TO_BTC || this.TYPE === SwapType_1.SwapType.TO_BTCLN ? SwapDirection_1.SwapDirection.TO_BTC : SwapDirection_1.SwapDirection.FROM_BTC;
+    }
+    /**
+     * Returns the current state of the swap
+     */
+    getState() {
+        return this.state;
+    }
+    //////////////////////////////
+    //// Storage
+    serialize() {
+        if (this.pricingInfo == null)
+            return {};
+        return {
+            id: this.getId(),
+            type: this.getType(),
+            escrowHash: this._getEscrowHash(),
+            initiator: this._getInitiator(),
+            _isValid: this.pricingInfo.isValid,
+            _differencePPM: this.pricingInfo.differencePPM == null ? null : this.pricingInfo.differencePPM.toString(10),
+            _satsBaseFee: this.pricingInfo.satsBaseFee == null ? null : this.pricingInfo.satsBaseFee.toString(10),
+            _feePPM: this.pricingInfo.feePPM == null ? null : this.pricingInfo.feePPM.toString(10),
+            _realPriceUSatPerToken: this.pricingInfo.realPriceUSatPerToken == null ? null : this.pricingInfo.realPriceUSatPerToken.toString(10),
+            _realPriceUsdPerBitcoin: this.pricingInfo.realPriceUsdPerBitcoin,
+            _swapPriceUSatPerToken: this.pricingInfo.swapPriceUSatPerToken == null ? null : this.pricingInfo.swapPriceUSatPerToken.toString(10),
+            state: this.state,
+            url: this.url,
+            swapFee: this.swapFee == null ? null : this.swapFee.toString(10),
+            swapFeeBtc: this.swapFeeBtc == null ? null : this.swapFeeBtc.toString(10),
+            expiry: this.expiry,
+            version: this.version,
+            initiated: this.initiated,
+            exactIn: this.exactIn,
+            createdAt: this.createdAt,
+            randomNonce: this.randomNonce
+        };
+    }
+    _save() {
+        if (this.isQuoteExpired()) {
+            return this.wrapper.removeSwapData(this);
+        }
+        else {
+            return this.wrapper.saveSwapData(this);
+        }
+    }
+    async _saveAndEmit(state) {
+        if (state != null)
+            this.state = state;
+        await this._save();
+        this._emitEvent();
+    }
+    //////////////////////////////
+    //// Events
+    _emitEvent() {
+        this.wrapper.events.emit("swapState", this);
+        this.events.emit("swapState", this);
+    }
+}
+exports.ISwap = ISwap;

package/dist/swaps/ISwapWithGasDrop.d.ts

@@ -0,0 +1,15 @@
+import { ChainType } from "@atomiqlabs/base";
+import { TokenAmount } from "../types/TokenAmount";
+import { SCToken } from "../types/Token";
+/**
+ * Type guard to check if a swap has gas drop functionality
+ * @category Swaps
+ */
+export declare function isSwapWithGasDrop(swap: any): swap is ISwapWithGasDrop<any>;
+/**
+ * Interface for swaps with gas drop functionality
+ * @category Swaps
+ */
+export interface ISwapWithGasDrop<T extends ChainType> {
+    getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+}