@sidhujag/sysweb3-keyring 1.0.491

package/cjs/transactions/ethereum.js

@@ -0,0 +1,1577 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumTransactions = void 0;
+const sysweb3_network_1 = require("@sidhujag/sysweb3-network");
+const sysweb3_utils_1 = require("@sidhujag/sysweb3-utils");
+const eth_sig_util_1 = require("eth-sig-util");
+const ethereumjs_util_1 = require("ethereumjs-util");
+const ethers_1 = require("ethers");
+const floor_1 = __importDefault(require("lodash/floor"));
+const omit_1 = __importDefault(require("lodash/omit"));
+const providers_1 = require("../providers");
+const types_1 = require("../types");
+/**
+ * Chain IDs for zkSync Era networks that require specialized L2 provider functionality.
+ * These networks use CustomL2JsonRpcProvider (which extends zksync-ethers.Provider)
+ * instead of CustomJsonRpcProvider.
+ *
+ * zkSync Era networks:
+ * - 324: zkSync Era Mainnet
+ * - 300: zkSync Era Sepolia Testnet
+ */
+const L2_NETWORK_CHAIN_IDS = [324, 300];
+class EthereumTransactions {
+    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner) {
+        this.signTypedData = async (addr, typedData, version) => {
+            const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { activeAccountType, accounts, activeAccountId } = this.getState();
+            const activeAccount = accounts[activeAccountType][activeAccountId];
+            // Validate that the derived address matches the active account to prevent race conditions
+            if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
+                throw {
+                    message: `Account state mismatch detected. Expected ${activeAccount.address} but got ${address}. Please try again after account switching completes.`,
+                };
+            }
+            const signTypedData = () => {
+                if (addr.toLowerCase() !== address.toLowerCase())
+                    throw {
+                        message: 'Decrypting for wrong address, change activeAccount maybe',
+                    };
+                const privKey = Buffer.from((0, ethereumjs_util_1.stripHexPrefix)(decryptedPrivateKey), 'hex');
+                return (0, eth_sig_util_1.signTypedMessage)(privKey, { data: typedData }, version);
+            };
+            const signTypedDataWithLedger = async () => {
+                if (addr.toLowerCase() !== activeAccount.address.toLowerCase())
+                    throw {
+                        message: 'Decrypting for wrong address, change activeAccount maybe',
+                    };
+                return await this.ledgerSigner.evm.signTypedData({
+                    version,
+                    accountIndex: activeAccountId,
+                    data: typedData,
+                });
+            };
+            const signTypedDataWithTrezor = async () => {
+                if (addr.toLowerCase() !== activeAccount.address.toLowerCase())
+                    throw {
+                        message: 'Decrypting for wrong address, change activeAccount maybe',
+                    };
+                return await this.trezorSigner.signTypedData({
+                    version,
+                    address: addr,
+                    data: typedData,
+                    index: activeAccountId,
+                });
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await signTypedDataWithTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await signTypedDataWithLedger();
+                default:
+                    return signTypedData();
+            }
+        };
+        this.verifyTypedSignature = (data, signature, version) => {
+            try {
+                const msgParams = {
+                    data,
+                    sig: signature,
+                };
+                return (0, eth_sig_util_1.recoverTypedMessage)(msgParams, version);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.ethSign = async (params) => {
+            const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { accounts, activeAccountId, activeAccountType, activeNetwork } = this.getState();
+            const activeAccount = accounts[activeAccountType][activeAccountId];
+            // Validate that the derived address matches the active account to prevent race conditions
+            if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
+                throw {
+                    message: `Account state mismatch detected. Expected ${activeAccount.address} but got ${address}. Please try again after account switching completes.`,
+                };
+            }
+            let msg = '';
+            //Comparisions do not need to care for checksum address
+            if (params[0].toLowerCase() === address.toLowerCase()) {
+                msg = (0, ethereumjs_util_1.stripHexPrefix)(params[1]);
+            }
+            else if (params[1].toLowerCase() === address.toLowerCase()) {
+                msg = (0, ethereumjs_util_1.stripHexPrefix)(params[0]);
+            }
+            else {
+                throw new Error('Signing for wrong address');
+            }
+            const sign = () => {
+                try {
+                    const bufPriv = (0, ethereumjs_util_1.toBuffer)(decryptedPrivateKey);
+                    // Validate and prepare the message for eth_sign
+                    let msgHash;
+                    // Check if message is a valid 32-byte hex string
+                    if (msg.length === 64 && /^[0-9a-fA-F]+$/.test(msg)) {
+                        // Message is already a 32-byte hex string
+                        msgHash = Buffer.from(msg, 'hex');
+                    }
+                    else {
+                        // Message is not a proper hash - provide helpful error
+                        throw new Error(`Expected message to be an Uint8Array with length 32. ` +
+                            `Got message of length ${msg.length}: "${msg.substring(0, 50)}${msg.length > 50 ? '...' : ''}". ` +
+                            `For signing arbitrary text, use personal_sign instead of eth_sign.`);
+                    }
+                    const sig = (0, ethereumjs_util_1.ecsign)(msgHash, bufPriv);
+                    const resp = (0, eth_sig_util_1.concatSig)((0, ethereumjs_util_1.toBuffer)(sig.v), sig.r, sig.s);
+                    return resp;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const signWithLedger = async () => {
+                try {
+                    const response = await this.ledgerSigner.evm.signPersonalMessage({
+                        accountIndex: activeAccountId,
+                        message: msg,
+                    });
+                    return response;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const signWithTrezor = async () => {
+                try {
+                    // For EVM networks, Trezor expects 'eth' regardless of the network's currency
+                    const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    const response = await this.trezorSigner.signMessage({
+                        coin: trezorCoin,
+                        address: activeAccount.address,
+                        index: activeAccountId,
+                        message: msg,
+                        slip44: activeNetwork.slip44,
+                    });
+                    return response.signature;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await signWithTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await signWithLedger();
+                default:
+                    return sign();
+            }
+        };
+        this.signPersonalMessage = async (params) => {
+            const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { accounts, activeAccountId, activeAccountType, activeNetwork } = this.getState();
+            const activeAccount = accounts[activeAccountType][activeAccountId];
+            // Validate that the derived address matches the active account to prevent race conditions
+            if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
+                throw {
+                    message: `Account state mismatch detected. Expected ${activeAccount.address} but got ${address}. Please try again after account switching completes.`,
+                };
+            }
+            let msg = '';
+            if (params[0].toLowerCase() === address.toLowerCase()) {
+                msg = params[1];
+            }
+            else if (params[1].toLowerCase() === address.toLowerCase()) {
+                msg = params[0];
+            }
+            else {
+                throw new Error('Signing for wrong address');
+            }
+            const signPersonalMessageWithDefaultWallet = () => {
+                try {
+                    const privateKey = (0, ethereumjs_util_1.toBuffer)(decryptedPrivateKey);
+                    // Handle both hex-encoded and plain text messages for personal_sign
+                    let message;
+                    if (msg.startsWith('0x')) {
+                        // Message is hex-encoded
+                        try {
+                            message = (0, ethereumjs_util_1.toBuffer)(msg);
+                        }
+                        catch (error) {
+                            // If hex parsing fails, treat as plain text
+                            message = Buffer.from(msg, 'utf8');
+                        }
+                    }
+                    else {
+                        // Message is plain text
+                        message = Buffer.from(msg, 'utf8');
+                    }
+                    const msgHash = (0, ethereumjs_util_1.hashPersonalMessage)(message);
+                    const sig = (0, ethereumjs_util_1.ecsign)(msgHash, privateKey);
+                    const serialized = (0, eth_sig_util_1.concatSig)((0, ethereumjs_util_1.toBuffer)(sig.v), sig.r, sig.s);
+                    return serialized;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const signPersonalMessageWithLedger = async () => {
+                try {
+                    // Handle both hex-encoded and plain text messages for personal_sign
+                    let messageForLedger;
+                    if (msg.startsWith('0x')) {
+                        // Message is hex-encoded, remove 0x prefix
+                        messageForLedger = msg.replace('0x', '');
+                    }
+                    else {
+                        // Message is plain text, convert to hex
+                        messageForLedger = Buffer.from(msg, 'utf8').toString('hex');
+                    }
+                    const response = await this.ledgerSigner.evm.signPersonalMessage({
+                        accountIndex: activeAccountId,
+                        message: messageForLedger,
+                    });
+                    return response;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const signPersonalMessageWithTrezor = async () => {
+                try {
+                    // Handle both hex-encoded and plain text messages for personal_sign
+                    let messageForTrezor;
+                    if (msg.startsWith('0x')) {
+                        // Message is hex-encoded, keep as is
+                        messageForTrezor = msg;
+                    }
+                    else {
+                        // Message is plain text, convert to hex with 0x prefix
+                        messageForTrezor = '0x' + Buffer.from(msg, 'utf8').toString('hex');
+                    }
+                    // For EVM networks, Trezor expects 'eth' regardless of the network's currency
+                    const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    const response = await this.trezorSigner.signMessage({
+                        coin: trezorCoin,
+                        address: activeAccount.address,
+                        index: activeAccountId,
+                        message: messageForTrezor,
+                        slip44: activeNetwork.slip44,
+                    });
+                    return response.signature;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await signPersonalMessageWithTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await signPersonalMessageWithLedger();
+                default:
+                    return signPersonalMessageWithDefaultWallet();
+            }
+        };
+        this.parsePersonalMessage = (hexMsg) => {
+            try {
+                return (0, ethereumjs_util_1.toAscii)(hexMsg);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.verifyPersonalMessage = (message, sign) => {
+            try {
+                const msgParams = {
+                    data: message,
+                    sig: sign,
+                };
+                return (0, eth_sig_util_1.recoverPersonalSignature)(msgParams);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getEncryptedPubKey = () => {
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            try {
+                return (0, eth_sig_util_1.getEncryptionPublicKey)((0, ethereumjs_util_1.stripHexPrefix)(decryptedPrivateKey));
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        // eth_decryptMessage
+        this.decryptMessage = (msgParams) => {
+            const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            let encryptedData = '';
+            if (msgParams[0].toLowerCase() === address.toLowerCase()) {
+                encryptedData = msgParams[1];
+            }
+            else if (msgParams[1].toLowerCase() === address.toLowerCase()) {
+                encryptedData = msgParams[0];
+            }
+            else {
+                throw new Error('Decrypting for wrong receiver');
+            }
+            encryptedData = (0, ethereumjs_util_1.stripHexPrefix)(encryptedData);
+            try {
+                const buff = Buffer.from(encryptedData, 'hex');
+                const cleanData = JSON.parse(buff.toString('utf8'));
+                const sig = (0, eth_sig_util_1.decrypt)(cleanData, (0, ethereumjs_util_1.stripHexPrefix)(decryptedPrivateKey));
+                return sig;
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.toBigNumber = (aBigNumberish) => ethers_1.ethers.BigNumber.from(String(aBigNumberish));
+        this.getData = ({ contractAddress, receivingAddress, value, }) => {
+            const abi = (0, sysweb3_utils_1.getErc20Abi)();
+            try {
+                const contract = (0, sysweb3_utils_1.createContractUsingAbi)(abi, contractAddress, this.web3Provider);
+                const data = contract.methods
+                    .transfer(receivingAddress, value)
+                    .encodeABI();
+                return data;
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getFeeDataWithDynamicMaxPriorityFeePerGas = async () => {
+            let maxFeePerGas = this.toBigNumber(0);
+            let maxPriorityFeePerGas = this.toBigNumber(0);
+            try {
+                const block = await this.web3Provider.getBlock('latest');
+                if (block && block.baseFeePerGas) {
+                    try {
+                        const ethMaxPriorityFee = await this.web3Provider.send('eth_maxPriorityFeePerGas', []);
+                        maxPriorityFeePerGas = ethers_1.ethers.BigNumber.from(ethMaxPriorityFee);
+                        maxFeePerGas = block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas);
+                    }
+                    catch (e) {
+                        maxPriorityFeePerGas = ethers_1.ethers.BigNumber.from('1500000000');
+                        maxFeePerGas = block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas);
+                    }
+                    return { maxFeePerGas, maxPriorityFeePerGas };
+                }
+                else if (block && !block.baseFeePerGas) {
+                    console.error('Chain doesnt support EIP1559');
+                    return { maxFeePerGas, maxPriorityFeePerGas };
+                }
+                else if (!block)
+                    throw new Error('Block not found');
+                return { maxFeePerGas, maxPriorityFeePerGas };
+            }
+            catch (error) {
+                console.error(error);
+                return { maxFeePerGas, maxPriorityFeePerGas };
+            }
+        };
+        this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy) => {
+            const newGasValues = {
+                maxFeePerGas: undefined,
+                maxPriorityFeePerGas: undefined,
+                gasPrice: undefined,
+                gasLimit: undefined,
+            };
+            const { maxFeePerGas, maxPriorityFeePerGas, gasLimit, gasPrice } = oldTxsParams;
+            const calculateAndConvertNewValue = (feeValue) => {
+                const calculateValue = String(feeValue * multiplierToUse);
+                const convertValueToHex = '0x' + parseInt(calculateValue, 10).toString(16);
+                return ethers_1.ethers.BigNumber.from(convertValueToHex);
+            };
+            const maxFeePerGasToNumber = maxFeePerGas?.toNumber();
+            const maxPriorityFeePerGasToNumber = maxPriorityFeePerGas?.toNumber();
+            const gasLimitToNumber = gasLimit?.toNumber();
+            const gasPriceToNumber = gasPrice?.toNumber();
+            const multiplierToUse = 1.2; //The same calculation we used in the edit fee modal, always using the 0.2 multiplier
+            if (!isLegacy) {
+                newGasValues.maxFeePerGas = calculateAndConvertNewValue(maxFeePerGasToNumber);
+                newGasValues.maxPriorityFeePerGas = calculateAndConvertNewValue(maxPriorityFeePerGasToNumber);
+            }
+            if (isLegacy) {
+                newGasValues.gasPrice = calculateAndConvertNewValue(gasPriceToNumber);
+            }
+            if (isForCancel) {
+                const DEFAULT_GAS_LIMIT_VALUE = '21000';
+                const convertToHex = '0x' + parseInt(DEFAULT_GAS_LIMIT_VALUE, 10).toString(16);
+                newGasValues.gasLimit = ethers_1.ethers.BigNumber.from(convertToHex);
+            }
+            if (!isForCancel) {
+                newGasValues.gasLimit = calculateAndConvertNewValue(gasLimitToNumber);
+            }
+            return newGasValues;
+        };
+        this.cancelSentTransaction = async (txHash, isLegacy) => {
+            const tx = (await this.web3Provider.getTransaction(txHash));
+            if (!tx) {
+                //If we don't find the TX or is already confirmed we send as error true to show this message
+                //in the alert at Pali
+                return {
+                    isCanceled: false,
+                    error: true,
+                };
+            }
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const wallet = new ethers_1.ethers.Wallet(decryptedPrivateKey, this.web3Provider);
+            let changedTxToCancel;
+            const oldTxsGasValues = {
+                maxFeePerGas: tx.maxFeePerGas,
+                maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+                gasPrice: tx.gasPrice,
+                gasLimit: tx.gasLimit,
+            };
+            if (!isLegacy) {
+                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, true, false);
+                //We have to send another TX using the same nonce but we can use the From and To for the same address and also
+                //the value as 0
+                changedTxToCancel = {
+                    nonce: tx.nonce,
+                    from: wallet.address,
+                    to: wallet.address,
+                    value: ethers_1.ethers.constants.Zero,
+                    maxFeePerGas: newGasValues.maxFeePerGas,
+                    maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
+                    gasLimit: newGasValues.gasLimit,
+                };
+            }
+            else {
+                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, true, true);
+                //We have to send another TX using the same nonce but we can use the From and To for the same address and also
+                //the value as 0
+                changedTxToCancel = {
+                    nonce: tx.nonce,
+                    from: wallet.address,
+                    to: wallet.address,
+                    value: ethers_1.ethers.constants.Zero,
+                    gasLimit: newGasValues.gasLimit,
+                    gasPrice: newGasValues.gasPrice,
+                };
+            }
+            const cancelTransaction = async () => {
+                try {
+                    const transactionResponse = await wallet.sendTransaction(changedTxToCancel);
+                    if (transactionResponse) {
+                        return {
+                            isCanceled: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isCanceled: false,
+                        };
+                    }
+                }
+                catch (error) {
+                    //If we don't find the TX or is already confirmed we send as error true to show this message
+                    //in the alert at Pali
+                    return {
+                        isCanceled: false,
+                        error: true,
+                    };
+                }
+            };
+            return await cancelTransaction();
+        };
+        //TODO: This function needs to be refactored
+        this.sendFormattedTransaction = async (params, isLegacy) => {
+            const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
+            const activeAccount = accounts[activeAccountType][activeAccountId];
+            const sendEVMLedgerTransaction = async () => {
+                const transactionNonce = await this.getRecommendedNonce(activeAccount.address);
+                const formatParams = (0, omit_1.default)(params, 'from'); //From is not needed we're already passing in the HD derivation path so it can be inferred
+                const txFormattedForEthers = isLegacy
+                    ? {
+                        ...formatParams,
+                        nonce: transactionNonce,
+                        chainId: activeNetwork.chainId,
+                    }
+                    : {
+                        ...formatParams,
+                        nonce: transactionNonce,
+                        chainId: activeNetwork.chainId,
+                        type: 2,
+                    };
+                const rawTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers);
+                const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    rawTx: rawTx.replace('0x', ''),
+                    accountIndex: activeAccountId,
+                });
+                const formattedSignature = {
+                    r: `0x${signature.r}`,
+                    s: `0x${signature.s}`,
+                    v: parseInt(signature.v, 16),
+                };
+                if (signature) {
+                    try {
+                        const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, formattedSignature);
+                        const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                        return finalTx;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                else {
+                    throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                }
+            };
+            const sendEVMTrezorTransaction = async () => {
+                const transactionNonce = await this.getRecommendedNonce(activeAccount.address);
+                let txFormattedForTrezor = {};
+                const formatParams = (0, omit_1.default)(params, 'from'); //From is not needed we're already passing in the HD derivation path so it can be inferred
+                switch (isLegacy) {
+                    case true:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasLimit: typeof formatParams.gasLimit === 'string'
+                                ? formatParams.gasLimit
+                                : // @ts-ignore
+                                    `${params.gasLimit.hex}`,
+                            value: typeof formatParams.value === 'string' ||
+                                typeof formatParams.value === 'number'
+                                ? `${formatParams.value}`
+                                : // @ts-ignore
+                                    `${params.value.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                        };
+                        break;
+                    case false:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasLimit: typeof formatParams.gasLimit === 'string'
+                                ? formatParams.gasLimit
+                                : // @ts-ignore
+                                    `${params.gasLimit.hex}`,
+                            maxFeePerGas: typeof formatParams.maxFeePerGas === 'string'
+                                ? formatParams.maxFeePerGas
+                                : // @ts-ignore
+                                    `${params.maxFeePerGas.hex}`,
+                            maxPriorityFeePerGas: typeof formatParams.maxPriorityFeePerGas === 'string'
+                                ? formatParams.maxPriorityFeePerGas
+                                : // @ts-ignore
+                                    `${params.maxPriorityFeePerGas.hex}`,
+                            value: typeof formatParams.value === 'string' ||
+                                typeof formatParams.value === 'number'
+                                ? `${formatParams.value}`
+                                : // @ts-ignore
+                                    `${params.value.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                        };
+                        break;
+                    default:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasLimit: typeof formatParams.gasLimit === 'string'
+                                ? formatParams.gasLimit
+                                : // @ts-ignore
+                                    `${params.gasLimit.hex}`,
+                            maxFeePerGas: typeof formatParams.maxFeePerGas === 'string'
+                                ? formatParams.maxFeePerGas
+                                : // @ts-ignore
+                                    `${params.maxFeePerGas.hex}`,
+                            maxPriorityFeePerGas: typeof formatParams.maxPriorityFeePerGas === 'string'
+                                ? formatParams.maxPriorityFeePerGas
+                                : // @ts-ignore
+                                    `${params.maxPriorityFeePerGas.hex}`,
+                            value: typeof formatParams.value === 'string' ||
+                                typeof formatParams.value === 'number'
+                                ? `${formatParams.value}`
+                                : // @ts-ignore
+                                    `${params.value.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                        };
+                        break;
+                }
+                const signature = await this.trezorSigner.signEthTransaction({
+                    index: `${activeAccountId}`,
+                    tx: txFormattedForTrezor,
+                    coin: activeNetwork.currency,
+                    slip44: activeNetwork.slip44,
+                });
+                if (signature.success) {
+                    try {
+                        const txFormattedForEthers = isLegacy
+                            ? {
+                                ...formatParams,
+                                nonce: transactionNonce,
+                                chainId: activeNetwork.chainId,
+                            }
+                            : {
+                                ...formatParams,
+                                nonce: transactionNonce,
+                                chainId: activeNetwork.chainId,
+                                type: 2,
+                            };
+                        signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
+                        const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, signature.payload);
+                        const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                        return finalTx;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                else {
+                    throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                }
+            };
+            const sendEVMTransaction = async () => {
+                const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                // Validate that we have the correct private key for the active account to prevent race conditions
+                // This is critical for transaction security during account switches
+                if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
+                    throw new Error(`Account state mismatch detected during transaction. Expected ${activeAccount.address} but got ${address}. Please wait for account switching to complete and try again.`);
+                }
+                const tx = params;
+                const wallet = new ethers_1.ethers.Wallet(decryptedPrivateKey, this.web3Provider);
+                try {
+                    const transaction = await wallet.sendTransaction(tx);
+                    const response = await this.web3Provider.getTransaction(transaction.hash);
+                    //TODO: more precisely on this lines
+                    if (!response) {
+                        return await this.getTransactionTimestamp(transaction);
+                    }
+                    else {
+                        return await this.getTransactionTimestamp(response);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await sendEVMTrezorTransaction();
+                case types_1.KeyringAccountType.Ledger:
+                    return await sendEVMLedgerTransaction();
+                default:
+                    return await sendEVMTransaction();
+            }
+        };
+        this.sendTransactionWithEditedFee = async (txHash, isLegacy) => {
+            const tx = (await this.web3Provider.getTransaction(txHash));
+            if (!tx) {
+                return {
+                    isSpeedUp: false,
+                    error: true,
+                };
+            }
+            const { decryptedPrivateKey, address } = this.getDecryptedPrivateKey();
+            const wallet = new ethers_1.ethers.Wallet(decryptedPrivateKey, this.web3Provider);
+            // Check if this might be a max send transaction by comparing total cost to balance
+            const currentBalance = await this.web3Provider.getBalance(address);
+            // Ensure all transaction values are resolved from promises
+            const gasLimit = await Promise.resolve(tx.gasLimit);
+            const gasPrice = await Promise.resolve(tx.gasPrice || 0);
+            const maxFeePerGas = await Promise.resolve(tx.maxFeePerGas || 0);
+            const maxPriorityFeePerGas = await Promise.resolve(tx.maxPriorityFeePerGas || 0);
+            const txValue = await Promise.resolve(tx.value);
+            const txData = await Promise.resolve(tx.data || '0x');
+            // Check if this is a contract call (has data)
+            const isContractCall = txData && txData !== '0x' && txData.length > 2;
+            const originalGasCost = isLegacy
+                ? gasLimit.mul(gasPrice || 0)
+                : gasLimit.mul(maxFeePerGas || 0);
+            const originalTotalCost = txValue.add(originalGasCost);
+            // If original transaction used >95% of balance, it's likely a max send
+            const balanceThreshold = currentBalance.mul(95).div(100);
+            const isLikelyMaxSend = originalTotalCost.gt(balanceThreshold);
+            let txWithEditedFee;
+            const oldTxsGasValues = {
+                maxFeePerGas: maxFeePerGas,
+                maxPriorityFeePerGas: maxPriorityFeePerGas,
+                gasPrice: gasPrice,
+                gasLimit: gasLimit,
+            };
+            if (!isLegacy) {
+                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, false);
+                let adjustedValue = txValue;
+                // For likely max sends, check if we need to adjust value
+                if (isLikelyMaxSend &&
+                    newGasValues.gasLimit &&
+                    newGasValues.maxFeePerGas) {
+                    const newGasCost = newGasValues.gasLimit.mul(newGasValues.maxFeePerGas);
+                    const newTotalCost = txValue.add(newGasCost);
+                    if (newTotalCost.gt(currentBalance)) {
+                        // If this is a contract call, we cannot adjust the value
+                        if (isContractCall) {
+                            console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
+                            return {
+                                isSpeedUp: false,
+                                error: true,
+                            };
+                        }
+                        // For non-contract calls, reduce value to fit within balance
+                        adjustedValue = currentBalance.sub(newGasCost);
+                        // Ensure we don't go below a minimum threshold (0.0001 ETH)
+                        const minValue = ethers_1.ethers.utils.parseEther('0.0001');
+                        if (adjustedValue.lt(minValue)) {
+                            console.warn('[SpeedUp] Adjusted value too low, keeping original');
+                            adjustedValue = txValue;
+                        }
+                    }
+                }
+                txWithEditedFee = {
+                    from: tx.from,
+                    to: tx.to,
+                    nonce: tx.nonce,
+                    value: adjustedValue,
+                    data: txData,
+                    maxFeePerGas: newGasValues.maxFeePerGas,
+                    maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
+                    gasLimit: newGasValues.gasLimit,
+                };
+            }
+            else {
+                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, true);
+                let adjustedValue = txValue;
+                // For likely max sends, check if we need to adjust value
+                if (isLikelyMaxSend && newGasValues.gasLimit && newGasValues.gasPrice) {
+                    const newGasCost = newGasValues.gasLimit.mul(newGasValues.gasPrice);
+                    const newTotalCost = txValue.add(newGasCost);
+                    if (newTotalCost.gt(currentBalance)) {
+                        // If this is a contract call, we cannot adjust the value
+                        if (isContractCall) {
+                            console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
+                            return {
+                                isSpeedUp: false,
+                                error: true,
+                            };
+                        }
+                        // For non-contract calls, reduce value to fit within balance
+                        adjustedValue = currentBalance.sub(newGasCost);
+                        // Ensure we don't go below a minimum threshold (0.0001 ETH)
+                        const minValue = ethers_1.ethers.utils.parseEther('0.0001');
+                        if (adjustedValue.lt(minValue)) {
+                            console.warn('[SpeedUp] Adjusted value too low, keeping original');
+                            adjustedValue = txValue;
+                        }
+                    }
+                }
+                txWithEditedFee = {
+                    from: tx.from,
+                    to: tx.to,
+                    nonce: tx.nonce,
+                    value: adjustedValue,
+                    data: txData,
+                    gasLimit: newGasValues.gasLimit,
+                    gasPrice: newGasValues.gasPrice,
+                };
+            }
+            const sendEditedTransaction = async () => {
+                try {
+                    const transactionResponse = await wallet.sendTransaction(txWithEditedFee);
+                    if (transactionResponse) {
+                        return {
+                            isSpeedUp: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isSpeedUp: false,
+                        };
+                    }
+                }
+                catch (error) {
+                    console.error('[SpeedUp] Failed to send replacement transaction:', error);
+                    //If we don't find the TX or is already confirmed we send as error true to show this message
+                    //in the alert at Pali
+                    return {
+                        isSpeedUp: false,
+                        error: true,
+                    };
+                }
+            };
+            return await sendEditedTransaction();
+        };
+        // TODO: refactor this function
+        this.sendTransaction = async ({ sender, receivingAddress, amount, gasLimit, token, }) => {
+            const tokenDecimals = token && token.decimals ? token.decimals : 18;
+            const decimals = this.toBigNumber(tokenDecimals);
+            const parsedAmount = ethers_1.ethers.utils.parseEther(String(amount));
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const wallet = new ethers_1.ethers.Wallet(decryptedPrivateKey, this.web3Provider);
+            const value = token && token.contract_address
+                ? parsedAmount.mul(this.toBigNumber('10').pow(decimals))
+                : parsedAmount;
+            const data = token && token.contract_address
+                ? this.getData({
+                    contractAddress: token.contract_address,
+                    receivingAddress,
+                    value,
+                })
+                : null;
+            // gas price, gas limit e maxPriorityFeePerGas (tip)
+            const { maxFeePerGas, maxPriorityFeePerGas } = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
+            const tx = {
+                to: receivingAddress,
+                value,
+                maxPriorityFeePerGas,
+                maxFeePerGas,
+                nonce: await this.web3Provider.getTransactionCount(sender, 'latest'),
+                type: 2,
+                chainId: this.web3Provider.network.chainId,
+                gasLimit: this.toBigNumber(0) || gasLimit,
+                data,
+            };
+            tx.gasLimit = await this.web3Provider.estimateGas(tx);
+            try {
+                const transaction = await wallet.sendTransaction(tx);
+                const response = await this.web3Provider.getTransaction(transaction.hash);
+                if (!response) {
+                    return await this.getTransactionTimestamp(transaction);
+                }
+                else {
+                    return await this.getTransactionTimestamp(response);
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.sendSignedErc20Transaction = async ({ receiver, tokenAddress, tokenAmount, isLegacy = false, maxPriorityFeePerGas, maxFeePerGas, gasPrice, decimals, gasLimit, saveTrezorTx, }) => {
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
+            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const sendERC20Token = async () => {
+                const currentWallet = new ethers_1.ethers.Wallet(decryptedPrivateKey);
+                const walletSigned = currentWallet.connect(this.web3Provider);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), walletSigned);
+                    const calculatedTokenAmount = ethers_1.ethers.BigNumber.from(decimals
+                        ? ethers_1.ethers.utils.parseUnits(tokenAmount, this.toBigNumber(decimals))
+                        : ethers_1.ethers.utils.parseEther(tokenAmount));
+                    let transferMethod;
+                    if (isLegacy) {
+                        const overrides = {
+                            nonce: await this.web3Provider.getTransactionCount(walletSigned.address, 'pending'),
+                            gasPrice,
+                            ...(gasLimit && { gasLimit }),
+                        };
+                        transferMethod = await _contract.transfer(receiver, calculatedTokenAmount, overrides);
+                    }
+                    else {
+                        const overrides = {
+                            nonce: await this.web3Provider.getTransactionCount(walletSigned.address, 'pending'),
+                            maxPriorityFeePerGas,
+                            maxFeePerGas,
+                            ...(gasLimit && { gasLimit }),
+                        };
+                        transferMethod = await _contract.transfer(receiver, calculatedTokenAmount, overrides);
+                    }
+                    return transferMethod;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC20TokenOnLedger = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), signer);
+                    const calculatedTokenAmount = ethers_1.ethers.BigNumber.from(ethers_1.ethers.utils.parseEther(tokenAmount));
+                    const txData = _contract.interface.encodeFunctionData('transfer', [
+                        receiver,
+                        calculatedTokenAmount,
+                    ]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('100000'); // ERC20 fallback
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2,
+                        };
+                    }
+                    const rawTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers);
+                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                    });
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, formattedSignature);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            saveTrezorTx && saveTrezorTx(finalTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC20TokenOnTrezor = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), signer);
+                    const calculatedTokenAmount = ethers_1.ethers.BigNumber.from(ethers_1.ethers.utils.parseEther(tokenAmount));
+                    const txData = _contract.interface.encodeFunctionData('transfer', [
+                        receiver,
+                        calculatedTokenAmount,
+                    ]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('100000'); // ERC20 fallback
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            gasPrice: `${gasPrice}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            maxFeePerGas: `${maxFeePerGas.hex}`,
+                            // @ts-ignore
+                            maxPriorityFeePerGas: `${maxPriorityFeePerGas.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    const signature = await this.trezorSigner.signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: activeNetwork.currency,
+                        slip44: activeNetwork.slip44,
+                    });
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2,
+                                };
+                            }
+                            signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, signature.payload);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            saveTrezorTx && saveTrezorTx(finalTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await sendERC20TokenOnTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await sendERC20TokenOnLedger();
+                default:
+                    return await sendERC20Token();
+            }
+        };
+        this.sendSignedErc721Transaction = async ({ receiver, tokenAddress, tokenId, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
+            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const sendERC721Token = async () => {
+                const currentWallet = new ethers_1.ethers.Wallet(decryptedPrivateKey);
+                const walletSigned = currentWallet.connect(this.web3Provider);
+                let transferMethod;
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), walletSigned);
+                    if (isLegacy) {
+                        const overrides = {
+                            nonce: await this.web3Provider.getTransactionCount(walletSigned.address, 'pending'),
+                            gasPrice,
+                            ...(gasLimit && { gasLimit }),
+                        };
+                        transferMethod = await _contract.transferFrom(walletSigned.address, receiver, tokenId, overrides);
+                    }
+                    else {
+                        const overrides = {
+                            nonce: await this.web3Provider.getTransactionCount(walletSigned.address, 'pending'),
+                        };
+                        transferMethod = await _contract.transferFrom(walletSigned.address, receiver, tokenId, overrides);
+                    }
+                    return transferMethod;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC721TokenOnLedger = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), signer);
+                    const txData = _contract.interface.encodeFunctionData('transferFrom', [
+                        activeAccountAddress,
+                        receiver,
+                        tokenId,
+                    ]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('150000'); // ERC721 fallback
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2,
+                        };
+                    }
+                    const rawTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers);
+                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                    });
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, formattedSignature);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC721TokenOnTrezor = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), signer);
+                    const txData = _contract.interface.encodeFunctionData('transferFrom', [
+                        activeAccountAddress,
+                        receiver,
+                        tokenId,
+                    ]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('150000'); // ERC721 fallback
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            gasPrice: `${gasPrice}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                        console.log({ txToBeSignedByTrezor });
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            maxFeePerGas: `${maxFeePerGas.hex}`,
+                            // @ts-ignore
+                            maxPriorityFeePerGas: `${maxPriorityFeePerGas.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    // For EVM networks, Trezor expects 'eth' regardless of the network's currency
+                    const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    const signature = await this.trezorSigner.signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: trezorCoin,
+                        slip44: activeNetwork.slip44,
+                    });
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2,
+                                };
+                            }
+                            signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, signature.payload);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            console.log({ error });
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    console.log({ errorDois: error });
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await sendERC721TokenOnTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await sendERC721TokenOnLedger();
+                default:
+                    return await sendERC721Token();
+            }
+        };
+        this.sendSignedErc1155Transaction = async ({ receiver, tokenAddress, tokenId, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
+            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const sendERC1155Token = async () => {
+                const currentWallet = new ethers_1.ethers.Wallet(decryptedPrivateKey);
+                const walletSigned = currentWallet.connect(this.web3Provider);
+                let transferMethod;
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), walletSigned);
+                    const amount = tokenAmount ? parseInt(tokenAmount) : 1;
+                    const overrides = {};
+                    transferMethod = await _contract.safeTransferFrom(walletSigned.address, receiver, tokenId, amount, [], overrides);
+                    return transferMethod;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC1155TokenOnLedger = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), signer);
+                    const amount = tokenAmount ? parseInt(tokenAmount) : 1;
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, tokenId, amount, []]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('200000'); // ERC1155 fallback
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: effectiveGasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2,
+                        };
+                    }
+                    const rawTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers);
+                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                    });
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, formattedSignature);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC1155TokenOnTrezor = async () => {
+                const signer = this.web3Provider.getSigner(activeAccountAddress);
+                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                try {
+                    const _contract = new ethers_1.ethers.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), signer);
+                    const amount = tokenAmount ? parseInt(tokenAmount) : 1;
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, tokenId, amount, []]);
+                    // Use fallback gas limit if not provided (for auto-estimation)
+                    const effectiveGasLimit = gasLimit || this.toBigNumber('200000'); // ERC1155 fallback
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            gasPrice: `${gasPrice}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            // @ts-ignore
+                            gasLimit: `${effectiveGasLimit.hex}`,
+                            // @ts-ignore
+                            maxFeePerGas: `${maxFeePerGas.hex}`,
+                            // @ts-ignore
+                            maxPriorityFeePerGas: `${maxPriorityFeePerGas.hex}`,
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    const signature = await this.trezorSigner.signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: activeNetwork.currency,
+                        slip44: activeNetwork.slip44,
+                    });
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: effectiveGasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2,
+                                };
+                            }
+                            signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
+                            const signedTx = ethers_1.ethers.utils.serializeTransaction(txFormattedForEthers, signature.payload);
+                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            console.log({ error });
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    console.log({ error });
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case types_1.KeyringAccountType.Trezor:
+                    return await sendERC1155TokenOnTrezor();
+                case types_1.KeyringAccountType.Ledger:
+                    return await sendERC1155TokenOnLedger();
+                default:
+                    return await sendERC1155Token();
+            }
+        };
+        this.getRecommendedNonce = async (address) => {
+            try {
+                return await this.web3Provider.getTransactionCount(address, 'pending');
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getFeeByType = async (type) => {
+            const gasPrice = (await this.getRecommendedGasPrice(false));
+            const low = this.toBigNumber(gasPrice)
+                .mul(ethers_1.ethers.BigNumber.from('8'))
+                .div(ethers_1.ethers.BigNumber.from('10'))
+                .toString();
+            const high = this.toBigNumber(gasPrice)
+                .mul(ethers_1.ethers.BigNumber.from('11'))
+                .div(ethers_1.ethers.BigNumber.from('10'))
+                .toString();
+            if (type === 'low')
+                return low;
+            if (type === 'high')
+                return high;
+            return gasPrice;
+        };
+        this.getGasLimit = async (toAddress) => {
+            try {
+                const estimated = await this.web3Provider.estimateGas({
+                    to: toAddress,
+                });
+                return Number(ethers_1.ethers.utils.formatUnits(estimated, 'gwei'));
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getTxGasLimit = async (tx) => {
+            try {
+                return this.web3Provider.estimateGas(tx);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getRecommendedGasPrice = async (formatted) => {
+            try {
+                const gasPriceBN = await this.web3Provider.getGasPrice();
+                if (formatted) {
+                    return {
+                        gwei: Number(ethers_1.ethers.utils.formatUnits(gasPriceBN, 'gwei')).toFixed(2),
+                        ethers: ethers_1.ethers.utils.formatEther(gasPriceBN),
+                    };
+                }
+                return gasPriceBN.toString();
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getBalance = async (address) => {
+            try {
+                const balance = await this.web3Provider.getBalance(address);
+                const formattedBalance = ethers_1.ethers.utils.formatEther(balance);
+                const roundedBalance = (0, floor_1.default)(parseFloat(formattedBalance), 4);
+                return roundedBalance;
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getTransactionTimestamp = async (transaction) => {
+            const { timestamp } = await this.web3Provider.getBlock(Number(transaction.blockNumber));
+            return {
+                ...transaction,
+                timestamp,
+            };
+        };
+        this.importAccount = (mnemonicOrPrivKey) => {
+            if (ethers_1.ethers.utils.isHexString(mnemonicOrPrivKey)) {
+                return new ethers_1.ethers.Wallet(mnemonicOrPrivKey);
+            }
+            const { privateKey } = ethers_1.ethers.Wallet.fromMnemonic(mnemonicOrPrivKey);
+            const account = new ethers_1.ethers.Wallet(privateKey);
+            return account;
+        };
+        this.getNetwork = getNetwork;
+        this.getDecryptedPrivateKey = getDecryptedPrivateKey;
+        this.abortController = new AbortController();
+        // NOTE: Defer network access until vault state getter is initialized
+        // The web3Provider will be created lazily when first accessed via getters
+        this.getState = getState;
+        this.trezorSigner = trezorSigner;
+        this.ledgerSigner = ledgerSigner;
+    }
+    // Getter that automatically ensures providers are initialized when accessed
+    get web3Provider() {
+        this.ensureProvidersInitialized();
+        return this._web3Provider;
+    }
+    // Helper method to ensure providers are initialized when first needed
+    ensureProvidersInitialized() {
+        if (!this._web3Provider) {
+            // Providers not initialized yet, initialize them now
+            try {
+                const currentNetwork = this.getNetwork();
+                this.setWeb3Provider(currentNetwork);
+            }
+            catch (error) {
+                // If vault state not available yet, providers will be initialized later
+                // when setWeb3Provider is called explicitly
+                console.log('[EthereumTransactions] Deferring provider initialization:', error.message);
+            }
+        }
+    }
+    // Helper method to detect UTXO networks
+    isUtxoNetwork(network) {
+        // Generic UTXO network detection patterns:
+        // 1. URL contains blockbook or trezor (most reliable)
+        // 2. Network kind is explicitly set to 'syscoin'
+        const hasBlockbookUrl = !!(network.url?.includes('blockbook') || network.url?.includes('trezor'));
+        const hasUtxoKind = network.kind === sysweb3_network_1.INetworkType.Syscoin;
+        return hasBlockbookUrl || hasUtxoKind;
+    }
+    setWeb3Provider(network) {
+        this.abortController.abort();
+        this.abortController = new AbortController();
+        // Check if network is a UTXO network to avoid creating web3 providers for blockbook URLs
+        const isUtxoNetwork = this.isUtxoNetwork(network);
+        if (isUtxoNetwork) {
+            // For UTXO networks, don't create web3 providers at all since they won't be used
+            console.log('[EthereumTransactions] setWeb3Provider: Skipping web3Provider creation for UTXO network:', network.url);
+            // Clear any existing providers for UTXO networks
+            this._web3Provider = undefined;
+        }
+        else {
+            // For EVM networks, create normal providers
+            const isL2Network = L2_NETWORK_CHAIN_IDS.includes(network.chainId);
+            const CurrentProvider = isL2Network
+                ? providers_1.CustomL2JsonRpcProvider
+                : providers_1.CustomJsonRpcProvider;
+            this._web3Provider = new CurrentProvider(this.abortController.signal, network.url);
+        }
+    }
+}
+exports.EthereumTransactions = EthereumTransactions;
+//# sourceMappingURL=ethereum.js.map