@atomiqlabs/sdk 8.1.8 → 8.3.1

package/dist/errors/IntermediaryError.d.ts

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

package/dist/errors/IntermediaryError.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntermediaryError = void 0;
 /**
  * An error or inconsistency in the intermediary's returned data, this will blacklist the intermediary
+ *
  * @category Errors
  */
 class IntermediaryError extends Error {

package/dist/errors/RequestError.d.ts

@@ -1,18 +1,32 @@
 /**
  * An error returned by the intermediary in a http response
+ *
  * @category Errors
  */
 export declare class RequestError extends Error {
     httpCode: number;
     constructor(msg: string, httpCode: number);
-    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;
 }
 /**
  * An error indicating out of bounds (amount too high or too low) on swap initialization
+ *
  * @category Errors
  */
 export declare 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/dist/errors/RequestError.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OutOfBoundsError = exports.RequestError = void 0;
 /**
  * An error returned by the intermediary in a http response
+ *
  * @category Errors
  */
 class RequestError extends Error {
@@ -18,6 +19,12 @@ class RequestError extends Error {
         Object.setPrototypeOf(this, RequestError.prototype);
         this.httpCode = httpCode;
     }
+    /**
+     * 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, httpCode) {
         try {
             const parsed = JSON.parse(msg);
@@ -33,6 +40,7 @@ class RequestError extends Error {
 exports.RequestError = RequestError;
 /**
  * An error indicating out of bounds (amount too high or too low) on swap initialization
+ *
  * @category Errors
  */
 class OutOfBoundsError extends RequestError {

package/dist/errors/UserError.d.ts

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

package/dist/errors/UserError.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserError = void 0;
 /**
  * An error on the user side, such as invalid address provided
+ *
  * @category Errors
  */
 class UserError extends Error {

package/dist/index.d.ts

@@ -1,9 +1,7 @@
-export { LightningNetworkApi, BitcoinRpc, BitcoinRpcWithAddressIndex, BitcoinNetwork, BtcRelay, ChainData, ChainInterface, ChainType, CannotInitializeATAError, SignatureVerificationError, SwapDataVerificationError, TransactionRevertedError, ChainEvents, Messenger, SpvVaultContract, SpvVaultData, SpvWithdrawalTransactionData, ExecutionData, IStorageManager, StorageObject, SwapContract, SwapData } from "@atomiqlabs/base";
+export { LightningNetworkApi, BitcoinRpc, BitcoinRpcWithAddressIndex, BitcoinNetwork, BtcRelay, ChainData, ChainInterface, ChainType, CannotInitializeATAError, SignatureVerificationError, SwapDataVerificationError, TransactionRevertedError, ChainEvents, Messenger, SpvVaultContract, SpvVaultData, SpvWithdrawalTransactionData, ExecutionData, IStorageManager, StorageObject, SwapContract, SwapData, AbstractSigner } from "@atomiqlabs/base";
 export { MempoolApi, MempoolBitcoinRpc, MempoolApiError } from "@atomiqlabs/btc-mempool";
 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";
 export * from "./enums/FeeType";
@@ -11,7 +9,6 @@ export * from "./enums/SwapAmountType";
 export * from "./enums/SwapDirection";
 export * from "./enums/SwapType";
 export * from "./errors/IntermediaryError";
-export * from "./errors/PaymentAuthError";
 export * from "./errors/RequestError";
 export * from "./errors/UserError";
 export { Intermediary } from "./intermediaries/Intermediary";
@@ -72,9 +69,11 @@ export * from "./types/fees/FeeBreakdown";
 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/dist/index.js

@@ -31,15 +31,12 @@ Object.defineProperty(exports, "MempoolBitcoinRpc", { enumerable: true, get: fun
 Object.defineProperty(exports, "MempoolApiError", { enumerable: true, get: function () { return btc_mempool_1.MempoolApiError; } });
 __exportStar(require("./bitcoin/wallet/BitcoinWallet"), exports);
 __exportStar(require("./bitcoin/wallet/IBitcoinWallet"), exports);
-__exportStar(require("./types/wallets/MinimalBitcoinWalletInterface"), exports);
-__exportStar(require("./types/wallets/MinimalLightningNetworkWalletInterface"), exports);
 __exportStar(require("./bitcoin/wallet/SingleAddressBitcoinWallet"), exports);
 __exportStar(require("./enums/FeeType"), exports);
 __exportStar(require("./enums/SwapAmountType"), exports);
 __exportStar(require("./enums/SwapDirection"), exports);
 __exportStar(require("./enums/SwapType"), exports);
 __exportStar(require("./errors/IntermediaryError"), exports);
-__exportStar(require("./errors/PaymentAuthError"), exports);
 __exportStar(require("./errors/RequestError"), exports);
 __exportStar(require("./errors/UserError"), exports);
 var Intermediary_1 = require("./intermediaries/Intermediary");
@@ -144,9 +141,11 @@ __exportStar(require("./types/fees/FeeBreakdown"), exports);
 __exportStar(require("./types/fees/PercentagePPM"), exports);
 __exportStar(require("./types/lnurl/LNURLPay"), exports);
 __exportStar(require("./types/lnurl/LNURLWithdraw"), exports);
+__exportStar(require("./types/wallets/MinimalBitcoinWalletInterface"), exports);
+__exportStar(require("./types/wallets/MinimalLightningNetworkWalletInterface"), exports);
+__exportStar(require("./types/wallets/LightningInvoiceCreateService"), exports);
 __exportStar(require("./types/AmountData"), exports);
 __exportStar(require("./types/CustomPriceFunction"), exports);
-__exportStar(require("./types/PriceInfoType"), exports);
 __exportStar(require("./types/SwapExecutionAction"), exports);
 __exportStar(require("./types/SwapWithSigner"), exports);
 __exportStar(require("./types/Token"), exports);

package/dist/intermediaries/Intermediary.d.ts

@@ -3,6 +3,7 @@ import { SwapHandlerInfoType } from "./IntermediaryDiscovery";
 import { ChainSwapType, LNNodeLiquidity, SwapContract } from "@atomiqlabs/base";
 /**
  * Services offered by an intermediary
+ *
  * @category Pricing and LPs
  */
 export type ServicesType = {
@@ -10,6 +11,7 @@ export type ServicesType = {
 };
 /**
  * Reputation data for an intermediary on a single chain
+ *
  * @category Pricing and LPs
  */
 export type SingleChainReputationType = {
@@ -26,21 +28,35 @@ export type SingleChainReputationType = {
 };
 /**
  * Smart chain liquidity data
+ *
  * @category Pricing and LPs
  */
 export type SCLiquidity = {
     [token: string]: bigint;
 };
 /**
- * Represents a liquidity provider/intermediary
+ * Represents an intermediary (liquidity provider)
+ *
  * @category Pricing and LPs
  */
 export declare 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]: {
@@ -57,18 +73,38 @@ export declare 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(url: string, addresses: {
         [chainIdentifier: string]: string;
     }, services: ServicesType, reputation?: {
         [chainIdentifier: string]: SingleChainReputationType;
     });
+    /**
+     * 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;
@@ -82,29 +118,40 @@ export declare 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;
     /**
      * 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
      */
     getReputation(chainIdentifier: string, swapContract: SwapContract<any>, tokens?: string[], abortSignal?: AbortSignal): Promise<SingleChainReputationType>;
     /**
-     * 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
      */
     getLiquidity(chainIdentifier: string, swapContract: SwapContract<any>, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * 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;
+    /**
+     * Returns intermediary's address on a given smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
     getAddress(chainIdentifier: string): string;
 }

package/dist/intermediaries/Intermediary.js

@@ -4,12 +4,21 @@ exports.Intermediary = void 0;
 const SwapType_1 = require("../enums/SwapType");
 const RetryUtils_1 = require("../utils/RetryUtils");
 /**
- * Represents a liquidity provider/intermediary
+ * Represents an intermediary (liquidity provider)
+ *
  * @category Pricing and LPs
  */
 class Intermediary {
     constructor(url, addresses, services, reputation = {}) {
+        /**
+         * Reputation of the intermediary on different smart chains, this is only fetched
+         *  on-demand when creating a swap where reputation is checked
+         */
         this.reputation = {};
+        /**
+         * Liquidity of the intermediary across different smart chains, this is only fetched
+         *  on-demand when creating a swap where intermediary's liquidity is checked
+         */
         this.liquidity = {};
         this.url = url;
         this.addresses = addresses;
@@ -33,14 +42,21 @@ 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, chainId, tokenAddress) {
         return this.swapBounds[swapType]?.[chainId]?.[tokenAddress];
     }
     /**
      * 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
      */
     getSupportedTokens(chainIdentifier, swapTypesArr = [
@@ -63,9 +79,10 @@ 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(chainIdentifier, swapContract, tokens, abortSignal) {
@@ -89,11 +106,11 @@ class Intermediary {
         return reputation;
     }
     /**
-     * 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(chainIdentifier, swapContract, token, abortSignal) {
@@ -103,11 +120,21 @@ class Intermediary {
         this.liquidity[chainIdentifier][token] = result;
         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) {
         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) {
         return this.addresses[chainIdentifier];
     }

package/dist/intermediaries/IntermediaryDiscovery.d.ts

@@ -4,7 +4,8 @@ import { SwapType } from "../enums/SwapType";
 import { SwapContract } from "@atomiqlabs/base";
 import { EventEmitter } from "events";
 /**
- * Swap handler type enum for intermediary communication
+ * Swap handler type mapping for intermediary communication
+ *
  * @category Pricing and LPs
  */
 export declare enum SwapHandlerType {
@@ -19,6 +20,7 @@ export declare enum SwapHandlerType {
 }
 /**
  * Swap handler information type
+ *
  * @category Pricing and LPs
  */
 export type SwapHandlerInfoType = {
@@ -34,6 +36,7 @@ export type SwapHandlerInfoType = {
 };
 /**
  * Token bounds (min/max) for swaps
+ *
  * @category Pricing and LPs
  */
 export type TokenBounds = {
@@ -43,14 +46,16 @@ export type TokenBounds = {
     };
 };
 /**
- * Multi-chain token bounds
+ * Multi-chain token bounds (min/max) for swaps
+ *
  * @category Pricing and LPs
  */
 export type MultichainTokenBounds = {
     [chainId: string]: TokenBounds;
 };
 /**
- * Swap bounds by type
+ * Swap bounds by swap protocol type
+ *
  * @category Pricing and LPs
  */
 export type SwapBounds = {
@@ -58,26 +63,46 @@ export type SwapBounds = {
 };
 /**
  * Multi-chain swap bounds
+ *
  * @category Pricing and LPs
  */
 export type MultichainSwapBounds = {
     [key in SwapType]?: MultichainTokenBounds;
 };
 /**
- * Discovery service for available liquidity providers/intermediaries
+ * Discovery service for available intermediaries (liquidity providers)
+ *
  * @category Pricing and LPs
  */
 export declare 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?;
     constructor(swapContracts: {
         [key: string]: SwapContract;
@@ -107,14 +132,19 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      */
     private loadIntermediary;
     /**
-     * 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>;
     /**
      * Reloads the saves a list of intermediaries
+     *
      * @param abortSignal
      */
     reloadIntermediaries(abortSignal?: AbortSignal): Promise<void>;
@@ -124,39 +154,42 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      * @param abortSignal
      */
     init(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
+     */
     getMultichainSwapBounds(): MultichainSwapBounds;
     /**
-     * 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;
     /**
-     * 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;
+    getSwapMinimum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null;
     /**
-     * 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;
+    getSwapMaximum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null;
     /**
      * 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[];
     /**
      * Removes a specific intermediary from the list of active intermediaries (used for blacklisting)
      *