@atomiqlabs/sdk 8.7.7 → 8.8.4

package/src/types/TokenAmount.ts

@@ -1,133 +1,133 @@
-import {ISwapPrice} from "../prices/abstract/ISwapPrice";
-import {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
-};
-
-/**
- * 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 {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
+};
+
+/**
+ * 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>;
 }

package/src/types/fees/Fee.ts

@@ -1,56 +1,56 @@
-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/src/types/fees/FeeBreakdown.ts

@@ -1,12 +1,12 @@
-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/src/types/fees/PercentagePPM.ts

@@ -1,26 +1,26 @@
-/**
- * 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 function ppmToPercentage(ppm: bigint): PercentagePPM {
-    const percentage = Number(ppm) / 10_000;
-    return {
-        ppm,
-        decimal: Number(ppm) / 1_000_000,
-        percentage: percentage,
-        toString: (decimals?: number) => (decimals != null ? percentage.toFixed(decimals) : percentage) + "%"
-    }
-}
+/**
+ * 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 function ppmToPercentage(ppm: bigint): PercentagePPM {
+    const percentage = Number(ppm) / 10_000;
+    return {
+        ppm,
+        decimal: Number(ppm) / 1_000_000,
+        percentage: percentage,
+        toString: (decimals?: number) => (decimals != null ? percentage.toFixed(decimals) : percentage) + "%"
+    }
+}

package/src/types/lnurl/LNURLPay.ts

@@ -1,79 +1,79 @@
-/**
- * Response of the LNURL-pay link
- *
- * @category Lightning
- */
-export type LNURLPayParams = {
-    tag: "payRequest";
-    callback: string;
-    domain: string;
-    minSendable: number;
-    maxSendable: number;
-    metadata: string;
-    decodedMetadata: string[][];
-    commentAllowed: number;
-}
-
-/**
- * Response of the LNURL-pay link with the added original url
- *
- * @category Lightning
- */
-export type LNURLPayParamsWithUrl = LNURLPayParams & { url: string };
-
-/**
- * Parsed LNURL-pay specification
- *
- * @category Lightning
- */
-export type LNURLPay = {
-    type: "pay",
-    min: bigint,
-    max: bigint,
-    commentMaxLength: number,
-    shortDescription?: string,
-    longDescription?: string,
-    icon?: string,
-    params: LNURLPayParamsWithUrl
-}
-
-/**
- * Type guard for {@link LNURLPayParams}
- *
- * @category Lightning
- * @internal
- */
-export function isLNURLPayParams(obj: any): obj is LNURLPayParams {
-    return obj.tag === "payRequest";
-}
-
-/**
- * Type guard for {@link LNURLPay}
- *
- * @category Lightning
- */
-export function isLNURLPay(value: any): value is LNURLPay {
-    return (
-        typeof value === "object" &&
-        value != null &&
-        value.type === "pay" &&
-        typeof (value.min) === "bigint" &&
-        typeof (value.max) === "bigint" &&
-        typeof value.commentMaxLength === "number" &&
-        (value.shortDescription === undefined || typeof value.shortDescription === "string") &&
-        (value.longDescription === undefined || typeof value.longDescription === "string") &&
-        (value.icon === undefined || typeof value.icon === "string") &&
-        isLNURLPayParams(value.params)
-    );
-}
-
-/**
- * Decoded LNURL-pay success action, revealed after a lightning payment is finished
- *
- * @category Lightning
- */
-export type LNURLDecodedSuccessAction = {
-    description: string,
-    text?: string,
-    url?: string
-};
+/**
+ * Response of the LNURL-pay link
+ *
+ * @category Lightning
+ */
+export type LNURLPayParams = {
+    tag: "payRequest";
+    callback: string;
+    domain: string;
+    minSendable: number;
+    maxSendable: number;
+    metadata: string;
+    decodedMetadata: string[][];
+    commentAllowed: number;
+}
+
+/**
+ * Response of the LNURL-pay link with the added original url
+ *
+ * @category Lightning
+ */
+export type LNURLPayParamsWithUrl = LNURLPayParams & { url: string };
+
+/**
+ * Parsed LNURL-pay specification
+ *
+ * @category Lightning
+ */
+export type LNURLPay = {
+    type: "pay",
+    min: bigint,
+    max: bigint,
+    commentMaxLength: number,
+    shortDescription?: string,
+    longDescription?: string,
+    icon?: string,
+    params: LNURLPayParamsWithUrl
+}
+
+/**
+ * Type guard for {@link LNURLPayParams}
+ *
+ * @category Lightning
+ * @internal
+ */
+export function isLNURLPayParams(obj: any): obj is LNURLPayParams {
+    return obj.tag === "payRequest";
+}
+
+/**
+ * Type guard for {@link LNURLPay}
+ *
+ * @category Lightning
+ */
+export function isLNURLPay(value: any): value is LNURLPay {
+    return (
+        typeof value === "object" &&
+        value != null &&
+        value.type === "pay" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        typeof value.commentMaxLength === "number" &&
+        (value.shortDescription === undefined || typeof value.shortDescription === "string") &&
+        (value.longDescription === undefined || typeof value.longDescription === "string") &&
+        (value.icon === undefined || typeof value.icon === "string") &&
+        isLNURLPayParams(value.params)
+    );
+}
+
+/**
+ * Decoded LNURL-pay success action, revealed after a lightning payment is finished
+ *
+ * @category Lightning
+ */
+export type LNURLDecodedSuccessAction = {
+    description: string,
+    text?: string,
+    url?: string
+};