@lifi/sdk 3.0.0-alpha.8 → 3.0.0-beta.0

package/package.json

@@ -1,7 +1,45 @@
 {
   "name": "@lifi/sdk",
-  "version": "3.0.0-alpha.8",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
+  "dependencies": {
+    "@lifi/types": "^13.12.0",
+    "@solana/wallet-adapter-base": "^0.9.23",
+    "@solana/web3.js": "^1.92.2",
+    "eth-rpc-errors": "^4.0.3",
+    "viem": "^2.13.7"
+  },
+  "peerDependencies": {
+    "@solana/wallet-adapter-base": "^0.9.0",
+    "@solana/web3.js": "^1.91.0",
+    "viem": "^2.10.0"
+  },
+  "version": "3.0.0-beta.0",
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.mock.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.handlers.ts",
+    "!src/**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/_types/index.d.ts",
+      "import": "./src/_esm/index.js",
+      "default": "./src/_cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./src/_cjs/index.js",
+  "module": "./src/_esm/index.js",
+  "types": "./src/_types/index.d.ts",
+  "typings": "./src/_types/index.d.ts",
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/lifinance/sdk.git"
+  },
   "keywords": [
     "bridge",
     "bridge-aggregation",
@@ -21,92 +59,5 @@
     "wagmi",
     "web3",
     "web3-react"
-  ],
-  "homepage": "https://github.com/lifinance/sdk",
-  "bugs": {
-    "url": "https://github.com/lifinance/sdk/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/lifinance/sdk.git"
-  },
-  "license": "Apache-2.0",
-  "author": "Max Klenk <max@li.finance>",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "directories": {
-    "test": "tests"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "addscope": "node tools/packagejson name @lifi/sdk",
-    "build": "yarn clean && tsc --project ./tsconfig.json && tsc --project ./tsconfig.cjs.json",
-    "clean": "node tools/cleanup",
-    "coverage": "vitest run --coverage",
-    "_postinstall": "husky install",
-    "lint": "eslint --ext .tsx --ext .ts ./src",
-    "lint:fix": "eslint --ext .tsx --ext .ts ./src --fix",
-    "prepack": "pinst --disable",
-    "postpack": "pinst --enable",
-    "package": "npm run build && npm pack",
-    "pre-commit": "lint-staged",
-    "pre-push": "yarn types:check && yarn build && yarn test:unit",
-    "prepublishOnly": "npm run build",
-    "prettier:fix": "prettier --write ./src/.",
-    "release": "standard-version -a",
-    "release:alpha": "standard-version -a --prerelease alpha --skip.changelog",
-    "release:beta": "standard-version -a --prerelease beta --skip.changelog",
-    "test": "vitest --run --dangerouslyIgnoreUnhandledErrors",
-    "test:cov": "yarn test --coverage",
-    "test:e2e": "yarn test -c vitest.e2e.config.ts",
-    "test:unit": "yarn test .unit.spec.ts",
-    "types:check": "tsc --noEmit",
-    "watch": "tsc -w -p ./tsconfig.json"
-  },
-  "lint-staged": {
-    "src/**/*.{ts,tsx}": [
-      "yarn run lint:fix",
-      "yarn run prettier:fix"
-    ]
-  },
-  "dependencies": {
-    "@lifi/types": "^9.0.0-alpha.12",
-    "@solana/web3.js": "^1.78.4",
-    "eth-rpc-errors": "^4.0.3",
-    "viem": "^1.10.3"
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^17.7.1",
-    "@commitlint/config-conventional": "^17.7.0",
-    "@mswjs/interceptors": "^0.22.16",
-    "@types/ws": "^8.5.5",
-    "@typescript-eslint/eslint-plugin": "^6.6.0",
-    "@typescript-eslint/parser": "^6.6.0",
-    "@vitest/coverage-v8": "^0.34.3",
-    "cross-fetch": "^4.0.0",
-    "eslint": "^8.48.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-jsdoc": "^46.5.1",
-    "eslint-plugin-prettier": "^5.0.0",
-    "husky": "^8.0.3",
-    "lint-staged": "^14.0.1",
-    "msw": "1.0.1",
-    "pinst": "^3.0.0",
-    "prettier": "^3.0.3",
-    "standard-version": "^9.5.0",
-    "typescript": "^5.2.2",
-    "vitest": "^0.34.3"
-  },
-  "packageManager": "yarn@3.6.3",
-  "publishConfig": {
-    "access": "public"
-  },
-  "standard-version": {
-    "scripts": {
-      "postbump": "node scripts/version.js && git add ."
-    }
-  }
+  ]
 }

package/src/_cjs/config.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.config = (() => {
+    const _config = {
+        integrator: 'lifi-sdk',
+        apiUrl: 'https://li.quest/v1',
+        rpcUrls: {},
+        chains: [],
+        providers: [],
+        preloadChains: true,
+    };
+    let _loading;
+    return {
+        set loading(loading) {
+            _loading = loading;
+        },
+        get() {
+            return _config;
+        },
+        set(options) {
+            const { chains, providers, rpcUrls, ...otherOptions } = options;
+            Object.assign(_config, otherOptions);
+            if (chains) {
+                this.setChains(chains);
+            }
+            if (providers) {
+                this.setProviders(providers);
+            }
+            if (rpcUrls) {
+                this.setRPCUrls(rpcUrls);
+            }
+            return _config;
+        },
+        setProviders(providers) {
+            const providerMap = new Map(_config.providers.map((provider) => [provider.type, provider]));
+            providers.forEach((provider) => providerMap.set(provider.type, provider));
+            _config.providers = Array.from(providerMap.values());
+        },
+        setChains(chains) {
+            const rpcUrls = chains.reduce((rpcUrls, chain) => {
+                if (chain.metamask?.rpcUrls?.length) {
+                    rpcUrls[chain.id] = chain.metamask.rpcUrls;
+                }
+                return rpcUrls;
+            }, {});
+            this.setRPCUrls(rpcUrls);
+            _config.chains = chains;
+            _loading = undefined;
+        },
+        async getChains() {
+            if (_loading) {
+                await _loading;
+            }
+            return _config.chains;
+        },
+        async getChainById(chainId) {
+            if (_loading) {
+                await _loading;
+            }
+            const chain = _config.chains?.find((chain) => chain.id === chainId);
+            if (!chain) {
+                throw new Error(`ChainId ${chainId} not found`);
+            }
+            return chain;
+        },
+        setRPCUrls(rpcUrls) {
+            for (const rpcUrlsKey in rpcUrls) {
+                const chainId = rpcUrlsKey;
+                const urls = rpcUrls[chainId];
+                if (!urls?.length) {
+                    continue;
+                }
+                if (!_config.rpcUrls[chainId]?.length) {
+                    _config.rpcUrls[chainId] = Array.from(urls);
+                }
+                else {
+                    _config.rpcUrls[chainId]?.push(...urls);
+                }
+            }
+        },
+        async getRPCUrls() {
+            if (_loading) {
+                await _loading;
+            }
+            return _config.rpcUrls;
+        },
+    };
+})();
+//# sourceMappingURL=config.js.map

package/src/_cjs/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../config.ts"],"names":[],"mappings":"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"}

package/{dist/cjs → src/_cjs}/constants.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulticallBatchSize = exports.AlternativeAddressZero = exports.AddressZero = void 0;
+exports.wrappedSolAddress = exports.AlternativeAddressZero = exports.AddressZero = void 0;
 exports.AddressZero = '0x0000000000000000000000000000000000000000';
 exports.AlternativeAddressZero = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-/**
- * Cronos require bigger multicall chunks than default 1024 (1 KB)
- */
-exports.MulticallBatchSize = 16384; // 16 Kilobytes (KB)
+exports.wrappedSolAddress = 'So11111111111111111111111111111111111111112';
+//# sourceMappingURL=constants.js.map

package/src/_cjs/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG,4CAA4C,CAAA;AAC1D,QAAA,sBAAsB,GACjC,4CAA4C,CAAA;AACjC,QAAA,iBAAiB,GAAG,6CAA6C,CAAA"}

package/src/_cjs/core/BaseStepExecutor.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStepExecutor = void 0;
+const StatusManager_js_1 = require("./StatusManager.js");
+const defaultInteractionSettings = {
+    allowInteraction: true,
+    allowUpdates: true,
+    allowExecution: true,
+};
+class BaseStepExecutor {
+    constructor(options) {
+        Object.defineProperty(this, "executionOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "statusManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "allowUserInteraction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "allowExecution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "setInteraction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (settings) => {
+                const interactionSettings = {
+                    ...defaultInteractionSettings,
+                    ...settings,
+                };
+                this.allowUserInteraction = interactionSettings.allowInteraction;
+                this.statusManager.allowUpdates(interactionSettings.allowUpdates);
+                this.allowExecution = interactionSettings.allowExecution;
+            }
+        });
+        this.statusManager = new StatusManager_js_1.StatusManager(options.routeId);
+        this.executionOptions = options.executionOptions;
+    }
+}
+exports.BaseStepExecutor = BaseStepExecutor;
+//# sourceMappingURL=BaseStepExecutor.js.map

package/src/_cjs/core/BaseStepExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseStepExecutor.js","sourceRoot":"","sources":["../../core/BaseStepExecutor.ts"],"names":[],"mappings":";;;AACA,yDAAkD;AASlD,MAAM,0BAA0B,GAAG;IACjC,gBAAgB,EAAE,IAAI;IACtB,YAAY,EAAE,IAAI;IAClB,cAAc,EAAE,IAAI;CACrB,CAAA;AAED,MAAsB,gBAAgB;IAOpC,YAAY,OAA4B;QAN9B;;;;;WAAmC;QACnC;;;;;WAA4B;QAE/B;;;;mBAAuB,IAAI;WAAA;QAC3B;;;;mBAAiB,IAAI;WAAA;QAO5B;;;;mBAAiB,CAAC,QAA8B,EAAQ,EAAE;gBACxD,MAAM,mBAAmB,GAAG;oBAC1B,GAAG,0BAA0B;oBAC7B,GAAG,QAAQ;iBACZ,CAAA;gBACD,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,CAAC,gBAAgB,CAAA;gBAChE,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAA;gBACjE,IAAI,CAAC,cAAc,GAAG,mBAAmB,CAAC,cAAc,CAAA;YAC1D,CAAC;WAAA;QAZC,IAAI,CAAC,aAAa,GAAG,IAAI,gCAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QACvD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAA;IAClD,CAAC;CAaF;AAvBD,4CAuBC"}

package/src/_cjs/core/EVM/EVM.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVM = void 0;
+const types_1 = require("@lifi/types");
+const viem_1 = require("viem");
+const EVMStepExecutor_js_1 = require("./EVMStepExecutor.js");
+const getENSAddress_js_1 = require("./getENSAddress.js");
+const getEVMBalance_js_1 = require("./getEVMBalance.js");
+function EVM(options) {
+    const _options = options ?? {};
+    return {
+        get type() {
+            return types_1.ChainType.EVM;
+        },
+        get multisig() {
+            return _options.multisig;
+        },
+        isAddress: viem_1.isAddress,
+        resolveAddress: getENSAddress_js_1.getENSAddress,
+        getBalance: getEVMBalance_js_1.getEVMBalance,
+        async getStepExecutor(options) {
+            if (!_options.getWalletClient) {
+                throw new Error(`getWalletClient is not provided.`);
+            }
+            const walletClient = await _options.getWalletClient();
+            const executor = new EVMStepExecutor_js_1.EVMStepExecutor({
+                walletClient,
+                multisig: _options.multisig,
+                routeId: options.routeId,
+                executionOptions: {
+                    ...options.executionOptions,
+                    switchChainHook: _options.switchChain ?? options.executionOptions?.switchChainHook,
+                },
+            });
+            return executor;
+        },
+        setOptions(options) {
+            Object.assign(_options, options);
+        },
+    };
+}
+exports.EVM = EVM;
+//# sourceMappingURL=EVM.js.map

package/src/_cjs/core/EVM/EVM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EVM.js","sourceRoot":"","sources":["../../../core/EVM/EVM.ts"],"names":[],"mappings":";;;AAAA,uCAAuC;AACvC,+BAAgC;AAEhC,6DAAsD;AACtD,yDAAkD;AAClD,yDAAkD;AAGlD,SAAgB,GAAG,CAAC,OAA4B;IAC9C,MAAM,QAAQ,GAAuB,OAAO,IAAI,EAAE,CAAA;IAClD,OAAO;QACL,IAAI,IAAI;YACN,OAAO,iBAAS,CAAC,GAAG,CAAA;QACtB,CAAC;QACD,IAAI,QAAQ;YACV,OAAO,QAAQ,CAAC,QAAQ,CAAA;QAC1B,CAAC;QACD,SAAS,EAAT,gBAAS;QACT,cAAc,EAAE,gCAAa;QAC7B,UAAU,EAAE,gCAAa;QACzB,KAAK,CAAC,eAAe,CACnB,OAA4B;YAE5B,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;gBAC9B,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;YACrD,CAAC;YAED,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAA;YAErD,MAAM,QAAQ,GAAG,IAAI,oCAAe,CAAC;gBACnC,YAAY;gBACZ,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,gBAAgB,EAAE;oBAChB,GAAG,OAAO,CAAC,gBAAgB;oBAC3B,eAAe,EACb,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC,gBAAgB,EAAE,eAAe;iBACpE;aACF,CAAC,CAAA;YAEF,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,UAAU,CAAC,OAA2B;YACpC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;QAClC,CAAC;KACF,CAAA;AACH,CAAC;AAtCD,kBAsCC"}

package/src/_cjs/core/EVM/EVMStepExecutor.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMStepExecutor = void 0;
+const viem_1 = require("viem");
+const config_js_1 = require("../../config.js");
+const api_js_1 = require("../../services/api.js");
+const index_js_1 = require("../../utils/index.js");
+const BaseStepExecutor_js_1 = require("../BaseStepExecutor.js");
+const checkBalance_js_1 = require("../checkBalance.js");
+const stepComparison_js_1 = require("../stepComparison.js");
+const utils_js_1 = require("../utils.js");
+const waitForReceivingTransaction_js_1 = require("../waitForReceivingTransaction.js");
+const checkAllowance_js_1 = require("./checkAllowance.js");
+const multisig_js_1 = require("./multisig.js");
+const switchChain_js_1 = require("./switchChain.js");
+const utils_js_2 = require("./utils.js");
+class EVMStepExecutor extends BaseStepExecutor_js_1.BaseStepExecutor {
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "walletClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "multisig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "checkWalletClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (step, process) => {
+                const updatedWalletClient = await (0, switchChain_js_1.switchChain)(this.walletClient, this.statusManager, step, this.allowUserInteraction, this.executionOptions?.switchChainHook);
+                if (updatedWalletClient) {
+                    this.walletClient = updatedWalletClient;
+                }
+                if (this.walletClient.account?.address !== step.action.fromAddress) {
+                    let processToUpdate = process;
+                    if (!processToUpdate) {
+                        processToUpdate = this.statusManager.findOrCreateProcess(step, 'TRANSACTION');
+                    }
+                    const errorMessage = 'The wallet address that requested the quote does not match the wallet address attempting to sign the transaction.';
+                    this.statusManager.updateProcess(step, processToUpdate.type, 'FAILED', {
+                        error: {
+                            code: index_js_1.LiFiErrorCode.WalletChangedDuringExecution,
+                            message: errorMessage,
+                        },
+                    });
+                    this.statusManager.updateExecution(step, 'FAILED');
+                    throw new index_js_1.TransactionError(index_js_1.LiFiErrorCode.WalletChangedDuringExecution, errorMessage);
+                }
+                return updatedWalletClient;
+            }
+        });
+        Object.defineProperty(this, "executeStep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (step) => {
+                step.execution = this.statusManager.initExecutionObject(step);
+                const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+                if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION') {
+                    const updatedWalletClient = await this.checkWalletClient(step);
+                    if (!updatedWalletClient) {
+                        return step;
+                    }
+                }
+                const isMultisigWalletClient = !!this.multisig?.isMultisigWalletClient;
+                const multisigBatchTransactions = [];
+                const shouldBatchTransactions = this.multisig?.shouldBatchTransactions &&
+                    !!this.multisig.sendBatchTransaction;
+                const fromChain = await config_js_1.config.getChainById(step.action.fromChainId);
+                const toChain = await config_js_1.config.getChainById(step.action.toChainId);
+                const isBridgeExecution = fromChain.id !== toChain.id;
+                const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
+                const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
+                const checkForAllowance = !existingProcess?.txHash &&
+                    !(0, index_js_1.isZeroAddress)(step.action.fromToken.address) &&
+                    (shouldBatchTransactions || !isMultisigWalletClient);
+                if (checkForAllowance) {
+                    const data = await (0, checkAllowance_js_1.checkAllowance)(fromChain, step, this.walletClient, this.statusManager, this.executionOptions, this.allowUserInteraction, shouldBatchTransactions);
+                    if (data) {
+                        const baseTransaction = {
+                            to: step.action.fromToken.address,
+                            data,
+                        };
+                        multisigBatchTransactions.push(baseTransaction);
+                    }
+                }
+                let process = this.statusManager.findOrCreateProcess(step, currentProcessType);
+                if (process.status !== 'DONE') {
+                    const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
+                    try {
+                        if (isMultisigWalletClient && multisigProcess) {
+                            const multisigTxHash = multisigProcess.multisigTxHash;
+                            if (!multisigTxHash) {
+                                throw new index_js_1.ValidationError('Multisig internal transaction hash is undefined.');
+                            }
+                            await (0, multisig_js_1.updateMultisigRouteProcess)(multisigTxHash, step, process.type, fromChain, this.statusManager, this.multisig);
+                        }
+                        let txHash;
+                        if (process.txHash) {
+                            const updatedWalletClient = await this.checkWalletClient(step, process);
+                            if (!updatedWalletClient) {
+                                return step;
+                            }
+                            txHash = process.txHash;
+                        }
+                        else {
+                            process = this.statusManager.updateProcess(step, process.type, 'STARTED');
+                            await (0, checkBalance_js_1.checkBalance)(this.walletClient.account.address, step);
+                            if (!step.transactionRequest) {
+                                const { execution, ...stepBase } = step;
+                                const updatedStep = await (0, api_js_1.getStepTransaction)(stepBase);
+                                const comparedStep = await (0, stepComparison_js_1.stepComparison)(this.statusManager, step, updatedStep, this.allowUserInteraction, this.executionOptions);
+                                step = {
+                                    ...comparedStep,
+                                    execution: step.execution,
+                                };
+                            }
+                            if (!step.transactionRequest) {
+                                throw new index_js_1.TransactionError(index_js_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            }
+                            const updatedWalletClient = await this.checkWalletClient(step, process);
+                            if (!updatedWalletClient) {
+                                return step;
+                            }
+                            process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
+                            if (!this.allowUserInteraction) {
+                                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,
+                                maxPriorityFeePerGas: this.walletClient.account?.type === 'local'
+                                    ? await (0, utils_js_2.getMaxPriorityFeePerGas)(this.walletClient.extend(viem_1.publicActions))
+                                    : step.transactionRequest.maxPriorityFeePerGas
+                                        ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
+                                        : undefined,
+                            };
+                            if (this.executionOptions?.updateTransactionRequestHook) {
+                                const customizedTransactionRequest = await this.executionOptions.updateTransactionRequestHook({
+                                    requestType: 'transaction',
+                                    ...transactionRequest,
+                                });
+                                transactionRequest = {
+                                    ...transactionRequest,
+                                    ...customizedTransactionRequest,
+                                };
+                            }
+                            if (shouldBatchTransactions && this.multisig?.sendBatchTransaction) {
+                                if (transactionRequest.to && transactionRequest.data) {
+                                    const populatedTransaction = {
+                                        value: transactionRequest.value,
+                                        to: transactionRequest.to,
+                                        data: transactionRequest.data,
+                                    };
+                                    multisigBatchTransactions.push(populatedTransaction);
+                                    txHash = await this.multisig?.sendBatchTransaction(multisigBatchTransactions);
+                                }
+                                else {
+                                    throw new index_js_1.TransactionError(index_js_1.LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                                }
+                            }
+                            else {
+                                txHash = await this.walletClient.sendTransaction({
+                                    to: transactionRequest.to,
+                                    account: this.walletClient.account,
+                                    data: transactionRequest.data,
+                                    value: transactionRequest.value,
+                                    gas: transactionRequest.gas,
+                                    gasPrice: transactionRequest.gasPrice,
+                                    maxFeePerGas: transactionRequest.maxFeePerGas,
+                                    maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+                                    chain: null,
+                                });
+                            }
+                            if (isMultisigWalletClient) {
+                                process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
+                                    multisigTxHash: txHash,
+                                });
+                            }
+                            else {
+                                process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                    txHash: txHash,
+                                    txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+                                });
+                            }
+                        }
+                        let replacementReason;
+                        const transactionReceipt = await this.walletClient
+                            .extend(viem_1.publicActions)
+                            .waitForTransactionReceipt({
+                            hash: txHash,
+                            onReplaced: (response) => {
+                                replacementReason = response.reason;
+                                this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                    txHash: response.transaction.hash,
+                                    txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+                                });
+                            },
+                            retryCount: utils_js_2.retryCount,
+                            retryDelay: utils_js_2.retryDelay,
+                        });
+                        if (transactionReceipt.status === 'reverted') {
+                            throw new index_js_1.TransactionError(index_js_1.LiFiErrorCode.TransactionFailed, 'Transaction was reverted.');
+                        }
+                        if (replacementReason === 'cancelled') {
+                            throw new index_js_1.TransactionError(index_js_1.LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+                        }
+                        if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
+                            await (0, multisig_js_1.updateMultisigRouteProcess)(transactionReceipt.transactionHash, step, process.type, fromChain, this.statusManager, this.multisig);
+                        }
+                        if (!isMultisigWalletClient) {
+                            process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: transactionReceipt.transactionHash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+                            });
+                        }
+                        if (isBridgeExecution) {
+                            process = this.statusManager.updateProcess(step, process.type, 'DONE');
+                        }
+                    }
+                    catch (e) {
+                        const error = await (0, index_js_1.parseError)(e, step, process);
+                        process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                            error: {
+                                message: error.message,
+                                htmlMessage: error.htmlMessage,
+                                code: error.code,
+                            },
+                        });
+                        this.statusManager.updateExecution(step, 'FAILED');
+                        throw error;
+                    }
+                }
+                const processTxHash = process.txHash;
+                if (isBridgeExecution) {
+                    process = this.statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+                }
+                let statusResponse;
+                try {
+                    if (!processTxHash) {
+                        throw new Error('Transaction hash is undefined.');
+                    }
+                    statusResponse = (await (0, waitForReceivingTransaction_js_1.waitForReceivingTransaction)(processTxHash, this.statusManager, process.type, step));
+                    const statusReceiving = statusResponse.receiving;
+                    process = this.statusManager.updateProcess(step, process.type, 'DONE', {
+                        substatus: statusResponse.substatus,
+                        substatusMessage: statusResponse.substatusMessage ||
+                            (0, utils_js_1.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                        txHash: statusReceiving?.txHash,
+                        txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
+                    });
+                    this.statusManager.updateExecution(step, 'DONE', {
+                        fromAmount: statusResponse.sending.amount,
+                        toAmount: statusReceiving?.amount,
+                        toToken: statusReceiving?.token,
+                        gasCosts: [
+                            {
+                                amount: statusResponse.sending.gasAmount,
+                                amountUSD: statusResponse.sending.gasAmountUSD,
+                                token: statusResponse.sending.gasToken,
+                                estimate: statusResponse.sending.gasUsed,
+                                limit: statusResponse.sending.gasUsed,
+                                price: statusResponse.sending.gasPrice,
+                                type: 'SEND',
+                            },
+                        ],
+                    });
+                }
+                catch (e) {
+                    const htmlMessage = await (0, index_js_1.getTransactionFailedMessage)(step, process.txLink);
+                    process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                        error: {
+                            code: index_js_1.LiFiErrorCode.TransactionFailed,
+                            message: 'Failed while waiting for receiving chain.',
+                            htmlMessage,
+                        },
+                    });
+                    this.statusManager.updateExecution(step, 'FAILED');
+                    console.warn(e);
+                    throw e;
+                }
+                return step;
+            }
+        });
+        this.walletClient = options.walletClient;
+        this.multisig = options.multisig;
+    }
+}
+exports.EVMStepExecutor = EVMStepExecutor;
+//# sourceMappingURL=EVMStepExecutor.js.map