@atomiqlabs/sdk 8.9.1 → 8.9.2

package/src/types/Token.ts

@@ -1,163 +1,163 @@
-/**
- * Type for all token types (BTC or smart chain)
- *
- * @category Tokens
- */
-export type Token<ChainIdentifier extends string = string> = {
-    /**
-     * Chain identifier for the token's chain
-     */
-    chainId: ChainIdentifier | "BITCOIN" | "LIGHTNING",
-
-    /**
-     * Ticker of the token
-     */
-    ticker: string,
-    /**
-     * Full name of the token
-     */
-    name: string,
-    /**
-     * Actual decimal places of the tokens
-     */
-    decimals: number,
-    /**
-     * The decimal places that should be rendered and displayed to the user
-     */
-    displayDecimals?: number,
-
-    /**
-     * Address of the token contract, or `""` for Bitcoin
-     */
-    address: string,
-
-    // legacy compatibility
-    /**
-     * Legacy chain identifier distinguishing between Smart Chain and Bitcoin tokens
-     */
-    chain: "SC" | "BTC",
-    /**
-     * Legacy lightning flag, determines whether a Bitcoin token is an Lightning or on-chain one
-     */
-    lightning?: boolean,
-
-    // helpers
-    /**
-     * Equality check between tokens
-     */
-    equals: (other: Token) => boolean,
-    /**
-     * Returns the
-     */
-    toString: () => string
-};
-
-/**
- * Type guard for a {@link Token} type, encompassing all tokens (BTC or smart chain)
- *
- * @category Tokens
- */
-export function isToken(obj: any): obj is Token {
-    return typeof (obj) === "object" &&
-      (obj.chain === "SC" || obj.chain === "BTC") &&
-      typeof (obj.ticker) === "string" &&
-      typeof (obj.decimals) === "number" &&
-      typeof (obj.name) === "string";
-}
-
-/**
- * Bitcoin token type (BTC on on-chain or lightning)
- *
- * @category Tokens
- */
-export type BtcToken<L = boolean> = Token & {
-    chainId: L extends true ? "LIGHTNING" : "BITCOIN",
-    ticker: "BTC",
-    name: L extends true ? "Bitcoin (lightning L2)" : "Bitcoin (on-chain L1)",
-    decimals: 8,
-    displayDecimals: 8,
-
-    address: "",
-
-    // legacy compatibility
-    chain: "BTC",
-    lightning: L,
-
-    toString: () => L extends true ? "BTC-LN" : "BTC"
-};
-
-/**
- * Type guard for {@link BtcToken} (token on the bitcoin network - lightning or on-chain)
- *
- * @category Tokens
- */
-export function isBtcToken(obj: any): obj is BtcToken {
-    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
- */
-export const BitcoinTokens: {
-    BTC: BtcToken<false>,
-    BTCLN: BtcToken<true>
-} = {
-    BTC: {
-        chain: "BTC",
-        chainId: "BITCOIN",
-        lightning: false,
-        ticker: "BTC",
-        decimals: 8,
-        displayDecimals: 8,
-        name: "Bitcoin (on-chain L1)",
-        address: "",
-        equals: (other: Token) => 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: Token) => other.chainId==="LIGHTNING" && other.ticker==="BTC",
-        toString: () => "BTC-LN"
-    }
-};
-
-/**
- * Token on the smart chain
- *
- * @category Tokens
- */
-export type SCToken<ChainIdentifier extends string = string> = Token<ChainIdentifier> & {
-    chainId: ChainIdentifier,
-    chain: "SC"
-
-    toString: () => `${ChainIdentifier}-${string}`
-};
-
-/**
- * Type guard for {@link SCToken} (token on the smart chain)
- * @category Tokens
- */
-export function isSCToken<ChainIdentifier extends string = string>(obj: any, chainIdentifier?: ChainIdentifier[]): obj is SCToken<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";
-}
+/**
+ * Type for all token types (BTC or smart chain)
+ *
+ * @category Tokens
+ */
+export type Token<ChainIdentifier extends string = string> = {
+    /**
+     * Chain identifier for the token's chain
+     */
+    chainId: ChainIdentifier | "BITCOIN" | "LIGHTNING",
+
+    /**
+     * Ticker of the token
+     */
+    ticker: string,
+    /**
+     * Full name of the token
+     */
+    name: string,
+    /**
+     * Actual decimal places of the tokens
+     */
+    decimals: number,
+    /**
+     * The decimal places that should be rendered and displayed to the user
+     */
+    displayDecimals?: number,
+
+    /**
+     * Address of the token contract, or `""` for Bitcoin
+     */
+    address: string,
+
+    // legacy compatibility
+    /**
+     * Legacy chain identifier distinguishing between Smart Chain and Bitcoin tokens
+     */
+    chain: "SC" | "BTC",
+    /**
+     * Legacy lightning flag, determines whether a Bitcoin token is an Lightning or on-chain one
+     */
+    lightning?: boolean,
+
+    // helpers
+    /**
+     * Equality check between tokens
+     */
+    equals: (other: Token) => boolean,
+    /**
+     * Returns the
+     */
+    toString: () => string
+};
+
+/**
+ * Type guard for a {@link Token} type, encompassing all tokens (BTC or smart chain)
+ *
+ * @category Tokens
+ */
+export function isToken(obj: any): obj is Token {
+    return typeof (obj) === "object" &&
+      (obj.chain === "SC" || obj.chain === "BTC") &&
+      typeof (obj.ticker) === "string" &&
+      typeof (obj.decimals) === "number" &&
+      typeof (obj.name) === "string";
+}
+
+/**
+ * Bitcoin token type (BTC on on-chain or lightning)
+ *
+ * @category Tokens
+ */
+export type BtcToken<L = boolean> = Token & {
+    chainId: L extends true ? "LIGHTNING" : "BITCOIN",
+    ticker: "BTC",
+    name: L extends true ? "Bitcoin (lightning L2)" : "Bitcoin (on-chain L1)",
+    decimals: 8,
+    displayDecimals: 8,
+
+    address: "",
+
+    // legacy compatibility
+    chain: "BTC",
+    lightning: L,
+
+    toString: () => L extends true ? "BTC-LN" : "BTC"
+};
+
+/**
+ * Type guard for {@link BtcToken} (token on the bitcoin network - lightning or on-chain)
+ *
+ * @category Tokens
+ */
+export function isBtcToken(obj: any): obj is BtcToken {
+    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
+ */
+export const BitcoinTokens: {
+    BTC: BtcToken<false>,
+    BTCLN: BtcToken<true>
+} = {
+    BTC: {
+        chain: "BTC",
+        chainId: "BITCOIN",
+        lightning: false,
+        ticker: "BTC",
+        decimals: 8,
+        displayDecimals: 8,
+        name: "Bitcoin (on-chain L1)",
+        address: "",
+        equals: (other: Token) => 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: Token) => other.chainId==="LIGHTNING" && other.ticker==="BTC",
+        toString: () => "BTC-LN"
+    }
+};
+
+/**
+ * Token on the smart chain
+ *
+ * @category Tokens
+ */
+export type SCToken<ChainIdentifier extends string = string> = Token<ChainIdentifier> & {
+    chainId: ChainIdentifier,
+    chain: "SC"
+
+    toString: () => `${ChainIdentifier}-${string}`
+};
+
+/**
+ * Type guard for {@link SCToken} (token on the smart chain)
+ * @category Tokens
+ */
+export function isSCToken<ChainIdentifier extends string = string>(obj: any, chainIdentifier?: ChainIdentifier[]): obj is SCToken<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";
+}

package/src/types/TokenAmount.ts

@@ -1,167 +1,167 @@
-import {ISwapPrice} from "../prices/abstract/ISwapPrice";
-import {isToken, Token} from "./Token";
-import {PriceInfoType} from "./PriceInfoType";
-import {toDecimal} from "../utils/Utils";
-
-/**
- * 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
-};
-
-/**
- * Type guard for {@link TokenAmount}
- *
- * @category Tokens
- */
-export function isTokenAmount<
-    T extends Token = Token,
-    Known extends boolean = boolean
->(
-    obj: any,
-    token?: T,
-    known?: Known
-): obj is TokenAmount<T, Known> {
-    const hasExpectedKnownState = known == null
-        ? (
-            (typeof(obj?.rawAmount) === "bigint" && obj?.isUnknown === false) ||
-            (obj?.rawAmount === undefined && obj?.isUnknown === true)
-        )
-        : known
-            ? typeof(obj?.rawAmount) === "bigint" && obj?.isUnknown === false
-            : obj?.rawAmount === undefined && obj?.isUnknown === true;
-
-    return obj != null &&
-        typeof(obj) === "object" &&
-        typeof(obj.amount) === "string" &&
-        typeof(obj._amount) === "number" &&
-        (token == null ? isToken(obj.token) : token.equals(obj.token)) &&
-        typeof(obj.currentUsdValue) === "function" &&
-        typeof(obj.usdValue) === "function" &&
-        (obj.pastUsdValue == null || typeof(obj.pastUsdValue) === "number") &&
-        typeof(obj.toString) === "function" &&
-        hasExpectedKnownState;
-}
-
-/**
- * Factory function to create a TokenAmount
- *
- * @category Tokens
- * @internal
- */
-export 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> {
-    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
-    } as TokenAmount<T>;
-    const amountStr = toDecimal(amount, token.decimals, undefined, token.displayDecimals);
-    const _amount = parseFloat(amountStr);
-
-    let usdValue: number | undefined = 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?: AbortSignal, preFetchedUsdPrice?: number) =>
-        prices.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
-
-    return {
-        rawAmount: amount,
-        amount: amountStr,
-        _amount,
-        token,
-        currentUsdValue,
-        pastUsdValue: usdValue,
-        usdValue: async (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => {
-            if (usdValue == null) {
-                usdValue = await currentUsdValue(abortSignal, preFetchedUsdPrice);
-            }
-            return usdValue;
-        },
-        toString: () => amountStr + " " + token.ticker,
-        isUnknown: false
-    } as TokenAmount<T>;
-}
+import {ISwapPrice} from "../prices/abstract/ISwapPrice";
+import {isToken, Token} from "./Token";
+import {PriceInfoType} from "./PriceInfoType";
+import {toDecimal} from "../utils/Utils";
+
+/**
+ * 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
+};
+
+/**
+ * Type guard for {@link TokenAmount}
+ *
+ * @category Tokens
+ */
+export function isTokenAmount<
+    T extends Token = Token,
+    Known extends boolean = boolean
+>(
+    obj: any,
+    token?: T,
+    known?: Known
+): obj is TokenAmount<T, Known> {
+    const hasExpectedKnownState = known == null
+        ? (
+            (typeof(obj?.rawAmount) === "bigint" && obj?.isUnknown === false) ||
+            (obj?.rawAmount === undefined && obj?.isUnknown === true)
+        )
+        : known
+            ? typeof(obj?.rawAmount) === "bigint" && obj?.isUnknown === false
+            : obj?.rawAmount === undefined && obj?.isUnknown === true;
+
+    return obj != null &&
+        typeof(obj) === "object" &&
+        typeof(obj.amount) === "string" &&
+        typeof(obj._amount) === "number" &&
+        (token == null ? isToken(obj.token) : token.equals(obj.token)) &&
+        typeof(obj.currentUsdValue) === "function" &&
+        typeof(obj.usdValue) === "function" &&
+        (obj.pastUsdValue == null || typeof(obj.pastUsdValue) === "number") &&
+        typeof(obj.toString) === "function" &&
+        hasExpectedKnownState;
+}
+
+/**
+ * Factory function to create a TokenAmount
+ *
+ * @category Tokens
+ * @internal
+ */
+export 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> {
+    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
+    } as TokenAmount<T>;
+    const amountStr = toDecimal(amount, token.decimals, undefined, token.displayDecimals);
+    const _amount = parseFloat(amountStr);
+
+    let usdValue: number | undefined = 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?: AbortSignal, preFetchedUsdPrice?: number) =>
+        prices.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
+
+    return {
+        rawAmount: amount,
+        amount: amountStr,
+        _amount,
+        token,
+        currentUsdValue,
+        pastUsdValue: usdValue,
+        usdValue: async (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => {
+            if (usdValue == null) {
+                usdValue = await currentUsdValue(abortSignal, preFetchedUsdPrice);
+            }
+            return usdValue;
+        },
+        toString: () => amountStr + " " + token.ticker,
+        isUnknown: false
+    } as TokenAmount<T>;
+}