@atomiqlabs/sdk 8.1.7 → 8.3.1

package/src/enums/SwapType.ts

@@ -1,15 +1,75 @@
-
 /**
- * Enum representing different types of swaps
+ * Enum representing different types of swap protocols used by atomiq.
+ *
  * @category Core
  */
 export enum SwapType {
+    /**
+     * Legacy escrow (PrTLC) based swap for Bitcoin -> Smart chains, requires manual initiation of the swap
+     *  on the destination chain.
+     *
+     * Handled by {@link FromBTCWrapper} & {@link FromBTCSwap}.
+     *
+     * Legacy swaps are only used on Solana!
+     */
     FROM_BTC=0,
+    /**
+     * Legacy escrow (HTLC) based swap for Bitcoin Lightning -> Smart chains, requires manual settlement of the swap on the
+     *  destination network once the lightning network payment is received by the LP
+     *
+     * Handled by {@link FromBTCLNWrapper} & {@link FromBTCLNSwap}.
+     *
+     * Legacy swaps are only used on Solana!
+     */
     FROM_BTCLN=1,
+    /**
+     * Escrow based (PrTLC) swap for Smart chains -> Bitcoin
+     *
+     * Handled by {@link ToBTCWrapper} & {@link ToBTCSwap}.
+     */
     TO_BTC=2,
+    /**
+     * Escrow based (HTLC) swap for Smart chains -> Bitcoin Lightning
+     *
+     * Handled by {@link ToBTCLNWrapper} & {@link ToBTCLNSwap}.
+     */
     TO_BTCLN=3,
+    /**
+     * Trusted swap for Bitcoin -> Smart chains, to be used for minor amounts to get gas tokens on the destination
+     *  chain, which is only needed for Solana, which still uses legacy swaps and doesn't support newer
+     *  {@link SPV_VAULT_FROM_BTC} & {@link FROM_BTCLN_AUTO} swaps.
+     *
+     * Handled by {@link OnchainForGasWrapper} & {@link OnchainForGasSwap}.
+     */
     TRUSTED_FROM_BTC=4,
+    /**
+     * Trusted swap for Bitcoin Lightning -> Smart chains, to be used for minor amounts to get gas tokens on the
+     *  destination chain, which is only needed for Solana, which still uses legacy swaps and doesn't support newer
+     *  {@link SPV_VAULT_FROM_BTC} & {@link FROM_BTCLN_AUTO} swaps.
+     *
+     * Handled by {@link LnForGasWrapper} & {@link LnForGasSwap}.
+     */
     TRUSTED_FROM_BTCLN=5,
+    /**
+     * New spv vault (UTXO-controlled vault) based swaps for Bitcoin -> Smart chain swaps not requiring any
+     *  initiation on the destination chain, and with the added possibility for the user to receive a
+     *  native token on the destination chain as part of the swap (a "gas drop" feature).
+     *
+     * Handled by {@link SpvFromBTCWrapper} & {@link SpvFromBTCSwap}.
+     *
+     * Used on all the supported chains except Solana!
+     */
     SPV_VAULT_FROM_BTC=6,
+    /**
+     * New escrow based (HTLC) swaps for Bitcoin Lightning -> Smart chain swaps not requiring manual
+     *  settlement on the destination by the user, and instead letting the LP initiate the escrow,
+     *  with the permissionless watchtower network managing the claiming of HTLC, with the swap secret
+     *  broadcasted over Nostr. Also adds a possibility for the user to receive a native token on the
+     *  destination chain as part of the swap (a "gas drop" feature).
+     *
+     * Handled by {@link FromBTCLNAutoWrapper} & {@link FromBTCLNAutoSwap}.
+     *
+     * Used on all the supported chains except Solana!
+     */
     FROM_BTCLN_AUTO=7
 }

package/src/errors/IntermediaryError.ts

@@ -1,9 +1,13 @@
 /**
  * An error or inconsistency in the intermediary's returned data, this will blacklist the intermediary
+ *
  * @category Errors
  */
 export class IntermediaryError extends Error {
 
+    /**
+     * Whether the error is recoverable and intermediary (LP) shouldn't be blacklisted for it
+     */
     recoverable: boolean;
     originalStack?: string;
 

package/src/errors/RequestError.ts

@@ -1,6 +1,7 @@
 
 /**
  * An error returned by the intermediary in a http response
+ *
  * @category Errors
  */
 export class RequestError extends Error {
@@ -18,7 +19,13 @@ export class RequestError extends Error {
         this.httpCode = httpCode;
     }
 
-    static parse(msg: string, httpCode: number): RequestError {
+    /**
+     * Parses a message + a response code returned by the intermediary (LP) as an error
+     *
+     * @param msg Raw response
+     * @param httpCode HTTP response status code
+     */
+    static parse(msg: string, httpCode: number): RequestError | OutOfBoundsError {
         try {
             const parsed = JSON.parse(msg);
             msg = parsed.msg;
@@ -34,11 +41,18 @@ export class RequestError extends Error {
 
 /**
  * An error indicating out of bounds (amount too high or too low) on swap initialization
+ *
  * @category Errors
  */
 export class OutOfBoundsError extends RequestError {
 
+    /**
+     * Swap minimum in base units of the token in which the quote was requested
+     */
     min: bigint;
+    /**
+     * Swap maximum in base units of the token in which the quote was requested
+     */
     max: bigint;
 
     constructor(msg: string, httpCode: number, min: bigint, max: bigint) {

package/src/errors/UserError.ts

@@ -1,5 +1,6 @@
 /**
  * An error on the user side, such as invalid address provided
+ *
  * @category Errors
  */
 export class UserError extends Error {

package/src/index.ts

@@ -20,7 +20,8 @@ export {
     IStorageManager,
     StorageObject,
     SwapContract,
-    SwapData
+    SwapData,
+    AbstractSigner
 } from "@atomiqlabs/base";
 
 export {
@@ -31,8 +32,6 @@ export {
 
 export * from "./bitcoin/wallet/BitcoinWallet";
 export * from "./bitcoin/wallet/IBitcoinWallet";
-export * from "./types/wallets/MinimalBitcoinWalletInterface";
-export * from "./types/wallets/MinimalLightningNetworkWalletInterface";
 export * from "./bitcoin/wallet/SingleAddressBitcoinWallet";
 
 export {CoinselectAddressTypes} from "./bitcoin/coinselect2";
@@ -43,7 +42,6 @@ export * from "./enums/SwapDirection";
 export * from "./enums/SwapType";
 
 export * from "./errors/IntermediaryError";
-export * from "./errors/PaymentAuthError";
 export * from "./errors/RequestError";
 export * from "./errors/UserError";
 
@@ -119,9 +117,12 @@ export * from "./types/fees/PercentagePPM";
 export * from "./types/lnurl/LNURLPay";
 export * from "./types/lnurl/LNURLWithdraw";
 
+export * from "./types/wallets/MinimalBitcoinWalletInterface";
+export * from "./types/wallets/MinimalLightningNetworkWalletInterface";
+export * from "./types/wallets/LightningInvoiceCreateService";
+
 export * from "./types/AmountData";
 export * from "./types/CustomPriceFunction";
-export * from "./types/PriceInfoType";
 export * from "./types/SwapExecutionAction";
 export * from "./types/SwapWithSigner";
 export * from "./types/Token";

package/src/intermediaries/Intermediary.ts

@@ -6,6 +6,7 @@ import {tryWithRetries} from "../utils/RetryUtils";
 
 /**
  * Services offered by an intermediary
+ *
  * @category Pricing and LPs
  */
 export type ServicesType = {
@@ -14,6 +15,7 @@ export type ServicesType = {
 
 /**
  * Reputation data for an intermediary on a single chain
+ *
  * @category Pricing and LPs
  */
 export type SingleChainReputationType = {
@@ -31,6 +33,7 @@ export type SingleChainReputationType = {
 
 /**
  * Smart chain liquidity data
+ *
  * @category Pricing and LPs
  */
 export type SCLiquidity = {
@@ -38,14 +41,27 @@ export type SCLiquidity = {
 };
 
 /**
- * Represents a liquidity provider/intermediary
+ * Represents an intermediary (liquidity provider)
+ *
  * @category Pricing and LPs
  */
 export class Intermediary {
 
+    /**
+     * Base URL where the intermediary is listening for HTTP requests
+     */
     readonly url: string;
+    /**
+     * Addresses of the intermediary on smart chains, used for checking the provided signatures
+     */
     readonly addresses: {[chainIdentifier: string]: string};
+    /**
+     * Swap protocol services offered by the intermediary
+     */
     readonly services: ServicesType;
+    /**
+     * Input/output swap bounds for various swap protocols offered by the intermediary
+     */
     readonly swapBounds: {
         [swapType in SwapType]?: {
             [chainIdentifier: string]: {
@@ -62,8 +78,21 @@ export class Intermediary {
             }
         }
     }
+    /**
+     * Reputation of the intermediary on different smart chains, this is only fetched
+     *  on-demand when creating a swap where reputation is checked
+     */
     reputation: { [chainIdentifier: string]: SingleChainReputationType } = {};
+    /**
+     * Liquidity of the intermediary across different smart chains, this is only fetched
+     *  on-demand when creating a swap where intermediary's liquidity is checked
+     */
     liquidity: { [chainIdentifier: string]: SCLiquidity } = {};
+    /**
+     * Data about a lightning network node used by this intermediary, if it offers lightning
+     *  network swaps, this is only fetched on-demand when creating a Bitcoin Lightning -> Smart chain
+     *  swap through the intermediary (which necessitates checking intermediary's channel capacities)
+     */
     lnData?: LNNodeLiquidity;
 
     constructor(
@@ -96,6 +125,13 @@ export class Intermediary {
         }
     }
 
+    /**
+     * Returns the input/output swap limit for given swap type, chain and token
+     *
+     * @param swapType Swap protocol service to check
+     * @param chainId Chain identifier of the smart chain to check
+     * @param tokenAddress Address of the token to check
+     */
     getSwapLimits(swapType: SwapType, chainId: string, tokenAddress: string): {input: {min?: bigint, max?: bigint}, output: {min?: bigint, max?: bigint}} | undefined {
         return this.swapBounds[swapType]?.[chainId]?.[tokenAddress];
     }
@@ -103,8 +139,8 @@ export class Intermediary {
     /**
      * Returns tokens supported by the intermediary, optionally constrained to the specific swap types
      *
-     * @param chainIdentifier
-     * @param swapTypesArr
+     * @param chainIdentifier Chain identifier of the smart chain to check
+     * @param swapTypesArr An array of swap type services to check
      * @private
      */
     private getSupportedTokens(chainIdentifier: string, swapTypesArr: SwapType[] = [
@@ -127,9 +163,10 @@ export class Intermediary {
     /**
      * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
      *
-     * @param chainIdentifier
-     * @param swapContract
-     * @param tokens
+     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param tokens An optional array of tokens to fetch the data for (by default it uses all tokens supported
+     *  by the intermediary)
      * @param abortSignal
      */
     async getReputation(
@@ -166,11 +203,11 @@ export class Intermediary {
     }
 
     /**
-     * Fetches, returns and saves the liquidity of the intermediaryfor a specific token
+     * Fetches, returns and saves the liquidity of the intermediary for a specific token
      *
-     * @param chainIdentifier
-     * @param swapContract
-     * @param token
+     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param token Token address of the token to fetch the liquidity for
      * @param abortSignal
      */
     async getLiquidity(
@@ -191,11 +228,21 @@ export class Intermediary {
         return result;
     }
 
+    /**
+     * Checks whether the intermediary supports swaps of any tokens on the smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
     supportsChain(chainIdentifier: string): boolean {
         if(this.addresses[chainIdentifier]==null) return false;
         return this.getSupportedTokens(chainIdentifier).size!==0;
     }
 
+    /**
+     * Returns intermediary's address on a given smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
     getAddress(chainIdentifier: string) {
         return this.addresses[chainIdentifier];
     }

package/src/intermediaries/IntermediaryDiscovery.ts

@@ -1,6 +1,6 @@
 import {Intermediary, ServicesType} from "./Intermediary";
 import {SwapType} from "../enums/SwapType";
-import {SignatureVerificationError, SwapContract} from "@atomiqlabs/base";
+import {SwapContract} from "@atomiqlabs/base";
 import {EventEmitter} from "events";
 import {Buffer} from "buffer";
 import {bigIntMax, bigIntMin, extendAbortController} from "../utils/Utils";
@@ -10,7 +10,8 @@ import {httpGet} from "../http/HttpUtils";
 import {tryWithRetries} from "../utils/RetryUtils";
 
 /**
- * Swap handler type enum for intermediary communication
+ * Swap handler type mapping for intermediary communication
+ *
  * @category Pricing and LPs
  */
 export enum SwapHandlerType {
@@ -26,6 +27,7 @@ export enum SwapHandlerType {
 
 /**
  * Swap handler information type
+ *
  * @category Pricing and LPs
  */
 export type SwapHandlerInfoType = {
@@ -47,6 +49,7 @@ type InfoHandlerResponseEnvelope = {
 
 /**
  * Token bounds (min/max) for swaps
+ *
  * @category Pricing and LPs
  */
 export type TokenBounds = {
@@ -57,7 +60,8 @@ export type TokenBounds = {
 }
 
 /**
- * Multi-chain token bounds
+ * Multi-chain token bounds (min/max) for swaps
+ *
  * @category Pricing and LPs
  */
 export type MultichainTokenBounds = {
@@ -65,7 +69,8 @@ export type MultichainTokenBounds = {
 }
 
 /**
- * Swap bounds by type
+ * Swap bounds by swap protocol type
+ *
  * @category Pricing and LPs
  */
 export type SwapBounds = {
@@ -74,6 +79,7 @@ export type SwapBounds = {
 
 /**
  * Multi-chain swap bounds
+ *
  * @category Pricing and LPs
  */
 export type MultichainSwapBounds = {
@@ -82,7 +88,7 @@ export type MultichainSwapBounds = {
 
 /**
  * Converts SwapHandlerType (represented as string & used in REST API communication with intermediaries) to regular
- *  SwapType
+ *  {@link SwapType}
  *
  * @param swapHandlerType
  */
@@ -108,7 +114,7 @@ function swapHandlerTypeToSwapType(swapHandlerType: SwapHandlerType): SwapType {
 }
 
 /**
- * A default intermediary comparator, only takes to announced fee into consideration
+ * A default intermediary comparator, only takes the announced fee into consideration
  *
  * @param swapType
  * @param tokenAddress
@@ -147,22 +153,41 @@ const REGISTRY_URL = "https://api.github.com/repos/adambor/SolLightning-registry
 const DEFAULT_CHAIN = "SOLANA";
 
 /**
- * Discovery service for available liquidity providers/intermediaries
+ * Discovery service for available intermediaries (liquidity providers)
+ *
  * @category Pricing and LPs
  */
 export class IntermediaryDiscovery extends EventEmitter {
 
+    /**
+     * A current list of active intermediaries
+     */
     intermediaries: Intermediary[] = [];
 
+    /**
+     * Swap contracts for checking intermediary signatures
+     */
     swapContracts: {[key: string]: SwapContract};
+    /**
+     * Registry URL used as a source for the list of intermediaries, this should be a link to a
+     *  github-hosted JSON file
+     */
     registryUrl: string;
 
+    /**
+     * Timeout for the HTTP handshake (/info) requests sent to the intermediaries
+     */
     httpRequestTimeout?: number;
     /**
-     * Maximum time (in millis) to wait for other LP's responses after the first one was founds
+     * Maximum time (in millis) to wait for other intermediary's responses after the first one was founds
      */
     maxWaitForOthersTimeout?: number;
 
+    /**
+     * The intermediary URLs passed in the constructor, to be used instead of querying the registry
+     *
+     * @private
+     */
     private overrideNodeUrls?: string[];
 
     constructor(
@@ -283,9 +308,13 @@ export class IntermediaryDiscovery extends EventEmitter {
     }
 
     /**
-     * Returns the intermediary at the provided URL, either from the already fetched list of LPs or fetches the data on-demand
+     * Returns the intermediary at the provided URL, either from the already fetched list of LPs
+     *  or fetches the data on-demand, by sending the handshake HTTP request (/info) to the LP.
      *
-     * @param url
+     * Doesn't save the fetched intermediary to the list of intermediaries if it isn't already
+     *  part of the known intermediaries
+     *
+     * @param url Base URL of the intermediary, which accepts HTTP requests
      * @param abortSignal
      */
     getIntermediary(url: string, abortSignal?: AbortSignal): Promise<Intermediary | null> {
@@ -296,6 +325,7 @@ export class IntermediaryDiscovery extends EventEmitter {
 
     /**
      * Reloads the saves a list of intermediaries
+     *
      * @param abortSignal
      */
     async reloadIntermediaries(abortSignal?: AbortSignal): Promise<void> {
@@ -334,6 +364,9 @@ export class IntermediaryDiscovery extends EventEmitter {
         return this.reloadIntermediaries(abortSignal);
     }
 
+    /**
+     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
+     */
     getMultichainSwapBounds(): MultichainSwapBounds {
         const bounds: MultichainSwapBounds = {};
 
@@ -366,7 +399,7 @@ export class IntermediaryDiscovery extends EventEmitter {
     }
 
     /**
-     * Returns aggregate swap bounds (in sats - BTC) as indicated by the intermediaries
+     * Returns aggregate swap bounds (in satoshis - BTC) as indicated by the intermediaries
      */
     getSwapBounds(chainIdentifier: string): SwapBounds {
         const bounds: SwapBounds = {};
@@ -397,15 +430,15 @@ export class IntermediaryDiscovery extends EventEmitter {
     }
 
     /**
-     * Returns the aggregate swap minimum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap minimum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMinimum(chainIdentifier: string, swapType: SwapType, token: any): number | null {
-        const tokenStr = token.toString();
+    getSwapMinimum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null {
+        const tokenStr = tokenAddress.toString();
         return this.intermediaries.reduce<number | null>((prevMin: number | null, intermediary: Intermediary) => {
             const swapService = intermediary.services[swapType];
             if(swapService==null) return prevMin;
@@ -417,15 +450,15 @@ export class IntermediaryDiscovery extends EventEmitter {
     }
 
     /**
-     * Returns the aggregate swap maximum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap maximum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMaximum(chainIdentifier: string, swapType: SwapType, token: any): number | null {
-        const tokenStr = token.toString();
+    getSwapMaximum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null {
+        const tokenStr = tokenAddress.toString();
         return this.intermediaries.reduce<number | null>((prevMax: number | null, intermediary: Intermediary) => {
             const swapService = intermediary.services[swapType];
             if(swapService==null) return prevMax;
@@ -439,13 +472,13 @@ export class IntermediaryDiscovery extends EventEmitter {
     /**
      * Returns swap candidates for a specific swap type & token address
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param tokenAddress
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      * @param amount Amount to be swapped in sats - BTC
      * @param count How many intermediaries to return at most
      */
-    getSwapCandidates(chainIdentifier: string, swapType: SwapType, tokenAddress: any, amount?: bigint, count?: number): Intermediary[] {
+    getSwapCandidates(chainIdentifier: string, swapType: SwapType, tokenAddress: string, amount?: bigint, count?: number): Intermediary[] {
         const candidates = this.intermediaries.filter(e => {
             const swapService = e.services[swapType];
             if(swapService==null) return false;

package/src/prices/RedundantSwapPrice.ts

@@ -13,6 +13,7 @@ import {tryWithRetries} from "../utils/RetryUtils";
 
 /**
  * Asset configuration for redundant swap pricing
+ *
  * @category Pricing and LPs
  */
 export type RedundantSwapPriceAssets<T extends MultiChain> = {
@@ -49,10 +50,20 @@ const logger = getLogger("RedundantSwapPrice: ");
 /**
  * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
  *  that there always is a functional API
+ *
  * @category Pricing and LPs
  */
 export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
 
+    /**
+     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
+     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
+     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
+     *
+     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
+     * @param assets Specifications of the assets
+     * @param cacheTimeout Timeout of the internal cache holding prices
+     */
     static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T> {
         const priceApis = [
             new BinancePriceProvider(assets.map(coinData => {
@@ -90,8 +101,8 @@ export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T
         return new RedundantSwapPrice(maxAllowedFeeDiffPPM, assets, priceApis, cacheTimeout);
     }
 
-    coinsDecimals: CoinDecimals<T> = {};
-    priceApis: {
+    protected coinsDecimals: CoinDecimals<T> = {};
+    protected priceApis: {
         priceApi: IPriceProvider<T>,
         operational?: boolean
     }[];
@@ -174,7 +185,7 @@ export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T
      * @param chainIdentifier
      * @param token
      * @param abortSignal
-     * @private
+     * @protected
      */
     protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint> {
         return tryWithRetries(async () => {
@@ -193,12 +204,14 @@ export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T
         }, undefined, RequestError, abortSignal);
     }
 
+    /**
+     * @inheritDoc
+     */
     protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null {
         if(this.coinsDecimals[chainIdentifier]==null) return null;
         return this.coinsDecimals[chainIdentifier]?.[token.toString()] ?? null;
     }
 
-
     /**
      * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
      *
@@ -228,6 +241,13 @@ export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T
         }
     }
 
+    /**
+     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param abortSignal
+     * @protected
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         return tryWithRetries(() => {
             const operationalPriceApi = this.getOperationalPriceApi();

package/src/prices/SingleSwapPrice.ts

@@ -3,7 +3,8 @@ import {ICachedSwapPrice} from "./abstract/ICachedSwapPrice";
 import {ChainIds, MultiChain} from "../swapper/Swapper";
 
 /**
- * Swap price API using single price source
+ * Swap price API using a single price source
+ *
  * @category Pricing and LPs
  */
 export class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
@@ -29,17 +30,19 @@ export class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
     }
 
     /**
-     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
-     *  token is not found
-     *
-     * @param chainIdentifier
-     * @param token
-     * @protected
+     * @inheritDoc
      */
     protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null {
         return this.priceProvider.getDecimals(chainIdentifier, token.toString());
     }
 
+    /**
+     * Fetches BTC price in USD
+     *
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         return this.priceProvider.getUsdPrice(abortSignal);
     }