@sidhujag/sysweb3-keyring 1.0.615 → 1.0.617

package/cjs/transactions/ethereum.js

@@ -16,6 +16,55 @@ const evm_local_signer_1 = require("./evm-local-signer");
 const derivation_paths_1 = require("../utils/derivation-paths");
 const stripHexPrefix = (value) => value.startsWith('0x') || value.startsWith('0X') ? value.slice(2) : value;
 const normalizeEthersOverrideValue = (value) => (0, ethers_v6_1.normalizeTxValue)(value);
+const nonNegativeFeeQuantity = (value, label) => {
+    // Match the exported BigNumberish object contract without trusting a
+    // private marker or BigNumber.from's null/empty-to-zero coercions. Normalize
+    // once so validation and conversion use the same integer representation.
+    if (value !== null && typeof value === 'object') {
+        const objectValue = value;
+        value =
+            objectValue._hex ??
+                objectValue.hex ??
+                (typeof objectValue.toString === 'function'
+                    ? objectValue.toString()
+                    : undefined);
+        if (typeof value !== 'string')
+            throw new Error(`Invalid ${label}`);
+    }
+    if (!((typeof value === 'string' && /^(?:0x[\da-f]+|\d+)$/i.test(value)) ||
+        (typeof value === 'number' &&
+            Number.isSafeInteger(value) &&
+            value >= 0) ||
+        (typeof value === 'bigint' && value >= 0n)))
+        throw new Error(`Invalid ${label}`);
+    const quantity = ethers_v6_1.BigNumber.from(value);
+    if (quantity.isNegative())
+        throw new Error(`Invalid ${label}`);
+    return quantity;
+};
+const isUnsupportedPriorityFeeRpc = (error) => {
+    const unsupportedCode = (code) => code === -32601 || code === 4200;
+    if (unsupportedCode(error?.code))
+        return true;
+    // Ethers' HTTP normalizer retains the matched JSON-RPC error and request
+    // under one of these two shapes. A generic outer unsupported/network error
+    // is not evidence that this particular RPC method is unavailable.
+    if (!['UNKNOWN_ERROR', 'UNSUPPORTED_OPERATION'].includes(error?.code)) {
+        return false;
+    }
+    if (error?.operation != null &&
+        error.operation !== 'eth_maxPriorityFeePerGas') {
+        return false;
+    }
+    return [
+        { cause: error.error, payload: error.payload },
+        { cause: error.info?.error, payload: error.info?.payload },
+    ].some(({ cause, payload }) => cause?.name !== 'AbortError' &&
+        unsupportedCode(cause?.code) &&
+        payload?.method === 'eth_maxPriorityFeePerGas' &&
+        Array.isArray(payload.params) &&
+        payload.params.length === 0);
+};
 const normalizeEthersOverrides = (overrides) => {
     const normalized = { ...overrides };
     for (const field of [
@@ -429,119 +478,68 @@ class EthereumTransactions {
             }
         };
         this.getFeeDataWithDynamicMaxPriorityFeePerGas = async (provider = this.web3Provider) => {
-            let maxFeePerGas = this.toBigNumber(0);
-            let maxPriorityFeePerGas = this.toBigNumber(0);
+            // Keep the actual legacy-price recommendation separate from the buffered
+            // EIP-1559 maximum. A failed read is not evidence of a zero/legacy fee.
+            const gasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'gas price');
+            const block = await provider.getBlock('latest');
+            if (!block)
+                throw new Error('Block not found');
+            if (block.baseFeePerGas == null) {
+                return {
+                    gasPrice,
+                    maxFeePerGas: ethers_v6_1.BigNumber.from(0),
+                    maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(0),
+                };
+            }
+            const baseFeePerGas = nonNegativeFeeQuantity(block.baseFeePerGas, 'base fee');
+            let maxPriorityFeePerGas;
             try {
-                // First, try to get the current gas price as a baseline
-                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 provider.send('eth_maxPriorityFeePerGas', []);
-                        maxPriorityFeePerGas = ethers_v6_1.BigNumber.from(ethMaxPriorityFee);
-                        // Apply minimum priority fee override if set
-                        if (this.gasOverrides.minPriorityFee &&
-                            maxPriorityFeePerGas.lt(this.gasOverrides.minPriorityFee)) {
-                            maxPriorityFeePerGas = this.gasOverrides.minPriorityFee;
-                        }
-                        if (maxPriorityFeePerGas.isZero()) {
-                            throw new Error('Max priority fee is zero');
-                        }
-                        // For networks with validation issues, use current gas price as baseline
-                        // This ensures we're not setting fees that the network will reject
-                        const baselineMaxFee = currentGasPrice.mul(120).div(100); // 20% above current gas price
-                        // Calculate standard maxFeePerGas
-                        const multiplier = this.gasOverrides.feeMultiplier || 250;
-                        const calculatedMaxFee = baseFeePerGas
-                            .mul(multiplier)
-                            .div(100)
-                            .add(maxPriorityFeePerGas);
-                        // Use the higher of the two to ensure transaction goes through
-                        maxFeePerGas = calculatedMaxFee.gt(baselineMaxFee)
-                            ? calculatedMaxFee
-                            : baselineMaxFee;
-                    }
-                    catch (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 provider.send('eth_feeHistory', [
-                                '0x5', // Last 5 blocks
-                                'latest',
-                                [25, 50, 75], // Percentiles for priority fees
-                            ]);
-                            if (feeHistory &&
-                                feeHistory.reward &&
-                                feeHistory.reward.length > 0) {
-                                // Use median of the 50th percentile from recent blocks
-                                const recentFees = feeHistory.reward
-                                    .map((r) => r[1]) // Get 50th percentile
-                                    .filter((f) => f && f !== '0x0')
-                                    .map((f) => ethers_v6_1.BigNumber.from(f));
-                                if (recentFees.length > 0) {
-                                    // Use the median value with a 50% buffer for better reliability
-                                    const sortedFees = recentFees.sort((a, b) => a.sub(b).isNegative() ? -1 : 1);
-                                    const medianFee = sortedFees[Math.floor(sortedFees.length / 2)];
-                                    maxPriorityFeePerGas = medianFee.mul(150).div(100); // Add 50% buffer
-                                }
-                                else {
-                                    // Fallback with higher default (5 gwei for better validation)
-                                    maxPriorityFeePerGas = ethers_v6_1.BigNumber.from('5000000000');
-                                }
-                            }
-                            else {
-                                // Fallback with higher default (5 gwei for better validation)
-                                maxPriorityFeePerGas = ethers_v6_1.BigNumber.from('5000000000');
-                            }
-                        }
-                        catch (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 provider.getGasPrice();
-                            maxPriorityFeePerGas = currentGasPrice.mul(10).div(100);
-                            // Ensure minimum of 1 gwei
-                            const minPriority = ethers_v6_1.BigNumber.from('1000000000');
-                            if (maxPriorityFeePerGas.lt(minPriority)) {
-                                maxPriorityFeePerGas = minPriority;
-                            }
-                        }
-                        // Calculate maxFeePerGas based on current network conditions
-                        const currentGasPrice = await provider.getGasPrice();
-                        const baselineMaxFee = currentGasPrice.mul(120).div(100);
-                        const calculatedMaxFee = baseFeePerGas
-                            .mul(250)
-                            .div(100)
-                            .add(maxPriorityFeePerGas);
-                        maxFeePerGas = calculatedMaxFee.gt(baselineMaxFee)
-                            ? calculatedMaxFee
-                            : baselineMaxFee;
-                    }
-                    // Ensure maxFeePerGas is at least 20% higher than maxPriorityFeePerGas
-                    const minMaxFee = maxPriorityFeePerGas.mul(120).div(100);
-                    if (maxFeePerGas.lt(minMaxFee)) {
-                        maxFeePerGas = minMaxFee;
-                    }
-                    return { maxFeePerGas, maxPriorityFeePerGas };
-                }
-                else if (block && block.baseFeePerGas == null) {
-                    // For non-EIP1559 chains, return zeros to indicate legacy transaction should be used
-                    console.log('Chain does not support EIP1559, use legacy transactions');
-                    return {
-                        maxFeePerGas: ethers_v6_1.BigNumber.from(0),
-                        maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(0),
-                    };
-                }
-                else if (!block)
-                    throw new Error('Block not found');
-                return { maxFeePerGas, maxPriorityFeePerGas };
+                maxPriorityFeePerGas = nonNegativeFeeQuantity(await provider.send('eth_maxPriorityFeePerGas', []), 'priority fee');
             }
             catch (error) {
-                console.error(error);
-                return { maxFeePerGas, maxPriorityFeePerGas };
-            }
+                if (error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                    error?.name === 'AbortError' ||
+                    this.abortController.signal.aborted ||
+                    provider.signal?.aborted ||
+                    !isUnsupportedPriorityFeeRpc(error))
+                    throw error;
+                // An explicitly unsupported method may use actual observed history,
+                // including zero rewards. Missing/corrupt history never invents a tip.
+                const history = await provider.send('eth_feeHistory', [
+                    '0x5',
+                    'latest',
+                    [25, 50, 75],
+                ]);
+                if (!Array.isArray(history?.reward) || history.reward.length === 0)
+                    throw new Error('Priority fee history unavailable');
+                const recentFees = history.reward
+                    .map((reward) => {
+                    if (!Array.isArray(reward) || reward.length !== 3)
+                        throw new Error('Invalid priority fee history');
+                    return nonNegativeFeeQuantity(reward[1], 'priority fee history');
+                })
+                    .sort((a, b) => (a.lt(b) ? -1 : a.gt(b) ? 1 : 0));
+                maxPriorityFeePerGas = recentFees[Math.floor(recentFees.length / 2)]
+                    .mul(150)
+                    .div(100);
+            }
+            if (this.gasOverrides.minPriorityFee &&
+                maxPriorityFeePerGas.lt(this.gasOverrides.minPriorityFee))
+                maxPriorityFeePerGas = this.gasOverrides.minPriorityFee;
+            const baselineMaxFee = gasPrice.mul(120).div(100);
+            const calculatedMaxFee = baseFeePerGas
+                .mul(this.gasOverrides.feeMultiplier || 250)
+                .div(100)
+                .add(maxPriorityFeePerGas);
+            let maxFeePerGas = calculatedMaxFee.gt(baselineMaxFee)
+                ? calculatedMaxFee
+                : baselineMaxFee;
+            const minMaxFee = maxPriorityFeePerGas.mul(120).div(100);
+            if (maxFeePerGas.lt(minMaxFee))
+                maxFeePerGas = minMaxFee;
+            if (maxFeePerGas.isZero())
+                throw new Error('Invalid EIP-1559 maximum fee');
+            return { gasPrice, baseFeePerGas, maxFeePerGas, maxPriorityFeePerGas };
         };
         this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy) => {
             const newGasValues = {
@@ -584,13 +582,22 @@ class EthereumTransactions {
         this.cancelSentTransaction = async (txHash, isLegacy, fallbackNonce) => {
             const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
             const activeAccount = accounts[activeAccountType][activeAccountId];
+            const currentEip1559Fees = async () => {
+                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
+                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 };
+            };
             let tx = (await this.web3Provider.getTransaction(txHash));
             // 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 = await this.web3Provider.getGasPrice();
+                    const currentGasPrice = nonNegativeFeeQuantity(await this.web3Provider.getGasPrice(), 'cancellation gas price');
                     tx = {
                         from: activeAccount.address,
                         to: activeAccount.address,
@@ -602,14 +609,14 @@ class EthereumTransactions {
                     };
                 }
                 else {
-                    const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
+                    const feeData = await currentEip1559Fees();
                     tx = {
                         from: activeAccount.address,
                         to: activeAccount.address,
                         value: ethers_v6_1.Zero,
                         nonce: fallbackNonce,
-                        maxFeePerGas: ethers_v6_1.BigNumber.from(feeData.maxFeePerGas || 0),
-                        maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(feeData.maxPriorityFeePerGas || 0),
+                        maxFeePerGas: feeData.maxFeePerGas,
+                        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
                         gasLimit: ethers_v6_1.BigNumber.from(42000),
                         data: '0x',
                     };
@@ -630,7 +637,10 @@ class EthereumTransactions {
                 gasLimit: tx.gasLimit,
             };
             if (isLegacy) {
-                const currentGasPrice = await this.web3Provider.getGasPrice();
+                const currentGasPrice = nonNegativeFeeQuantity(await this.web3Provider.getGasPrice(), 'cancellation gas price');
+                if (oldTxsGasValues.gasPrice != null) {
+                    oldTxsGasValues.gasPrice = nonNegativeFeeQuantity(oldTxsGasValues.gasPrice, 'original gas price');
+                }
                 if (!oldTxsGasValues.gasPrice ||
                     oldTxsGasValues.gasPrice.isZero() ||
                     oldTxsGasValues.gasPrice.lt(currentGasPrice)) {
@@ -638,13 +648,13 @@ class EthereumTransactions {
                 }
             }
             else {
-                const currentGasPrice = await this.web3Provider.getGasPrice();
-                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
-                const currentMaxFeePerGas = ethers_v6_1.BigNumber.from(feeData.maxFeePerGas || 0);
-                const currentPriorityFeePerGas = ethers_v6_1.BigNumber.from(feeData.maxPriorityFeePerGas || 0);
-                const currentMaxPriorityFeePerGas = currentPriorityFeePerGas.isZero()
-                    ? currentGasPrice
-                    : currentPriorityFeePerGas;
+                const { maxFeePerGas: currentMaxFeePerGas, maxPriorityFeePerGas: currentMaxPriorityFeePerGas, } = await currentEip1559Fees();
+                if (oldTxsGasValues.maxFeePerGas != null) {
+                    oldTxsGasValues.maxFeePerGas = nonNegativeFeeQuantity(oldTxsGasValues.maxFeePerGas, 'original maximum fee');
+                }
+                if (oldTxsGasValues.maxPriorityFeePerGas != null) {
+                    oldTxsGasValues.maxPriorityFeePerGas = nonNegativeFeeQuantity(oldTxsGasValues.maxPriorityFeePerGas, 'original priority fee');
+                }
                 if (!oldTxsGasValues.maxFeePerGas ||
                     oldTxsGasValues.maxFeePerGas.isZero() ||
                     oldTxsGasValues.maxFeePerGas.lt(currentMaxFeePerGas)) {
@@ -658,7 +668,24 @@ class EthereumTransactions {
                     oldTxsGasValues.maxFeePerGas = oldTxsGasValues.maxPriorityFeePerGas;
                 }
             }
-            const newGasValues = this.calculateNewGasValues(oldTxsGasValues, true, isLegacy || false);
+            // Preserve the existing 20% replacement policy with exact integer math.
+            // Nodes also require a strictly larger cap and tip than an old pending
+            // transaction; zero/small fees therefore need at least a one-wei bump.
+            // This is a replacement bump, not a fabricated network priority floor.
+            const bumpCancelFee = (fee) => {
+                const percentageBump = fee.mul(120).div(100);
+                const strictBump = fee.add(1);
+                return percentageBump.gt(strictBump) ? percentageBump : strictBump;
+            };
+            const newGasValues = {
+                gasLimit: ethers_v6_1.BigNumber.from(42000),
+                ...(isLegacy
+                    ? { gasPrice: bumpCancelFee(oldTxsGasValues.gasPrice) }
+                    : {
+                        maxFeePerGas: bumpCancelFee(oldTxsGasValues.maxFeePerGas),
+                        maxPriorityFeePerGas: bumpCancelFee(oldTxsGasValues.maxPriorityFeePerGas),
+                    }),
+            };
             // Base cancel transaction parameters (same for all wallet types)
             const baseCancelTx = {
                 nonce: tx.nonce,
@@ -847,24 +874,24 @@ class EthereumTransactions {
         this.sendFormattedTransactionInternal = async (params, isLegacy, beforeBroadcast) => {
             const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
             const activeAccount = accounts[activeAccountType][activeAccountId];
-            // Check if we should force legacy transactions for networks with EIP-1559 issues
-            // Some networks have issues with EIP-1559 validation
-            if (!isLegacy && params.maxFeePerGas && params.maxPriorityFeePerGas) {
-                const maxFee = ethers_v6_1.BigNumber.from(params.maxFeePerGas);
-                const priorityFee = ethers_v6_1.BigNumber.from(params.maxPriorityFeePerGas);
-                // If fees are zero or network doesn't support EIP-1559, use legacy
-                if (maxFee.isZero() || priorityFee.isZero()) {
-                    console.log('Switching to legacy transaction due to zero fees');
-                    isLegacy = true;
-                    // Convert to legacy by using gasPrice
-                    const gasPrice = await this.web3Provider.getGasPrice();
-                    params.gasPrice = gasPrice.mul(110).div(100); // 10% buffer
-                    // @ts-ignore
-                    delete params.maxFeePerGas;
-                    // @ts-ignore
-                    delete params.maxPriorityFeePerGas;
-                }
-            }
+            const explicitEip1559 = params.type != null && ethers_v6_1.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 && this.gasOverrides.minGasLimit) {
@@ -891,20 +918,24 @@ class EthereumTransactions {
                     params.gasPrice = await this.web3Provider.getGasPrice();
                 }
             }
-            else if (!params.maxFeePerGas || params.maxPriorityFeePerGas == null) {
+            else if (params.maxFeePerGas == null ||
+                params.maxPriorityFeePerGas == null) {
                 const feeData = await this.web3Provider.getFeeData();
-                params.maxFeePerGas =
-                    params.maxFeePerGas || feeData.maxFeePerGas || feeData.gasPrice;
+                params.maxFeePerGas = params.maxFeePerGas ?? feeData.maxFeePerGas;
                 params.maxPriorityFeePerGas =
                     params.maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas;
-                if (!params.maxFeePerGas || params.maxPriorityFeePerGas == null) {
+                if (params.maxFeePerGas == null || params.maxPriorityFeePerGas == null) {
+                    if (requestedEip1559)
+                        throw new Error('EIP-1559 fee data unavailable');
                     isLegacy = true;
                     params.gasPrice =
-                        feeData.gasPrice || (await this.web3Provider.getGasPrice());
+                        feeData.gasPrice ?? (await this.web3Provider.getGasPrice());
                     delete params.maxFeePerGas;
                     delete params.maxPriorityFeePerGas;
                 }
             }
+            if (!isLegacy)
+                validateEip1559Fees();
             const sendEVMLedgerTransaction = async () => {
                 const transactionNonce = await this.getRecommendedNonce(activeAccount.address);
                 const formatParams = isLegacy
@@ -2119,6 +2150,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');
@@ -2143,6 +2178,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');
@@ -2192,39 +2232,21 @@ class EthereumTransactions {
                     maxPriorityFeePerGas: undefined,
                 };
             }
-            try {
-                // Try EIP-1559 fees first
-                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas();
-                // If fees are zero or too low, fallback to legacy
-                if (!feeData.maxFeePerGas ||
-                    feeData.maxFeePerGas.isZero() ||
-                    !feeData.maxPriorityFeePerGas ||
-                    feeData.maxPriorityFeePerGas.isZero()) {
-                    console.log('EIP-1559 fees invalid, falling back to legacy gas price');
-                    const gasPrice = await this.web3Provider.getGasPrice();
-                    const bufferedGasPrice = gasPrice.mul(110).div(100);
-                    return {
-                        gasPrice: bufferedGasPrice,
-                        maxFeePerGas: undefined,
-                        maxPriorityFeePerGas: undefined,
-                    };
-                }
-                return {
-                    gasPrice: undefined,
-                    maxFeePerGas: feeData.maxFeePerGas,
-                    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-                };
-            }
-            catch (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);
+            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,
+            };
         };
         this.getNetwork = getNetwork;
         this.getDecryptedPrivateKey = getDecryptedPrivateKey;