fix(rpc): add fee/value and balance to insufficient funds RPC error

crates/rpc/rpc-eth-types/src/error.rs

@@ -2,7 +2,7 @@
 
 use std::time::Duration;
 
-use alloy_primitives::{Address, Bytes};
+use alloy_primitives::{Address, Bytes, U256};
 use alloy_sol_types::decode_revert_reason;
 use reth_errors::RethError;
 use reth_primitives::{revm_primitives::InvalidHeader, BlockId};
@@ -304,9 +304,14 @@ pub enum RpcInvalidTransactionError {
     /// thrown if creation transaction provides the init code bigger than init code size limit.
     #[error("max initcode size exceeded")]
     MaxInitCodeSizeExceeded,
-    /// Represents the inability to cover max cost + value (account balance too low).
-    #[error("insufficient funds for gas * price + value")]
-    InsufficientFunds,
+    /// Represents the inability to cover max fee + value (account balance too low).
+    #[error("insufficient funds for gas * price + value: have {balance} want {cost}")]
+    InsufficientFunds {
+        /// Transaction cost.
+        cost: U256,
+        /// Current balance of transaction sender.
+        balance: U256,
+    },
     /// Thrown when calculating gas usage
     #[error("gas uint64 overflow")]
     GasUintOverflow,
@@ -476,7 +481,9 @@ impl From<revm::primitives::InvalidTransaction> for RpcInvalidTransactionError {
             InvalidTransaction::CallerGasLimitMoreThanBlock |
             InvalidTransaction::CallGasCostMoreThanGasLimit => Self::GasTooHigh,
             InvalidTransaction::RejectCallerWithCode => Self::SenderNoEOA,
-            InvalidTransaction::LackOfFundForMaxFee { .. } => Self::InsufficientFunds,
+            InvalidTransaction::LackOfFundForMaxFee { fee, balance } => {
+                Self::InsufficientFunds { cost: *fee, balance: *balance }
+            }
             InvalidTransaction::OverflowPaymentInTransaction => Self::GasUintOverflow,
             InvalidTransaction::NonceOverflowInTransaction => Self::NonceMaxValue,
             InvalidTransaction::CreateInitCodeSizeLimit => Self::MaxInitCodeSizeExceeded,
@@ -518,7 +525,9 @@ impl From<reth_primitives::InvalidTransactionError> for RpcInvalidTransactionErr
         // This conversion is used to convert any transaction errors that could occur inside the
         // txpool (e.g. `eth_sendRawTransaction`) to their corresponding RPC
         match err {
-            InvalidTransactionError::InsufficientFunds { .. } => Self::InsufficientFunds,
+            InvalidTransactionError::InsufficientFunds(res) => {
+                Self::InsufficientFunds { cost: res.expected, balance: res.got }
+            }
             InvalidTransactionError::NonceNotConsistent { tx, state } => {
                 Self::NonceTooLow { tx, state }
             }
@@ -678,8 +687,8 @@ impl From<InvalidPoolTransactionError> for RpcPoolError {
             InvalidPoolTransactionError::Other(err) => Self::PoolTransactionError(err),
             InvalidPoolTransactionError::Eip4844(err) => Self::Eip4844(err),
             InvalidPoolTransactionError::Eip7702(err) => Self::Eip7702(err),
-            InvalidPoolTransactionError::Overdraft => {
-                Self::Invalid(RpcInvalidTransactionError::InsufficientFunds)
+            InvalidPoolTransactionError::Overdraft { cost, balance } => {
+                Self::Invalid(RpcInvalidTransactionError::InsufficientFunds { cost, balance })
             }
         }
     }

crates/rpc/rpc-eth-types/src/revm_utils.rs

@@ -47,16 +47,19 @@ where
     DB: Database,
     EthApiError: From<<DB as Database>::Error>,
 {
-    Ok(db
-        // Get the caller account.
-        .basic(env.caller)?
-        // Get the caller balance.
-        .map(|acc| acc.balance)
-        .unwrap_or_default()
-        // Subtract transferred value from the caller balance.
+    // Get the caller account.
+    let caller = db.basic(env.caller)?;
+    // Get the caller balance.
+    let balance = caller.map(|acc| acc.balance).unwrap_or_default();
+    // Get transaction value.
+    let value = env.value;
+    // Subtract transferred value from the caller balance. Return error if the caller has
+    // insufficient funds.
+    let balance = balance
         .checked_sub(env.value)
-        // Return error if the caller has insufficient funds.
-        .ok_or_else(|| RpcInvalidTransactionError::InsufficientFunds)?
+        .ok_or_else(|| RpcInvalidTransactionError::InsufficientFunds { cost: value, balance })?;
+
+    Ok(balance
         // Calculate the amount of gas the caller can afford with the specified gas price.
         .checked_div(env.gas_price)
         // This will be 0 if gas price is 0. It is fine, because we check it before.

crates/transaction-pool/src/error.rs

@@ -1,6 +1,6 @@
 //! Transaction pool errors
 
-use alloy_primitives::{Address, TxHash};
+use alloy_primitives::{Address, TxHash, U256};
 use reth_primitives::{BlobTransactionValidationError, InvalidTransactionError};
 
 /// Transaction pool result type.
@@ -203,8 +203,13 @@ pub enum InvalidPoolTransactionError {
     #[error("transaction underpriced")]
     Underpriced,
     /// Thrown if the transaction's would require an account to be overdrawn
-    #[error("transaction overdraws from account")]
-    Overdraft,
+    #[error("transaction overdraws from account, balance: {balance}, cost: {cost}")]
+    Overdraft {
+        /// Cost transaction is allowed to consume. See `reth_transaction_pool::PoolTransaction`.
+        cost: U256,
+        /// Balance of account.
+        balance: U256,
+    },
     /// EIP-4844 related errors
     #[error(transparent)]
     Eip4844(#[from] Eip4844PoolTransactionError),
@@ -274,7 +279,7 @@ impl InvalidPoolTransactionError {
                 false
             }
             Self::IntrinsicGasTooLow => true,
-            Self::Overdraft => false,
+            Self::Overdraft { .. } => false,
             Self::Other(err) => err.is_bad_transaction(),
             Self::Eip4844(eip4844_err) => {
                 match eip4844_err {

crates/transaction-pool/src/pool/txpool.rs

@@ -553,7 +553,10 @@ impl<T: TransactionOrdering> TxPool<T> {
                     )),
                     InsertErr::Overdraft { transaction } => Err(PoolError::new(
                         *transaction.hash(),
-                        PoolErrorKind::InvalidTransaction(InvalidPoolTransactionError::Overdraft),
+                        PoolErrorKind::InvalidTransaction(InvalidPoolTransactionError::Overdraft {
+                            cost: transaction.cost(),
+                            balance: on_chain_balance,
+                        }),
                     )),
                     InsertErr::TxTypeConflict { transaction } => Err(PoolError::new(
                         *transaction.hash(),