@lifi/sdk 2.1.2 → 2.1.3-beta.0

package/dist/allowance/checkAllowance.d.ts

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

package/dist/allowance/checkAllowance.js

@@ -1,9 +1,9 @@
 import BigNumber from 'bignumber.js';
-import { constants } from 'ethers';
+import { constants, } from 'ethers';
 import { getApproved, setApproval } from '../allowance/utils';
 import { getProvider } from '../utils/getProvider';
 import { parseError } from '../utils/parseError';
-export const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false) => {
+export const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false, shouldBatchTransactions = false) => {
     // Ask the user to set an allowance
     let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
     // Check allowance
@@ -41,7 +41,12 @@ export const checkAllowance = async (signer, step, statusManager, settings, chai
                 const approvalAmount = settings.infiniteApproval
                     ? constants.MaxUint256.toString()
                     : step.action.fromAmount;
-                const approveTx = await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
+                if (shouldBatchTransactions) {
+                    const populatedTransaction = await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
+                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+                    return populatedTransaction;
+                }
+                const approveTx = (await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount));
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
                     txHash: approveTx.hash,
                     txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,

package/dist/allowance/utils.d.ts

@@ -1,10 +1,10 @@
 import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { ChainId, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
-import { ContractTransaction, Signer } from 'ethers';
+import { ContractTransaction, PopulatedTransaction, Signer } from 'ethers';
 import { RevokeTokenData } from '../types';
 export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string, transactionRequest?: TransactionRequest) => Promise<BigNumber>;
-export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
+export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string, returnPopulatedTransaction?: boolean) => Promise<ContractTransaction | PopulatedTransaction>;
 export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
     token: Token;
     approvalAddress: string;

package/dist/allowance/utils.js

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { Contract, ethers } from 'ethers';
+import { Contract, ethers, } from 'ethers';
 import ChainsService from '../services/ChainsService';
 import { ERC20_ABI } from '../types';
 import { ServerError } from '../utils/errors';
@@ -20,8 +20,11 @@ export const getApproved = async (signer, tokenAddress, contractAddress, transac
         return new BigNumber(0);
     }
 };
-export const setApproval = async (signer, tokenAddress, contractAddress, amount) => {
+export const setApproval = async (signer, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
     const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
+    if (returnPopulatedTransaction) {
+        return erc20.populateTransaction.approve(contractAddress, amount);
+    }
     const transactionRequest = await erc20.populateTransaction.approve(contractAddress, amount);
     try {
         const estimatedGasLimit = await signer.estimateGas(transactionRequest);
@@ -31,7 +34,7 @@ export const setApproval = async (signer, tokenAddress, contractAddress, amount)
         }
     }
     catch (error) { }
-    return signer.sendTransaction(transactionRequest);
+    return erc20.approve(contractAddress, amount);
 };
 export const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {
     const chainsService = ChainsService.getInstance();

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

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

package/dist/cjs/allowance/checkAllowance.js

@@ -9,7 +9,7 @@ const ethers_1 = require("ethers");
 const utils_1 = require("../allowance/utils");
 const getProvider_1 = require("../utils/getProvider");
 const parseError_1 = require("../utils/parseError");
-const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false) => {
+const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false, shouldBatchTransactions = false) => {
     // Ask the user to set an allowance
     let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
     // Check allowance
@@ -47,7 +47,12 @@ const checkAllowance = async (signer, step, statusManager, settings, chain, allo
                 const approvalAmount = settings.infiniteApproval
                     ? ethers_1.constants.MaxUint256.toString()
                     : step.action.fromAmount;
-                const approveTx = await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
+                if (shouldBatchTransactions) {
+                    const populatedTransaction = await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
+                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+                    return populatedTransaction;
+                }
+                const approveTx = (await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount));
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
                     txHash: approveTx.hash,
                     txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,

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

@@ -1,10 +1,10 @@
 import { TransactionRequest } from '@ethersproject/abstract-provider';
 import { ChainId, Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
-import { ContractTransaction, Signer } from 'ethers';
+import { ContractTransaction, PopulatedTransaction, Signer } from 'ethers';
 import { RevokeTokenData } from '../types';
 export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string, transactionRequest?: TransactionRequest) => Promise<BigNumber>;
-export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
+export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string, returnPopulatedTransaction?: boolean) => Promise<ContractTransaction | PopulatedTransaction>;
 export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
     token: Token;
     approvalAddress: string;

package/dist/cjs/allowance/utils.js

@@ -27,8 +27,11 @@ const getApproved = async (signer, tokenAddress, contractAddress, transactionReq
     }
 };
 exports.getApproved = getApproved;
-const setApproval = async (signer, tokenAddress, contractAddress, amount) => {
+const setApproval = async (signer, tokenAddress, contractAddress, amount, returnPopulatedTransaction) => {
     const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
+    if (returnPopulatedTransaction) {
+        return erc20.populateTransaction.approve(contractAddress, amount);
+    }
     const transactionRequest = await erc20.populateTransaction.approve(contractAddress, amount);
     try {
         const estimatedGasLimit = await signer.estimateGas(transactionRequest);
@@ -38,7 +41,7 @@ const setApproval = async (signer, tokenAddress, contractAddress, amount) => {
         }
     }
     catch (error) { }
-    return signer.sendTransaction(transactionRequest);
+    return erc20.approve(contractAddress, amount);
 };
 exports.setApproval = setApproval;
 const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {

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

@@ -10,7 +10,7 @@ interface Receipt {
     gasAmountUSD?: string;
 }
 type InternalUpdateRouteCallback = (route: Route) => void;
-type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
+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.

package/dist/cjs/execution/StepExecutionManager.js

@@ -16,6 +16,8 @@ const utils_1 = require("../utils/utils");
 const stepComparison_1 = require("./stepComparison");
 const switchChain_1 = require("./switchChain");
 const utils_2 = require("./utils");
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const multisig_1 = require("./multisig");
 class StepExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
@@ -23,6 +25,11 @@ class StepExecutionManager {
             this.allowUserInteraction = value;
         };
         this.execute = async ({ signer, step, statusManager, settings, }) => {
+            const config = ConfigService_1.default.getInstance().getConfig();
+            const isMultisigSigner = !!config.multisigConfig?.isMultisigSigner;
+            const multisigBatchTransactions = [];
+            const shouldBatchTransactions = config.multisigConfig?.shouldBatchTransactions &&
+                !!config.multisigConfig.sendBatchTransaction;
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService_1.default.getInstance();
             const fromChain = await chainsService.getChainById(step.action.fromChainId);
@@ -32,14 +39,43 @@ class StepExecutionManager {
             // STEP 1: Check allowance
             const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
             // Check token approval only if fromToken is not the native token => no approval needed in that case
-            if (!existingProcess?.txHash &&
-                !(0, utils_1.isZeroAddress)(step.action.fromToken.address)) {
-                await (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
+            const checkForAllowance = !existingProcess?.txHash &&
+                !(0, utils_1.isZeroAddress)(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigSigner);
+            if (checkForAllowance) {
+                const populatedTransaction = await (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
+                if (populatedTransaction) {
+                    const { to, data } = populatedTransaction;
+                    if (to && data) {
+                        // allowance doesn't need value
+                        const cleanedPopulatedTransaction = {
+                            value: ethers_1.BigNumber.from(0).toString(),
+                            to,
+                            data,
+                        };
+                        multisigBatchTransactions.push(cleanedPopulatedTransaction);
+                    }
+                }
             }
             // STEP 2: Get transaction
             let process = statusManager.findOrCreateProcess(step, currentProcessType);
             if (process.status !== 'DONE') {
+                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
                 try {
+                    if (isMultisigSigner && multisigProcess) {
+                        if (!multisigProcess) {
+                            throw new errors_1.ValidationError('Multisig process is undefined.');
+                        }
+                        if (!config.multisigConfig?.getMultisigTransactionDetails) {
+                            throw new errors_1.ValidationError('"getMultisigTransactionDetails()" is missing in Multisig config.');
+                        }
+                        const multisigTxHash = multisigProcess.multisigTxHash;
+                        if (!multisigTxHash) {
+                            // need to check what happens in failed tx
+                            throw new errors_1.ValidationError('Multisig internal transaction hash is undefined.');
+                        }
+                        await (0, multisig_1.updateMultisigRouteProcess)(multisigTxHash, step, statusManager, process, fromChain);
+                    }
                     let transaction;
                     if (process.txHash) {
                         // Make sure that the chain is still correct
@@ -105,8 +141,52 @@ class StepExecutionManager {
                             catch (error) { }
                         }
                         // Submit the transaction
-                        transaction = await signer.sendTransaction(transactionRequest);
+                        if (shouldBatchTransactions &&
+                            config.multisigConfig?.sendBatchTransaction) {
+                            const { to, data, value } = await signer.populateTransaction(transactionRequest);
+                            const isValidTransaction = to && data;
+                            if (isValidTransaction) {
+                                const populatedTransaction = {
+                                    value: value?.toString() ?? ethers_1.BigNumber.from(0).toString(),
+                                    to,
+                                    data: data.toString(),
+                                };
+                                multisigBatchTransactions.push(populatedTransaction);
+                                transaction = await config.multisigConfig?.sendBatchTransaction(multisigBatchTransactions);
+                            }
+                            else {
+                                throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            }
+                        }
+                        else {
+                            transaction = await signer.sendTransaction(transactionRequest);
+                        }
                         // STEP 4: Wait for the transaction
+                        if (isMultisigSigner) {
+                            process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
+                                multisigTxHash: transaction.hash,
+                            });
+                        }
+                        else {
+                            process = statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: transaction.hash,
+                                txLink: fromChain.metamask.blockExplorerUrls[0] +
+                                    'tx/' +
+                                    transaction.hash,
+                            });
+                        }
+                    }
+                    await transaction.wait?.();
+                    // if it's multisig signer and the process is in ACTION_REQUIRED
+                    // then signatures are still needed
+                    if (isMultisigSigner &&
+                        process.status === 'ACTION_REQUIRED' &&
+                        transaction.hash) {
+                        // Return the execution object without updating the process
+                        // The execution would progress once all multisigs signer approve
+                        await (0, multisig_1.updateMultisigRouteProcess)(transaction.hash, step, statusManager, process, fromChain);
+                    }
+                    if (!isMultisigSigner) {
                         process = statusManager.updateProcess(step, process.type, 'PENDING', {
                             txHash: transaction.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
@@ -114,11 +194,6 @@ class StepExecutionManager {
                                 transaction.hash,
                         });
                     }
-                    await transaction.wait();
-                    process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                        txHash: transaction.hash,
-                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
-                    });
                     if (isBridgeExecution) {
                         process = statusManager.updateProcess(step, process.type, 'DONE');
                     }

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

@@ -0,0 +1,3 @@
+import { ExtendedChain, LifiStep, Process } from '@lifi/types';
+import { StatusManager } from '.';
+export declare const updateMultisigRouteProcess: (internalTxHash: string, step: LifiStep, statusManager: StatusManager, process: Process, fromChain: ExtendedChain) => Promise<void>;

package/dist/cjs/execution/multisig.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMultisigRouteProcess = void 0;
+const ConfigService_1 = __importDefault(require("../services/ConfigService"));
+const errors_1 = require("../utils/errors");
+const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, process, fromChain) => {
+    const config = ConfigService_1.default.getInstance().getConfig();
+    if (!config.multisigConfig?.getMultisigTransactionDetails) {
+        throw new Error('"getMultisigTransactionDetails()" is missing in Multisig config.');
+    }
+    const multisigStatusResponse = await config.multisigConfig?.getMultisigTransactionDetails(internalTxHash, fromChain.id);
+    if (multisigStatusResponse.status === 'DONE') {
+        process = statusManager.updateProcess(step, process.type, 'PENDING', {
+            txHash: multisigStatusResponse.txHash,
+            multisigTxHash: undefined,
+            txLink: fromChain.metamask.blockExplorerUrls[0] +
+                'tx/' +
+                multisigStatusResponse.txHash,
+        });
+    }
+    if (multisigStatusResponse.status === 'FAILED') {
+        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionFailed, 'Multisig transaction failed.');
+    }
+    if (multisigStatusResponse.status === 'CANCELLED') {
+        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionRejected, 'Transaction was rejected by users.');
+    }
+};
+exports.updateMultisigRouteProcess = updateMultisigRouteProcess;

package/dist/cjs/services/ConfigService.js

@@ -42,6 +42,8 @@ class ConfigService {
             this.config.integrator = configUpdate.integrator || this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
+            this.config.multisigConfig =
+                configUpdate.multisigConfig || this.config.multisigConfig;
             return this.config;
         };
         this.updateChains = (chains) => {

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

@@ -35,7 +35,27 @@ export type Config = {
     userId?: string;
     integrator: string;
     widgetVersion?: string;
+    multisigConfig?: MultisigConfig;
 };
+export interface MultisigTxDetails {
+    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
+    message: string;
+    txHash?: string;
+}
+export interface MultisigTransactionResponse {
+    hash: string;
+}
+export interface BaseTransaction {
+    to: string;
+    value: string;
+    data: string;
+}
+export interface MultisigConfig {
+    isMultisigSigner: boolean;
+    getMultisigTransactionDetails: (txHash: string, fromChainId: number) => Promise<MultisigTxDetails>;
+    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<MultisigTransactionResponse>;
+    shouldBatchTransactions?: boolean;
+}
 export type ConfigUpdate = {
     apiUrl?: string;
     rpcs?: Record<number, string[]>;
@@ -46,6 +66,7 @@ export type ConfigUpdate = {
     userId?: string;
     integrator: string;
     widgetVersion?: string;
+    multisigConfig?: MultisigConfig;
 };
 export type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
 export interface AcceptSlippageUpdateHookParams {

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.1.2";
+export declare const version = "2.1.3-beta.0";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '2.1.2';
+exports.version = '2.1.3-beta.0';

package/dist/execution/StatusManager.d.ts

@@ -10,7 +10,7 @@ interface Receipt {
     gasAmountUSD?: string;
 }
 type InternalUpdateRouteCallback = (route: Route) => void;
-type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
+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.

package/dist/execution/StepExecutionManager.js

@@ -3,13 +3,15 @@ import { checkAllowance } from '../allowance';
 import { checkBalance } from '../balance';
 import ApiService from '../services/ApiService';
 import ChainsService from '../services/ChainsService';
-import { LifiErrorCode, TransactionError } from '../utils/errors';
+import { LifiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
 import { getProvider } from '../utils/getProvider';
 import { getTransactionFailedMessage, parseError } from '../utils/parseError';
 import { isZeroAddress, personalizeStep } from '../utils/utils';
 import { stepComparison } from './stepComparison';
 import { switchChain } from './switchChain';
 import { getSubstatusMessage, waitForReceivingTransaction } from './utils';
+import ConfigService from '../services/ConfigService';
+import { updateMultisigRouteProcess } from './multisig';
 export class StepExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
@@ -17,6 +19,11 @@ export class StepExecutionManager {
             this.allowUserInteraction = value;
         };
         this.execute = async ({ signer, step, statusManager, settings, }) => {
+            const config = ConfigService.getInstance().getConfig();
+            const isMultisigSigner = !!config.multisigConfig?.isMultisigSigner;
+            const multisigBatchTransactions = [];
+            const shouldBatchTransactions = config.multisigConfig?.shouldBatchTransactions &&
+                !!config.multisigConfig.sendBatchTransaction;
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService.getInstance();
             const fromChain = await chainsService.getChainById(step.action.fromChainId);
@@ -26,14 +33,43 @@ export class StepExecutionManager {
             // STEP 1: Check allowance
             const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
             // Check token approval only if fromToken is not the native token => no approval needed in that case
-            if (!existingProcess?.txHash &&
-                !isZeroAddress(step.action.fromToken.address)) {
-                await checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
+            const checkForAllowance = !existingProcess?.txHash &&
+                !isZeroAddress(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigSigner);
+            if (checkForAllowance) {
+                const populatedTransaction = await checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
+                if (populatedTransaction) {
+                    const { to, data } = populatedTransaction;
+                    if (to && data) {
+                        // allowance doesn't need value
+                        const cleanedPopulatedTransaction = {
+                            value: BigNumber.from(0).toString(),
+                            to,
+                            data,
+                        };
+                        multisigBatchTransactions.push(cleanedPopulatedTransaction);
+                    }
+                }
             }
             // STEP 2: Get transaction
             let process = statusManager.findOrCreateProcess(step, currentProcessType);
             if (process.status !== 'DONE') {
+                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
                 try {
+                    if (isMultisigSigner && multisigProcess) {
+                        if (!multisigProcess) {
+                            throw new ValidationError('Multisig process is undefined.');
+                        }
+                        if (!config.multisigConfig?.getMultisigTransactionDetails) {
+                            throw new ValidationError('"getMultisigTransactionDetails()" is missing in Multisig config.');
+                        }
+                        const multisigTxHash = multisigProcess.multisigTxHash;
+                        if (!multisigTxHash) {
+                            // need to check what happens in failed tx
+                            throw new ValidationError('Multisig internal transaction hash is undefined.');
+                        }
+                        await updateMultisigRouteProcess(multisigTxHash, step, statusManager, process, fromChain);
+                    }
                     let transaction;
                     if (process.txHash) {
                         // Make sure that the chain is still correct
@@ -99,8 +135,52 @@ export class StepExecutionManager {
                             catch (error) { }
                         }
                         // Submit the transaction
-                        transaction = await signer.sendTransaction(transactionRequest);
+                        if (shouldBatchTransactions &&
+                            config.multisigConfig?.sendBatchTransaction) {
+                            const { to, data, value } = await signer.populateTransaction(transactionRequest);
+                            const isValidTransaction = to && data;
+                            if (isValidTransaction) {
+                                const populatedTransaction = {
+                                    value: value?.toString() ?? BigNumber.from(0).toString(),
+                                    to,
+                                    data: data.toString(),
+                                };
+                                multisigBatchTransactions.push(populatedTransaction);
+                                transaction = await config.multisigConfig?.sendBatchTransaction(multisigBatchTransactions);
+                            }
+                            else {
+                                throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            }
+                        }
+                        else {
+                            transaction = await signer.sendTransaction(transactionRequest);
+                        }
                         // STEP 4: Wait for the transaction
+                        if (isMultisigSigner) {
+                            process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
+                                multisigTxHash: transaction.hash,
+                            });
+                        }
+                        else {
+                            process = statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: transaction.hash,
+                                txLink: fromChain.metamask.blockExplorerUrls[0] +
+                                    'tx/' +
+                                    transaction.hash,
+                            });
+                        }
+                    }
+                    await transaction.wait?.();
+                    // if it's multisig signer and the process is in ACTION_REQUIRED
+                    // then signatures are still needed
+                    if (isMultisigSigner &&
+                        process.status === 'ACTION_REQUIRED' &&
+                        transaction.hash) {
+                        // Return the execution object without updating the process
+                        // The execution would progress once all multisigs signer approve
+                        await updateMultisigRouteProcess(transaction.hash, step, statusManager, process, fromChain);
+                    }
+                    if (!isMultisigSigner) {
                         process = statusManager.updateProcess(step, process.type, 'PENDING', {
                             txHash: transaction.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
@@ -108,11 +188,6 @@ export class StepExecutionManager {
                                 transaction.hash,
                         });
                     }
-                    await transaction.wait();
-                    process = statusManager.updateProcess(step, process.type, 'PENDING', {
-                        txHash: transaction.hash,
-                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
-                    });
                     if (isBridgeExecution) {
                         process = statusManager.updateProcess(step, process.type, 'DONE');
                     }

package/dist/execution/multisig.d.ts

@@ -0,0 +1,3 @@
+import { ExtendedChain, LifiStep, Process } from '@lifi/types';
+import { StatusManager } from '.';
+export declare const updateMultisigRouteProcess: (internalTxHash: string, step: LifiStep, statusManager: StatusManager, process: Process, fromChain: ExtendedChain) => Promise<void>;

package/dist/execution/multisig.js

@@ -0,0 +1,24 @@
+import ConfigService from '../services/ConfigService';
+import { LifiErrorCode, TransactionError } from '../utils/errors';
+export const updateMultisigRouteProcess = async (internalTxHash, step, statusManager, process, fromChain) => {
+    const config = ConfigService.getInstance().getConfig();
+    if (!config.multisigConfig?.getMultisigTransactionDetails) {
+        throw new Error('"getMultisigTransactionDetails()" is missing in Multisig config.');
+    }
+    const multisigStatusResponse = await config.multisigConfig?.getMultisigTransactionDetails(internalTxHash, fromChain.id);
+    if (multisigStatusResponse.status === 'DONE') {
+        process = statusManager.updateProcess(step, process.type, 'PENDING', {
+            txHash: multisigStatusResponse.txHash,
+            multisigTxHash: undefined,
+            txLink: fromChain.metamask.blockExplorerUrls[0] +
+                'tx/' +
+                multisigStatusResponse.txHash,
+        });
+    }
+    if (multisigStatusResponse.status === 'FAILED') {
+        throw new TransactionError(LifiErrorCode.TransactionFailed, 'Multisig transaction failed.');
+    }
+    if (multisigStatusResponse.status === 'CANCELLED') {
+        throw new TransactionError(LifiErrorCode.TransactionRejected, 'Transaction was rejected by users.');
+    }
+};

package/dist/services/ConfigService.js

@@ -40,6 +40,8 @@ class ConfigService {
             this.config.integrator = configUpdate.integrator || this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
+            this.config.multisigConfig =
+                configUpdate.multisigConfig || this.config.multisigConfig;
             return this.config;
         };
         this.updateChains = (chains) => {

package/dist/types/internal.types.d.ts

@@ -35,7 +35,27 @@ export type Config = {
     userId?: string;
     integrator: string;
     widgetVersion?: string;
+    multisigConfig?: MultisigConfig;
 };
+export interface MultisigTxDetails {
+    status: 'DONE' | 'FAILED' | 'PENDING' | 'CANCELLED';
+    message: string;
+    txHash?: string;
+}
+export interface MultisigTransactionResponse {
+    hash: string;
+}
+export interface BaseTransaction {
+    to: string;
+    value: string;
+    data: string;
+}
+export interface MultisigConfig {
+    isMultisigSigner: boolean;
+    getMultisigTransactionDetails: (txHash: string, fromChainId: number) => Promise<MultisigTxDetails>;
+    sendBatchTransaction?: (batchTransactions: BaseTransaction[]) => Promise<MultisigTransactionResponse>;
+    shouldBatchTransactions?: boolean;
+}
 export type ConfigUpdate = {
     apiUrl?: string;
     rpcs?: Record<number, string[]>;
@@ -46,6 +66,7 @@ export type ConfigUpdate = {
     userId?: string;
     integrator: string;
     widgetVersion?: string;
+    multisigConfig?: MultisigConfig;
 };
 export type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
 export interface AcceptSlippageUpdateHookParams {

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "2.1.2";
+export declare const version = "2.1.3-beta.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk';
-export const version = '2.1.2';
+export const version = '2.1.3-beta.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/sdk",
-  "version": "2.1.2",
+  "version": "2.1.3-beta.0",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
   "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",