@lifi/sdk 3.0.0-alpha.9 → 3.0.0-beta.1

package/dist/services/ApiService.js

@@ -1,321 +0,0 @@
-import { request } from '../request';
-import { isRoutesRequest, isStep } from '../typeguards';
-import { ValidationError } from '../utils/errors';
-import { parseBackendError } from '../utils/parseError';
-import { ConfigService } from './ConfigService';
-/**
- * @param requestConfig
- * @param options
- * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
- */
-const getPossibilities = async (requestConfig, options) => {
-    if (!requestConfig) {
-        requestConfig = {};
-    }
-    const config = ConfigService.getInstance().getConfig();
-    // apply defaults
-    if (requestConfig.bridges || config.defaultRouteOptions.bridges) {
-        requestConfig.bridges =
-            requestConfig.bridges || config.defaultRouteOptions.bridges;
-    }
-    if (requestConfig.exchanges || config.defaultRouteOptions.exchanges) {
-        requestConfig.exchanges =
-            requestConfig.exchanges || config.defaultRouteOptions.exchanges;
-    }
-    // send request
-    try {
-        const response = await request(`${config.apiUrl}/advanced/possibilities`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(requestConfig),
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getToken = async (chain, token, options) => {
-    if (!chain) {
-        throw new ValidationError('Required parameter "chain" is missing.');
-    }
-    if (!token) {
-        throw new ValidationError('Required parameter "token" is missing.');
-    }
-    const config = ConfigService.getInstance().getConfig();
-    try {
-        const response = await request(`${config.apiUrl}/token?${new URLSearchParams({
-            chain,
-            token,
-        })}`, {
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getQuote = async (requestConfig, options) => {
-    const config = ConfigService.getInstance().getConfig();
-    const requiredParameters = [
-        'fromChain',
-        'fromToken',
-        'fromAddress',
-        'fromAmount',
-        'toChain',
-        'toToken',
-    ];
-    requiredParameters.forEach((requiredParameter) => {
-        if (!requestConfig[requiredParameter]) {
-            throw new ValidationError(`Required parameter "${requiredParameter}" is missing.`);
-        }
-    });
-    // apply defaults
-    requestConfig.order || (requestConfig.order = config.defaultRouteOptions.order);
-    requestConfig.slippage || (requestConfig.slippage = config.defaultRouteOptions.slippage);
-    requestConfig.integrator || (requestConfig.integrator = config.defaultRouteOptions.integrator);
-    requestConfig.referrer || (requestConfig.referrer = config.defaultRouteOptions.referrer);
-    requestConfig.fee || (requestConfig.fee = config.defaultRouteOptions.fee);
-    requestConfig.allowBridges || (requestConfig.allowBridges = config.defaultRouteOptions.bridges?.allow);
-    requestConfig.denyBridges || (requestConfig.denyBridges = config.defaultRouteOptions.bridges?.deny);
-    requestConfig.preferBridges || (requestConfig.preferBridges = config.defaultRouteOptions.bridges?.prefer);
-    requestConfig.allowExchanges || (requestConfig.allowExchanges = config.defaultRouteOptions.exchanges?.allow);
-    requestConfig.denyExchanges || (requestConfig.denyExchanges = config.defaultRouteOptions.exchanges?.deny);
-    requestConfig.preferExchanges || (requestConfig.preferExchanges = config.defaultRouteOptions.exchanges?.prefer);
-    Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
-        delete requestConfig[key]);
-    try {
-        const response = await request(`${config.apiUrl}/quote?${new URLSearchParams(requestConfig)}`, {
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getContractCallQuote = async (requestConfig, options) => {
-    const config = ConfigService.getInstance().getConfig();
-    // validation
-    const requiredParameters = [
-        'fromChain',
-        'fromToken',
-        'fromAddress',
-        'toChain',
-        'toToken',
-        'toAmount',
-        'toContractAddress',
-        'toContractCallData',
-        'toContractGasLimit',
-    ];
-    requiredParameters.forEach((requiredParameter) => {
-        if (!requestConfig[requiredParameter]) {
-            throw new ValidationError(`Required parameter "${requiredParameter}" is missing.`);
-        }
-    });
-    // apply defaults
-    // option.order is not used in this endpoint
-    requestConfig.slippage || (requestConfig.slippage = config.defaultRouteOptions.slippage);
-    requestConfig.integrator || (requestConfig.integrator = config.defaultRouteOptions.integrator);
-    requestConfig.referrer || (requestConfig.referrer = config.defaultRouteOptions.referrer);
-    requestConfig.fee || (requestConfig.fee = config.defaultRouteOptions.fee);
-    requestConfig.allowBridges || (requestConfig.allowBridges = config.defaultRouteOptions.bridges?.allow);
-    requestConfig.denyBridges || (requestConfig.denyBridges = config.defaultRouteOptions.bridges?.deny);
-    requestConfig.preferBridges || (requestConfig.preferBridges = config.defaultRouteOptions.bridges?.prefer);
-    requestConfig.allowExchanges || (requestConfig.allowExchanges = config.defaultRouteOptions.exchanges?.allow);
-    requestConfig.denyExchanges || (requestConfig.denyExchanges = config.defaultRouteOptions.exchanges?.deny);
-    requestConfig.preferExchanges || (requestConfig.preferExchanges = config.defaultRouteOptions.exchanges?.prefer);
-    // send request
-    try {
-        const response = await request(`${config.apiUrl}/quote/contractCall`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(requestConfig),
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getStatus = async (requestConfig, options) => {
-    if (!requestConfig.txHash) {
-        throw new ValidationError('Required parameter "txHash" is missing.');
-    }
-    const config = ConfigService.getInstance().getConfig();
-    const queryParams = new URLSearchParams(requestConfig);
-    try {
-        const response = await request(`${config.apiUrl}/status?${queryParams}`, {
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getChains = async (options) => {
-    const config = ConfigService.getInstance().getConfig();
-    try {
-        const response = await request(`${config.apiUrl}/chains`, {
-            signal: options?.signal,
-        });
-        return response.chains;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getRoutes = async (requestConfig, options) => {
-    if (!isRoutesRequest(requestConfig)) {
-        throw new ValidationError('Invalid routes request.');
-    }
-    const config = ConfigService.getInstance().getConfig();
-    // apply defaults
-    requestConfig.options = {
-        ...config.defaultRouteOptions,
-        ...requestConfig.options,
-    };
-    // send request
-    try {
-        const response = await request(`${config.apiUrl}/advanced/routes`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(requestConfig),
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getStepTransaction = async (step, options) => {
-    if (!isStep(step)) {
-        // While the validation fails for some users we should not enforce it
-        // eslint-disable-next-line no-console
-        console.warn('SDK Validation: Invalid Step', step);
-    }
-    const config = ConfigService.getInstance().getConfig();
-    try {
-        const response = await request(`${config.apiUrl}/advanced/stepTransaction`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(step),
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getTools = async (requestConfig, options) => {
-    const config = ConfigService.getInstance().getConfig();
-    if (requestConfig) {
-        Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
-            delete requestConfig[key]);
-    }
-    const response = await request(`${config.apiUrl}/tools?${new URLSearchParams(requestConfig)}`, {
-        signal: options?.signal,
-    });
-    return response;
-};
-const getTokens = async (requestConfig, options) => {
-    const config = ConfigService.getInstance().getConfig();
-    if (requestConfig) {
-        Object.keys(requestConfig).forEach((key) => !requestConfig[key] &&
-            delete requestConfig[key]);
-    }
-    const response = await request(`${config.apiUrl}/tokens?${new URLSearchParams(requestConfig)}`, {
-        signal: options?.signal,
-    });
-    return response;
-};
-const getGasRecommendation = async ({ chainId, fromChain, fromToken }, options) => {
-    const config = ConfigService.getInstance().getConfig();
-    if (!chainId) {
-        throw new ValidationError('Required parameter "chainId" is missing.');
-    }
-    const url = new URL(`${config.apiUrl}/gas/suggestion/${chainId}`);
-    if (fromChain) {
-        url.searchParams.append('fromChain', fromChain);
-    }
-    if (fromToken) {
-        url.searchParams.append('fromToken', fromToken);
-    }
-    try {
-        const response = await request(url, {
-            signal: options?.signal,
-        });
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-const getAvailableConnections = async (connectionRequest) => {
-    const config = ConfigService.getInstance().getConfig();
-    const url = new URL(`${config.apiUrl}/connections`);
-    const { fromChain, fromToken, toChain, toToken } = connectionRequest;
-    if (fromChain) {
-        url.searchParams.append('fromChain', fromChain);
-    }
-    if (fromToken) {
-        url.searchParams.append('fromToken', fromToken);
-    }
-    if (toChain) {
-        url.searchParams.append('toChain', toChain);
-    }
-    if (toToken) {
-        url.searchParams.append('toToken', toToken);
-    }
-    const connectionRequestArrayParams = [
-        'allowBridges',
-        'denyBridges',
-        'preferBridges',
-        'allowExchanges',
-        'denyExchanges',
-        'preferExchanges',
-    ];
-    connectionRequestArrayParams.forEach((parameter) => {
-        const connectionRequestArrayParam = connectionRequest[parameter];
-        if (connectionRequestArrayParam?.length) {
-            connectionRequestArrayParam?.forEach((value) => {
-                url.searchParams.append(parameter, value);
-            });
-        }
-    });
-    try {
-        const response = await request(url);
-        return response;
-    }
-    catch (e) {
-        throw await parseBackendError(e);
-    }
-};
-export default {
-    getChains,
-    getContractCallQuote,
-    getGasRecommendation,
-    getPossibilities,
-    getQuote,
-    getRoutes,
-    getStatus,
-    getStepTransaction,
-    getToken,
-    getTokens,
-    getTools,
-    getAvailableConnections,
-};

package/dist/services/ChainsService.d.ts

@@ -1,11 +0,0 @@
-import type { ChainId, ExtendedChain } from '@lifi/types';
-export declare class ChainsService {
-    private static instance;
-    private readonly loadingPromise;
-    private chains;
-    constructor();
-    private loadAvailableChains;
-    static getInstance(): ChainsService;
-    getChainById(chainId: ChainId): Promise<ExtendedChain>;
-    getChains(): Promise<ExtendedChain[]>;
-}

package/dist/services/ChainsService.js

@@ -1,33 +0,0 @@
-import { ValidationError } from '../utils/errors';
-import ApiService from './ApiService';
-export class ChainsService {
-    constructor() {
-        this.chains = [];
-        this.loadingPromise = this.loadAvailableChains();
-    }
-    async loadAvailableChains() {
-        this.chains = await ApiService.getChains();
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ChainsService();
-        }
-        return this.instance;
-    }
-    async getChainById(chainId) {
-        if (this.loadingPromise) {
-            await this.loadingPromise;
-        }
-        const chain = this.chains.find((chain) => chain.id === chainId);
-        if (!chain) {
-            throw new ValidationError(`Unknown chainId passed: ${chainId}.`);
-        }
-        return chain;
-    }
-    async getChains() {
-        if (this.loadingPromise) {
-            await this.loadingPromise;
-        }
-        return this.chains;
-    }
-}

package/dist/services/ConfigService.d.ts

@@ -1,26 +0,0 @@
-import type { Chain } from '@lifi/types';
-import type { SDKConfig, SDKOptions } from '../types';
-export declare 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
-     * @returns SDKConfig
-     */
-    getConfig: () => SDKConfig;
-    /**
-     * This call waits for all setup promises to be done.
-     * Use this if you need access to chain data (RPCs or multicalls)
-     * @returns SDKConfig
-     */
-    getConfigAsync: () => Promise<SDKConfig>;
-    updateConfig: (configUpdate: Partial<SDKOptions>) => SDKConfig;
-    updateChains: (chains: Chain[]) => SDKConfig;
-}

package/dist/services/ConfigService.js

@@ -1,100 +0,0 @@
-import { ChainId } from '@lifi/types';
-const DefaultExecutionSettings = {
-    updateRouteHook: () => { },
-    switchChainHook: () => Promise.resolve(undefined),
-    acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
-    infiniteApproval: false,
-    executeInBackground: false,
-};
-export class ConfigService {
-    constructor() {
-        this.resolveSetupPromise = undefined;
-        /**
-         * 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
-         * @returns SDKConfig
-         */
-        this.getConfig = () => {
-            return this.config;
-        };
-        /**
-         * This call waits for all setup promises to be done.
-         * Use this if you need access to chain data (RPCs or multicalls)
-         * @returns SDKConfig
-         */
-        this.getConfigAsync = async () => {
-            await this.setupPromise;
-            return this.config;
-        };
-        this.updateConfig = (configUpdate) => {
-            // API
-            this.config.apiUrl = configUpdate.apiUrl || this.config.apiUrl;
-            // RPCS
-            this.config.rpcs = Object.assign(this.config.rpcs, configUpdate.rpcs);
-            // MULTICALL
-            this.config.multicallAddresses = Object.assign(this.config.multicallAddresses, configUpdate.multicallAddresses);
-            // SETTINGS
-            this.config.defaultExecutionSettings = Object.assign(this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
-            // OPTIONS
-            this.config.defaultRouteOptions = Object.assign(this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
-            this.config.apiKey = configUpdate.apiKey || this.config.apiKey;
-            this.config.userId = configUpdate.userId || this.config.userId;
-            this.config.integrator = configUpdate.integrator || this.config.integrator;
-            this.config.defaultRouteOptions.integrator =
-                configUpdate.integrator ||
-                    configUpdate.defaultRouteOptions?.integrator ||
-                    this.config.integrator;
-            this.config.widgetVersion =
-                configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisig = configUpdate.multisig || this.config.multisig;
-            return this.config;
-        };
-        this.updateChains = (chains) => {
-            for (const chain of chains) {
-                const chainId = chain.id;
-                // set RPCs if they were not configured by the user before
-                if (!this.config.rpcs[chainId]?.length) {
-                    this.config.rpcs[chainId] = chain.metamask.rpcUrls;
-                }
-                // set multicall addresses if they exist and were not configured by the user before
-                if (chain.multicallAddress && !this.config.multicallAddresses[chainId]) {
-                    this.config.multicallAddresses[chainId] = chain.multicallAddress;
-                }
-            }
-            this.resolveSetupPromise?.();
-            return this.config;
-        };
-        this.config = ConfigService.getDefaultConfig();
-        this.setupPromise = new Promise((resolve) => {
-            this.resolveSetupPromise = resolve;
-        });
-    }
-    static chainIdToObject(val) {
-        const result = {};
-        const values = Object.values(ChainId);
-        values.forEach((chainId) => {
-            if (typeof chainId !== 'string') {
-                result[chainId] = val ? JSON.parse(JSON.stringify(val)) : val;
-            }
-        });
-        return result;
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ConfigService();
-        }
-        return this.instance;
-    }
-}
-ConfigService.getDefaultConfig = () => {
-    return {
-        apiUrl: 'https://li.quest/v1',
-        rpcs: ConfigService.chainIdToObject([]),
-        multicallAddresses: ConfigService.chainIdToObject(undefined),
-        defaultExecutionSettings: DefaultExecutionSettings,
-        defaultRouteOptions: {
-            integrator: 'lifi-sdk',
-        },
-        integrator: 'lifi-sdk',
-    };
-};

package/dist/typeguards.d.ts

@@ -1,4 +0,0 @@
-import type { LiFiStep, RoutesRequest, StaticToken } from '@lifi/types';
-export declare const isRoutesRequest: (routesRequest: RoutesRequest) => routesRequest is RoutesRequest;
-export declare const isStep: (step: LiFiStep) => step is LiFiStep;
-export declare const isToken: (token: StaticToken) => token is StaticToken;

package/dist/types/abi.d.ts

@@ -1,5 +0,0 @@
-import type { Abi } from 'viem';
-export declare const approveAbi: Abi;
-export declare const allowanceAbi: Abi;
-export declare const getEthBalanceAbi: Abi;
-export declare const balanceOfAbi: Abi;

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './abi';
-export * from './internal';

package/dist/types/index.js

@@ -1,2 +0,0 @@
-export * from './abi';
-export * from './internal';

package/dist/types/internal.js

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

package/dist/utils/errors.d.ts

@@ -1,107 +0,0 @@
-declare enum ErrorType {
-    RPCError = "RPCError",
-    ProviderError = "ProviderError",
-    ServerError = "ServerError",
-    TransactionError = "TransactionError",
-    ValidationError = "ValidationError",
-    NotFoundError = "NotFoundError",
-    UnknownError = "UnknownError",
-    SlippageError = "SlippageError"
-}
-export declare enum LiFiErrorCode {
-    InternalError = 1000,
-    ValidationError = 1001,
-    TransactionUnderpriced = 1002,
-    TransactionFailed = 1003,
-    Timeout = 1004,
-    ProviderUnavailable = 1005,
-    NotFound = 1006,
-    ChainSwitchError = 1007,
-    TransactionUnprepared = 1008,
-    GasLimitError = 1009,
-    TransactionCanceled = 1010,
-    SlippageError = 1011,
-    SignatureRejected = 1012,
-    BalanceError = 1013,
-    AllowanceRequired = 1014,
-    InsufficientFunds = 1015,
-    ExchangeRateUpdateCanceled = 1016
-}
-export declare enum EthersErrorType {
-    ActionRejected = "ACTION_REJECTED",
-    CallExecption = "CALL_EXCEPTION",
-    InsufficientFunds = "INSUFFICIENT_FUNDS"
-}
-export declare enum EthersErrorMessage {
-    ERC20Allowance = "ERC20: transfer amount exceeds allowance",
-    LowGas = "intrinsic gas too low",
-    OutOfGas = "out of gas",
-    Underpriced = "underpriced",
-    LowReplacementFee = "replacement fee too low"
-}
-export declare enum ErrorMessage {
-    UnknownError = "Unknown error occurred.",
-    SlippageError = "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.",
-    GasLimitLow = "Gas limit is too low.",
-    TransactionUnderpriced = "Transaction is underpriced.",
-    Default = "Something went wrong."
-}
-export declare enum MetaMaskRPCErrorCode {
-    invalidInput = -32000,
-    resourceNotFound = -32001,
-    resourceUnavailable = -32002,
-    transactionRejected = -32003,
-    methodNotSupported = -32004,
-    limitExceeded = -32005,
-    parse = -32700,
-    invalidRequest = -32600,
-    methodNotFound = -32601,
-    invalidParams = -32602,
-    internal = -32603
-}
-export declare enum MetaMaskProviderErrorCode {
-    userRejectedRequest = 4001,
-    unauthorized = 4100,
-    unsupportedMethod = 4200,
-    disconnected = 4900,
-    chainDisconnected = 4901
-}
-export type ErrorCode = LiFiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
-export declare class LiFiError extends Error {
-    code: ErrorCode;
-    htmlMessage?: string;
-    constructor(type: ErrorType, code: number, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class RPCError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ProviderError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ServerError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ValidationError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class TransactionError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class SlippageError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class BalanceError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class NotFoundError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class UnknownError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class HTTPError extends Error {
-    response: Response;
-    status: number;
-    constructor(response: Response);
-}
-export {};

package/dist/utils/getMaxPriorityFeePerGas.d.ts

@@ -1,2 +0,0 @@
-import type { PublicClient } from 'viem';
-export declare const getMaxPriorityFeePerGas: (client: PublicClient) => Promise<bigint | undefined>;

package/dist/utils/index.d.ts

@@ -1,5 +0,0 @@
-export * from './errors';
-export * from './getMaxPriorityFeePerGas';
-export * from './median';
-export * from './parseError';
-export * from './utils';

package/dist/utils/index.js

@@ -1,5 +0,0 @@
-export * from './errors';
-export * from './getMaxPriorityFeePerGas';
-export * from './median';
-export * from './parseError';
-export * from './utils';

package/dist/utils/median.d.ts

@@ -1 +0,0 @@
-export declare const median: (arr: bigint[]) => bigint | undefined;

package/dist/version.d.ts

@@ -1,2 +0,0 @@
-export declare const name = "@lifi/sdk";
-export declare const version = "3.0.0-alpha.9";

package/dist/version.js

@@ -1,2 +0,0 @@
-export const name = '@lifi/sdk';
-export const version = '3.0.0-alpha.9';