@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swaps/trusted/onchain/OnchainForGasWrapper.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens } from "../../ISwapWrapper";
+import { ChainType } from "@atomiqlabs/base";
+import { OnchainForGasSwap, OnchainForGasSwapState } from "./OnchainForGasSwap";
+import { BitcoinRpcWithAddressIndex } from "../../../bitcoin/BitcoinRpcWithAddressIndex";
+import { ISwapPrice } from "../../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { Intermediary } from "../../../intermediaries/Intermediary";
+import { SwapType } from "../../../enums/SwapType";
+import { UnifiedSwapEventListener } from "../../../events/UnifiedSwapEventListener";
+import { UnifiedSwapStorage } from "../../../storage/UnifiedSwapStorage";
+import { ISwap } from "../../ISwap";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+export type OnchainForGasWrapperOptions = ISwapWrapperOptions & {
+    bitcoinNetwork: BTC_NETWORK;
+};
+export type OnchainForGasSwapTypeDefinition<T extends ChainType> = SwapTypeDefinition<T, OnchainForGasWrapper<T>, OnchainForGasSwap<T>>;
+export declare class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, OnchainForGasSwapTypeDefinition<T>, OnchainForGasWrapperOptions> {
+    readonly TYPE = SwapType.TRUSTED_FROM_BTC;
+    readonly swapDeserializer: typeof OnchainForGasSwap;
+    readonly btcRpc: BitcoinRpcWithAddressIndex<any>;
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param prices Pricing to use
+     * @param tokens
+     * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, btcRpc: BitcoinRpcWithAddressIndex<any>, options: OnchainForGasWrapperOptions, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    /**
+     * Returns a newly created swap, receiving 'amount' base units of gas token
+     *
+     * @param signer
+     * @param amount            Amount you wish to receive in base units
+     * @param lpOrUrl           Intermediary/Counterparty swap service Intermediary object or raw url
+     * @param refundAddress     Bitcoin address to receive refund on in case the counterparty cannot execute the swap
+     */
+    create(signer: string, amount: bigint, lpOrUrl: Intermediary | string, refundAddress?: string): Promise<OnchainForGasSwap<T>>;
+    readonly pendingSwapStates: OnchainForGasSwapState[];
+    readonly tickSwapState: undefined;
+    protected processEvent: undefined;
+}

package/dist/swaps/trusted/onchain/OnchainForGasWrapper.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainForGasWrapper = void 0;
+const ISwapWrapper_1 = require("../../ISwapWrapper");
+const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
+const IntermediaryError_1 = require("../../../errors/IntermediaryError");
+const OnchainForGasSwap_1 = require("./OnchainForGasSwap");
+const SwapType_1 = require("../../../enums/SwapType");
+class OnchainForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param prices Pricing to use
+     * @param tokens
+     * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, btcRpc, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+        this.TYPE = SwapType_1.SwapType.TRUSTED_FROM_BTC;
+        this.swapDeserializer = OnchainForGasSwap_1.OnchainForGasSwap;
+        this.pendingSwapStates = [OnchainForGasSwap_1.OnchainForGasSwapState.PR_CREATED];
+        this.tickSwapState = undefined;
+        this.processEvent = undefined;
+        this.btcRpc = btcRpc;
+    }
+    /**
+     * Returns a newly created swap, receiving 'amount' base units of gas token
+     *
+     * @param signer
+     * @param amount            Amount you wish to receive in base units
+     * @param lpOrUrl           Intermediary/Counterparty swap service Intermediary object or raw url
+     * @param refundAddress     Bitcoin address to receive refund on in case the counterparty cannot execute the swap
+     */
+    async create(signer, amount, lpOrUrl, refundAddress) {
+        if (!this.isInitialized)
+            throw new Error("Not initialized, call init() first!");
+        const lpUrl = typeof (lpOrUrl) === "string" ? lpOrUrl : lpOrUrl.url;
+        const token = this.chain.getNativeCurrencyAddress();
+        const resp = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
+            address: signer,
+            amount,
+            refundAddress,
+            token
+        }, this.options.getRequestTimeout);
+        if (resp.total !== amount)
+            throw new IntermediaryError_1.IntermediaryError("Invalid total returned");
+        const pricingInfo = await this.verifyReturnedPrice(typeof (lpOrUrl) === "string" || lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTC] == null ?
+            { swapFeePPM: 10000, swapBaseFee: 10 } :
+            lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTC], false, resp.amountSats, amount, this.chain.getNativeCurrencyAddress(), {});
+        const quote = new OnchainForGasSwap_1.OnchainForGasSwap(this, {
+            paymentHash: resp.paymentHash,
+            sequence: resp.sequence,
+            address: resp.btcAddress,
+            inputAmount: resp.amountSats,
+            outputAmount: resp.total,
+            recipient: signer,
+            refundAddress,
+            pricingInfo,
+            url: lpUrl,
+            expiry: resp.expiresAt,
+            swapFee: resp.swapFee,
+            swapFeeBtc: resp.swapFeeSats,
+            exactIn: false,
+            token
+        });
+        await quote._save();
+        return quote;
+    }
+}
+exports.OnchainForGasWrapper = OnchainForGasWrapper;

package/dist/types/AmountData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple amount definition for swap operations
+ * @category Tokens
+ */
+export type AmountData = {
+    amount: bigint;
+    token: string;
+    exactIn: boolean;
+};

package/dist/types/AmountData.js

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

package/dist/types/CustomPriceFunction.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Custom pricing callback function type
+ * @category Pricing and LPs
+ */
+export type CustomPriceFunction = (tickers: string[], abortSignal?: AbortSignal) => Promise<number[]>;

package/dist/types/CustomPriceFunction.js

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

package/dist/types/PriceInfoType.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pricing information for swap validation
+ * @category Pricing and LPs
+ */
+export type PriceInfoType = {
+    isValid: boolean;
+    differencePPM: bigint;
+    satsBaseFee: bigint;
+    feePPM: bigint;
+    realPriceUSatPerToken?: bigint;
+    realPriceUsdPerBitcoin?: number;
+    swapPriceUSatPerToken: bigint;
+};
+/**
+ * Type guard for PriceInfoType
+ * @category Pricing and LPs
+ */
+export declare function isPriceInfoType(obj: any): obj is PriceInfoType;
+/**
+ * Serializes PriceInfoType for storage
+ * @category Pricing and LPs
+ */
+export declare function serializePriceInfoType(obj: PriceInfoType | undefined): any;
+/**
+ * Deserializes PriceInfoType from storage
+ * @category Pricing and LPs
+ */
+export declare function deserializePriceInfoType(obj: any): PriceInfoType | undefined;

package/dist/types/PriceInfoType.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializePriceInfoType = exports.serializePriceInfoType = exports.isPriceInfoType = void 0;
+const Utils_1 = require("../utils/Utils");
+/**
+ * Type guard for PriceInfoType
+ * @category Pricing and LPs
+ */
+function isPriceInfoType(obj) {
+    return obj != null &&
+        typeof (obj.isValid) === "boolean" &&
+        typeof (obj.differencePPM) === "bigint" &&
+        typeof (obj.satsBaseFee) === "bigint" &&
+        typeof (obj.feePPM) === "bigint" &&
+        (obj.realPriceUSatPerToken == null || typeof (obj.realPriceUSatPerToken) === "bigint") &&
+        (obj.realPriceUsdPerBitcoin == null || typeof (obj.realPriceUsdPerBitcoin) === "number") &&
+        typeof (obj.swapPriceUSatPerToken) === "bigint";
+}
+exports.isPriceInfoType = isPriceInfoType;
+/**
+ * Serializes PriceInfoType for storage
+ * @category Pricing and LPs
+ */
+function serializePriceInfoType(obj) {
+    if (obj == null)
+        return null;
+    return {
+        isValid: obj.isValid,
+        differencePPM: obj.differencePPM == null ? null : obj.differencePPM.toString(10),
+        satsBaseFee: obj.satsBaseFee == null ? null : obj.satsBaseFee.toString(10),
+        feePPM: obj.feePPM == null ? null : obj.feePPM.toString(10),
+        realPriceUSatPerToken: obj.realPriceUSatPerToken == null ? null : obj.realPriceUSatPerToken.toString(10),
+        realPriceUsdPerBitcoin: obj.realPriceUsdPerBitcoin,
+        swapPriceUSatPerToken: obj.swapPriceUSatPerToken == null ? null : obj.swapPriceUSatPerToken.toString(10),
+    };
+}
+exports.serializePriceInfoType = serializePriceInfoType;
+/**
+ * Deserializes PriceInfoType from storage
+ * @category Pricing and LPs
+ */
+function deserializePriceInfoType(obj) {
+    if (obj == null)
+        return;
+    if (obj.isValid != null && obj.differencePPM != null && obj.satsBaseFee != null &&
+        obj.feePPM != null && obj.swapPriceUSatPerToken != null)
+        return {
+            isValid: obj.isValid,
+            differencePPM: (0, Utils_1.toBigInt)(obj.differencePPM),
+            satsBaseFee: (0, Utils_1.toBigInt)(obj.satsBaseFee),
+            feePPM: (0, Utils_1.toBigInt)(obj.feePPM),
+            realPriceUSatPerToken: (0, Utils_1.toBigInt)(obj.realPriceUSatPerToken),
+            realPriceUsdPerBitcoin: obj.realPriceUsdPerBitcoin,
+            swapPriceUSatPerToken: (0, Utils_1.toBigInt)(obj.swapPriceUSatPerToken),
+        };
+}
+exports.deserializePriceInfoType = deserializePriceInfoType;

package/dist/types/SwapExecutionAction.d.ts

@@ -0,0 +1,7 @@
+import { ChainType } from "@atomiqlabs/base";
+export type SwapExecutionAction<T extends ChainType> = {
+    name: "Payment" | "Commit" | "Claim";
+    description: string;
+    chain: "LIGHTNING" | "BITCOIN" | T["ChainId"];
+    txs: any[];
+};

package/dist/types/SwapExecutionAction.js

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

package/dist/types/SwapWithSigner.d.ts

@@ -0,0 +1,14 @@
+import { ISwap } from "../swaps/ISwap";
+import { ChainType } from "@atomiqlabs/base";
+/**
+ * Proxy type that auto-injects signer into swap methods
+ * @category Swaps
+ */
+export type SwapWithSigner<T extends ISwap> = {
+    [K in keyof T]: K extends "commit" ? (abortSignal?: AbortSignal, skipChecks?: boolean) => Promise<string> : K extends "refund" ? (abortSignal?: AbortSignal) => Promise<string> : K extends "claim" ? (abortSignal?: AbortSignal) => Promise<string> : K extends "commitAndClaim" ? (abortSignal?: AbortSignal, skipChecks?: boolean) => Promise<string> : T[K];
+};
+/**
+ * Wraps a swap with automatic signer injection for methods like commit, refund, and claim
+ * @category Swaps
+ */
+export declare function wrapSwapWithSigner<C extends ChainType, T extends ISwap<C>>(swap: T, signer: C["Signer"]): SwapWithSigner<T>;

package/dist/types/SwapWithSigner.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSwapWithSigner = void 0;
+const IToBTCSwap_1 = require("../swaps/escrow_swaps/tobtc/IToBTCSwap");
+const IFromBTCSelfInitSwap_1 = require("../swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap");
+const FromBTCLNSwap_1 = require("../swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap");
+/**
+ * Wraps a swap with automatic signer injection for methods like commit, refund, and claim
+ * @category Swaps
+ */
+function wrapSwapWithSigner(swap, signer) {
+    return new Proxy(swap, {
+        get: (target, prop, receiver) => {
+            // Override the "sayGoodbye" method
+            if (prop === "commit") {
+                if (swap instanceof IToBTCSwap_1.IToBTCSwap || swap instanceof IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap) {
+                    return (abortSignal, skipChecks) => swap.commit(signer, abortSignal, skipChecks);
+                }
+            }
+            if (prop === "refund") {
+                if (swap instanceof IToBTCSwap_1.IToBTCSwap) {
+                    return (abortSignal) => swap.refund(signer, abortSignal);
+                }
+            }
+            if (prop === "claim") {
+                if (swap instanceof IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap) {
+                    return (abortSignal) => swap.claim(signer, abortSignal);
+                }
+            }
+            if (prop === "commitAndClaim") {
+                if (swap instanceof FromBTCLNSwap_1.FromBTCLNSwap) {
+                    return (abortSignal, skipChecks) => swap.commitAndClaim(signer, abortSignal, skipChecks);
+                }
+            }
+            // Delegate other properties and methods to the original instance
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+}
+exports.wrapSwapWithSigner = wrapSwapWithSigner;

package/dist/types/Token.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Bitcoin token type (on-chain or lightning)
+ * @category Tokens
+ */
+export type BtcToken<L = boolean> = {
+    chain: "BTC";
+    lightning: L;
+    ticker: "BTC";
+    decimals: 8;
+    name: L extends true ? "Bitcoin (lightning L2)" : "Bitcoin (on-chain L1)";
+    displayDecimals?: number;
+};
+/**
+ * Type guard for BtcToken
+ * @category Tokens
+ */
+export declare function isBtcToken(obj: any): obj is BtcToken;
+/**
+ * Predefined Bitcoin token constants
+ * @category Tokens
+ */
+export declare const BitcoinTokens: {
+    BTC: BtcToken<false>;
+    BTCLN: BtcToken<true>;
+};
+/**
+ * Smart Chain token type
+ * @category Tokens
+ */
+export type SCToken<ChainIdentifier extends string = string> = {
+    chain: "SC";
+    chainId: ChainIdentifier;
+    address: string;
+    ticker: string;
+    decimals: number;
+    displayDecimals?: number;
+    name: string;
+};
+/**
+ * Type guard for SCToken
+ * @category Tokens
+ */
+export declare function isSCToken(obj: any): obj is SCToken;
+/**
+ * Union type for all token types (BTC or smart chain)
+ * @category Tokens
+ */
+export type Token<ChainIdentifier extends string = string> = BtcToken | SCToken<ChainIdentifier>;
+/**
+ * Type guard for Token
+ * @category Tokens
+ */
+export declare function isToken(obj: any): obj is Token;

package/dist/types/Token.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isToken = exports.isSCToken = exports.BitcoinTokens = exports.isBtcToken = void 0;
+/**
+ * Type guard for BtcToken
+ * @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",
+        lightning: false,
+        ticker: "BTC",
+        decimals: 8,
+        name: "Bitcoin (on-chain L1)"
+    },
+    BTCLN: {
+        chain: "BTC",
+        lightning: true,
+        ticker: "BTC",
+        decimals: 8,
+        name: "Bitcoin (lightning L2)"
+    }
+};
+/**
+ * Type guard for SCToken
+ * @category Tokens
+ */
+function isSCToken(obj) {
+    return typeof (obj) === "object" &&
+        obj.chain === "SC" &&
+        typeof (obj.chainId) === "string" &&
+        typeof (obj.address) === "string" &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+exports.isSCToken = isSCToken;
+/**
+ * Type guard for Token
+ * @category Tokens
+ */
+function isToken(obj) {
+    return isBtcToken(obj) || isSCToken(obj);
+}
+exports.isToken = isToken;

package/dist/types/TokenAmount.d.ts

@@ -0,0 +1,57 @@
+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<ChainIdentifier extends string = string, T extends Token<ChainIdentifier> = Token<ChainIdentifier>> = {
+    /**
+     * Raw amount in base units represented as bigint
+     */
+    rawAmount: bigint;
+    /**
+     * Human readable amount with decimal places
+     */
+    amount: string;
+    /**
+     * Number representation of the decimal token amount (can lose precision!)
+     */
+    _amount: number;
+    /**
+     * Token associated with this amount
+     */
+    token: T;
+    /**
+     * Fetches the current USD value of the amount
+     *
+     * @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
+     *
+     * @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)
+     */
+    pastUsdValue?: number;
+    /**
+     * Returns the string representation of the amount along with the token ticker in format: {amount} {ticker}
+     */
+    toString: () => string;
+};
+/**
+ * Factory function to create a TokenAmount
+ * @category Tokens
+ */
+export declare function toTokenAmount<ChainIdentifier extends string = string, T extends Token<ChainIdentifier> = Token<ChainIdentifier>>(amount: bigint, token: T, prices: ISwapPrice, pricingInfo?: PriceInfoType): TokenAmount<ChainIdentifier, T>;

package/dist/types/TokenAmount.js

@@ -0,0 +1,47 @@
+"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
+ */
+function toTokenAmount(amount, token, prices, pricingInfo) {
+    if (amount == null)
+        return null; //Shouldn't happen
+    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
+    };
+}
+exports.toTokenAmount = toTokenAmount;

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

@@ -0,0 +1,49 @@
+import { PercentagePPM } from "./PercentagePPM";
+import { TokenAmount } from "../TokenAmount";
+import { Token } from "../Token";
+/**
+ * Represents a fee in both source and destination tokens, as well as providing USD valuation helpers and
+ *  fee composition
+ * @category Pricing and LPs
+ */
+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<ChainIdentifier, TSrc>;
+    /**
+     * Fee value equivalent in destination token
+     */
+    amountInDstToken: TokenAmount<ChainIdentifier, TDst>;
+    /**
+     * 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<ChainIdentifier>;
+        percentage: PercentagePPM;
+    };
+};

package/dist/types/fees/Fee.js

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

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

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

package/dist/types/fees/FeeBreakdown.js

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

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

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

package/dist/types/fees/PercentagePPM.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ppmToPercentage = void 0;
+/**
+ * Converts parts-per-million to percentage representation
+ * @category Pricing and LPs
+ */
+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;