@atomiqlabs/sdk 8.6.6 → 8.6.8

package/dist/types/Token.js

@@ -1,76 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinTokens = void 0;
-exports.isToken = isToken;
-exports.isBtcToken = isBtcToken;
-exports.isSCToken = isSCToken;
-/**
- * Type guard for a {@link Token} type, encompassing all tokens (BTC or smart chain)
- *
- * @category Tokens
- */
-function isToken(obj) {
-    return typeof (obj) === "object" &&
-        (obj.chain === "SC" || obj.chain === "BTC") &&
-        typeof (obj.ticker) === "string" &&
-        typeof (obj.decimals) === "number" &&
-        typeof (obj.name) === "string";
-}
-/**
- * Type guard for {@link BtcToken} (token on the bitcoin network - lightning or on-chain)
- *
- * @category Tokens
- */
-function isBtcToken(obj) {
-    return typeof (obj) === "object" &&
-        obj.chain === "BTC" &&
-        typeof (obj.lightning) === "boolean" &&
-        typeof (obj.ticker) === "string" &&
-        typeof (obj.decimals) === "number" &&
-        typeof (obj.name) === "string";
-}
-/**
- * Predefined Bitcoin token constants
- *
- * @category Tokens
- */
-exports.BitcoinTokens = {
-    BTC: {
-        chain: "BTC",
-        chainId: "BITCOIN",
-        lightning: false,
-        ticker: "BTC",
-        decimals: 8,
-        displayDecimals: 8,
-        name: "Bitcoin (on-chain L1)",
-        address: "",
-        equals: (other) => other.chainId === "BITCOIN" && other.ticker === "BTC",
-        toString: () => "BTC"
-    },
-    BTCLN: {
-        chain: "BTC",
-        chainId: "LIGHTNING",
-        lightning: true,
-        ticker: "BTC",
-        decimals: 8,
-        displayDecimals: 8,
-        name: "Bitcoin (lightning L2)",
-        address: "",
-        equals: (other) => other.chainId === "LIGHTNING" && other.ticker === "BTC",
-        toString: () => "BTC-LN"
-    }
-};
-/**
- * Type guard for {@link SCToken} (token on the smart chain)
- * @category Tokens
- */
-function isSCToken(obj, chainIdentifier) {
-    return typeof (obj) === "object" &&
-        obj.chain === "SC" &&
-        typeof (obj.chainId) === "string" &&
-        (chainIdentifier == null || chainIdentifier.includes(obj.chainId)) &&
-        typeof (obj.address) === "string" &&
-        typeof (obj.ticker) === "string" &&
-        typeof (obj.decimals) === "number" &&
-        typeof (obj.name) === "string";
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSCToken = exports.BitcoinTokens = exports.isBtcToken = exports.isToken = void 0;
+/**
+ * Type guard for a {@link Token} type, encompassing all tokens (BTC or smart chain)
+ *
+ * @category Tokens
+ */
+function isToken(obj) {
+    return typeof (obj) === "object" &&
+        (obj.chain === "SC" || obj.chain === "BTC") &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+exports.isToken = isToken;
+/**
+ * Type guard for {@link BtcToken} (token on the bitcoin network - lightning or on-chain)
+ *
+ * @category Tokens
+ */
+function isBtcToken(obj) {
+    return typeof (obj) === "object" &&
+        obj.chain === "BTC" &&
+        typeof (obj.lightning) === "boolean" &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+exports.isBtcToken = isBtcToken;
+/**
+ * Predefined Bitcoin token constants
+ *
+ * @category Tokens
+ */
+exports.BitcoinTokens = {
+    BTC: {
+        chain: "BTC",
+        chainId: "BITCOIN",
+        lightning: false,
+        ticker: "BTC",
+        decimals: 8,
+        displayDecimals: 8,
+        name: "Bitcoin (on-chain L1)",
+        address: "",
+        equals: (other) => other.chainId === "BITCOIN" && other.ticker === "BTC",
+        toString: () => "BTC"
+    },
+    BTCLN: {
+        chain: "BTC",
+        chainId: "LIGHTNING",
+        lightning: true,
+        ticker: "BTC",
+        decimals: 8,
+        displayDecimals: 8,
+        name: "Bitcoin (lightning L2)",
+        address: "",
+        equals: (other) => other.chainId === "LIGHTNING" && other.ticker === "BTC",
+        toString: () => "BTC-LN"
+    }
+};
+/**
+ * Type guard for {@link SCToken} (token on the smart chain)
+ * @category Tokens
+ */
+function isSCToken(obj, chainIdentifier) {
+    return typeof (obj) === "object" &&
+        obj.chain === "SC" &&
+        typeof (obj.chainId) === "string" &&
+        (chainIdentifier == null || chainIdentifier.includes(obj.chainId)) &&
+        typeof (obj.address) === "string" &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+exports.isSCToken = isSCToken;

package/dist/types/TokenAmount.d.ts

@@ -1,69 +1,69 @@
-import { ISwapPrice } from "../prices/abstract/ISwapPrice";
-import { Token } from "./Token";
-import { PriceInfoType } from "./PriceInfoType";
-/**
- * Represents a token amount along with its formatted values and USD valuation helpers
- *
- * @category Tokens
- */
-export type TokenAmount<T extends Token = Token, Known extends boolean = boolean> = {
-    /**
-     * Raw amount in base units represented as bigint, might be `undefined` when the amount is unknown
-     */
-    rawAmount: Known extends true ? bigint : undefined;
-    /**
-     * Human readable amount with decimal places, might be empty string `""` when the amount is unknown
-     */
-    amount: string;
-    /**
-     * Number representation of the decimal token amount (can lose precision!), might be `NaN` when
-     *  the amount is unknown
-     */
-    _amount: number;
-    /**
-     * Token associated with this amount
-     */
-    token: T;
-    /**
-     * Fetches the current USD value of the amount, might return `NaN` when the amount is unknown
-     *
-     * @param abortSignal
-     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
-     * @returns A promise resolving to the current USD value of the token amount
-     */
-    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
-    /**
-     * Gets USD value of the amount, if this amount was returned from a swap it uses the USD value
-     *  when the swap was created, otherwise fetches the usd value on-demand, might return `NaN`
-     *  when the amount is unknown
-     *
-     * @param abortSignal
-     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
-     * @returns A promise resolving to the current USD value of the token amount
-     */
-    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
-    /**
-     * USD value of the amount when swap was created - only present for token amounts obtained
-     *  from swaps, left for convenience only, use usdValue() instead, which automatically
-     *  recognizes which pricing to use (either past value if available or fetches it on-demand),
-     *  might be `NaN` when the amount is unknown
-     */
-    pastUsdValue?: number;
-    /**
-     * Returns the string representation of the amount along with the token ticker in format: `"{amount} {ticker}"`,
-     *  in case the anmount is unknown returns `"??? {ticker}"`
-     */
-    toString: () => string;
-    /**
-     * Whether the token amount contains an unknown or undefined amount, in this case numeric values are `NaN`,
-     *  raw amount is `undefined`, string representation is `""` and `toString()` returns `"??? {ticker}"`
-     */
-    isUnknown: Known extends true ? false : true;
-};
-/**
- * Factory function to create a TokenAmount
- *
- * @category Tokens
- * @internal
- */
-export declare function toTokenAmount<T extends Token = Token, Known extends boolean = boolean>(amount: Known extends true ? bigint : null, token: T, prices: ISwapPrice, pricingInfo?: PriceInfoType): TokenAmount<T, Known>;
+import { ISwapPrice } from "../prices/abstract/ISwapPrice";
+import { Token } from "./Token";
+import { PriceInfoType } from "./PriceInfoType";
+/**
+ * Represents a token amount along with its formatted values and USD valuation helpers
+ *
+ * @category Tokens
+ */
+export type TokenAmount<T extends Token = Token, Known extends boolean = boolean> = {
+    /**
+     * Raw amount in base units represented as bigint, might be `undefined` when the amount is unknown
+     */
+    rawAmount: Known extends true ? bigint : undefined;
+    /**
+     * Human readable amount with decimal places, might be empty string `""` when the amount is unknown
+     */
+    amount: string;
+    /**
+     * Number representation of the decimal token amount (can lose precision!), might be `NaN` when
+     *  the amount is unknown
+     */
+    _amount: number;
+    /**
+     * Token associated with this amount
+     */
+    token: T;
+    /**
+     * Fetches the current USD value of the amount, might return `NaN` when the amount is unknown
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
+    /**
+     * Gets USD value of the amount, if this amount was returned from a swap it uses the USD value
+     *  when the swap was created, otherwise fetches the usd value on-demand, might return `NaN`
+     *  when the amount is unknown
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
+    /**
+     * USD value of the amount when swap was created - only present for token amounts obtained
+     *  from swaps, left for convenience only, use usdValue() instead, which automatically
+     *  recognizes which pricing to use (either past value if available or fetches it on-demand),
+     *  might be `NaN` when the amount is unknown
+     */
+    pastUsdValue?: number;
+    /**
+     * Returns the string representation of the amount along with the token ticker in format: `"{amount} {ticker}"`,
+     *  in case the anmount is unknown returns `"??? {ticker}"`
+     */
+    toString: () => string;
+    /**
+     * Whether the token amount contains an unknown or undefined amount, in this case numeric values are `NaN`,
+     *  raw amount is `undefined`, string representation is `""` and `toString()` returns `"??? {ticker}"`
+     */
+    isUnknown: Known extends true ? false : true;
+};
+/**
+ * Factory function to create a TokenAmount
+ *
+ * @category Tokens
+ * @internal
+ */
+export declare function toTokenAmount<T extends Token = Token, Known extends boolean = boolean>(amount: Known extends true ? bigint : null, token: T, prices: ISwapPrice, pricingInfo?: PriceInfoType): TokenAmount<T, Known>;

package/dist/types/TokenAmount.js

@@ -1,59 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toTokenAmount = toTokenAmount;
-const Utils_1 = require("../utils/Utils");
-/**
- * Factory function to create a TokenAmount
- *
- * @category Tokens
- * @internal
- */
-function toTokenAmount(amount, token, prices, pricingInfo) {
-    if (amount == null)
-        return {
-            rawAmount: undefined,
-            amount: "",
-            _amount: NaN,
-            token,
-            currentUsdValue: () => Promise.resolve(NaN),
-            pastUsdValue: NaN,
-            usdValue: () => Promise.resolve(NaN),
-            toString: () => "??? " + token.ticker,
-            isUnknown: true
-        };
-    const amountStr = (0, Utils_1.toDecimal)(amount, token.decimals, undefined, token.displayDecimals);
-    const _amount = parseFloat(amountStr);
-    let usdValue = undefined;
-    if (pricingInfo != null) {
-        if (token.chain === "BTC" && token.ticker === "BTC") {
-            if (pricingInfo.realPriceUsdPerBitcoin != null) {
-                usdValue = Number(amount) * pricingInfo.realPriceUsdPerBitcoin;
-            }
-        }
-        else {
-            if (pricingInfo.realPriceUsdPerBitcoin != null && pricingInfo.realPriceUSatPerToken != null) {
-                usdValue = _amount
-                    * pricingInfo.realPriceUsdPerBitcoin
-                    * Number(pricingInfo.realPriceUSatPerToken)
-                    / 1_000_000;
-            }
-        }
-    }
-    const currentUsdValue = (abortSignal, preFetchedUsdPrice) => prices.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
-    return {
-        rawAmount: amount,
-        amount: amountStr,
-        _amount,
-        token,
-        currentUsdValue,
-        pastUsdValue: usdValue,
-        usdValue: async (abortSignal, preFetchedUsdPrice) => {
-            if (usdValue == null) {
-                usdValue = await currentUsdValue(abortSignal, preFetchedUsdPrice);
-            }
-            return usdValue;
-        },
-        toString: () => amountStr + " " + token.ticker,
-        isUnknown: false
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTokenAmount = void 0;
+const Utils_1 = require("../utils/Utils");
+/**
+ * Factory function to create a TokenAmount
+ *
+ * @category Tokens
+ * @internal
+ */
+function toTokenAmount(amount, token, prices, pricingInfo) {
+    if (amount == null)
+        return {
+            rawAmount: undefined,
+            amount: "",
+            _amount: NaN,
+            token,
+            currentUsdValue: () => Promise.resolve(NaN),
+            pastUsdValue: NaN,
+            usdValue: () => Promise.resolve(NaN),
+            toString: () => "??? " + token.ticker,
+            isUnknown: true
+        };
+    const amountStr = (0, Utils_1.toDecimal)(amount, token.decimals, undefined, token.displayDecimals);
+    const _amount = parseFloat(amountStr);
+    let usdValue = undefined;
+    if (pricingInfo != null) {
+        if (token.chain === "BTC" && token.ticker === "BTC") {
+            if (pricingInfo.realPriceUsdPerBitcoin != null) {
+                usdValue = Number(amount) * pricingInfo.realPriceUsdPerBitcoin;
+            }
+        }
+        else {
+            if (pricingInfo.realPriceUsdPerBitcoin != null && pricingInfo.realPriceUSatPerToken != null) {
+                usdValue = _amount
+                    * pricingInfo.realPriceUsdPerBitcoin
+                    * Number(pricingInfo.realPriceUSatPerToken)
+                    / 1000000;
+            }
+        }
+    }
+    const currentUsdValue = (abortSignal, preFetchedUsdPrice) => prices.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
+    return {
+        rawAmount: amount,
+        amount: amountStr,
+        _amount,
+        token,
+        currentUsdValue,
+        pastUsdValue: usdValue,
+        usdValue: async (abortSignal, preFetchedUsdPrice) => {
+            if (usdValue == null) {
+                usdValue = await currentUsdValue(abortSignal, preFetchedUsdPrice);
+            }
+            return usdValue;
+        },
+        toString: () => amountStr + " " + token.ticker,
+        isUnknown: false
+    };
+}
+exports.toTokenAmount = toTokenAmount;

package/dist/types/fees/Fee.d.ts

@@ -1,50 +1,50 @@
-import { PercentagePPM } from "./PercentagePPM";
-import { TokenAmount } from "../TokenAmount";
-import { Token } from "../Token";
-/**
- * Fee represented in both, source and destination tokens, as well as providing USD valuation helpers and
- *  fee composition
- *
- * @category Pricing
- */
-export type Fee<ChainIdentifier extends string = string, TSrc extends Token<ChainIdentifier> = Token<ChainIdentifier>, TDst extends Token<ChainIdentifier> = Token<ChainIdentifier>> = {
-    /**
-     * Fee value equivalent in source token
-     */
-    amountInSrcToken: TokenAmount<TSrc, true>;
-    /**
-     * Fee value equivalent in destination token
-     */
-    amountInDstToken: TokenAmount<TDst, true>;
-    /**
-     * Fetches the current USD value of the fee
-     *
-     * @param abortSignal
-     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
-     * @returns A promise resolving to the current USD value of the token amount
-     */
-    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
-    /**
-     * Gets USD value of the fee, if the USD value when the swap was created is known (newer swaps) it returns this value,
-     *  otherwise fetches the usd value on-demand
-     *
-     * @param abortSignal
-     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
-     * @returns A promise resolving to the current USD value of the fee
-     */
-    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
-    /**
-     * USD value of the fee when swap was created - only present for newer swaps where the USD value at create
-     *  time is known. Left for convenience only, use usdValue() instead, which automatically
-     *  recognizes which pricing to use (either past value if available or fetches it on-demand)
-     */
-    pastUsdValue?: number;
-    /**
-     * Returns the composition of the fee (base fee + percentage fee) if known, the total fee is calculated as:
-     *  base_fee + amount * percentage_fee
-     */
-    composition?: {
-        base: TokenAmount;
-        percentage: PercentagePPM;
-    };
-};
+import { PercentagePPM } from "./PercentagePPM";
+import { TokenAmount } from "../TokenAmount";
+import { Token } from "../Token";
+/**
+ * Fee represented in both, source and destination tokens, as well as providing USD valuation helpers and
+ *  fee composition
+ *
+ * @category Pricing
+ */
+export type Fee<ChainIdentifier extends string = string, TSrc extends Token<ChainIdentifier> = Token<ChainIdentifier>, TDst extends Token<ChainIdentifier> = Token<ChainIdentifier>> = {
+    /**
+     * Fee value equivalent in source token
+     */
+    amountInSrcToken: TokenAmount<TSrc, true>;
+    /**
+     * Fee value equivalent in destination token
+     */
+    amountInDstToken: TokenAmount<TDst, true>;
+    /**
+     * Fetches the current USD value of the fee
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
+    /**
+     * Gets USD value of the fee, if the USD value when the swap was created is known (newer swaps) it returns this value,
+     *  otherwise fetches the usd value on-demand
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the fee
+     */
+    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>;
+    /**
+     * USD value of the fee when swap was created - only present for newer swaps where the USD value at create
+     *  time is known. Left for convenience only, use usdValue() instead, which automatically
+     *  recognizes which pricing to use (either past value if available or fetches it on-demand)
+     */
+    pastUsdValue?: number;
+    /**
+     * Returns the composition of the fee (base fee + percentage fee) if known, the total fee is calculated as:
+     *  base_fee + amount * percentage_fee
+     */
+    composition?: {
+        base: TokenAmount;
+        percentage: PercentagePPM;
+    };
+};

package/dist/types/fees/Fee.js

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

package/dist/types/fees/FeeBreakdown.d.ts

@@ -1,11 +1,11 @@
-import { FeeType } from "../../enums/FeeType";
-import { Fee } from "./Fee";
-/**
- * Breakdown of fees by type (swap fee, network fee, etc.)
- *
- * @category Pricing
- */
-export type FeeBreakdown<ChainIdentifier extends string = string> = {
-    type: FeeType;
-    fee: Fee<ChainIdentifier>;
-}[];
+import { FeeType } from "../../enums/FeeType";
+import { Fee } from "./Fee";
+/**
+ * Breakdown of fees by type (swap fee, network fee, etc.)
+ *
+ * @category Pricing
+ */
+export type FeeBreakdown<ChainIdentifier extends string = string> = {
+    type: FeeType;
+    fee: Fee<ChainIdentifier>;
+}[];

package/dist/types/fees/FeeBreakdown.js

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

package/dist/types/fees/PercentagePPM.d.ts

@@ -1,17 +1,17 @@
-/**
- * Parts-per-million fee representation with conversion helpers
- *
- * @category Pricing
- */
-export type PercentagePPM = {
-    ppm: bigint;
-    decimal: number;
-    percentage: number;
-    toString: (decimal?: number) => string;
-};
-/**
- * Converts parts-per-million to percentage representation
- *
- * @category Pricing
- */
-export declare function ppmToPercentage(ppm: bigint): PercentagePPM;
+/**
+ * Parts-per-million fee representation with conversion helpers
+ *
+ * @category Pricing
+ */
+export type PercentagePPM = {
+    ppm: bigint;
+    decimal: number;
+    percentage: number;
+    toString: (decimal?: number) => string;
+};
+/**
+ * Converts parts-per-million to percentage representation
+ *
+ * @category Pricing
+ */
+export declare function ppmToPercentage(ppm: bigint): PercentagePPM;

package/dist/types/fees/PercentagePPM.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ppmToPercentage = ppmToPercentage;
-/**
- * Converts parts-per-million to percentage representation
- *
- * @category Pricing
- */
-function ppmToPercentage(ppm) {
-    const percentage = Number(ppm) / 10_000;
-    return {
-        ppm,
-        decimal: Number(ppm) / 1_000_000,
-        percentage: percentage,
-        toString: (decimals) => (decimals != null ? percentage.toFixed(decimals) : percentage) + "%"
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ppmToPercentage = void 0;
+/**
+ * Converts parts-per-million to percentage representation
+ *
+ * @category Pricing
+ */
+function ppmToPercentage(ppm) {
+    const percentage = Number(ppm) / 10000;
+    return {
+        ppm,
+        decimal: Number(ppm) / 1000000,
+        percentage: percentage,
+        toString: (decimals) => (decimals != null ? percentage.toFixed(decimals) : percentage) + "%"
+    };
+}
+exports.ppmToPercentage = ppmToPercentage;