@lifi/sdk 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/execution/stepComparison.js

@@ -9,7 +9,7 @@ import { checkStepSlippageThreshold } from './utils';
  * @param newStep
  * @param settings
  * @param allowUserInteraction
- * @returns Return LifiStep
+ * @returns Return LiFiStep
  */
 export const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
     // Check if changed exchange rate is in the range of slippage threshold

package/dist/execution/switchChain.d.ts

@@ -1,7 +1,7 @@
-import type { LifiStep } from '@lifi/types';
+import type { LiFiStep } from '@lifi/types';
 import type { WalletClient } from 'viem';
-import type { SwitchChainHook } from '../types';
 import type { StatusManager } from './StatusManager';
+import type { SwitchChainHook } from './types';
 /**
  * This method checks whether the wallet client is configured for the correct chain.
  * If yes it returns the wallet clien.
@@ -17,5 +17,6 @@ import type { StatusManager } from './StatusManager';
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
+ * @returns New WalletClient
  */
-export declare const switchChain: (walletClient: WalletClient, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;
+export declare const switchChain: (walletClient: WalletClient, statusManager: StatusManager, step: LiFiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;

package/dist/execution/switchChain.js

@@ -14,6 +14,7 @@ import { LiFiErrorCode, ProviderError } from '../utils/errors';
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
+ * @returns New WalletClient
  */
 export const switchChain = async (walletClient, statusManager, step, switchChainHook, allowUserInteraction) => {
     // if we are already on the correct chain we can proceed directly

package/dist/{types/internal.types.d.ts → execution/types.d.ts}

@@ -1,7 +1,18 @@
-import type { ChainId, LifiStep, Route, RouteOptions, Token } from '@lifi/types';
+import type { LiFiStep, Route, Token } from '@lifi/types';
 import type { Hash, Hex, WalletClient } from 'viem';
-import type { StatusManager } from '../execution/StatusManager';
-import type { StepExecutor } from '../execution/StepExecutor';
+import type { BaseStepExecutor } from './BaseStepExecutor';
+import type { StatusManager } from './StatusManager';
+export interface StepExecutorOptions {
+    statusManager: StatusManager;
+    settings: InternalExecutionSettings;
+}
+export interface RouteExecutionData {
+    route: Route;
+    executors: BaseStepExecutor[];
+    settings: InternalExecutionSettings;
+}
+export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
+export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
 export type TransactionParameters = {
     chainId?: number;
     to?: string;
@@ -14,59 +25,11 @@ export type TransactionParameters = {
     maxFeePerGas?: bigint;
     maxPriorityFeePerGas?: bigint;
 };
-export interface ExecutionParams {
-    walletClient: WalletClient;
-    step: LifiStep;
-    statusManager: StatusManager;
-    settings: InternalExecutionSettings;
-}
 export type UpdateRouteHook = (updatedRoute: Route) => void;
 export interface TransactionRequestParameters extends TransactionParameters {
     requestType: 'approve' | 'transaction';
 }
 export type TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequestParameters) => Promise<TransactionParameters>;
-export type Config = {
-    apiUrl: string;
-    rpcs: Record<ChainId, string[]>;
-    multicallAddresses: Record<ChainId, string | undefined>;
-    defaultExecutionSettings: InternalExecutionSettings;
-    defaultRouteOptions: RouteOptions;
-    disableVersionCheck?: boolean;
-    userId?: string;
-    integrator: string;
-    widgetVersion?: string;
-    multisig?: MultisigConfig;
-};
-export interface MultisigTxDetails {
-    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
-    txHash?: Hash;
-}
-export interface MultisigTransactionResponse {
-    hash: string;
-}
-export interface BaseTransaction {
-    to: string;
-    value?: bigint;
-    data: string;
-}
-export interface MultisigConfig {
-    isMultisigWalletClient: boolean;
-    getMultisigTransactionDetails: (txHash: Hash, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
-    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<Hash>;
-    shouldBatchTransactions?: boolean;
-}
-export type ConfigUpdate = {
-    apiUrl?: string;
-    rpcs?: Record<number, string[]>;
-    multicallAddresses?: Record<number, string | undefined>;
-    defaultExecutionSettings?: ExecutionSettings;
-    defaultRouteOptions?: RouteOptions;
-    disableVersionCheck?: boolean;
-    userId?: string;
-    integrator: string;
-    widgetVersion?: string;
-    multisigConfig?: MultisigConfig;
-};
 export type SwitchChainHook = (requiredChainId: number) => Promise<WalletClient | undefined>;
 export interface AcceptSlippageUpdateHookParams {
     toToken: Token;
@@ -82,11 +45,6 @@ export interface ExchangeRateUpdateParams {
     newToAmount: string;
 }
 export type AcceptExchangeRateUpdateHook = (params: ExchangeRateUpdateParams) => Promise<boolean | undefined>;
-export interface RouteExecutionData {
-    route: Route;
-    executors: StepExecutor[];
-    settings: InternalExecutionSettings;
-}
 export type ExecutionSettings = Partial<InternalExecutionSettings>;
 export interface InternalExecutionSettings {
     acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
@@ -96,50 +54,29 @@ export interface InternalExecutionSettings {
     executeInBackground: boolean;
     infiniteApproval: boolean;
 }
-export type RouteExecutionDictionary = Partial<Record<string, RouteExecutionData>>;
-export type RouteExecutionPromiseDictionary = Partial<Record<string, Promise<Route>>>;
+export interface ExecutionParams {
+    walletClient: WalletClient;
+    step: LiFiStep;
+    statusManager: StatusManager;
+    settings: InternalExecutionSettings;
+}
 export interface InteractionSettings {
     allowInteraction?: boolean;
     allowUpdates?: boolean;
-    stopExecution?: boolean;
+    allowExecution?: boolean;
 }
-export interface TenderlyResponse {
-    hash: string;
-    block_hash: string;
-    block_number: number;
-    from: string;
-    gas: number;
-    gas_price: number;
-    gas_fee_cap: number;
-    gas_tip_cap: number;
-    cumulative_gas_used: number;
-    gas_used: number;
-    effective_gas_price: number;
-    input: string;
-    nonce: number;
+export interface MultisigTxDetails {
+    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
+    txHash?: Hash;
+}
+export interface BaseTransaction {
     to: string;
-    index: number;
-    value: string;
-    access_list: any;
-    status: boolean;
-    addresses: string[];
-    contract_ids: string[];
-    network_id: string;
-    timestamp: string;
-    function_selector: string;
-    l1_block_number: number;
-    l1_timestamp: number;
-    deposit_tx: boolean;
-    system_tx: boolean;
-    mint: number;
-    sig: Signature;
-    error_message: string;
-    method: string;
-    decoded_input: any;
-    call_trace: any;
+    value?: bigint;
+    data: string;
 }
-export interface Signature {
-    v: string;
-    r: string;
-    s: string;
+export interface MultisigConfig {
+    isMultisigWalletClient: boolean;
+    getMultisigTransactionDetails: (txHash: Hash, fromChainId: number, updateIntermediateStatus?: () => void) => Promise<MultisigTxDetails>;
+    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<Hash>;
+    shouldBatchTransactions?: boolean;
 }

package/dist/execution/utils.d.ts

@@ -1,4 +1,4 @@
-import type { LifiStep, ProcessType, Status, StatusMessage, Substatus } from '@lifi/types';
+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;
 /**
@@ -9,4 +9,4 @@ export declare function getSubstatusMessage(status: StatusMessage, substatus?: S
  * @param newStep
  * @returns Boolean
  */
-export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;
+export declare function checkStepSlippageThreshold(oldStep: LiFiStep, newStep: LiFiStep): boolean;

package/dist/execution/waitForReceivingTransaction.d.ts

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

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { LifiStep, Route } from '@lifi/types';
+import type { LiFiStep, Route } from '@lifi/types';
 import type { TenderlyResponse } from './types';
 /**
  * Returns a random number between min (inclusive) and max (inclusive)
@@ -14,5 +14,5 @@ export declare const checkPackageUpdates: (packageName?: string, packageVersion?
  * @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 convertQuoteToRoute: (step: LiFiStep) => Route;
 export declare const fetchTxErrorDetails: (txHash: string, chainId: number) => Promise<TenderlyResponse>;

package/dist/index.d.ts

@@ -1,5 +1,9 @@
+export * from '@lifi/types';
+export { LiFi } from './LiFi';
 export * from './execution';
 export * from './helpers';
-export { LiFi } from './LiFi';
+export { EVM, type EVMProviderOptions } from './providers/EVM';
+export { Solana, type SolanaProviderOptions } from './providers/Solana';
 export * from './types';
 export * from './utils/errors';
+export { ErrorCode, LiFiError } from './utils/errors';

package/dist/index.js

@@ -1,6 +1,9 @@
-// expose types and helpers
+export * from '@lifi/types';
+export { LiFi } from './LiFi';
 export * from './execution';
 export * from './helpers';
-export { LiFi } from './LiFi';
+export { EVM } from './providers/EVM';
+export { Solana } from './providers/Solana';
 export * from './types';
 export * from './utils/errors';
+export { LiFiError } from './utils/errors';

package/dist/providers/EVM.d.ts

@@ -0,0 +1,10 @@
+import { type WalletClient } from 'viem';
+import type { SDKProvider } from './types';
+export interface EVMProviderOptions {
+    getWalletClient: () => Promise<WalletClient>;
+}
+export interface EVMProvider extends SDKProvider {
+    setOptions(options: EVMProviderOptions): void;
+}
+export declare function EVM(options?: EVMProviderOptions): EVMProvider;
+export declare function isEVM(provider: SDKProvider): provider is EVMProvider;

package/dist/providers/EVM.js

@@ -0,0 +1,29 @@
+import { isAddress } from 'viem';
+import { EVMStepExecutor } from '../execution/EVMStepExecutor';
+import { ProviderType } from './types';
+export function EVM(options) {
+    let getWalletClient = options?.getWalletClient;
+    return {
+        get type() {
+            return ProviderType.EVM;
+        },
+        isProviderStep(step) {
+            const isProviderStep = isAddress(step.action.fromAddress);
+            return isProviderStep;
+        },
+        async getStepExecutor(options) {
+            if (!getWalletClient) {
+                throw new Error(`getWalletClient is not provided.`);
+            }
+            const walletClient = await getWalletClient();
+            const executor = new EVMStepExecutor({ walletClient, ...options });
+            return executor;
+        },
+        setOptions(options) {
+            getWalletClient = options.getWalletClient;
+        },
+    };
+}
+export function isEVM(provider) {
+    return provider.type === ProviderType.EVM;
+}

package/dist/providers/Solana.d.ts

@@ -0,0 +1,9 @@
+import type { SDKProvider } from './types';
+export interface SolanaProviderOptions {
+    getWalletClient: () => Promise<unknown>;
+}
+export interface SolanaProvider extends SDKProvider {
+    setOptions(options: SolanaProviderOptions): void;
+}
+export declare function Solana(options?: SolanaProviderOptions): SolanaProvider;
+export declare function isEVM(provider: SDKProvider): provider is SolanaProvider;

package/dist/providers/Solana.js

@@ -0,0 +1,33 @@
+import { PublicKey } from '@solana/web3.js';
+import { ProviderType } from './types';
+export function Solana(options) {
+    let getWalletClient = options?.getWalletClient;
+    return {
+        get type() {
+            return ProviderType.Solana;
+        },
+        isProviderStep(step) {
+            try {
+                const publickKey = new PublicKey(step.action.fromAddress);
+                const isProviderStep = PublicKey.isOnCurve(publickKey);
+                return isProviderStep;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        async getStepExecutor(options) {
+            if (!getWalletClient) {
+                throw new Error(`getWalletClient is not provided.`);
+            }
+            const walletClient = await getWalletClient();
+            return null;
+        },
+        setOptions(options) {
+            getWalletClient = options.getWalletClient;
+        },
+    };
+}
+export function isEVM(provider) {
+    return provider.type === ProviderType.Solana;
+}

package/dist/providers/index.d.ts

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

package/dist/providers/index.js

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

package/dist/providers/types.d.ts

@@ -0,0 +1,12 @@
+import type { LiFiStep } from '@lifi/types';
+import type { BaseStepExecutor } from '../execution/BaseStepExecutor';
+import type { StepExecutorOptions } from '../execution/types';
+export interface SDKProvider {
+    readonly type: ProviderType;
+    isProviderStep(step: LiFiStep): boolean;
+    getStepExecutor(options: StepExecutorOptions): Promise<BaseStepExecutor>;
+}
+export declare enum ProviderType {
+    EVM = "EVM",
+    Solana = "Solana"
+}

package/dist/providers/types.js

@@ -0,0 +1,5 @@
+export var ProviderType;
+(function (ProviderType) {
+    ProviderType["EVM"] = "EVM";
+    ProviderType["Solana"] = "Solana";
+})(ProviderType || (ProviderType = {}));

package/dist/request.js

@@ -1,4 +1,4 @@
-import ConfigService from './services/ConfigService';
+import { ConfigService } from './services/ConfigService';
 import { HTTPError } from './utils/errors';
 import { wait } from './utils/utils';
 import { version } from './version';
@@ -8,32 +8,38 @@ export const requestSettings = {
 export const request = async (url, options = {
     retries: requestSettings.retries,
 }) => {
-    const { userId, integrator, widgetVersion } = ConfigService.getInstance().getConfig();
+    const { userId, integrator, widgetVersion, apiKey } = ConfigService.getInstance().getConfig();
     options.retries = options.retries ?? requestSettings.retries;
     try {
         if (!options.skipTrackingHeaders) {
+            if (apiKey) {
+                options.headers = {
+                    ...options?.headers,
+                    'x-lifi-api-key': apiKey,
+                };
+            }
             if (userId) {
                 options.headers = {
                     ...options?.headers,
-                    'X-LIFI-UserId': userId,
+                    'x-lifi-userid': userId,
                 };
             }
             if (widgetVersion) {
                 options.headers = {
                     ...options?.headers,
-                    'X-LIFI-Widget': widgetVersion,
+                    'x-lifi-widget': widgetVersion,
                 };
             }
             if (version) {
                 options.headers = {
                     ...options?.headers,
-                    'X-LIFI-SDK': version,
+                    'x-lifi-sdk': version,
                 };
             }
             // integrator is mandatory during SDK initialization
             options.headers = {
                 ...options?.headers,
-                'X-LIFI-Integrator': integrator,
+                'x-lifi-integrator': integrator,
             };
         }
         const response = await fetch(url, options);

package/dist/services/ApiService.d.ts

@@ -1,14 +1,13 @@
-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';
+import type { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LiFiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
 declare const _default: {
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
-    getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;
+    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>;
+    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>;
+    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>;

package/dist/services/ApiService.js

@@ -2,7 +2,7 @@ import { request } from '../request';
 import { isRoutesRequest, isStep } from '../typeguards';
 import { ValidationError } from '../utils/errors';
 import { parseBackendError } from '../utils/parseError';
-import ConfigService from './ConfigService';
+import { ConfigService } from './ConfigService';
 /**
  * @param requestConfig
  * @param options
@@ -276,10 +276,10 @@ const getAvailableConnections = async (connectionRequest) => {
         url.searchParams.append('fromToken', fromToken);
     }
     if (toChain) {
-        url.searchParams.append('fromToken', toChain);
+        url.searchParams.append('toChain', toChain);
     }
     if (toToken) {
-        url.searchParams.append('fromToken', toToken);
+        url.searchParams.append('toToken', toToken);
     }
     const connectionRequestArrayParams = [
         'allowBridges',

package/dist/services/ChainsService.d.ts

@@ -1,5 +1,5 @@
 import type { ChainId, ExtendedChain } from '@lifi/types';
-export default class ChainsService {
+export declare class ChainsService {
     private static instance;
     private readonly loadingPromise;
     private chains;

package/dist/services/ChainsService.js

@@ -1,6 +1,6 @@
 import { ValidationError } from '../utils/errors';
 import ApiService from './ApiService';
-export default class ChainsService {
+export class ChainsService {
     constructor() {
         this.chains = [];
         this.loadingPromise = this.loadAvailableChains();

package/dist/services/ConfigService.d.ts

@@ -1,5 +1,6 @@
-import type { Chain, Config, ConfigUpdate } from '../types';
-export default class ConfigService {
+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;
@@ -11,13 +12,15 @@ export default class 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: () => Config;
+    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<Config>;
-    updateConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
-    updateChains: (chains: Chain[]) => Config;
+    getConfigAsync: () => Promise<SDKConfig>;
+    updateConfig: (configUpdate: Partial<SDKOptions>) => SDKConfig;
+    updateChains: (chains: Chain[]) => SDKConfig;
 }

package/dist/services/ConfigService.js

@@ -1,18 +1,18 @@
-import { ChainId } from '../types';
+import { ChainId } from '@lifi/types';
 const DefaultExecutionSettings = {
-    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
     updateRouteHook: () => { },
     switchChainHook: () => Promise.resolve(undefined),
     acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
     executeInBackground: false,
 };
-class ConfigService {
+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;
@@ -20,6 +20,7 @@ class ConfigService {
         /**
          * 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;
@@ -36,6 +37,7 @@ class ConfigService {
             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 =
@@ -44,7 +46,7 @@ class ConfigService {
                     this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisig = configUpdate.multisigConfig || this.config.multisig;
+            this.config.multisig = configUpdate.multisig || this.config.multisig;
             return this.config;
         };
         this.updateChains = (chains) => {
@@ -96,4 +98,3 @@ ConfigService.getDefaultConfig = () => {
         integrator: 'lifi-sdk',
     };
 };
-export default ConfigService;

package/dist/typeguards.d.ts

@@ -1,4 +1,4 @@
-import type { LifiStep, RoutesRequest, StaticToken } from './types';
+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 isStep: (step: LiFiStep) => step is LiFiStep;
 export declare const isToken: (token: StaticToken) => token is StaticToken;

package/dist/types/index.d.ts

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

package/dist/types/index.js

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

package/dist/types/internal.d.ts

@@ -0,0 +1,60 @@
+import type { ChainId, RouteOptions } from '@lifi/types';
+import type { ExecutionSettings, InternalExecutionSettings, MultisigConfig } from '../execution/types';
+import type { SDKProvider } from '../providers';
+export interface SDKConfig {
+    apiUrl: string;
+    apiKey?: string;
+    rpcs: Record<ChainId, string[]>;
+    multicallAddresses: Record<ChainId, string | undefined>;
+    defaultExecutionSettings: InternalExecutionSettings;
+    defaultRouteOptions: RouteOptions;
+    disableVersionCheck?: boolean;
+    userId?: string;
+    integrator: string;
+    widgetVersion?: string;
+    multisig?: MultisigConfig;
+    providers?: SDKProvider[];
+}
+export interface SDKOptions extends Partial<Omit<SDKConfig, 'defaultExecutionSettings' | 'integrator'>> {
+    defaultExecutionSettings?: ExecutionSettings;
+    integrator: string;
+}
+export interface TenderlyResponse {
+    hash: string;
+    block_hash: string;
+    block_number: number;
+    from: string;
+    gas: number;
+    gas_price: number;
+    gas_fee_cap: number;
+    gas_tip_cap: number;
+    cumulative_gas_used: number;
+    gas_used: number;
+    effective_gas_price: number;
+    input: string;
+    nonce: number;
+    to: string;
+    index: number;
+    value: string;
+    access_list: unknown;
+    status: boolean;
+    addresses: string[];
+    contract_ids: string[];
+    network_id: string;
+    timestamp: string;
+    function_selector: string;
+    l1_block_number: number;
+    l1_timestamp: number;
+    deposit_tx: boolean;
+    system_tx: boolean;
+    mint: number;
+    sig: {
+        v: string;
+        r: string;
+        s: string;
+    };
+    error_message: string;
+    method: string;
+    decoded_input: unknown;
+    call_trace: unknown;
+}

package/dist/types/internal.js

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