@lifi/sdk 3.0.0-alpha.4 → 3.0.0-alpha.7

package/dist/execution/RouteExecutionManager.js

@@ -1,21 +1,20 @@
+import { EVMProvider } from '../providers/EVMProvider';
 import ConfigService from '../services/ConfigService';
 import { ValidationError } from '../utils/errors';
 import { StatusManager } from './StatusManager';
-import { StepExecutor } from './StepExecutor';
 import { prepareRestart } from './prepareRestart';
 export class RouteExecutionManager {
-    constructor(configUpdate) {
+    constructor(options) {
         this.executionDictionary = {};
         this.executionPromiseDictionary = {};
         /**
          * Execute a route.
-         * @param walletClient - The walletClient required to send the transactions.
          * @param route - The route that should be executed. Cannot be an active route.
          * @param settings - An object containing settings and callbacks.
          * @returns The executed route.
          * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.executeRoute = async (walletClient, route, settings) => {
+        this.executeRoute = async (route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             let executionPromise = this.executionPromiseDictionary[clonedRoute.id];
@@ -23,24 +22,23 @@ export class RouteExecutionManager {
             if (executionPromise) {
                 return executionPromise;
             }
-            executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
+            executionPromise = this.executeSteps(clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;
         };
         /**
          * Resume the execution of a route that has been stopped or had an error while executing.
-         * @param walletClient - The walletClient required to send the transactions.
          * @param route - The route that is to be executed. Cannot be an active route.
          * @param settings - An object containing settings and callbacks.
          * @returns The executed route.
          * @throws {LiFiError} Throws a LiFiError if the execution fails.
          */
-        this.resumeRoute = async (walletClient, route, settings) => {
+        this.resumeRoute = async (route, settings) => {
             // Deep clone to prevent side effects
             const clonedRoute = structuredClone(route);
             const execution = this.executionDictionary[clonedRoute.id];
             if (execution) {
-                const executionHalted = execution.executors.some((executor) => executor.executionStopped);
+                const executionHalted = execution.executors.some((executor) => !executor.allowExecution);
                 if (!executionHalted) {
                     // Check if we want to resume route execution in the background
                     this.updateRouteExecution(route, {
@@ -50,12 +48,12 @@ export class RouteExecutionManager {
                     return executionPromise ?? clonedRoute;
                 }
             }
-            await prepareRestart(clonedRoute, walletClient);
-            const executionPromise = this.executeSteps(walletClient, clonedRoute, settings);
+            await prepareRestart(clonedRoute);
+            const executionPromise = this.executeSteps(clonedRoute, settings);
             this.executionPromiseDictionary[clonedRoute.id] = executionPromise;
             return executionPromise;
         };
-        this.executeSteps = async (walletClient, route, settings) => {
+        this.executeSteps = async (route, settings) => {
             const config = this.configService.getConfig();
             const execution = {
                 route,
@@ -87,17 +85,21 @@ export class RouteExecutionManager {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
                 try {
-                    const stepExecutor = new StepExecutor(statusManager, execution.settings);
+                    const provider = this.providers.find((provider) => provider.isProviderStep(step));
+                    const stepExecutor = await provider.getStepExecutor({
+                        statusManager,
+                        settings: execution.settings,
+                    });
                     execution.executors.push(stepExecutor);
                     // Check if we want to execute this step in the background
                     this.updateRouteExecution(route, execution.settings);
-                    const executedStep = await stepExecutor.executeStep(walletClient, step);
+                    const executedStep = await stepExecutor.executeStep(step);
                     // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
                     if (executedStep.execution?.status !== 'DONE') {
                         this.stopExecution(route);
                     }
                     // Execution stopped during the current step, we don't want to continue to the next step so we return already
-                    if (stepExecutor.executionStopped) {
+                    if (stepExecutor.allowExecution) {
                         return route;
                     }
                 }
@@ -163,7 +165,7 @@ export class RouteExecutionManager {
                 executor.setInteraction({
                     allowInteraction: false,
                     allowUpdates: false,
-                    stopExecution: true,
+                    allowExecution: false,
                 });
             }
             delete this.executionDictionary[route.id];
@@ -187,9 +189,7 @@ export class RouteExecutionManager {
             return this.executionDictionary[route.id]?.route;
         };
         this.configService = ConfigService.getInstance();
-        if (configUpdate) {
-            // Update API urls before we request chains
-            this.configService.updateConfig(configUpdate);
-        }
+        this.configService.updateConfig(options);
+        this.providers = options.providers ?? [new EVMProvider()];
     }
 }

package/dist/execution/StatusManager.d.ts

@@ -1,4 +1,5 @@
-import type { Execution, InternalExecutionSettings, LifiStep, Process, ProcessType, Route, Status, Token } from '../types';
+import type { Execution, LiFiStep, Process, ProcessType, Route, Status, Token } from '@lifi/types';
+import type { InternalExecutionSettings } from './types';
 interface Receipt {
     fromAmount?: string;
     toAmount?: string;
@@ -29,7 +30,7 @@ export declare class StatusManager {
      * @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;
+    initExecutionObject: (step: LiFiStep) => Execution;
     /**
      * Updates the execution object of a Step.
      * @param step  The current step in execution
@@ -37,7 +38,7 @@ export declare class StatusManager {
      * @param receipt Optional. Information about received tokens
      * @returns       The step with the updated execution object
      */
-    updateExecution(step: LifiStep, status: Status, receipt?: Receipt): LifiStep;
+    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.
@@ -45,7 +46,7 @@ export declare class StatusManager {
      * @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;
+    findOrCreateProcess: (step: LiFiStep, type: ProcessType, status?: Status) => Process;
     /**
      * Update a process object.
      * @param step The step where the process should be updated
@@ -54,14 +55,14 @@ export declare class StatusManager {
      * @param [params]   Additional parameters to append to the process.
      * @returns The update process
      */
-    updateProcess: (step: LifiStep, type: ProcessType, status: Status, params?: OptionalParameters) => 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;
+    removeProcess: (step: LiFiStep, type: ProcessType) => void;
+    updateStepInRoute: (step: LiFiStep) => LiFiStep;
     allowUpdates(value: boolean): void;
 }
 export {};

package/dist/execution/StatusManager.js

@@ -1,4 +1,4 @@
-import { emptyExecution } from '../types';
+import { emptyExecution } from '@lifi/types';
 import { getProcessMessage } from './utils';
 /**
  * Manages status updates of a route and provides various functions for tracking processes

package/dist/execution/StepExecutionManager.d.ts

@@ -1,7 +1,7 @@
-import type { Execution } from '@lifi/types';
-import type { ExecutionParams } from '../types';
+import type { LiFiStep } 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>;
+    execute: ({ walletClient, step, statusManager, settings, }: ExecutionParams) => Promise<LiFiStep>;
 }

package/dist/execution/StepExecutionManager.js

@@ -67,7 +67,7 @@ export class StepExecutionManager {
                         const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
-                            return step.execution;
+                            return step;
                         }
                         walletClient = updatedWalletClient;
                         // Load exiting transaction
@@ -86,30 +86,7 @@ export class StepExecutionManager {
                                 execution: step.execution,
                             };
                         }
-                        let transactionRequest = {
-                            to: step.transactionRequest?.to,
-                            from: step.transactionRequest?.from,
-                            data: step.transactionRequest?.data,
-                            value: step.transactionRequest?.value
-                                ? BigInt(step.transactionRequest.value)
-                                : undefined,
-                            maxPriorityFeePerGas: walletClient.account?.type === 'local'
-                                ? await getMaxPriorityFeePerGas(client)
-                                : undefined,
-                            // gas: step.transactionRequest?.gasLimit
-                            //   ? BigInt(step.transactionRequest.gasLimit as string)
-                            //   : undefined,
-                            // gasPrice: step.transactionRequest?.gasPrice
-                            //   ? BigInt(step.transactionRequest.gasPrice as string)
-                            //   : undefined,
-                            // maxFeePerGas: step.transactionRequest?.maxFeePerGas
-                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
-                            //   : undefined,
-                            // maxPriorityFeePerGas: step.transactionRequest?.maxPriorityFeePerGas
-                            //   ? BigInt(step.transactionRequest.maxPriorityFeePerGas as string)
-                            //   : undefined,
-                        };
-                        if (!transactionRequest) {
+                        if (!step.transactionRequest) {
                             throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                         }
                         // STEP 3: Send the transaction
@@ -117,15 +94,40 @@ export class StepExecutionManager {
                         const updatedWalletClient = await switchChain(walletClient, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedWalletClient) {
                             // Chain switch was not successful, stop execution here
-                            return step.execution;
+                            return step;
                         }
                         walletClient = updatedWalletClient;
                         process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
                         if (!this.allowUserInteraction) {
-                            return step.execution;
+                            return step;
                         }
+                        let transactionRequest = {
+                            to: step.transactionRequest.to,
+                            from: step.transactionRequest.from,
+                            data: step.transactionRequest.data,
+                            value: step.transactionRequest.value
+                                ? BigInt(step.transactionRequest.value)
+                                : undefined,
+                            gas: step.transactionRequest.gasLimit
+                                ? BigInt(step.transactionRequest.gasLimit)
+                                : undefined,
+                            // gasPrice: step.transactionRequest.gasPrice
+                            //   ? BigInt(step.transactionRequest.gasPrice as string)
+                            //   : undefined,
+                            // maxFeePerGas: step.transactionRequest.maxFeePerGas
+                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+                            //   : undefined,
+                            maxPriorityFeePerGas: walletClient.account?.type === 'local'
+                                ? await getMaxPriorityFeePerGas(client)
+                                : step.transactionRequest.maxPriorityFeePerGas
+                                    ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
+                                    : undefined,
+                        };
                         if (settings.updateTransactionRequestHook) {
-                            const customizedTransactionRequest = await settings.updateTransactionRequestHook(transactionRequest);
+                            const customizedTransactionRequest = await settings.updateTransactionRequestHook({
+                                requestType: 'transaction',
+                                ...transactionRequest,
+                            });
                             transactionRequest = {
                                 ...transactionRequest,
                                 ...customizedTransactionRequest,
@@ -151,6 +153,9 @@ export class StepExecutionManager {
                                 to: transactionRequest.to,
                                 account: walletClient.account,
                                 data: transactionRequest.data,
+                                gas: transactionRequest.gas,
+                                gasPrice: transactionRequest.gasPrice,
+                                maxFeePerGas: transactionRequest.maxFeePerGas,
                                 maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
                                 chain: null,
                             });
@@ -254,7 +259,7 @@ export class StepExecutionManager {
                 throw e;
             }
             // DONE
-            return step.execution;
+            return step;
         };
     }
 }

package/dist/execution/checkAllowance.d.ts

@@ -1,4 +1,5 @@
+import type { Chain, LiFiStep } from '@lifi/types';
 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>;
+import type { InternalExecutionSettings } 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/execution/checkAllowance.js

@@ -21,7 +21,7 @@ export const checkAllowance = async (walletClient, step, statusManager, settings
                     ? maxUint256
                     : fromAmount;
                 if (shouldBatchTransactions) {
-                    const approveTxHash = await setAllowance(walletClient, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
+                    const approveTxHash = await setAllowance(walletClient, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, settings, true);
                     allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
                     return approveTxHash;
                 }

package/dist/execution/checkBalance.d.ts

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

package/dist/execution/index.d.ts

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

package/dist/execution/index.js

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

package/dist/execution/multisig.d.ts

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

package/dist/execution/prepareRestart.d.ts

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

package/dist/execution/prepareRestart.js

@@ -1,11 +1,11 @@
 import { publicActions } from 'viem';
 import { LiFiErrorCode } from '../utils/errors';
-export const prepareRestart = async (route, walletClient) => {
+export const prepareRestart = async (route) => {
     for (let index = 0; index < route.steps.length; index++) {
         const step = route.steps[index];
         const stepHasFailed = step.execution?.status === 'FAILED';
         if (stepHasFailed) {
-            await handleErrorType(walletClient, step);
+            // await handleErrorType(walletClient, step)
             deleteFailedProcesses(step);
             deleteTransactionData(step);
         }

package/dist/execution/stepComparison.d.ts

@@ -1,5 +1,6 @@
-import type { InternalExecutionSettings, LifiStep } from '../types';
+import type { LiFiStep } from '@lifi/types';
 import type { StatusManager } from './StatusManager';
+import type { InternalExecutionSettings } from './types';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
@@ -9,6 +10,6 @@ import type { StatusManager } from './StatusManager';
  * @param newStep
  * @param settings
  * @param allowUserInteraction
- * @returns Return LifiStep
+ * @returns Return LiFiStep
  */
-export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;
+export declare const stepComparison: (statusManager: StatusManager, oldStep: LiFiStep, newStep: LiFiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LiFiStep>;

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,56 +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 type TransactionRequestUpdateHook = (updatedTxRequest: TransactionParameters) => 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 interface TransactionRequestParameters extends TransactionParameters {
+    requestType: 'approve' | 'transaction';
 }
-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 TransactionRequestUpdateHook = (updatedTxRequest: TransactionRequestParameters) => Promise<TransactionParameters>;
 export type SwitchChainHook = (requiredChainId: number) => Promise<WalletClient | undefined>;
 export interface AcceptSlippageUpdateHookParams {
     toToken: Token;
@@ -79,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;
@@ -93,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,7 @@
+export * from '@lifi/types';
+export { LiFi } from './LiFi';
 export * from './execution';
 export * from './helpers';
-export { LiFi } from './LiFi';
 export * from './types';
 export * from './utils/errors';
+export { ErrorCode, LiFiError } from './utils/errors';

package/dist/index.js

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

package/dist/providers/BaseProvider.d.ts

@@ -0,0 +1,7 @@
+import type { LiFiStep } from '@lifi/types';
+import type { BaseStepExecutor } from '../execution/BaseStepExecutor';
+import type { StepExecutorOptions } from '../execution/types';
+export declare abstract class BaseProvider {
+    abstract isProviderStep(step: LiFiStep): boolean;
+    abstract getStepExecutor(options: StepExecutorOptions): Promise<BaseStepExecutor>;
+}

package/dist/providers/BaseProvider.js

@@ -0,0 +1,2 @@
+export class BaseProvider {
+}