@sidhujag/sysweb3-keyring 1.0.613 → 1.0.616

package/cjs/transactions/ethereum.js

@@ -7,6 +7,7 @@ exports.EthereumTransactions = void 0;
 const eth_sig_util_1 = require("@metamask/eth-sig-util");
 const sysweb3_network_1 = require("@sidhujag/sysweb3-network");
 const sysweb3_utils_1 = require("@sidhujag/sysweb3-utils");
+const transaction_1 = require("ethers/transaction");
 const omit_1 = __importDefault(require("lodash/omit"));
 const ethers_v6_1 = require("../ethers-v6");
 const providers_1 = require("../providers");
@@ -427,18 +428,18 @@ class EthereumTransactions {
                 throw error;
             }
         };
-        this.getFeeDataWithDynamicMaxPriorityFeePerGas = async () => {
+        this.getFeeDataWithDynamicMaxPriorityFeePerGas = async (provider = this.web3Provider) => {
             let maxFeePerGas = this.toBigNumber(0);
             let maxPriorityFeePerGas = this.toBigNumber(0);
             try {
                 // First, try to get the current gas price as a baseline
-                const currentGasPrice = await this.web3Provider.getGasPrice();
-                const block = await this.web3Provider.getBlock('latest');
+                const currentGasPrice = await provider.getGasPrice();
+                const block = await provider.getBlock('latest');
                 if (block && block.baseFeePerGas != null) {
                     const baseFeePerGas = ethers_v6_1.BigNumber.from(block.baseFeePerGas);
                     try {
                         // Some networks don't support this RPC method
-                        const ethMaxPriorityFee = await this.web3Provider.send('eth_maxPriorityFeePerGas', []);
+                        const ethMaxPriorityFee = await provider.send('eth_maxPriorityFeePerGas', []);
                         maxPriorityFeePerGas = ethers_v6_1.BigNumber.from(ethMaxPriorityFee);
                         // Apply minimum priority fee override if set
                         if (this.gasOverrides.minPriorityFee &&
@@ -463,10 +464,14 @@ class EthereumTransactions {
                             : baselineMaxFee;
                     }
                     catch (e) {
+                        if (e?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                            e?.name === 'AbortError' ||
+                            this.abortController.signal.aborted)
+                            throw e;
                         // Use a more aggressive fallback strategy with higher priority fees
                         // Check if we can get fee history for better estimation
                         try {
-                            const feeHistory = await this.web3Provider.send('eth_feeHistory', [
+                            const feeHistory = await provider.send('eth_feeHistory', [
                                 '0x5', // Last 5 blocks
                                 'latest',
                                 [25, 50, 75], // Percentiles for priority fees
@@ -496,10 +501,15 @@ class EthereumTransactions {
                             }
                         }
                         catch (feeHistoryError) {
+                            if (feeHistoryError?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                                feeHistoryError?.name === 'AbortError' ||
+                                this.abortController.signal.aborted) {
+                                throw feeHistoryError;
+                            }
                             // If fee history fails, use current gas price as reference
                             console.warn('Fee history not available, using gas price based estimation');
                             // Use 10% of current gas price as priority fee
-                            const currentGasPrice = await this.web3Provider.getGasPrice();
+                            const currentGasPrice = await provider.getGasPrice();
                             maxPriorityFeePerGas = currentGasPrice.mul(10).div(100);
                             // Ensure minimum of 1 gwei
                             const minPriority = ethers_v6_1.BigNumber.from('1000000000');
@@ -508,7 +518,7 @@ class EthereumTransactions {
                             }
                         }
                         // Calculate maxFeePerGas based on current network conditions
-                        const currentGasPrice = await this.web3Provider.getGasPrice();
+                        const currentGasPrice = await provider.getGasPrice();
                         const baselineMaxFee = currentGasPrice.mul(120).div(100);
                         const calculatedMaxFee = baseFeePerGas
                             .mul(250)
@@ -538,6 +548,10 @@ class EthereumTransactions {
                 return { maxFeePerGas, maxPriorityFeePerGas };
             }
             catch (error) {
+                if (error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                    error?.name === 'AbortError' ||
+                    this.abortController.signal.aborted)
+                    throw error;
                 console.error(error);
                 return { maxFeePerGas, maxPriorityFeePerGas };
             }
@@ -1060,13 +1074,101 @@ class EthereumTransactions {
                     return await sendEVMTransaction();
             }
         };
-        this.sendTransactionWithEditedFee = async (txHash, isLegacy) => {
-            let tx = (await this.web3Provider.getTransaction(txHash));
+        this.sendTransactionWithEditedFee = async (txHash, isLegacy = false, options = {}) => {
+            const { assertCurrentContext, validateOriginal, beforeBroadcast, approvedMaximumFee, } = options;
+            const previewOnly = options.previewOnly === true;
+            if (!previewOnly &&
+                (typeof approvedMaximumFee !== 'string' ||
+                    !/^\d{1,78}$/.test(approvedMaximumFee))) {
+                throw new Error('Replacement fee approval required');
+            }
+            const assertCurrent = () => assertCurrentContext?.();
+            const assertBeforeBroadcast = () => {
+                assertCurrent();
+                beforeBroadcast?.();
+                assertCurrent();
+            };
+            const assertSignedSender = (signedTx) => {
+                if (transaction_1.Transaction.from(signedTx).from?.toLowerCase() !== expectedSender) {
+                    throw new Error('Replacement signature does not match account');
+                }
+            };
+            assertCurrent();
+            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 === types_1.KeyringAccountType.SmartAccount)) {
+                throw new Error('Replacement signing account is unavailable');
+            }
+            const expectedSender = activeAccount.address.toLowerCase();
+            const requestedHash = txHash.toLowerCase();
+            const provider = this.web3Provider;
+            assertCurrent();
+            const validateLookup = (transaction) => {
+                assertCurrent();
+                if (!transaction)
+                    return null;
+                const fields = (0, ethers_v6_1.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; // Effective RPC gas price is not signed in type 2.
+                const original = transaction_1.Transaction.from(fields);
+                if (!original.signature ||
+                    original.hash !== requestedHash ||
+                    original.from?.toLowerCase() !== expectedSender ||
+                    original.chainId !== BigInt(activeNetwork.chainId)) {
+                    throw new Error('Original transaction is not authenticated');
+                }
+                if (type !== 1)
+                    isLegacy = type === 0;
+                if (isLegacy &&
+                    type === 1 &&
+                    activeAccountType === types_1.KeyringAccountType.Trezor) {
+                    throw new Error('Trezor does not support type 1 replacement signing');
+                }
+                // Read only detached, authenticated signed fields after asynchronous work.
+                const authenticated = (0, providers_1.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,
+                });
+                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)));
-                    tx = (await this.web3Provider.getTransaction(txHash));
+                    assertCurrent();
+                    tx = validateLookup(await provider.getTransaction(txHash));
                 }
                 if (!tx) {
                     return {
@@ -1077,17 +1179,17 @@ class EthereumTransactions {
                     };
                 }
             }
-            const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
-            const activeAccount = accounts[activeAccountType][activeAccountId];
             // Check if this might be a max send transaction by comparing total cost to balance
-            const currentBalance = await this.web3Provider.getBalance(activeAccount.address);
+            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.maxFeePerGas || 0);
-            const maxPriorityFeePerGas = await Promise.resolve(tx.maxPriorityFeePerGas || 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
@@ -1097,113 +1199,73 @@ class EthereumTransactions {
             // If original transaction used >95% of balance, it's likely a max send
             const balanceThreshold = currentBalance.mul(95).div(100);
             const isLikelyMaxSend = originalTotalCost.gt(balanceThreshold);
-            let txWithEditedFee;
-            // If the original tx has 0 or very low gas price, fetch current network gas prices
             const oldTxsGasValues = {
                 maxFeePerGas: maxFeePerGas,
                 maxPriorityFeePerGas: maxPriorityFeePerGas,
                 gasPrice: gasPrice,
                 gasLimit: gasLimit,
             };
-            // Only fetch current gas prices if the original tx has exactly 0 or undefined gas
-            // This avoids unnecessary backend calls for legitimate low-gas networks (L2s, testnets)
-            if (isLegacy) {
-                if (!oldTxsGasValues.gasPrice || oldTxsGasValues.gasPrice.isZero()) {
-                    // Fetch current network gas price for replacement
-                    const currentGasPrice = await this.web3Provider.getGasPrice();
-                    oldTxsGasValues.gasPrice = currentGasPrice;
-                }
-            }
-            else {
-                // For EIP-1559 transactions
-                if (!oldTxsGasValues.maxFeePerGas ||
-                    oldTxsGasValues.maxFeePerGas.isZero()) {
-                    // Fetch current network fee data for replacement
-                    const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
-                    oldTxsGasValues.maxFeePerGas = ethers_v6_1.BigNumber.from(feeData.maxFeePerGas || 0);
-                    oldTxsGasValues.maxPriorityFeePerGas = ethers_v6_1.BigNumber.from(feeData.maxPriorityFeePerGas || 0);
+            // 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 = ethers_v6_1.BigNumber.from(feeData.maxFeePerGas || 0);
+                oldTxsGasValues.maxPriorityFeePerGas = ethers_v6_1.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);
+            let adjustedValue = txValue;
+            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',
+                    };
                 }
+                adjustedValue = currentBalance.gt(maximumFee)
+                    ? currentBalance.sub(maximumFee)
+                    : ethers_v6_1.Zero;
             }
-            if (!isLegacy) {
-                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, false);
-                let adjustedValue = txValue;
-                // For likely max sends, check if we need to adjust value
-                if (isLikelyMaxSend &&
-                    newGasValues.gasLimit &&
-                    newGasValues.maxFeePerGas) {
-                    const newGasCost = newGasValues.gasLimit.mul(newGasValues.maxFeePerGas);
-                    const newTotalCost = txValue.add(newGasCost);
-                    if (newTotalCost.gt(currentBalance)) {
-                        // If this is a contract call, we cannot adjust the value
-                        if (isContractCall) {
-                            console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
-                            return {
-                                isSpeedUp: false,
-                                error: true,
-                                code: 'CONTRACT_CALL_MAX_SEND',
-                                message: 'Cannot speed up a likely max-send contract call; value cannot be adjusted to fit new gas',
-                            };
-                        }
-                        // For non-contract calls, reduce value to fit within balance (clamp at zero)
-                        adjustedValue = currentBalance.gt(newGasCost)
-                            ? currentBalance.sub(newGasCost)
-                            : ethers_v6_1.Zero;
-                    }
-                }
-                txWithEditedFee = {
-                    from: tx.from,
-                    to: tx.to,
-                    nonce: tx.nonce,
-                    value: adjustedValue,
-                    data: txData,
-                    maxFeePerGas: newGasValues.maxFeePerGas,
-                    maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
-                    gasLimit: newGasValues.gasLimit,
-                    // Don't set type - let ethers auto-detect for EIP-1559
-                };
-            }
-            else {
-                const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, true);
-                let adjustedValue = txValue;
-                // For likely max sends, check if we need to adjust value
-                if (isLikelyMaxSend && newGasValues.gasLimit && newGasValues.gasPrice) {
-                    const newGasCost = newGasValues.gasLimit.mul(newGasValues.gasPrice);
-                    const newTotalCost = txValue.add(newGasCost);
-                    if (newTotalCost.gt(currentBalance)) {
-                        // If this is a contract call, we cannot adjust the value
-                        if (isContractCall) {
-                            console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
-                            return {
-                                isSpeedUp: false,
-                                error: true,
-                                code: 'CONTRACT_CALL_MAX_SEND',
-                                message: 'Cannot speed up a likely max-send contract call; value cannot be adjusted to fit new gas',
-                            };
-                        }
-                        // For non-contract calls, reduce value to fit within balance (clamp at zero)
-                        adjustedValue = currentBalance.gt(newGasCost)
-                            ? currentBalance.sub(newGasCost)
-                            : ethers_v6_1.Zero;
-                    }
-                }
-                txWithEditedFee = {
-                    from: tx.from,
-                    to: tx.to,
-                    nonce: tx.nonce,
-                    value: adjustedValue,
-                    data: txData,
-                    gasLimit: newGasValues.gasLimit,
-                    gasPrice: newGasValues.gasPrice,
-                    type: 0, // Force Type 0 for legacy speedup
-                };
-            }
+            const txWithEditedFee = {
+                chainId: activeNetwork.chainId,
+                from: tx.from,
+                to: tx.to,
+                nonce: tx.nonce,
+                value: adjustedValue,
+                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 (previewOnly)
+                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 (0, ethers_v6_1.resolveProperties)((0, omit_1.default)(txWithEditedFee, 'from'));
                     const formatParams = {
                         ...resolvedParams,
-                        nonce: resolvedParams.nonce
+                        nonce: resolvedParams.nonce != null
                             ? Number(resolvedParams.nonce.toString())
                             : undefined,
                     };
@@ -1211,7 +1273,7 @@ class EthereumTransactions {
                         ? {
                             ...formatParams,
                             chainId: activeNetwork.chainId,
-                            type: 0, // Need explicit type for hardware wallet serialization
+                            type: txWithEditedFee.type,
                         }
                         : {
                             ...formatParams,
@@ -1219,6 +1281,7 @@ class EthereumTransactions {
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    assertCurrent();
                     const signature = await this.ledgerSigner.evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -1230,7 +1293,9 @@ class EthereumTransactions {
                     };
                     if (signature) {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
-                        const transactionResponse = await this.web3Provider.sendTransaction(signedTx);
+                        assertSignedSender(signedTx);
+                        assertBeforeBroadcast();
+                        const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1276,7 +1341,7 @@ class EthereumTransactions {
                             : this.toHex0x(formattedTx.value, 'value'),
                         nonce: this.toHex0x(formattedTx.nonce, 'nonce'),
                         chainId: activeNetwork.chainId,
-                        type: isLegacy ? 0 : 2, // Need explicit type for hardware wallet serialization
+                        type: isLegacy ? txWithEditedFee.type : 2,
                     };
                     if (formattedTx.data && formattedTx.data !== '0x') {
                         txFormattedForTrezor.data = formattedTx.data;
@@ -1297,6 +1362,7 @@ class EthereumTransactions {
                                 ? formattedTx.maxPriorityFeePerGas
                                 : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
                     }
+                    assertCurrent();
                     const signature = await this.trezorSigner.signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
@@ -1305,7 +1371,9 @@ class EthereumTransactions {
                     });
                     if (signature.success) {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, signature.payload);
-                        const transactionResponse = await this.web3Provider.sendTransaction(signedTx);
+                        assertSignedSender(signedTx);
+                        assertBeforeBroadcast();
+                        const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1339,8 +1407,13 @@ class EthereumTransactions {
             // Regular wallet speedup handler
             const speedUpWithPrivateKey = async () => {
                 try {
-                    const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
-                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(this.web3Provider, decryptedPrivateKey, txWithEditedFee);
+                    assertCurrent();
+                    const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey(targetAccount);
+                    assertCurrent();
+                    if (address.toLowerCase() !== expectedSender) {
+                        throw new Error('Replacement signing account changed');
+                    }
+                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, txWithEditedFee, assertBeforeBroadcast, assertCurrent);
                     if (transactionResponse) {
                         return {
                             isSpeedUp: true,
@@ -2059,6 +2132,10 @@ class EthereumTransactions {
                 return withBuffer;
             }
             catch (error) {
+                if (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 = ethers_v6_1.BigNumber.from('100000');
@@ -2083,6 +2160,11 @@ class EthereumTransactions {
                     return withBuffer;
                 }
                 catch (secondError) {
+                    if (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 this.gasOverrides.minGasLimit || ethers_v6_1.BigNumber.from('100000');
@@ -2156,6 +2238,10 @@ class EthereumTransactions {
                 };
             }
             catch (error) {
+                if (error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                    error?.name === 'AbortError' ||
+                    this.abortController.signal.aborted)
+                    throw error;
                 console.warn('Failed to get EIP-1559 fees, using legacy:', error);
                 const gasPrice = await this.web3Provider.getGasPrice();
                 const bufferedGasPrice = gasPrice.mul(110).div(100);