@sidhujag/sysweb3-keyring 2.1.2 → 2.1.4

package/esm/transactions/ethereum.js

@@ -0,0 +1,2753 @@
+import { decrypt, signTypedData as signTypedDataUtil, getEncryptionPublicKey, recoverPersonalSignature, recoverTypedSignature, } from '@metamask/eth-sig-util';
+import { INetworkType } from '@sidhujag/sysweb3-network';
+import { createContractUsingAbi, getErc20Abi, getErc21Abi, getErc55Abi, } from '@sidhujag/sysweb3-utils';
+import { accessListify, Transaction } from 'ethers/transaction';
+import { hexlify } from 'ethers/utils';
+import omit from 'lodash/omit';
+import { BigNumber, Contract, Zero, formatEther, formatUnits, isHexString, normalizeTransactionRequest, normalizeTxValue, resolveProperties, serializeTransaction as serializeUncheckedTransaction, } from '../ethers-v6';
+import { assertEvmGasLimit, bufferedEvmGasLimit, EvmGasLimitError, getEvmFeeData, parseEvmFeeQuantity, planEvmCancellationFees, } from '../evm-fees';
+import { CustomJsonRpcProvider, wrapTransactionResponse } from '../providers';
+import { KeyringAccountType, } from '../types';
+import { assertEvmCancellationEnvelope } from './evm-cancellation';
+import { deriveEvmAccountFromMnemonic, parsePersonalMessage as parseLocalPersonalMessage, privateKeyToAccount, normalizeGasLimitedTransaction, sendLocalEvmTransaction, signDigestHex, signPersonalMessage as signLocalPersonalMessage, } from './evm-local-signer';
+import { captureEvmSubmission, submitSignedEvmTransaction, submitSignedHardwareEvmTransaction, evmSubmissionFailure, copyEvmSubmissionFailure, } from './evm-submission';
+import { signPreparedEvmEnvelope, snapshotPreparedEvmRequest, } from './prepared-evm';
+import { getAddressDerivationPath } from '../utils/derivation-paths';
+const hardwareSignerUnavailable = (hardware) => Object.assign(new Error(`${hardware} signer is unavailable in this host`), {
+    code: 'HARDWARE_SIGNER_UNAVAILABLE',
+});
+const assertHardwareTransactionSender = (signedTx, expectedAddress) => {
+    if (Transaction.from(signedTx).from?.toLowerCase() !==
+        expectedAddress.toLowerCase()) {
+        throw Object.assign(new Error('Hardware signature does not match the approved account'), {
+            code: 'HARDWARE_ACCOUNT_MISMATCH',
+        });
+    }
+};
+const stripHexPrefix = (value) => {
+    return value.startsWith('0x') || value.startsWith('0X')
+        ? value.slice(2)
+        : value;
+};
+// Connect returns hexadecimal signature fields; normalize their encoding
+// without mutating the response or reparsing an already numeric recovery v.
+const trezorSignature = (signature) => {
+    const { r, s, v } = signature;
+    if (![r, s].every((value) => /^(?:0x)?[0-9a-f]{64}$/i.test(value))) {
+        throw new Error('Invalid Trezor signature scalar encoding');
+    }
+    if (typeof v === 'string' && !/^(?:0x)?[0-9a-f]+$/i.test(v)) {
+        throw new Error('Invalid Trezor signature recovery value');
+    }
+    const recovery = typeof v === 'number' ? v : Number.parseInt(v, 16);
+    if (!Number.isSafeInteger(recovery) || recovery < 0) {
+        throw new Error('Invalid Trezor signature recovery value');
+    }
+    return {
+        r: `0x${stripHexPrefix(r)}`,
+        s: `0x${stripHexPrefix(s)}`,
+        v: recovery,
+    };
+};
+const normalizeEthersOverrideValue = (value) => normalizeTxValue(value);
+// The same protocol bound applies to software and external-device envelopes.
+// Keep this at serialization as well as before handing a request to a device.
+const assertTransactionGasLimit = (transaction) => assertEvmGasLimit(parseEvmFeeQuantity(transaction.gasLimit, 'gas limit'), parseEvmFeeQuantity(transaction.chainId ?? 0, 'chain ID'));
+const serializeTransaction = (...args) => {
+    const snapshot = normalizeGasLimitedTransaction(args[0]);
+    return serializeUncheckedTransaction(snapshot, args[1]);
+};
+const nonNegativeFeeQuantity = (value, label) => BigNumber.from(parseEvmFeeQuantity(value, label));
+const normalizeEthersOverrides = (overrides) => {
+    const normalized = { ...overrides };
+    for (const field of [
+        'gasLimit',
+        'gasPrice',
+        'maxFeePerGas',
+        'maxPriorityFeePerGas',
+    ]) {
+        if (normalized[field] != null) {
+            normalized[field] = normalizeEthersOverrideValue(normalized[field]);
+        }
+    }
+    return normalized;
+};
+/** Bind all replacement input fields to the requested signed transaction. */
+const authenticateReplacementOriginal = (transaction, requestedHash, expectedSender, chainId) => {
+    const fields = normalizeTransactionRequest(transaction);
+    if (fields.hash != null)
+        fields.hash = fields.hash.toLowerCase();
+    const type = fields.type ??
+        (fields.maxFeePerGas != null ? 2 : fields.accessList != null ? 1 : 0);
+    if (![0, 1, 2].includes(type)) {
+        throw new Error('Unsupported replacement transaction type');
+    }
+    fields.signature = fields.signature ?? {
+        r: fields.r,
+        s: fields.s,
+        v: fields.v ?? fields.yParity,
+    };
+    fields.type = type;
+    fields.data = fields.data ?? fields.input ?? '0x';
+    if (type === 2)
+        delete fields.gasPrice; // Not signed in type 2.
+    const original = Transaction.from(fields);
+    if (!original.signature ||
+        original.hash !== requestedHash ||
+        original.from?.toLowerCase() !== expectedSender ||
+        original.chainId !== BigInt(chainId)) {
+        throw new Error('Original transaction is not authenticated');
+    }
+    // Do not retain mutable RPC fields across subsequent asynchronous work.
+    return wrapTransactionResponse({
+        ...original.toJSON(),
+        hash: original.hash,
+        from: original.from,
+        gasPrice: original.gasPrice ?? 0,
+        maxFeePerGas: original.maxFeePerGas ?? 0,
+        maxPriorityFeePerGas: original.maxPriorityFeePerGas ?? 0,
+        signature: original.signature,
+        blockNumber: transaction.blockNumber,
+    });
+};
+const assertSynchronousOriginalValidation = (result, message = 'Original transaction validator must be synchronous') => {
+    if (result === undefined)
+        return;
+    if (result !== null &&
+        (typeof result === 'object' || typeof result === 'function') &&
+        typeof result.then === 'function') {
+        // A void callback type also accepts async functions. Decline their pending
+        // decision and consume a later rejection without allowing signing to start.
+        void Promise.resolve(result).catch(() => undefined);
+    }
+    throw new Error(message);
+};
+export class EthereumTransactions {
+    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext, captureSubmissionLifecycle) {
+        // Allow manual override of gas parameters when automatic estimation fails
+        this.gasOverrides = {};
+        this.requireLedgerSigner = () => {
+            if (!this.ledgerSigner)
+                throw hardwareSignerUnavailable('Ledger');
+            return this.ledgerSigner;
+        };
+        this.requireTrezorSigner = () => {
+            if (!this.trezorSigner)
+                throw hardwareSignerUnavailable('Trezor');
+            return this.trezorSigner;
+        };
+        this.assertHardwareSignerAvailable = (targetAccount) => {
+            const state = this.getState();
+            const type = targetAccount?.type ?? state.activeAccountType;
+            const id = targetAccount?.id ?? state.activeAccountId;
+            const account = state.accounts[type]?.[id];
+            if (type === KeyringAccountType.Ledger || account?.isLedgerWallet)
+                this.requireLedgerSigner();
+            if (type === KeyringAccountType.Trezor || account?.isTrezorWallet)
+                this.requireTrezorSigner();
+        };
+        this.captureSessionGuard = () => {
+            const guard = this.captureSigningContext();
+            if (typeof guard !== 'function') {
+                void Promise.resolve(guard).catch(() => undefined);
+                throw new TypeError('Signing context must return a synchronous guard');
+            }
+            return () => assertSynchronousOriginalValidation(guard(), 'Signing context guard must be synchronous');
+        };
+        this.captureEvmSigningContext = (target) => {
+            this.assertHardwareSignerAvailable(target);
+            const state = this.getState();
+            const selectedType = state.activeAccountType;
+            const selectedId = state.activeAccountId;
+            const selectedAddress = state.accounts[selectedType]?.[selectedId]?.address;
+            const activeAccountType = target?.type ?? selectedType;
+            const activeAccountId = target?.id ?? selectedId;
+            const selectedAccount = state.accounts[activeAccountType]?.[activeAccountId];
+            if (!selectedAccount || !selectedAddress)
+                throw new Error('Active account not found');
+            const account = { address: selectedAccount.address };
+            const network = { ...state.activeNetwork };
+            const assertSession = this.captureSessionGuard();
+            const provider = this.web3Provider;
+            const assertCurrent = () => {
+                assertSession();
+                const current = this.getState();
+                const currentAccount = current.accounts[activeAccountType]?.[activeAccountId];
+                if (current.activeAccountId !== selectedId ||
+                    current.activeAccountType !== selectedType ||
+                    current.accounts[selectedType]?.[selectedId]?.address?.toLowerCase() !==
+                        selectedAddress.toLowerCase() ||
+                    currentAccount?.address?.toLowerCase() !==
+                        account.address.toLowerCase() ||
+                    [current.activeNetwork, this.getNetwork()].some((selected) => selected.kind !== network.kind ||
+                        selected.chainId !== network.chainId ||
+                        selected.slip44 !== network.slip44 ||
+                        selected.url !== network.url) ||
+                    this.web3Provider !== provider)
+                    throw new Error('Wallet signing context changed');
+            };
+            assertCurrent();
+            return {
+                activeAccount: account,
+                activeAccountType,
+                activeAccountId,
+                activeNetwork: network,
+                provider,
+                assertCurrent,
+            };
+        };
+        this.captureSubmission = (operation, account, type, id, network, assertCurrent, originalHash) => {
+            if (!this.captureSubmissionLifecycle)
+                throw new TypeError('A durable EVM submission lifecycle is required');
+            return captureEvmSubmission({
+                operation,
+                account: { address: account.address, type, id },
+                network: {
+                    kind: network.kind,
+                    chainId: network.chainId,
+                    slip44: network.slip44,
+                    url: network.url,
+                },
+                ...(originalHash !== undefined ? { originalHash } : {}),
+            }, assertCurrent, this.captureSubmissionLifecycle);
+        };
+        this.authorizeHardwareTransaction = async (provider, assertCurrent, signal = this.abortController.signal) => {
+            assertCurrent();
+            await provider.verifyConfiguredChainId();
+            assertCurrent();
+            return { assertCurrent, signal };
+        };
+        this.submitSignedHardwareTransaction = (provider, raw, broadcast, submission, beforeBroadcast, expectedUnsigned) => submitSignedHardwareEvmTransaction(raw, broadcast, submission, beforeBroadcast, expectedUnsigned, 
+        // A device confirmation or journal write can outlast the earlier check.
+        () => provider.verifyConfiguredChainId(true));
+        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 signTypedDataLocal = () => {
+                if (addr.toLowerCase() !== address.toLowerCase())
+                    throw {
+                        message: 'Decrypting for wrong address, change activeAccount maybe',
+                    };
+                const privKey = Buffer.from(stripHexPrefix(decryptedPrivateKey), 'hex');
+                return signTypedDataUtil({
+                    privateKey: 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.requireLedgerSigner().evm.signTypedData({
+                    version,
+                    accountIndex: activeAccountId,
+                    expectedAddress: activeAccount.address,
+                    data: typedData,
+                });
+            };
+            const signTypedDataWithTrezor = async () => {
+                if (addr.toLowerCase() !== activeAccount.address.toLowerCase())
+                    throw {
+                        message: 'Decrypting for wrong address, change activeAccount maybe',
+                    };
+                return await this.requireTrezorSigner().signTypedData({
+                    version,
+                    address: addr,
+                    data: typedData,
+                    index: activeAccountId,
+                });
+            };
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await signTypedDataWithTrezor();
+                case KeyringAccountType.Ledger:
+                    return await signTypedDataWithLedger();
+                default:
+                    return signTypedDataLocal();
+            }
+        };
+        // Verify a UTXO address on the connected hardware wallet (Ledger or Trezor)
+        // Routes to the appropriate device based on activeAccountType
+        this.verifyUtxoAddress = async (accountIndex, currency, slip44) => {
+            const { activeAccountType } = this.getState();
+            switch (activeAccountType) {
+                case KeyringAccountType.Ledger:
+                    return await this.requireLedgerSigner().verifyUtxoAddress(accountIndex, currency, slip44);
+                case KeyringAccountType.Trezor:
+                    return await this.requireTrezorSigner().verifyUtxoAddress(accountIndex, currency, slip44);
+                default:
+                    throw new Error('verifyUtxoAddress is only available for hardware wallet accounts');
+            }
+        };
+        this.verifyTypedSignature = (data, signature, version) => {
+            try {
+                return recoverTypedSignature({ data: data, signature, 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 = stripHexPrefix(params[1]);
+            }
+            else if (params[1].toLowerCase() === address.toLowerCase()) {
+                msg = stripHexPrefix(params[0]);
+            }
+            else {
+                throw new Error('Signing for wrong address');
+            }
+            const sign = () => {
+                try {
+                    // 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.`);
+                    }
+                    return signDigestHex(msgHash, decryptedPrivateKey);
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const signWithLedger = async () => {
+                try {
+                    const response = await this.requireLedgerSigner().evm.signPersonalMessage({
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                        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.requireTrezorSigner().signMessage({
+                        coin: trezorCoin,
+                        address: activeAccount.address,
+                        index: activeAccountId,
+                        message: msg,
+                        slip44: activeNetwork.slip44,
+                    });
+                    return response.signature;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await signWithTrezor();
+                case 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 {
+                    // Handle both hex-encoded and plain text messages for personal_sign
+                    let message;
+                    if (msg.startsWith('0x')) {
+                        const rawHex = stripHexPrefix(msg);
+                        if (rawHex.length % 2 === 0 && isHexString(msg)) {
+                            // Message is valid hex-encoded bytes.
+                            message = Buffer.from(rawHex, 'hex');
+                        }
+                        else {
+                            // Malformed 0x-prefixed strings are literal text, not lossy hex.
+                            message = Buffer.from(msg, 'utf8');
+                        }
+                    }
+                    else {
+                        // Message is plain text
+                        message = Buffer.from(msg, 'utf8');
+                    }
+                    return signLocalPersonalMessage(message, decryptedPrivateKey);
+                }
+                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.requireLedgerSigner().evm.signPersonalMessage({
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                        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.requireTrezorSigner().signMessage({
+                        coin: trezorCoin,
+                        address: activeAccount.address,
+                        index: activeAccountId,
+                        message: messageForTrezor,
+                        slip44: activeNetwork.slip44,
+                    });
+                    return response.signature;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await signPersonalMessageWithTrezor();
+                case KeyringAccountType.Ledger:
+                    return await signPersonalMessageWithLedger();
+                default:
+                    return signPersonalMessageWithDefaultWallet();
+            }
+        };
+        this.parsePersonalMessage = (hexMsg) => {
+            try {
+                return parseLocalPersonalMessage(hexMsg);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.verifyPersonalMessage = (message, sign) => {
+            try {
+                const msgParams = {
+                    data: message,
+                    signature: sign,
+                };
+                return recoverPersonalSignature(msgParams);
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getEncryptedPubKey = () => {
+            const { activeAccountType } = this.getState();
+            // Hardware wallets don't support encryption public key generation
+            if (activeAccountType === KeyringAccountType.Trezor ||
+                activeAccountType === KeyringAccountType.Ledger) {
+                throw new Error('Hardware wallets do not support eth_getEncryptionPublicKey');
+            }
+            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+            try {
+                return getEncryptionPublicKey(stripHexPrefix(decryptedPrivateKey));
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        // eth_decryptMessage
+        this.decryptMessage = (msgParams) => {
+            const { activeAccountType } = this.getState();
+            // Hardware wallets don't support message decryption
+            if (activeAccountType === KeyringAccountType.Trezor ||
+                activeAccountType === KeyringAccountType.Ledger) {
+                throw new Error('Hardware wallets do not support eth_decrypt');
+            }
+            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 = stripHexPrefix(encryptedData);
+            try {
+                const buff = Buffer.from(encryptedData, 'hex');
+                const cleanData = JSON.parse(buff.toString('utf8'));
+                const sig = decrypt({
+                    encryptedData: cleanData,
+                    privateKey: stripHexPrefix(decryptedPrivateKey),
+                });
+                return sig;
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.toBigNumber = (aBigNumberish) => BigNumber.from(String(aBigNumberish));
+        this.toHex0x = (value, fieldName) => {
+            if (value === undefined || value === null)
+                return '0x0';
+            if (typeof value === 'string') {
+                const v = value.trim();
+                if (v === '')
+                    return '0x0';
+                if (v.startsWith('0x'))
+                    return v;
+                return BigNumber.from(v).toHexString();
+            }
+            if (typeof value === 'number')
+                return BigNumber.from(value).toHexString();
+            if (BigNumber.isBigNumber(value))
+                return value.toHexString();
+            const maybeHex = value?._hex ?? value?.hex ?? value;
+            try {
+                return BigNumber.from(maybeHex).toHexString();
+            }
+            catch (_e) {
+                throw new Error(`Invalid numeric field "${fieldName}" for EVM tx: ${String(value)}`);
+            }
+        };
+        this.captureReviewedTokenApproval = (approval, standard) => {
+            if (!approval ||
+                typeof approval.assertCurrent !== 'function' ||
+                !(approval.signal instanceof AbortSignal))
+                throw new Error(`${standard} transaction approval required`);
+            const { assertCurrent, signal } = approval;
+            const assertApproval = () => {
+                if (signal.aborted)
+                    throw Object.assign(new Error(`${standard} transaction approval expired`), {
+                        transactionNotBroadcast: true,
+                    });
+                assertSynchronousOriginalValidation(assertCurrent(), `${standard} transaction approval must be synchronous`);
+            };
+            assertApproval();
+            return { assertApproval, signal };
+        };
+        this.reviewedTokenFees = (request, chainId, standard) => {
+            const { isLegacy } = request;
+            if (typeof isLegacy !== 'boolean' ||
+                (isLegacy
+                    ? request.maxFeePerGas !== undefined ||
+                        request.maxPriorityFeePerGas !== undefined
+                    : request.gasPrice !== undefined))
+                throw new Error(`Invalid ${standard} transaction fee model`);
+            const gasLimit = BigNumber.from(assertEvmGasLimit(parseEvmFeeQuantity(request.gasLimit, `${standard} gas limit`), BigInt(chainId)));
+            const gasPrice = isLegacy
+                ? BigNumber.from(parseEvmFeeQuantity(request.gasPrice, `${standard} gas price`))
+                : undefined;
+            const maxFeePerGas = !isLegacy
+                ? BigNumber.from(parseEvmFeeQuantity(request.maxFeePerGas, `${standard} maximum fee`))
+                : undefined;
+            const maxPriorityFeePerGas = !isLegacy
+                ? BigNumber.from(parseEvmFeeQuantity(request.maxPriorityFeePerGas, `${standard} priority fee`))
+                : undefined;
+            if (gasPrice?.isZero() ||
+                (maxFeePerGas &&
+                    (maxFeePerGas.isZero() || maxPriorityFeePerGas.gt(maxFeePerGas))))
+                throw new Error(`Invalid ${standard} fees`);
+            return { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas };
+        };
+        this.getData = ({ contractAddress, receivingAddress, value, }) => {
+            const abi = getErc20Abi();
+            try {
+                const contract = createContractUsingAbi(abi, contractAddress, this.web3Provider);
+                const data = contract.interface.encodeFunctionData('transfer', [
+                    receivingAddress,
+                    value,
+                ]);
+                return data;
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getFeeDataWithDynamicMaxPriorityFeePerGas = async (provider = this.web3Provider) => {
+            const fee = await getEvmFeeData(provider, {
+                signal: this.abortController.signal,
+                minPriorityFee: this.gasOverrides.minPriorityFee,
+                feeMultiplier: this.gasOverrides.feeMultiplier,
+            });
+            return {
+                gasPrice: BigNumber.from(fee.gasPrice),
+                ...(fee.baseFeePerGas === undefined
+                    ? {}
+                    : {
+                        baseFeePerGas: BigNumber.from(fee.baseFeePerGas),
+                    }),
+                maxFeePerGas: BigNumber.from(fee.maxFeePerGas),
+                maxPriorityFeePerGas: BigNumber.from(fee.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) => {
+                // Apply multiplier for replacement transaction (cancel or speedup)
+                const newValue = feeValue * multiplierToUse;
+                const calculateValue = String(newValue);
+                const convertValueToHex = '0x' + parseInt(calculateValue, 10).toString(16);
+                return 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) {
+                // For EIP-1559 transactions
+                newGasValues.maxFeePerGas = calculateAndConvertNewValue(maxFeePerGasToNumber);
+                newGasValues.maxPriorityFeePerGas = calculateAndConvertNewValue(maxPriorityFeePerGasToNumber);
+            }
+            if (isLegacy) {
+                newGasValues.gasPrice = calculateAndConvertNewValue(gasPriceToNumber);
+            }
+            if (isForCancel) {
+                const DEFAULT_GAS_LIMIT_VALUE = '42000';
+                const convertToHex = '0x' + parseInt(DEFAULT_GAS_LIMIT_VALUE, 10).toString(16);
+                newGasValues.gasLimit = BigNumber.from(convertToHex);
+            }
+            if (!isForCancel) {
+                newGasValues.gasLimit = calculateAndConvertNewValue(gasLimitToNumber);
+            }
+            return newGasValues;
+        };
+        this.cancelSentTransaction = async (txHash, isLegacy, fallbackNonce, options) => {
+            // Cancellation is a signing operation too. Keep its account, network and
+            // provider fixed across RPC requests and hardware approval.
+            if (typeof options?.assertCurrentContext !== 'function') {
+                throw new Error('Cancellation context required');
+            }
+            if (typeof options.validateOriginal !== 'function') {
+                throw new Error('Cancellation original validator required');
+            }
+            if (fallbackNonce !== undefined &&
+                (!Number.isSafeInteger(fallbackNonce) || fallbackNonce < 0)) {
+                throw new Error('Invalid cancellation fallback nonce');
+            }
+            const previewOnly = options.previewOnly === true;
+            const approvedMaximumFee = options.approvedMaximumFee;
+            if (!previewOnly &&
+                (typeof approvedMaximumFee !== 'string' ||
+                    !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee))) {
+                throw new Error('Cancellation fee approval required');
+            }
+            const { assertCurrentContext, validateOriginal } = options;
+            const assertHostContext = () => assertSynchronousOriginalValidation(assertCurrentContext(), 'Transaction context guard must be synchronous');
+            assertHostContext();
+            const state = this.getState();
+            const selectedType = state.activeAccountType;
+            const selectedId = state.activeAccountId;
+            const selectedAddress = state.accounts?.[selectedType]?.[selectedId]?.address;
+            const activeAccountType = options.targetAccount?.type ?? selectedType;
+            const activeAccountId = options.targetAccount?.id ?? selectedId;
+            const targetAccount = options.targetAccount
+                ? { type: activeAccountType, id: activeAccountId }
+                : undefined;
+            const activeAccount = {
+                ...state.accounts?.[activeAccountType]?.[activeAccountId],
+            };
+            const activeNetwork = { ...state.activeNetwork };
+            if (!selectedAddress ||
+                !activeAccount.address ||
+                (targetAccount && activeAccountType === KeyringAccountType.SmartAccount)) {
+                throw new Error('Cancellation signing account is unavailable');
+            }
+            if (!previewOnly)
+                this.assertHardwareSignerAvailable(targetAccount);
+            const provider = this.web3Provider;
+            const assertSession = this.captureSessionGuard();
+            const assertKeyringContext = () => {
+                assertSession();
+                const current = this.getState();
+                if (current.activeAccountType !== selectedType ||
+                    current.activeAccountId !== selectedId ||
+                    current.accounts?.[selectedType]?.[selectedId]?.address?.toLowerCase() !== selectedAddress.toLowerCase() ||
+                    current.accounts?.[activeAccountType]?.[activeAccountId]?.address?.toLowerCase() !== activeAccount.address.toLowerCase() ||
+                    [current.activeNetwork, this.getNetwork()].some((selected) => selected.kind !== activeNetwork.kind ||
+                        selected.chainId !== activeNetwork.chainId ||
+                        selected.slip44 !== activeNetwork.slip44 ||
+                        selected.url !== activeNetwork.url) ||
+                    this.web3Provider !== provider) {
+                    throw new Error('Wallet signing context changed');
+                }
+            };
+            const assertSigningCurrent = () => {
+                assertHostContext();
+                assertKeyringContext();
+            };
+            assertSigningCurrent();
+            const submission = previewOnly
+                ? undefined
+                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+            const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
+            const currentEip1559Fees = async () => {
+                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
+                assertCurrent();
+                const maxFeePerGas = nonNegativeFeeQuantity(feeData.maxFeePerGas, 'cancellation maximum fee');
+                const maxPriorityFeePerGas = nonNegativeFeeQuantity(feeData.maxPriorityFeePerGas, 'cancellation priority fee');
+                if (maxFeePerGas.isZero() || maxPriorityFeePerGas.gt(maxFeePerGas)) {
+                    throw new Error('Invalid cancellation EIP-1559 fees');
+                }
+                return { maxFeePerGas, maxPriorityFeePerGas };
+            };
+            const response = await provider.getTransaction(txHash);
+            assertCurrent();
+            if (response?.blockNumber != null || response?.blockHash != null) {
+                throw new Error('Original transaction is already mined');
+            }
+            let tx = response === null
+                ? null
+                : authenticateReplacementOriginal(response, txHash.toLowerCase(), activeAccount.address.toLowerCase(), activeNetwork.chainId);
+            const software = activeAccountType !== KeyringAccountType.Ledger &&
+                activeAccountType !== KeyringAccountType.Trezor;
+            const softwareNonce = software ? tx?.nonce ?? fallbackNonce : undefined;
+            // The host validator may retain the wrapped response and its fee objects.
+            const softwareOriginalFees = software && tx
+                ? {
+                    gasPrice: tx.gasPrice.toBigInt(),
+                    maxFeePerGas: tx.maxFeePerGas.toBigInt(),
+                    maxPriorityFeePerGas: tx.maxPriorityFeePerGas.toBigInt(),
+                }
+                : undefined;
+            assertSynchronousOriginalValidation(validateOriginal(tx));
+            assertCurrent();
+            // If transaction not found, create a minimal tx object with current gas prices
+            // This handles cases where tx with 0 gas never made it to the mempool
+            if (!tx && fallbackNonce !== undefined) {
+                // Fetch current network gas prices for the cancellation
+                if (isLegacy) {
+                    const currentGasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
+                    assertCurrent();
+                    tx = {
+                        from: activeAccount.address,
+                        to: activeAccount.address,
+                        value: Zero,
+                        nonce: fallbackNonce,
+                        gasPrice: currentGasPrice,
+                        data: '0x',
+                    };
+                }
+                else {
+                    const feeData = await currentEip1559Fees();
+                    tx = {
+                        from: activeAccount.address,
+                        to: activeAccount.address,
+                        value: Zero,
+                        nonce: fallbackNonce,
+                        maxFeePerGas: feeData.maxFeePerGas,
+                        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+                        data: '0x',
+                    };
+                }
+            }
+            else if (!tx) {
+                // No fallback nonce provided and tx not found
+                return {
+                    isCanceled: false,
+                    error: true,
+                };
+            }
+            const { gasPrice: originalGasPrice, maxFeePerGas: originalMaxFeePerGas, maxPriorityFeePerGas: originalMaxPriorityFeePerGas, } = softwareOriginalFees ?? tx;
+            let feePlan;
+            if (isLegacy) {
+                const currentGasPrice = parseEvmFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
+                assertCurrent();
+                feePlan = planEvmCancellationFees({
+                    type: 0,
+                    currentGasPrice,
+                    originalGasPrice: originalGasPrice == null
+                        ? undefined
+                        : parseEvmFeeQuantity(originalGasPrice, 'original gas price'),
+                });
+            }
+            else {
+                const currentFees = await currentEip1559Fees();
+                feePlan = planEvmCancellationFees({
+                    type: 2,
+                    currentMaxFeePerGas: currentFees.maxFeePerGas.toBigInt(),
+                    currentMaxPriorityFeePerGas: currentFees.maxPriorityFeePerGas.toBigInt(),
+                    originalMaxFeePerGas: originalMaxFeePerGas == null
+                        ? undefined
+                        : parseEvmFeeQuantity(originalMaxFeePerGas, 'original maximum fee'),
+                    originalMaxPriorityFeePerGas: originalMaxPriorityFeePerGas == null
+                        ? undefined
+                        : parseEvmFeeQuantity(originalMaxPriorityFeePerGas, 'original priority fee'),
+                });
+            }
+            const maximumFee = BigNumber.from(feePlan.maximumFee);
+            assertCurrent();
+            if (!submission)
+                return {
+                    isCanceled: false,
+                    error: false,
+                    maximumFee: maximumFee.toString(),
+                };
+            if (maximumFee.gt(approvedMaximumFee))
+                throw new Error('Cancellation fee exceeds approval');
+            const assertApprovedEnvelope = (transaction) => {
+                const gas = nonNegativeFeeQuantity(transaction.gasLimit, 'cancellation gas limit');
+                const cap = nonNegativeFeeQuantity(isLegacy ? transaction.gasPrice : transaction.maxFeePerGas, 'cancellation maximum fee');
+                if (!gas.eq(feePlan.gasLimit) || gas.mul(cap).gt(approvedMaximumFee))
+                    throw new Error('Cancellation fee exceeds approval');
+            };
+            // Base cancel transaction parameters (same for all wallet types)
+            const baseCancelTx = {
+                nonce: software ? softwareNonce : tx.nonce,
+                from: activeAccount.address,
+                to: activeAccount.address,
+                value: Zero,
+                gasLimit: BigNumber.from(feePlan.gasLimit),
+            };
+            const changedTxToCancel = feePlan.type === 0
+                ? {
+                    ...baseCancelTx,
+                    gasPrice: BigNumber.from(feePlan.gasPrice),
+                    type: 0, // Force Type 0 for legacy cancel
+                }
+                : {
+                    ...baseCancelTx,
+                    maxFeePerGas: BigNumber.from(feePlan.maxFeePerGas),
+                    maxPriorityFeePerGas: BigNumber.from(feePlan.maxPriorityFeePerGas),
+                    // Don't set type - let ethers auto-detect
+                };
+            // Ledger cancel handler
+            const cancelWithLedger = async () => {
+                try {
+                    assertCurrent();
+                    const resolvedParams = await resolveProperties(omit(changedTxToCancel, 'from'));
+                    assertCurrent();
+                    const formatParams = {
+                        ...resolvedParams,
+                        nonce: resolvedParams.nonce
+                            ? Number(resolvedParams.nonce.toString())
+                            : undefined,
+                    };
+                    const txFormattedForEthers = isLegacy
+                        ? {
+                            ...formatParams,
+                            chainId: activeNetwork.chainId,
+                            type: 0, // Need explicit type for hardware wallet serialization
+                        }
+                        : {
+                            ...formatParams,
+                            chainId: activeNetwork.chainId,
+                            type: 2, // Need explicit type for hardware wallet serialization
+                        };
+                    assertApprovedEnvelope(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                    assertCurrent();
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                        assertCurrent();
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                        return {
+                            isCanceled: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isCanceled: false,
+                            error: true,
+                        };
+                    }
+                }
+                catch (error) {
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isCanceled: false,
+                        error: true,
+                    };
+                }
+            };
+            // Trezor cancel handler
+            const cancelWithTrezor = async () => {
+                try {
+                    assertCurrent();
+                    const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    const formattedTx = await resolveProperties(omit(changedTxToCancel, 'from'));
+                    assertCurrent();
+                    const txFormattedForTrezor = {
+                        ...formattedTx,
+                        gasLimit: typeof formattedTx.gasLimit === 'string'
+                            ? formattedTx.gasLimit
+                            : this.toHex0x(formattedTx.gasLimit, 'gasLimit'),
+                        value: '0x0',
+                        nonce: this.toHex0x(formattedTx.nonce, 'nonce'),
+                        chainId: activeNetwork.chainId,
+                        type: isLegacy ? 0 : 2, // Need explicit type for hardware wallet serialization
+                    };
+                    if (isLegacy) {
+                        txFormattedForTrezor.gasPrice =
+                            typeof formattedTx.gasPrice === 'string'
+                                ? formattedTx.gasPrice
+                                : this.toHex0x(formattedTx.gasPrice, 'gasPrice');
+                    }
+                    else {
+                        txFormattedForTrezor.maxFeePerGas =
+                            typeof formattedTx.maxFeePerGas === 'string'
+                                ? formattedTx.maxFeePerGas
+                                : this.toHex0x(formattedTx.maxFeePerGas, 'maxFeePerGas');
+                        txFormattedForTrezor.maxPriorityFeePerGas =
+                            typeof formattedTx.maxPriorityFeePerGas === 'string'
+                                ? formattedTx.maxPriorityFeePerGas
+                                : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
+                    }
+                    assertApprovedEnvelope(txFormattedForTrezor);
+                    assertTransactionGasLimit(txFormattedForTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                        coin: trezorCoin,
+                        tx: txFormattedForTrezor,
+                        index: activeAccountId.toString(),
+                        slip44: activeNetwork.slip44,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                    assertCurrent();
+                    if (signature.success) {
+                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
+                        assertCurrent();
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                        return {
+                            isCanceled: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isCanceled: false,
+                            error: true,
+                        };
+                    }
+                }
+                catch (error) {
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isCanceled: false,
+                        error: true,
+                    };
+                }
+            };
+            // Regular wallet cancel handler
+            const cancelWithPrivateKey = async () => {
+                try {
+                    assertCurrent();
+                    const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey(targetAccount);
+                    if (address?.toLowerCase() !== activeAccount.address.toLowerCase()) {
+                        throw new Error('Wallet signing context changed');
+                    }
+                    const transactionResponse = await sendLocalEvmTransaction(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, (transaction) => {
+                        assertApprovedEnvelope(transaction);
+                        assertEvmCancellationEnvelope(serializeTransaction(transaction), {
+                            payer: activeAccount.address,
+                            chainId: activeNetwork.chainId,
+                            nonce: softwareNonce,
+                            feePlan,
+                        });
+                    }, submission);
+                    if (transactionResponse) {
+                        return {
+                            isCanceled: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isCanceled: false,
+                        };
+                    }
+                }
+                catch (error) {
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isCanceled: false,
+                        error: true,
+                    };
+                }
+            };
+            // Route based on account type
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await cancelWithTrezor();
+                case KeyringAccountType.Ledger:
+                    return await cancelWithLedger();
+                default:
+                    return await cancelWithPrivateKey();
+            }
+        };
+        //TODO: This function needs to be refactored
+        this.sendFormattedTransaction = async (...args) => {
+            const [params, isLegacy, options] = args;
+            let broadcastAttempted = false;
+            try {
+                if (!options ||
+                    typeof options !== 'object' ||
+                    Array.isArray(options) ||
+                    (options.mode !== 'reviewed-native' &&
+                        options.mode !== 'specialized') ||
+                    typeof options.assertCurrent !== 'function')
+                    throw new Error('Explicit transaction approval is required');
+                // Capture once; later caller mutations cannot replace this invocation's
+                // admission decision while chain checks or device approval are pending.
+                const { assertCurrent: assertHostCurrent, mode } = options;
+                const assertApproved = () => {
+                    const result = assertHostCurrent();
+                    if (result !== undefined) {
+                        assertSynchronousOriginalValidation(result, 'Transaction context guard must be synchronous');
+                        throw new Error('Transaction context guard must return undefined');
+                    }
+                };
+                assertApproved();
+                return await this.sendFormattedTransactionInternal(params, isLegacy, () => {
+                    broadcastAttempted = true;
+                }, assertApproved, mode);
+            }
+            catch (error) {
+                // A broadcast transport error may mean the node accepted the signed
+                // transaction. Derive this marker from this invocation, never RPC data.
+                const submissionError = Object.assign(new Error(error instanceof Error ? error.message : String(error)), error, {
+                    transactionNotBroadcast: !broadcastAttempted ||
+                        evmSubmissionFailure(error).transactionNotBroadcast,
+                });
+                if (error instanceof Error) {
+                    submissionError.name = error.name;
+                    submissionError.stack = error.stack;
+                }
+                copyEvmSubmissionFailure(error, submissionError);
+                throw submissionError;
+            }
+        };
+        this.sendFormattedTransactionInternal = async (input, isLegacy, beforeBroadcast, assertHostCurrent, mode) => {
+            // Hardware approval may outlive the selected account, network or unlocked
+            // session. Keep immutable identities and one provider for this invocation.
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertKeyringCurrent, } = this.captureEvmSigningContext();
+            const assertSigningCurrent = () => {
+                assertHostCurrent();
+                assertKeyringCurrent();
+            };
+            const assertBeforeBroadcast = () => {
+                assertCurrent();
+                beforeBroadcast();
+            };
+            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent);
+            const assertCurrent = submission.assertCurrent;
+            if (mode === 'reviewed-native') {
+                const { transaction } = snapshotPreparedEvmRequest({
+                    account: {
+                        id: activeAccountId,
+                        type: activeAccountType,
+                        expectedAddress: activeAccount.address,
+                    },
+                    network: {
+                        kind: activeNetwork.kind,
+                        chainId: String(activeNetwork.chainId),
+                        slip44: activeNetwork.slip44,
+                        url: activeNetwork.url,
+                    },
+                    transaction: input,
+                });
+                const minimum = this.gasOverrides.minGasLimit;
+                if (transaction.data !== '0x' ||
+                    BigInt(transaction.value) === 0n ||
+                    BigInt(transaction.gasLimit) < 21000n ||
+                    (transaction.type === 2 && BigInt(transaction.maxFeePerGas) === 0n) ||
+                    (minimum && BigInt(transaction.gasLimit) < minimum.toBigInt()) ||
+                    (isLegacy !== undefined && isLegacy !== (transaction.type === 0)))
+                    throw new Error('Invalid reviewed native transfer approval');
+                assertCurrent();
+                await provider.verifyConfiguredChainId();
+                assertCurrent();
+                if (this.gasOverrides.minGasLimit !== minimum)
+                    throw new Error('Reviewed native gas policy changed');
+                const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                if (address.toLowerCase() !== transaction.from.toLowerCase())
+                    throw new Error('Reviewed native signer does not match the approved account');
+                assertCurrent();
+                const { signed, expectedUnsigned } = signPreparedEvmEnvelope(transaction, decryptedPrivateKey);
+                return submitSignedEvmTransaction(signed.rawTransaction, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsigned);
+            }
+            // Detach supplied values before any RPC/device await. Autofill updates only
+            // this invocation; caller mutations cannot replace already supplied fields.
+            let params = input;
+            if (!params || typeof params !== 'object' || Array.isArray(params))
+                throw new TypeError('Invalid EVM transaction request');
+            const supplied = { ...params };
+            // Validate original scalar spellings before conversion. Normalization's
+            // permissive zero coercion must not bypass the bounded wire parser.
+            for (const field of [
+                'chainId',
+                'nonce',
+                'gasLimit',
+                'gasPrice',
+                'maxFeePerGas',
+                'maxPriorityFeePerGas',
+                'value',
+                'type',
+            ]) {
+                if (supplied[field] != null) {
+                    const value = parseEvmFeeQuantity(supplied[field], field);
+                    if (field === 'nonce' || field === 'type') {
+                        if (value > BigInt(Number.MAX_SAFE_INTEGER))
+                            throw new Error(`Invalid transaction ${field}`);
+                        supplied[field] = Number(value);
+                    }
+                    else
+                        supplied[field] = value;
+                }
+            }
+            if (supplied.data != null)
+                supplied.data = hexlify(supplied.data);
+            if (supplied.accessList != null)
+                supplied.accessList = accessListify(supplied.accessList);
+            params = supplied;
+            assertCurrent();
+            // Capture the reviewed nonce before any fee/RPC await. Hardware and the
+            // final serializer must use the same immutable integer, including zero.
+            let explicitHardwareNonce;
+            if (activeAccountType === KeyringAccountType.Ledger ||
+                activeAccountType === KeyringAccountType.Trezor) {
+                const suppliedNonce = params.nonce;
+                if (suppliedNonce != null) {
+                    const nonce = parseEvmFeeQuantity(suppliedNonce, 'transaction nonce');
+                    if (nonce > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new Error('Invalid transaction nonce');
+                    explicitHardwareNonce = Number(nonce);
+                }
+            }
+            const explicitEip1559 = params.type != null && BigNumber.from(params.type).eq(2);
+            const requestedEip1559 = explicitEip1559 ||
+                params.maxFeePerGas != null ||
+                params.maxPriorityFeePerGas != null;
+            if (isLegacy && requestedEip1559)
+                throw new Error('EIP-1559 fees conflict with legacy pricing');
+            const validateEip1559Fees = () => {
+                const maximum = nonNegativeFeeQuantity(params.maxFeePerGas, 'maximum fee');
+                const priority = nonNegativeFeeQuantity(params.maxPriorityFeePerGas, 'priority fee');
+                if (maximum.isZero() || priority.gt(maximum))
+                    throw new Error('Invalid EIP-1559 fees');
+                params.maxFeePerGas = maximum;
+                params.maxPriorityFeePerGas = priority;
+            };
+            if (!isLegacy &&
+                params.maxFeePerGas != null &&
+                params.maxPriorityFeePerGas != null)
+                validateEip1559Fees();
+            // Only apply a minimum gas limit when a network-specific override is set.
+            // Otherwise keep the user/dapp-approved gas limit unchanged.
+            if (params.gasLimit != null && this.gasOverrides.minGasLimit) {
+                const minGasLimit = this.gasOverrides.minGasLimit;
+                const currentGasLimit = BigNumber.from(params.gasLimit);
+                if (currentGasLimit.lt(minGasLimit)) {
+                    params.gasLimit = minGasLimit;
+                }
+            }
+            const txForEstimation = isLegacy
+                ? omit({
+                    ...params,
+                    from: params.from || activeAccount.address,
+                }, ['maxFeePerGas', 'maxPriorityFeePerGas', 'type'])
+                : omit({
+                    ...params,
+                    from: params.from || activeAccount.address,
+                }, ['gasPrice']);
+            if (params.gasLimit == null) {
+                params.gasLimit = await provider.estimateGas(txForEstimation);
+                assertCurrent();
+            }
+            assertTransactionGasLimit({
+                gasLimit: params.gasLimit,
+                chainId: activeNetwork.chainId,
+            });
+            if (isLegacy) {
+                if (params.gasPrice == null) {
+                    params.gasPrice = await provider.getGasPrice();
+                    assertCurrent();
+                }
+            }
+            else if (params.maxFeePerGas == null ||
+                params.maxPriorityFeePerGas == null) {
+                const feeData = await provider.getFeeData();
+                assertCurrent();
+                params.maxFeePerGas = params.maxFeePerGas ?? feeData.maxFeePerGas;
+                params.maxPriorityFeePerGas =
+                    params.maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas;
+                if (params.maxFeePerGas == null || params.maxPriorityFeePerGas == null) {
+                    if (requestedEip1559)
+                        throw new Error('EIP-1559 fee data unavailable');
+                    isLegacy = true;
+                    params.gasPrice = feeData.gasPrice ?? (await provider.getGasPrice());
+                    assertCurrent();
+                    delete params.maxFeePerGas;
+                    delete params.maxPriorityFeePerGas;
+                }
+            }
+            if (!isLegacy)
+                validateEip1559Fees();
+            const sendEVMLedgerTransaction = async () => {
+                assertCurrent();
+                const transactionNonce = explicitHardwareNonce ??
+                    (await provider.getTransactionCount(activeAccount.address, 'pending'));
+                assertCurrent();
+                const formatParams = isLegacy
+                    ? omit(params, 'from')
+                    : omit(params, ['from', 'gasPrice']); // Strip gasPrice for EIP-1559
+                const txFormattedForEthers = isLegacy
+                    ? {
+                        ...formatParams,
+                        nonce: transactionNonce,
+                        chainId: activeNetwork.chainId,
+                        type: 0, // Force Type 0 for legacy
+                    }
+                    : {
+                        ...formatParams,
+                        nonce: transactionNonce,
+                        chainId: activeNetwork.chainId,
+                        type: 2, // Need explicit type for hardware wallet serialization
+                    };
+                const rawTx = serializeTransaction(txFormattedForEthers);
+                const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                    rawTx: rawTx.replace('0x', ''),
+                    accountIndex: activeAccountId,
+                    expectedAddress: activeAccount.address,
+                }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                assertCurrent();
+                const formattedSignature = {
+                    r: `0x${signature.r}`,
+                    s: `0x${signature.s}`,
+                    v: parseInt(signature.v, 16),
+                };
+                if (signature) {
+                    try {
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        return finalTx;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                else {
+                    throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                }
+            };
+            const sendEVMTrezorTransaction = async () => {
+                assertCurrent();
+                const transactionNonce = explicitHardwareNonce ??
+                    (await provider.getTransactionCount(activeAccount.address, 'pending'));
+                assertCurrent();
+                let txFormattedForTrezor = {};
+                const formatParams = isLegacy
+                    ? omit(params, 'from')
+                    : omit(params, ['from', 'gasPrice']); // Strip gasPrice for EIP-1559
+                switch (isLegacy) {
+                    case true:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasPrice: this.toHex0x(params.gasPrice, 'gasPrice'),
+                            gasLimit: this.toHex0x(formatParams.gasLimit ?? params.gasLimit, 'gasLimit'),
+                            value: this.toHex0x(formatParams.value ?? params.value, 'value'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: formatParams.data ?? '0x',
+                        };
+                        break;
+                    case false:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasLimit: this.toHex0x(formatParams.gasLimit ?? params.gasLimit, 'gasLimit'),
+                            maxFeePerGas: this.toHex0x(formatParams.maxFeePerGas ??
+                                params.maxFeePerGas, 'maxFeePerGas'),
+                            maxPriorityFeePerGas: this.toHex0x(formatParams.maxPriorityFeePerGas ??
+                                params.maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
+                            value: this.toHex0x(formatParams.value ?? params.value, 'value'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: formatParams.data ?? '0x',
+                        };
+                        break;
+                    default:
+                        txFormattedForTrezor = {
+                            ...formatParams,
+                            gasLimit: this.toHex0x(formatParams.gasLimit ?? params.gasLimit, 'gasLimit'),
+                            maxFeePerGas: this.toHex0x(formatParams.maxFeePerGas ??
+                                params.maxFeePerGas, 'maxFeePerGas'),
+                            maxPriorityFeePerGas: this.toHex0x(formatParams.maxPriorityFeePerGas ??
+                                params.maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
+                            value: this.toHex0x(formatParams.value ?? params.value, 'value'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: formatParams.data ?? '0x',
+                        };
+                        break;
+                }
+                assertTransactionGasLimit(txFormattedForTrezor);
+                const expectedUnsignedTransaction = serializeTransaction({
+                    ...txFormattedForTrezor,
+                    type: isLegacy ? 0 : 2,
+                });
+                const signature = await this.requireTrezorSigner().signEthTransaction({
+                    index: `${activeAccountId}`,
+                    tx: txFormattedForTrezor,
+                    coin: activeNetwork.currency,
+                    slip44: activeNetwork.slip44,
+                }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                assertCurrent();
+                if (signature.success) {
+                    try {
+                        const txFormattedForEthers = isLegacy
+                            ? {
+                                ...formatParams,
+                                nonce: transactionNonce,
+                                chainId: activeNetwork.chainId,
+                                type: 0, // Force Type 0 for legacy
+                            }
+                            : {
+                                ...formatParams,
+                                nonce: transactionNonce,
+                                chainId: activeNetwork.chainId,
+                                type: 2, // Need explicit type for hardware wallet serialization
+                            };
+                        const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        return finalTx;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                else {
+                    throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                }
+            };
+            const sendEVMTransaction = async () => {
+                assertCurrent();
+                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.`);
+                }
+                // Explicitly set transaction type based on isLegacy flag
+                // For EIP-1559, ensure gasPrice is not present to avoid ethers throwing
+                const tx = isLegacy
+                    ? { ...params, type: 0 } // Force Type 0 for legacy transactions
+                    : omit(params, ['gasPrice']); // Strip gasPrice for EIP-1559
+                try {
+                    const transaction = await sendLocalEvmTransaction(provider, decryptedPrivateKey, tx, assertBeforeBroadcast, assertCurrent, undefined, submission);
+                    // The broadcast response already has the hash. Pending transactions
+                    // have no block number, so a block lookup can fail after a successful
+                    // broadcast and incorrectly report the send as failed.
+                    return transaction;
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await sendEVMTrezorTransaction();
+                case KeyringAccountType.Ledger:
+                    return await sendEVMLedgerTransaction();
+                default:
+                    return await sendEVMTransaction();
+            }
+        };
+        this.sendTransactionWithEditedFee = async (txHash, isLegacy, options) => {
+            const previewOnly = options?.previewOnly === true;
+            const approvedMaximumFee = options?.approvedMaximumFee;
+            if (!previewOnly &&
+                (typeof approvedMaximumFee !== 'string' ||
+                    !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee)))
+                throw new Error('Replacement fee approval required');
+            if (typeof options?.assertCurrentContext !== 'function')
+                throw new Error('Replacement context required');
+            if (typeof options.validateOriginal !== 'function')
+                throw new Error('Replacement original validator required');
+            const { assertCurrentContext, validateOriginal, beforeBroadcast } = options;
+            if (!previewOnly)
+                this.assertHardwareSignerAvailable(options.targetAccount);
+            isLegacy ?? (isLegacy = false);
+            let assertCapturedSignerCurrent;
+            const assertSigningCurrent = () => {
+                assertSynchronousOriginalValidation(assertCurrentContext(), 'Transaction context guard must be synchronous');
+                assertCapturedSignerCurrent?.();
+            };
+            const assertBeforeBroadcast = () => {
+                assertSigningCurrent();
+                assertSynchronousOriginalValidation(beforeBroadcast?.(), 'Transaction broadcast guard must be synchronous');
+                assertSigningCurrent();
+            };
+            const assertSignedSender = (signedTx) => {
+                if (Transaction.from(signedTx).from?.toLowerCase() !== expectedSender) {
+                    throw new Error('Replacement signature does not match account');
+                }
+            };
+            assertSigningCurrent();
+            const state = this.getState();
+            const activeAccountType = options.targetAccount?.type ?? state.activeAccountType;
+            const activeAccountId = options.targetAccount?.id ?? state.activeAccountId;
+            const targetAccount = options.targetAccount
+                ? { type: activeAccountType, id: activeAccountId }
+                : undefined;
+            const activeAccount = {
+                ...state.accounts?.[activeAccountType]?.[activeAccountId],
+            };
+            const activeNetwork = { ...state.activeNetwork };
+            if (!activeAccount.address ||
+                (targetAccount && activeAccountType === KeyringAccountType.SmartAccount)) {
+                throw new Error('Replacement signing account is unavailable');
+            }
+            if (!previewOnly)
+                assertCapturedSignerCurrent =
+                    this.captureEvmSigningContext(targetAccount).assertCurrent;
+            const expectedSender = activeAccount.address.toLowerCase();
+            const requestedHash = txHash.toLowerCase();
+            const provider = this.web3Provider;
+            assertSigningCurrent();
+            const submission = previewOnly
+                ? undefined
+                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+            const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
+            const validateLookup = (transaction) => {
+                assertCurrent();
+                if (!transaction)
+                    return null;
+                const authenticated = authenticateReplacementOriginal(transaction, requestedHash, expectedSender, activeNetwork.chainId);
+                const type = authenticated.type;
+                if (type !== 1)
+                    isLegacy = type === 0;
+                if (isLegacy &&
+                    type === 1 &&
+                    activeAccountType === KeyringAccountType.Trezor) {
+                    throw new Error('Trezor does not support type 1 replacement signing');
+                }
+                assertSynchronousOriginalValidation(validateOriginal(authenticated));
+                assertCurrent();
+                return authenticated;
+            };
+            let tx = validateLookup(await provider.getTransaction(txHash));
+            if (!tx) {
+                // Retry a couple of times in case the node hasn't indexed the pending tx yet
+                for (let attempt = 0; attempt < 2 && !tx; attempt++) {
+                    await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                    assertCurrent();
+                    tx = validateLookup(await provider.getTransaction(txHash));
+                }
+                if (!tx) {
+                    return {
+                        isSpeedUp: false,
+                        error: true,
+                        code: 'TX_NOT_FOUND',
+                        message: 'Original transaction not yet available from RPC provider',
+                    };
+                }
+            }
+            // Check if this might be a max send transaction by comparing total cost to balance
+            const currentBalance = await provider.getBalance(activeAccount.address);
+            assertCurrent();
+            // 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.type === 1 ? tx.gasPrice : tx.maxFeePerGas);
+            const maxPriorityFeePerGas = await Promise.resolve(tx.type === 1 ? tx.gasPrice : tx.maxPriorityFeePerGas);
+            const txValue = await Promise.resolve(tx.value);
+            const txData = await Promise.resolve(tx.data || '0x');
+            assertCurrent();
+            // 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);
+            const oldTxsGasValues = {
+                maxFeePerGas: maxFeePerGas,
+                maxPriorityFeePerGas: maxPriorityFeePerGas,
+                gasPrice: gasPrice,
+                gasLimit: gasLimit,
+            };
+            // A zero-fee original may need a current estimate; the preview shows it
+            // and the final candidate must stay within the user's approved ceiling.
+            if (isLegacy && oldTxsGasValues.gasPrice.isZero()) {
+                oldTxsGasValues.gasPrice = await provider.getGasPrice();
+                assertCurrent();
+            }
+            else if (!isLegacy && oldTxsGasValues.maxFeePerGas.isZero()) {
+                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
+                assertCurrent();
+                oldTxsGasValues.maxFeePerGas = BigNumber.from(feeData.maxFeePerGas || 0);
+                oldTxsGasValues.maxPriorityFeePerGas = BigNumber.from(feeData.maxPriorityFeePerGas || 0);
+            }
+            const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, isLegacy);
+            if (!newGasValues.gasLimit.gt(0))
+                throw new Error('Invalid replacement gas limit');
+            if (!isLegacy &&
+                newGasValues.maxPriorityFeePerGas.gt(newGasValues.maxFeePerGas))
+                throw new Error('Invalid replacement fee');
+            const maximumFee = newGasValues.gasLimit.mul(isLegacy ? newGasValues.gasPrice : newGasValues.maxFeePerGas);
+            if (isLikelyMaxSend && txValue.add(maximumFee).gt(currentBalance)) {
+                if (isContractCall) {
+                    console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
+                    return {
+                        isSpeedUp: false,
+                        error: true,
+                        code: 'CONTRACT_CALL_MAX_SEND',
+                        message: 'Cannot speed up a likely max-send contract call; value cannot be adjusted to fit new gas',
+                    };
+                }
+                return {
+                    isSpeedUp: false,
+                    error: true,
+                    code: 'REPLACEMENT_VALUE_WOULD_CHANGE',
+                    message: 'Add funds before speeding up this transaction; the original amount will not be changed',
+                };
+            }
+            const txWithEditedFee = {
+                chainId: activeNetwork.chainId,
+                from: tx.from,
+                to: tx.to,
+                nonce: tx.nonce,
+                value: txValue,
+                data: txData,
+                gasLimit: newGasValues.gasLimit,
+                ...(tx.accessList != null ? { accessList: tx.accessList } : {}),
+                ...(isLegacy
+                    ? { gasPrice: newGasValues.gasPrice, type: tx.type === 1 ? 1 : 0 }
+                    : {
+                        maxFeePerGas: newGasValues.maxFeePerGas,
+                        maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
+                    }),
+            };
+            if (!submission)
+                return { isSpeedUp: false, maximumFee: maximumFee.toString() };
+            if (maximumFee.gt(approvedMaximumFee))
+                throw new Error('Replacement fee exceeds approval');
+            // Ledger speedup handler
+            const speedUpWithLedger = async () => {
+                try {
+                    const resolvedParams = await resolveProperties(omit(txWithEditedFee, 'from'));
+                    const formatParams = {
+                        ...resolvedParams,
+                        nonce: resolvedParams.nonce != null
+                            ? Number(resolvedParams.nonce.toString())
+                            : undefined,
+                    };
+                    const txFormattedForEthers = isLegacy
+                        ? {
+                            ...formatParams,
+                            chainId: activeNetwork.chainId,
+                            type: txWithEditedFee.type,
+                        }
+                        : {
+                            ...formatParams,
+                            chainId: activeNetwork.chainId,
+                            type: 2, // Need explicit type for hardware wallet serialization
+                        };
+                    const rawTx = serializeTransaction(txFormattedForEthers);
+                    assertCurrent();
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                        assertSignedSender(signedTx);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        return {
+                            isSpeedUp: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isSpeedUp: false,
+                            error: true,
+                        };
+                    }
+                }
+                catch (error) {
+                    console.error('[SpeedUp] Failed to send replacement transaction with Ledger:', error);
+                    const message = error?.message || String(error);
+                    const lower = message.toLowerCase();
+                    const code = lower.includes('underpriced')
+                        ? 'REPLACEMENT_UNDERPRICED'
+                        : lower.includes('known transaction') ||
+                            lower.includes('already known')
+                            ? 'REPLACEMENT_ALREADY_KNOWN'
+                            : 'REPLACEMENT_SEND_FAILED';
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isSpeedUp: false,
+                        error: true,
+                        code,
+                        message,
+                    };
+                }
+            };
+            // Trezor speedup handler
+            const speedUpWithTrezor = async () => {
+                try {
+                    const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    const formattedTx = await resolveProperties(omit(txWithEditedFee, 'from'));
+                    const txFormattedForTrezor = {
+                        ...formattedTx,
+                        gasLimit: typeof formattedTx.gasLimit === 'string'
+                            ? formattedTx.gasLimit
+                            : this.toHex0x(formattedTx.gasLimit, 'gasLimit'),
+                        value: typeof formattedTx.value === 'string'
+                            ? formattedTx.value
+                            : this.toHex0x(formattedTx.value, 'value'),
+                        nonce: this.toHex0x(formattedTx.nonce, 'nonce'),
+                        chainId: activeNetwork.chainId,
+                        type: isLegacy ? txWithEditedFee.type : 2,
+                    };
+                    if (formattedTx.data && formattedTx.data !== '0x') {
+                        txFormattedForTrezor.data = formattedTx.data;
+                    }
+                    if (isLegacy) {
+                        txFormattedForTrezor.gasPrice =
+                            typeof formattedTx.gasPrice === 'string'
+                                ? formattedTx.gasPrice
+                                : this.toHex0x(formattedTx.gasPrice, 'gasPrice');
+                    }
+                    else {
+                        txFormattedForTrezor.maxFeePerGas =
+                            typeof formattedTx.maxFeePerGas === 'string'
+                                ? formattedTx.maxFeePerGas
+                                : this.toHex0x(formattedTx.maxFeePerGas, 'maxFeePerGas');
+                        txFormattedForTrezor.maxPriorityFeePerGas =
+                            typeof formattedTx.maxPriorityFeePerGas === 'string'
+                                ? formattedTx.maxPriorityFeePerGas
+                                : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
+                    }
+                    assertCurrent();
+                    assertTransactionGasLimit(txFormattedForTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                        coin: trezorCoin,
+                        tx: txFormattedForTrezor,
+                        index: activeAccountId.toString(),
+                        slip44: activeNetwork.slip44,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
+                    if (signature.success) {
+                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
+                        assertSignedSender(signedTx);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        return {
+                            isSpeedUp: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isSpeedUp: false,
+                            error: true,
+                        };
+                    }
+                }
+                catch (error) {
+                    console.error('[SpeedUp] Failed to send replacement transaction with Trezor:', error);
+                    const message = error?.message || String(error);
+                    const lower = message.toLowerCase();
+                    const code = lower.includes('underpriced')
+                        ? 'REPLACEMENT_UNDERPRICED'
+                        : lower.includes('known transaction') ||
+                            lower.includes('already known')
+                            ? 'REPLACEMENT_ALREADY_KNOWN'
+                            : 'REPLACEMENT_SEND_FAILED';
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isSpeedUp: false,
+                        error: true,
+                        code,
+                        message,
+                    };
+                }
+            };
+            // Regular wallet speedup handler
+            const speedUpWithPrivateKey = async () => {
+                try {
+                    assertCurrent();
+                    const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey(targetAccount);
+                    assertCurrent();
+                    if (address.toLowerCase() !== expectedSender) {
+                        throw new Error('Replacement signing account changed');
+                    }
+                    const transactionResponse = await sendLocalEvmTransaction(provider, decryptedPrivateKey, txWithEditedFee, assertBeforeBroadcast, assertCurrent, undefined, submission);
+                    if (transactionResponse) {
+                        return {
+                            isSpeedUp: true,
+                            transaction: transactionResponse,
+                        };
+                    }
+                    else {
+                        return {
+                            isSpeedUp: false,
+                        };
+                    }
+                }
+                catch (error) {
+                    console.error('[SpeedUp] Failed to send replacement transaction:', error);
+                    const message = error?.message || String(error);
+                    const lower = message.toLowerCase();
+                    const code = lower.includes('underpriced')
+                        ? 'REPLACEMENT_UNDERPRICED'
+                        : lower.includes('known transaction') ||
+                            lower.includes('already known')
+                            ? 'REPLACEMENT_ALREADY_KNOWN'
+                            : lower.includes('insufficient funds')
+                                ? 'INSUFFICIENT_FUNDS_REPLACEMENT'
+                                : 'REPLACEMENT_SEND_FAILED';
+                    return {
+                        ...evmSubmissionFailure(error),
+                        isSpeedUp: false,
+                        error: true,
+                        code,
+                        message,
+                    };
+                }
+            };
+            // Route based on account type
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await speedUpWithTrezor();
+                case KeyringAccountType.Ledger:
+                    return await speedUpWithLedger();
+                default:
+                    return await speedUpWithPrivateKey();
+            }
+        };
+        this.sendSignedErc20Transaction = async (request, approval) => {
+            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC20');
+            const { receiver, tokenAddress, tokenAmountUnits, saveTrezorTx, networkUrl, } = request;
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
+            const activeAccountAddress = activeAccount.address;
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC20 transaction approval network changed');
+            if ('tokenAmount' in request ||
+                'decimals' in request ||
+                'tokenId' in request ||
+                typeof tokenAmountUnits !== 'string' ||
+                !/^(0|[1-9][0-9]{0,77})$/.test(tokenAmountUnits))
+                throw new Error('Invalid ERC20 amount');
+            const exactTokenAmount = parseEvmFeeQuantity(tokenAmountUnits, 'ERC20 amount');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC20');
+            const submission = this.captureSubmission('erc20', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
+            const sendERC20Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc20Abi(), provider);
+                    let transferMethod;
+                    if (isLegacy) {
+                        const overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            gasPrice,
+                            gasLimit,
+                            type: 0, // Explicitly set Type 0 for legacy token transfers
+                        };
+                        assertCurrent();
+                        transferMethod = await _contract.transfer.populateTransaction(receiver, exactTokenAmount, normalizeEthersOverrides(overrides));
+                    }
+                    else {
+                        const overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            maxPriorityFeePerGas,
+                            maxFeePerGas,
+                            gasLimit,
+                        };
+                        assertCurrent();
+                        transferMethod = await _contract.transfer.populateTransaction(receiver, exactTokenAmount, normalizeEthersOverrides(overrides));
+                    }
+                    return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
+                        ...transferMethod,
+                        chainId: activeNetwork.chainId,
+                        from: activeAccountAddress,
+                        value: '0x0',
+                    }, assertCurrent, assertCurrent, undefined, submission);
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC20TokenOnLedger = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc20Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('transfer', [
+                        receiver,
+                        exactTokenAmount,
+                    ]);
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: gasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: gasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2, // Need explicit type for hardware wallet serialization
+                        };
+                    }
+                    const rawTx = serializeTransaction(txFormattedForEthers);
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
+                                const response = await provider.sendTransaction(raw);
+                                saveTrezorTx && saveTrezorTx(response);
+                                return response;
+                            }, submission, undefined, rawTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC20TokenOnTrezor = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc20Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('transfer', [
+                        receiver,
+                        exactTokenAmount,
+                    ]);
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
+                            maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: activeNetwork.currency,
+                        slip44: activeNetwork.slip44,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: gasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit: gasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2, // Need explicit type for hardware wallet serialization
+                                };
+                            }
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
+                                const response = await provider.sendTransaction(raw);
+                                saveTrezorTx && saveTrezorTx(response);
+                                return response;
+                            }, submission, undefined, expectedUnsignedTransaction);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            switch (activeAccountType) {
+                case KeyringAccountType.Trezor:
+                    return await sendERC20TokenOnTrezor();
+                case KeyringAccountType.Ledger:
+                    return await sendERC20TokenOnLedger();
+                default:
+                    return (await sendERC20Token());
+            }
+        };
+        this.sendSignedErc721Transaction = async (request, approval) => {
+            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC721');
+            const { receiver, tokenAddress, tokenId, networkUrl } = request;
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC721 transaction approval network changed');
+            if ('tokenAmountUnits' in request || 'decimals' in request)
+                throw new Error('ERC20 amount is not allowed for NFT transfers');
+            if (typeof tokenId !== 'string' || !/^(0|[1-9][0-9]{0,77})$/.test(tokenId))
+                throw new Error('Invalid ERC721 token ID');
+            const normalizedTokenId = parseEvmFeeQuantity(tokenId, 'ERC721 token ID');
+            if ('tokenAmount' in request)
+                throw new Error('ERC721 transfer must contain one token');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC721');
+            const activeAccountAddress = activeAccount.address;
+            const submission = this.captureSubmission('erc721', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
+            const sendERC721Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                let transferMethod;
+                try {
+                    const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
+                    if (isLegacy) {
+                        const overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            gasPrice,
+                            gasLimit,
+                            type: 0, // Explicitly set Type 0 for legacy NFT transfers
+                        };
+                        transferMethod = await _contract.transferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, normalizeEthersOverrides(overrides));
+                    }
+                    else {
+                        const overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            maxPriorityFeePerGas,
+                            maxFeePerGas,
+                            gasLimit,
+                        };
+                        transferMethod = await _contract.transferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, normalizeEthersOverrides(overrides));
+                    }
+                    return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
+                        ...transferMethod,
+                        chainId: activeNetwork.chainId,
+                        from: activeAccountAddress,
+                        value: '0x0',
+                    }, assertCurrent, assertCurrent, undefined, submission);
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC721TokenOnLedger = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('transferFrom', [
+                        activeAccountAddress,
+                        receiver,
+                        normalizedTokenId,
+                    ]);
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2, // Need explicit type for hardware wallet serialization
+                        };
+                    }
+                    const rawTx = serializeTransaction(txFormattedForEthers);
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC721TokenOnTrezor = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('transferFrom', [
+                        activeAccountAddress,
+                        receiver,
+                        normalizedTokenId,
+                    ]);
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                        console.log({ txToBeSignedByTrezor });
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
+                            maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
+                            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;
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: trezorCoin,
+                        slip44: activeNetwork.slip44,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2, // Need explicit type for hardware wallet serialization
+                                };
+                            }
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            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 KeyringAccountType.Trezor:
+                    return await sendERC721TokenOnTrezor();
+                case KeyringAccountType.Ledger:
+                    return await sendERC721TokenOnLedger();
+                default:
+                    return (await sendERC721Token());
+            }
+        };
+        this.sendSignedErc1155Transaction = async (request, approval) => {
+            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC1155');
+            const { receiver, tokenAddress, tokenId, networkUrl } = request;
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC1155 transaction approval network changed');
+            if ('tokenAmountUnits' in request || 'decimals' in request)
+                throw new Error('ERC20 amount is not allowed for NFT transfers');
+            if (typeof tokenId !== 'string' || !/^(0|[1-9][0-9]{0,77})$/.test(tokenId))
+                throw new Error('Invalid ERC1155 token ID');
+            const normalizedTokenId = parseEvmFeeQuantity(tokenId, 'ERC1155 token ID');
+            const { tokenAmount } = request;
+            if (typeof tokenAmount !== 'string' ||
+                !/^[1-9][0-9]{0,77}$/.test(tokenAmount))
+                throw new Error('Invalid ERC1155 amount');
+            const amount = parseEvmFeeQuantity(tokenAmount, 'ERC1155 amount');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC1155');
+            const activeAccountAddress = activeAccount.address;
+            const submission = this.captureSubmission('erc1155', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
+            const sendERC1155Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                let transferMethod;
+                try {
+                    const _contract = new Contract(tokenAddress, getErc55Abi(), provider);
+                    // Use BigNumber to avoid JS number overflow/precision loss
+                    let overrides;
+                    if (isLegacy) {
+                        overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            gasPrice,
+                            gasLimit,
+                            type: 0, // Explicitly set Type 0 for legacy ERC1155 transfers
+                        };
+                    }
+                    else {
+                        overrides = {
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            maxPriorityFeePerGas,
+                            maxFeePerGas,
+                            gasLimit,
+                        };
+                    }
+                    transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, amount, '0x', normalizeEthersOverrides(overrides));
+                    return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
+                        ...transferMethod,
+                        chainId: activeNetwork.chainId,
+                        from: activeAccountAddress,
+                        value: '0x0',
+                    }, assertCurrent, assertCurrent, undefined, submission);
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC1155TokenOnLedger = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc55Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, normalizedTokenId, amount, '0x']);
+                    let txFormattedForEthers;
+                    if (isLegacy) {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit,
+                            gasPrice,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 0,
+                        };
+                    }
+                    else {
+                        txFormattedForEthers = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: txData,
+                            nonce: transactionNonce,
+                            chainId: activeNetwork.chainId,
+                            type: 2, // Need explicit type for hardware wallet serialization
+                        };
+                    }
+                    const rawTx = serializeTransaction(txFormattedForEthers);
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
+                        rawTx: rawTx.replace('0x', ''),
+                        accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    const formattedSignature = {
+                        r: `0x${signature.r}`,
+                        s: `0x${signature.s}`,
+                        v: parseInt(signature.v, 16),
+                    };
+                    if (signature) {
+                        try {
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            return finalTx;
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    }
+                    else {
+                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            };
+            const sendERC1155TokenOnTrezor = async () => {
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
+                try {
+                    const _contract = new Contract(tokenAddress, getErc55Abi(), provider);
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, normalizedTokenId, amount, '0x']);
+                    let txToBeSignedByTrezor;
+                    if (isLegacy) {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    else {
+                        txToBeSignedByTrezor = {
+                            to: tokenAddress,
+                            value: '0x0',
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
+                            maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
+                            maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
+                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            chainId: activeNetwork.chainId,
+                            data: txData,
+                        };
+                    }
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                        index: `${activeAccountId}`,
+                        tx: txToBeSignedByTrezor,
+                        coin: activeNetwork.currency,
+                        slip44: activeNetwork.slip44,
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
+                    assertCurrent();
+                    if (signature.success) {
+                        try {
+                            let txFormattedForEthers;
+                            if (isLegacy) {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit,
+                                    gasPrice,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 0,
+                                };
+                            }
+                            else {
+                                txFormattedForEthers = {
+                                    to: tokenAddress,
+                                    value: '0x0',
+                                    gasLimit,
+                                    maxFeePerGas,
+                                    maxPriorityFeePerGas,
+                                    data: txData,
+                                    nonce: transactionNonce,
+                                    chainId: activeNetwork.chainId,
+                                    type: 2, // Need explicit type for hardware wallet serialization
+                                };
+                            }
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
+                            assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            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 KeyringAccountType.Trezor:
+                    return await sendERC1155TokenOnTrezor();
+                case 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(BigNumber.from('8'))
+                .div(BigNumber.from('10'))
+                .toString();
+            const high = this.toBigNumber(gasPrice)
+                .mul(BigNumber.from('11'))
+                .div(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(BigNumber.from(estimated).toString());
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getTxGasLimit = async (tx) => {
+            const request = { ...tx };
+            const network = this.getNetwork();
+            const identity = {
+                kind: network.kind,
+                chainId: network.chainId,
+                slip44: network.slip44,
+                url: network.url,
+            };
+            const chainId = parseEvmFeeQuantity(identity.chainId, 'chain ID');
+            const provider = this.web3Provider;
+            const controller = this.abortController;
+            const minimum = this.gasOverrides.minGasLimit;
+            const assertCurrent = () => {
+                const current = this.getNetwork();
+                if (controller.signal.aborted ||
+                    controller !== this.abortController ||
+                    current.kind !== identity.kind ||
+                    current.chainId !== identity.chainId ||
+                    current.slip44 !== identity.slip44 ||
+                    current.url !== identity.url ||
+                    this.web3Provider !== provider) {
+                    const error = new Error('EVM gas estimate context changed');
+                    error.name = 'AbortError';
+                    throw error;
+                }
+            };
+            const checked = (limit) => {
+                assertCurrent();
+                return BigNumber.from(assertEvmGasLimit(typeof limit === 'bigint' ? limit : limit.toBigInt(), chainId));
+            };
+            const hasCalldata = Boolean(request.data && request.data !== '0x' && request.data !== '0x0');
+            try {
+                // First attempt: standard estimation
+                assertCurrent();
+                const estimated = await provider.estimateGas(request);
+                return checked(bufferedEvmGasLimit(estimated.toBigInt(), minimum?.toBigInt()));
+            }
+            catch (error) {
+                assertCurrent();
+                if (error instanceof EvmGasLimitError ||
+                    error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                    error?.name === 'AbortError' ||
+                    this.abortController.signal.aborted)
+                    throw error;
+                console.warn('Gas estimation failed:', error);
+                if (hasCalldata) {
+                    const calldataFallback = BigNumber.from('100000');
+                    if (minimum && calldataFallback.lt(minimum)) {
+                        return checked(minimum);
+                    }
+                    return checked(calldataFallback);
+                }
+                // Try a simpler estimation for basic transfers
+                try {
+                    const simpleEstimate = await provider.estimateGas({
+                        to: request.to,
+                        from: request.from,
+                        value: request.value || '0x0',
+                    });
+                    const withBuffer = simpleEstimate.mul(150).div(100); // 50% buffer for failed estimations
+                    if (minimum && withBuffer.lt(minimum)) {
+                        return checked(minimum);
+                    }
+                    return checked(withBuffer);
+                }
+                catch (secondError) {
+                    assertCurrent();
+                    if (secondError instanceof EvmGasLimitError ||
+                        secondError?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                        secondError?.name === 'AbortError' ||
+                        this.abortController.signal.aborted) {
+                        throw secondError;
+                    }
+                    // Ultimate fallback
+                    console.warn('Simple estimation also failed, using default', secondError);
+                    return checked(minimum || BigNumber.from('100000'));
+                }
+            }
+        };
+        this.getRecommendedGasPrice = async (formatted) => {
+            try {
+                const gasPriceBN = await this.web3Provider.getGasPrice();
+                if (formatted) {
+                    return {
+                        gwei: Number(formatUnits(gasPriceBN, 'gwei')).toFixed(2),
+                        ethers: formatEther(gasPriceBN),
+                    };
+                }
+                return gasPriceBN.toString();
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.getBalance = async (address) => {
+            try {
+                const balance = await this.web3Provider.getBalance(address);
+                const formattedBalance = formatEther(balance);
+                return parseFloat(formattedBalance); // Return full precision
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.importAccount = (mnemonicOrPrivKey) => {
+            if (isHexString(mnemonicOrPrivKey)) {
+                return privateKeyToAccount(mnemonicOrPrivKey);
+            }
+            return deriveEvmAccountFromMnemonic(mnemonicOrPrivKey, getAddressDerivationPath('eth', 60, 0, false, 0));
+        };
+        // Method to get safe fee data that works around network-specific validation issues
+        this.getSafeFeeData = async (forceLegacy = false) => {
+            if (forceLegacy) {
+                // For legacy transactions, just return gas price
+                const gasPrice = await this.web3Provider.getGasPrice();
+                const bufferedGasPrice = gasPrice.mul(110).div(100); // 10% buffer
+                return {
+                    gasPrice: bufferedGasPrice,
+                    maxFeePerGas: undefined,
+                    maxPriorityFeePerGas: undefined,
+                };
+            }
+            const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
+            if (feeData.baseFeePerGas === undefined) {
+                // Only an actual pre-London header authorizes legacy selection.
+                const bufferedGasPrice = feeData.gasPrice.mul(110).div(100);
+                return {
+                    gasPrice: bufferedGasPrice,
+                    maxFeePerGas: undefined,
+                    maxPriorityFeePerGas: undefined,
+                };
+            }
+            return {
+                gasPrice: undefined,
+                maxFeePerGas: feeData.maxFeePerGas,
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+            };
+        };
+        if (typeof captureSigningContext !== 'function')
+            throw new TypeError('Ethereum transactions require a signing context');
+        if (captureSubmissionLifecycle !== null &&
+            typeof captureSubmissionLifecycle !== 'function')
+            throw new TypeError('Ethereum transactions require an explicit submission capability');
+        this.getNetwork = getNetwork;
+        this.getDecryptedPrivateKey = (targetAccount) => {
+            this.assertHardwareSignerAvailable(targetAccount);
+            return getDecryptedPrivateKey(targetAccount);
+        };
+        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;
+        this.captureSigningContext = captureSigningContext;
+        this.captureSubmissionLifecycle = captureSubmissionLifecycle;
+    }
+    // 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() {
+        // Keep provider in sync with current network selection.
+        // Hardware-wallet signing (e.g., Trezor) commits to a chainId; if the provider points at a different
+        // RPC/network than `activeNetwork`, nodes will reject broadcasts with chain-id mismatch errors.
+        try {
+            const currentNetwork = this.getNetwork();
+            if (currentNetwork?.kind !== INetworkType.Ethereum) {
+                if (this._web3Provider)
+                    this.setWeb3Provider(currentNetwork);
+                return;
+            }
+            const currentKey = `${currentNetwork.chainId}|${currentNetwork.url ?? ''}`;
+            const needsInit = !this._web3Provider || this._web3ProviderKey !== currentKey;
+            if (needsInit) {
+                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 || error);
+        }
+    }
+    setWeb3Provider(network) {
+        this.abortController.abort();
+        this.abortController = new AbortController();
+        if (network?.kind !== INetworkType.Ethereum) {
+            this._web3Provider = undefined;
+            this._web3ProviderKey = undefined;
+            return;
+        }
+        this._web3Provider = new CustomJsonRpcProvider(this.abortController.signal, network.url, network.chainId);
+        this._web3ProviderKey = `${network.chainId}|${network.url ?? ''}`;
+    }
+    // Method to configure gas overrides for networks with validation issues
+    setGasOverrides(overrides) {
+        this.gasOverrides = {
+            minGasLimit: overrides.minGasLimit
+                ? BigNumber.from(overrides.minGasLimit)
+                : undefined,
+            minPriorityFee: overrides.minPriorityFee
+                ? BigNumber.from(overrides.minPriorityFee)
+                : undefined,
+            feeMultiplier: overrides.feeMultiplier,
+        };
+    }
+    // Get the current gas overrides
+    getGasOverrides() {
+        return this.gasOverrides;
+    }
+}
+//# sourceMappingURL=ethereum.js.map