@lifi/sdk 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/allowance/index.js

@@ -1,3 +0,0 @@
-export * from './getAllowance';
-export * from './setAllowance';
-export * from './types';

package/dist/allowance/setAllowance.d.ts

@@ -1,5 +0,0 @@
-import type { Hash, WalletClient } from 'viem';
-import type { ApproveTokenRequest, RevokeApprovalRequest } from './types';
-export declare const setAllowance: (walletClient: WalletClient, tokenAddress: string, contractAddress: string, amount: bigint, returnPopulatedTransaction?: boolean) => Promise<Hash>;
-export declare const setTokenAllowance: ({ walletClient, token, spenderAddress, amount, infiniteApproval, }: ApproveTokenRequest) => Promise<Hash | undefined>;
-export declare const revokeTokenApproval: ({ walletClient, token, spenderAddress, }: RevokeApprovalRequest) => Promise<Hash | undefined>;

package/dist/allowance/types.js

@@ -1 +0,0 @@
-export {};

package/dist/balance/index.d.ts

@@ -1,2 +0,0 @@
-export * from './getBalance';
-export * from './getTokenBalance';

package/dist/balance/index.js

@@ -1,2 +0,0 @@
-export * from './getBalance';
-export * from './getTokenBalance';

package/dist/cjs/LiFi.d.ts

@@ -1,171 +0,0 @@
-import type { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
-import type { Hash, PublicClient } from 'viem';
-import type { ApproveTokenRequest, RevokeApprovalRequest, TokenAllowance, TokenSpender } from './allowance';
-import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import type { Config, ConfigUpdate } from './types';
-export declare class LiFi extends RouteExecutionManager {
-    private chainsService;
-    constructor(configUpdate: ConfigUpdate);
-    /**
-     * Get the current configuration of the SDK
-     * @returns - The config object
-     */
-    getConfig: () => Config;
-    /**
-     * Get the SDK configuration after all setup calls are finished
-     * @returns - The config object
-     */
-    getConfigAsync: () => Promise<Config>;
-    /**
-     * Get an instance of a provider for a specific chain
-     * @param chainId - Id of the chain the provider is for
-     * @returns The public client for the given chain
-     */
-    getPublicClient: (chainId: number) => Promise<PublicClient>;
-    /**
-     * Set a new confuration for the SDK
-     * @param configUpdate - An object containing the configuration fields that should be updated.
-     * @returns The renewed config object
-     */
-    setConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
-    /**
-     * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
-     * @param request - Object defining preferences regarding chain, exchanges and bridges
-     * @param options
-     * @returns Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
-     */
-    getPossibilities: (request?: PossibilitiesRequest, options?: RequestOptions) => Promise<PossibilitiesResponse>;
-    /**
-     * Fetch information about a Token
-     * @param chain - Id or key of the chain that contains the token
-     * @param token - Address or symbol of the token on the requested chain
-     * @param options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     */
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions) => Promise<Token>;
-    /**
-     * Get a quote for a token transfer
-     * @param request - The configuration of the requested quote
-     * @param options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     */
-    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Get a quote for a destination contract call
-     * @param request - The configuration of the requested destination call
-     * @param options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns - Returns step.
-     */
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
-     * @param request - Configuration of the requested status
-     * @param options - Rrquest options.
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns Returns status response.
-     */
-    getStatus: (request: GetStatusRequest, options?: RequestOptions) => Promise<StatusResponse>;
-    /**
-     * Get the available tools to bridge and swap tokens.
-     * @param request - The configuration of the requested tools
-     * @param options
-     * @returns The tools that are available on the requested chains
-     */
-    getTools: (request?: ToolsRequest, options?: RequestOptions) => Promise<ToolsResponse>;
-    /**
-     * Get all known tokens.
-     * @param request - The configuration of the requested tokens
-     * @param options
-     * @returns The tokens that are available on the requested chains
-     */
-    getTokens: (request?: TokensRequest, options?: RequestOptions) => Promise<TokensResponse>;
-    /**
-     * Get all available chains
-     * @returns A list of all available chains
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getChains: () => Promise<ExtendedChain[]>;
-    /**
-     * Get a set of routes for a request that describes a transfer of tokens.
-     * @param request - A description of the transfer.
-     * @param options
-     * @returns The resulting routes that can be used to realize the described transfer of tokens.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
-    /**
-     * Get the transaction data for a single step of a route
-     * @param step - The step object.
-     * @param options
-     * @returns The step populated with the transaction data.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getStepTransaction: (step: LifiStep, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Get gas recommendation for a certain chain
-     * @param request - Configuration of the requested recommendation.
-     * @param options
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
-    /**
-     * Returns the balances of a specific token a wallet holds across all aggregated chains.
-     * @param walletAddress - A wallet address.
-     * @param token - A Token object.
-     * @returns An object containing the token and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
-    /**
-     * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
-     * @param walletAddress - A wallet address.
-     * @param tokens - A list of Token objects.
-     * @returns A list of objects containing the tokens and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-    /**
-     * This method queries the balances of tokens for a specific list of chains for a given wallet.
-     * @param walletAddress - A walletaddress.
-     * @param tokensByChain - A list of Token objects organized by chain ids.
-     * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalancesByChain: (walletAddress: string, tokensByChain: {
-        [chainId: number]: Token[];
-    }) => Promise<{
-        [chainId: number]: TokenAmount[];
-    }>;
-    /**
-     * Get the current allowance for a certain token.
-     * @param token - The token that should be checked
-     * @param ownerAddress - The owner of the token
-     * @param spenderAddress - The spender address that has to be approved
-     */
-    getTokenAllowance: (token: Token, ownerAddress: string, spenderAddress: string) => Promise<bigint | undefined>;
-    /**
-     * Get the current allowance for a list of token / spender address pairs.
-     * @param ownerAddress - The owner of the tokens
-     * @param tokens - A list of token and spender address pairs
-     */
-    getTokenAllowanceMulticall: (ownerAddress: string, tokens: TokenSpender[]) => Promise<TokenAllowance[]>;
-    /**
-     * Set approval for a certain token and amount.
-     * @param request - The approval request
-     */
-    setTokenApproval: (request: ApproveTokenRequest) => Promise<Hash | void>;
-    /**
-     * Revoke approval for a certain token.
-     * @param request - The revoke request
-     */
-    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<Hash | void>;
-    /**
-     * Get all the available connections for swap/bridging tokens
-     * @param connectionRequest ConnectionsRequest
-     * @returns ConnectionsResponse
-     */
-    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-}

package/dist/cjs/allowance/index.d.ts

@@ -1,3 +0,0 @@
-export * from './getAllowance';
-export * from './setAllowance';
-export * from './types';

package/dist/cjs/allowance/setAllowance.d.ts

@@ -1,5 +0,0 @@
-import type { Hash, WalletClient } from 'viem';
-import type { ApproveTokenRequest, RevokeApprovalRequest } from './types';
-export declare const setAllowance: (walletClient: WalletClient, tokenAddress: string, contractAddress: string, amount: bigint, returnPopulatedTransaction?: boolean) => Promise<Hash>;
-export declare const setTokenAllowance: ({ walletClient, token, spenderAddress, amount, infiniteApproval, }: ApproveTokenRequest) => Promise<Hash | undefined>;
-export declare const revokeTokenApproval: ({ walletClient, token, spenderAddress, }: RevokeApprovalRequest) => Promise<Hash | undefined>;

package/dist/cjs/allowance/types.d.ts

@@ -1,27 +0,0 @@
-import type { Token } from '@lifi/types';
-import type { WalletClient } from 'viem';
-export type TokenSpender = {
-    token: Token;
-    spenderAddress: string;
-};
-export type TokenAllowance = {
-    token: Token;
-    allowance?: bigint;
-};
-export type TokenSpenderAllowance = {
-    token: Token;
-    spenderAddress: string;
-    allowance?: bigint;
-};
-export interface ApproveTokenRequest {
-    walletClient: WalletClient;
-    token: Token;
-    spenderAddress: string;
-    amount: bigint;
-    infiniteApproval?: boolean;
-}
-export interface RevokeApprovalRequest {
-    walletClient: WalletClient;
-    token: Token;
-    spenderAddress: string;
-}

package/dist/cjs/balance/getBalance.d.ts

@@ -1,2 +0,0 @@
-import type { Token, TokenAmount } from '@lifi/types';
-export declare const getBalance: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;

package/dist/cjs/balance/getTokenBalance.d.ts

@@ -1,8 +0,0 @@
-import type { Token, TokenAmount } from '@lifi/types';
-export declare const getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
-export declare const getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-export declare const getTokenBalancesByChain: (walletAddress: string, tokensByChain: {
-    [chainId: number]: Token[];
-}) => Promise<{
-    [chainId: number]: TokenAmount[];
-}>;

package/dist/cjs/balance/index.d.ts

@@ -1,2 +0,0 @@
-export * from './getBalance';
-export * from './getTokenBalance';

package/dist/cjs/execution/StatusManager.d.ts

@@ -1,67 +0,0 @@
-import type { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
-interface Receipt {
-    fromAmount?: string;
-    toAmount?: string;
-    toToken?: Token;
-    gasPrice?: string;
-    gasUsed?: string;
-    gasToken?: Token;
-    gasAmount?: string;
-    gasAmountUSD?: string;
-}
-type InternalUpdateRouteCallback = (route: Route) => void;
-type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage' | 'multisigTxHash'>>;
-/**
- * Manages status updates of a route and provides various functions for tracking processes
- * @param {Route} route The route this StatusManger belongs to.
- * @param {InternalExecutionSettings} settings The ExecutionSettings for this route.
- * @param {InternalUpdateRouteCallback} internalUpdateRouteCallback Internal callback to propage route changes.
- * @returns {StatusManager} An instance of StatusManager.
- */
-export declare class StatusManager {
-    private readonly route;
-    private readonly settings;
-    private readonly internalUpdateRouteCallback;
-    private shouldUpdate;
-    constructor(route: Route, settings: InternalExecutionSettings, internalUpdateRouteCallback: InternalUpdateRouteCallback);
-    /**
-     * Initializes the execution object of a Step.
-     * @param step  The current step in execution
-     * @returns The initialized execution object for this step and a function to update this step
-     */
-    initExecutionObject: (step: LifiStep) => Execution;
-    /**
-     * Updates the execution object of a Step.
-     * @param step  The current step in execution
-     * @param status  The status for the execution
-     * @param receipt Optional. Information about received tokens
-     * @returns       The step with the updated execution object
-     */
-    updateExecution(step: LifiStep, status: Status, receipt?: Receipt): LifiStep;
-    /**
-     * Create and push a new process into the execution.
-     * @param step The step that should contain the new process.
-     * @param type Type of the process. Used to identify already existing processes.
-     * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
-     * @returns Returns process.
-     */
-    findOrCreateProcess: (step: LifiStep, type: ProcessType, status?: Status) => Process;
-    /**
-     * Update a process object.
-     * @param step The step where the process should be updated
-     * @param type  The process type to update
-     * @param status The status the process gets.
-     * @param [params]   Additional parameters to append to the process.
-     * @returns The update process
-     */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
-    /**
-     * Remove a process from the execution
-     * @param step The step where the process should be removed from
-     * @param type  The process type to remove
-     */
-    removeProcess: (step: LifiStep, type: ProcessType) => void;
-    updateStepInRoute: (step: LifiStep) => LifiStep;
-    allowUpdates(value: boolean): void;
-}
-export {};

package/dist/cjs/execution/StepExecutionManager.d.ts

@@ -1,7 +0,0 @@
-import type { Execution } from '@lifi/types';
-import type { ExecutionParams } from '../types';
-export declare class StepExecutionManager {
-    allowUserInteraction: boolean;
-    allowInteraction: (value: boolean) => void;
-    execute: ({ walletClient, step, statusManager, settings, }: ExecutionParams) => Promise<Execution>;
-}

package/dist/cjs/execution/StepExecutor.d.ts

@@ -1,15 +0,0 @@
-import type { WalletClient } from 'viem';
-import type { InteractionSettings, InternalExecutionSettings, LifiStep } from '../types';
-import type { StatusManager } from './StatusManager';
-import { StepExecutionManager } from './StepExecutionManager';
-export declare class StepExecutor {
-    stepExecutionManager: StepExecutionManager;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-    allowUserInteraction: boolean;
-    executionStopped: boolean;
-    constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
-    setInteraction: (settings?: InteractionSettings) => void;
-    checkChain: () => never;
-    executeStep: (walletClient: WalletClient, step: LifiStep) => Promise<LifiStep>;
-}

package/dist/cjs/execution/StepExecutor.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepExecutor = void 0;
-const StepExecutionManager_1 = require("./StepExecutionManager");
-const switchChain_1 = require("./switchChain");
-// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
-const defaultInteractionSettings = {
-    allowInteraction: true,
-    allowUpdates: true,
-    stopExecution: false,
-};
-class StepExecutor {
-    constructor(statusManager, settings) {
-        this.allowUserInteraction = true;
-        this.executionStopped = false;
-        this.setInteraction = (settings) => {
-            const interactionSettings = {
-                ...defaultInteractionSettings,
-                ...settings,
-            };
-            this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.stepExecutionManager.allowInteraction(interactionSettings.allowInteraction);
-            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
-            this.executionStopped = interactionSettings.stopExecution;
-        };
-        // TODO: add checkChain method and update wallet client inside executors
-        // This can come in handy when we execute multiple routes simultaneously and
-        // should be sure that we are on the right chain when waiting for transactions.
-        this.checkChain = () => {
-            throw new Error('checkChain is not implemented.');
-        };
-        this.executeStep = async (walletClient, step) => {
-            // Make sure that the chain is still correct
-            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
-            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
-            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
-            // All changes are already done from the source chain
-            // Return the step
-            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
-                !recievingChainProcess) {
-                const updatedWalletClient = await (0, switchChain_1.switchChain)(walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
-                if (!updatedWalletClient) {
-                    // Chain switch was not successful, stop execution here
-                    return step;
-                }
-                walletClient = updatedWalletClient;
-            }
-            const parameters = {
-                walletClient,
-                step,
-                settings: this.settings,
-                statusManager: this.statusManager,
-            };
-            await this.stepExecutionManager.execute(parameters);
-            return step;
-        };
-        this.stepExecutionManager = new StepExecutionManager_1.StepExecutionManager();
-        this.statusManager = statusManager;
-        this.settings = settings;
-    }
-}
-exports.StepExecutor = StepExecutor;

package/dist/cjs/execution/checkAllowance.d.ts

@@ -1,4 +0,0 @@
-import type { Hash, WalletClient } from 'viem';
-import type { StatusManager } from '../execution/StatusManager';
-import type { Chain, InternalExecutionSettings, LifiStep } from '../types';
-export declare const checkAllowance: (walletClient: WalletClient, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<Hash | void>;

package/dist/cjs/execution/checkBalance.d.ts

@@ -1,2 +0,0 @@
-import type { LifiStep } from '..';
-export declare const checkBalance: (walletAddress: string, step: LifiStep, depth?: number) => Promise<void>;

package/dist/cjs/execution/index.d.ts

@@ -1 +0,0 @@
-export * from './StatusManager';

package/dist/cjs/execution/multisig.d.ts

@@ -1,4 +0,0 @@
-import type { ExtendedChain, LifiStep, ProcessType } from '@lifi/types';
-import type { Hash } from 'viem';
-import type { StatusManager } from '.';
-export declare const updateMultisigRouteProcess: (internalTxHash: Hash, step: LifiStep, statusManager: StatusManager, processType: ProcessType, fromChain: ExtendedChain) => Promise<void>;

package/dist/cjs/execution/prepareRestart.d.ts

@@ -1,3 +0,0 @@
-import { type WalletClient } from 'viem';
-import type { Route } from '../types';
-export declare const prepareRestart: (route: Route, walletClient: WalletClient) => Promise<void>;

package/dist/cjs/execution/utils.d.ts

@@ -1,12 +0,0 @@
-import type { LifiStep, ProcessType, Status, StatusMessage, Substatus } from '@lifi/types';
-export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
-export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
-/**
- * Used to check if changed exchange rate is in the range of slippage threshold.
- * We use a slippage value as a threshold to trigger the rate change hook.
- * This can result in almost doubled slippage for the user and need to be revisited.
- * @param oldStep
- * @param newStep
- * @returns Boolean
- */
-export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

package/dist/cjs/execution/waitForReceivingTransaction.d.ts

@@ -1,3 +0,0 @@
-import type { LifiStep, ProcessType, StatusResponse } from '@lifi/types';
-import type { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;

package/dist/cjs/helpers.d.ts

@@ -1,18 +0,0 @@
-import type { LifiStep, Route } from '@lifi/types';
-import type { TenderlyResponse } from './types';
-/**
- * Returns a random number between min (inclusive) and max (inclusive)
- * @param min - minimum number.
- * @param max - maximum number.
- * @returns - random number.
- */
-export declare const getRandomNumber: (min: number, max: number) => number;
-export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
-/**
- * Converts a quote to Route
- * @param step - Step returned from the quote endpoint.
- * @returns - The route to be executed.
- * @throws {ValidationError} Throws a ValidationError if the step has missing values.
- */
-export declare const convertQuoteToRoute: (step: LifiStep) => Route;
-export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;

package/dist/cjs/index.d.ts

@@ -1,5 +0,0 @@
-export * from './execution';
-export * from './helpers';
-export { LiFi } from './LiFi';
-export * from './types';
-export * from './utils/errors';

package/dist/cjs/request.d.ts

@@ -1,9 +0,0 @@
-export declare const requestSettings: {
-    retries: number;
-};
-interface ExtendedRequestInit extends RequestInit {
-    retries?: number;
-    skipTrackingHeaders?: boolean;
-}
-export declare const request: <T = Response>(url: RequestInfo | URL, options?: ExtendedRequestInit) => Promise<T>;
-export {};

package/dist/cjs/services/ApiService.d.ts

@@ -1,17 +0,0 @@
-import type { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import type { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
-declare const _default: {
-    getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
-    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getGasRecommendation: ({ chainId, fromChain, fromToken }: GasRecommendationRequest, options?: RequestOptions | undefined) => Promise<GasRecommendationResponse>;
-    getPossibilities: (requestConfig?: PossibilitiesRequest | undefined, options?: RequestOptions | undefined) => Promise<PossibilitiesResponse>;
-    getQuote: (requestConfig: QuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getRoutes: (requestConfig: RoutesRequest, options?: RequestOptions | undefined) => Promise<RoutesResponse>;
-    getStatus: (requestConfig: GetStatusRequest, options?: RequestOptions | undefined) => Promise<StatusResponse>;
-    getStepTransaction: (step: LifiStep, options?: RequestOptions | undefined) => Promise<LifiStep>;
-    getToken: (chain: ChainId | ChainKey, token: string, options?: RequestOptions | undefined) => Promise<Token>;
-    getTokens: (requestConfig?: TokensRequest | undefined, options?: RequestOptions | undefined) => Promise<TokensResponse>;
-    getTools: (requestConfig?: ToolsRequest | undefined, options?: RequestOptions | undefined) => Promise<ToolsResponse>;
-    getAvailableConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-};
-export default _default;

package/dist/cjs/services/ConfigService.d.ts

@@ -1,23 +0,0 @@
-import type { Chain, Config, ConfigUpdate } from '../types';
-export default class ConfigService {
-    private static instance;
-    private readonly config;
-    private readonly setupPromise;
-    private resolveSetupPromise;
-    constructor();
-    private static chainIdToObject;
-    private static getDefaultConfig;
-    static getInstance(): ConfigService;
-    /**
-     * This call immediately returns the current config. It does not make sure that all chain data is already loaded
-     * Use this if you need access to basic information like API urls or settings
-     */
-    getConfig: () => Config;
-    /**
-     * This call waits for all setup promises to be done.
-     * Use this if you need access to chain data (RPCs or multicalls)
-     */
-    getConfigAsync: () => Promise<Config>;
-    updateConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
-    updateChains: (chains: Chain[]) => Config;
-}

package/dist/cjs/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from '@lifi/types';
-export { ErrorCode, LiFiError } from '../utils/errors';
-export * from './abi';
-export * from './internal.types';