Expose error details when block production fails

blockchain-interface/Cargo.toml

@@ -27,6 +27,7 @@ serde = "1.0"
 thiserror = "1.0"
 tokio-stream = { version = "0.1", features = ["sync"] }
 
+nimiq-account = { workspace = true, features = [] }
 nimiq-block = { workspace = true }
 nimiq-collections = { workspace = true }
 nimiq-database-value = { workspace = true }

blockchain-interface/src/error.rs

@@ -1,3 +1,4 @@
+use nimiq_account::AccountsError;
 use nimiq_block::{Block, BlockError, EquivocationProofError, ForkProof};
 use nimiq_hash::Blake2bHash;
 use nimiq_primitives::{account::AccountError, networks::NetworkId};
@@ -74,8 +75,8 @@ pub enum PushError {
     DuplicateTransaction,
     #[error("Equivocation proof: {0}")]
     InvalidEquivocationProof(#[from] EquivocationProofError),
-    #[error("Account error: {0}")]
-    AccountsError(#[from] AccountError),
+    #[error("Accounts error: {0}")]
+    AccountsError(#[from] AccountsError),
     #[error("Invalid fork")]
     InvalidFork,
     #[error("Blockchain error: {0}")]

blockchain/src/block_production/mod.rs

@@ -1,4 +1,4 @@
-use nimiq_account::BlockState;
+use nimiq_account::{Account, AccountsError, BlockState};
 use nimiq_block::{
     EquivocationProof, MacroBlock, MacroBody, MacroHeader, MicroBlock, MicroBody, MicroHeader,
     MicroJustification, SkipBlockInfo, SkipBlockProof,
@@ -8,7 +8,7 @@ use nimiq_bls::KeyPair as BlsKeyPair;
 use nimiq_database::{mdbx::MdbxReadTransaction as DBTransaction, traits::WriteTransaction};
 use nimiq_hash::{Blake2bHash, Blake2sHash, Hash};
 use nimiq_keys::KeyPair as SchnorrKeyPair;
-use nimiq_primitives::{account::AccountError, policy::Policy};
+use nimiq_primitives::policy::Policy;
 use nimiq_transaction::{
     historic_transaction::HistoricTransaction, inherent::Inherent, Transaction,
 };
@@ -19,14 +19,37 @@ use crate::{interface::HistoryInterface, Blockchain};
 
 #[derive(Debug, Error)]
 pub enum BlockProducerError {
-    #[error("Failed to commit accounts: {0}")]
-    AccountError(#[from] AccountError),
+    #[error("Failed to commit: error={0}, account={1:?}, transactions={2:?}, inherents={3:?}")]
+    AccountsError(AccountsError, Account, Vec<Transaction>, Vec<Inherent>),
     #[error("Failed to add to history")]
     HistoryError,
     #[error("Accounts are incomplete")]
     AccountsIncomplete,
 }
 
+impl BlockProducerError {
+    fn accounts_error(
+        blockchain: &Blockchain,
+        error: AccountsError,
+        transactions: Vec<Transaction>,
+        inherents: Vec<Inherent>,
+    ) -> Self {
+        let Some(account) = (match &error {
+            AccountsError::InvalidTransaction(_, transaction) => {
+                blockchain.get_account_if_complete(&transaction.sender)
+            }
+            AccountsError::InvalidInherent(_, inherent) => {
+                blockchain.get_account_if_complete(inherent.target())
+            }
+            AccountsError::InvalidDiff(_) => unreachable!(),
+        }) else {
+            return BlockProducerError::AccountsIncomplete;
+        };
+
+        BlockProducerError::AccountsError(error, account, transactions, inherents)
+    }
+}
+
 /// Struct that contains all necessary information to actually produce blocks.
 /// It has the validator keys for this validator.
 #[derive(Clone)]
@@ -140,7 +163,15 @@ impl BlockProducer {
         let (state_root, diff_root, executed_txns) = blockchain
             .state
             .accounts
-            .exercise_transactions(&transactions, &inherents, &block_state)?;
+            .exercise_transactions(&transactions, &inherents, &block_state)
+            .map_err(|error| {
+                BlockProducerError::accounts_error(
+                    blockchain,
+                    error,
+                    transactions,
+                    inherents.clone(),
+                )
+            })?;
 
         // Calculate the historic transactions from the transactions and the inherents.
         let hist_txs = HistoricTransaction::from(
@@ -331,11 +362,13 @@ impl BlockProducer {
 
         // Update the state and add the state root to the header.
         let block_state = BlockState::new(block_number, timestamp);
-        let (state_root, diff_root, _) =
-            blockchain
-                .state
-                .accounts
-                .exercise_transactions(&[], &inherents, &block_state)?;
+        let (state_root, diff_root, _) = blockchain
+            .state
+            .accounts
+            .exercise_transactions(&[], &inherents, &block_state)
+            .map_err(|error| {
+                BlockProducerError::accounts_error(blockchain, error, vec![], inherents.clone())
+            })?;
 
         macro_block.header.state_root = state_root;
         macro_block.header.diff_root = diff_root;

primitives/account/src/accounts.rs

@@ -23,9 +23,9 @@ use nimiq_trie::{trie::MerkleRadixTrie, WriteTransactionProxy};
 
 use crate::{
     Account, AccountInherentInteraction, AccountPruningInteraction, AccountReceipt,
-    AccountTransactionInteraction, BlockLogger, BlockState, DataStore, InherentLogger,
-    InherentOperationReceipt, OperationReceipt, Receipts, ReservedBalance, RevertInfo,
-    TransactionLog, TransactionOperationReceipt, TransactionReceipt,
+    AccountTransactionInteraction, AccountsError, BlockLogger, BlockState, DataStore,
+    InherentLogger, InherentOperationReceipt, OperationReceipt, Receipts, ReservedBalance,
+    RevertInfo, TransactionLog, TransactionOperationReceipt, TransactionReceipt,
 };
 
 declare_table!(AccountsTrieTable, "AccountsTrie", KeyNibbles => TrieNode);
@@ -269,7 +269,7 @@ impl Accounts {
         transactions: &[Transaction],
         inherents: &[Inherent],
         block_state: &BlockState,
-    ) -> Result<(Blake2bHash, Blake2bHash, Vec<ExecutedTransaction>), AccountError> {
+    ) -> Result<(Blake2bHash, Blake2bHash, Vec<ExecutedTransaction>), AccountsError> {
         let mut raw_txn = self.env.write_transaction();
         let mut txn: WriteTransactionProxy = (&mut raw_txn).into();
         assert!(self.is_complete(Some(&txn)), "Tree must be complete");
@@ -310,7 +310,7 @@ impl Accounts {
         inherents: &[Inherent],
         block_state: &BlockState,
         block_logger: &mut BlockLogger,
-    ) -> Result<Receipts, AccountError> {
+    ) -> Result<Receipts, AccountsError> {
         let receipts =
             self.commit_batch(txn, transactions, inherents, block_state, block_logger)?;
         self.tree.update_root(txn).expect("Tree must be complete");
@@ -321,7 +321,7 @@ impl Accounts {
         &self,
         txn: &mut WriteTransactionProxy,
         diff: TrieDiff,
-    ) -> Result<RevertTrieDiff, AccountError> {
+    ) -> Result<RevertTrieDiff, AccountsError> {
         let diff = self.tree.apply_diff(txn, diff)?;
         self.tree.update_root(txn).ok();
         Ok(diff)
@@ -334,27 +334,31 @@ impl Accounts {
         inherents: &[Inherent],
         block_state: &BlockState,
         block_logger: &mut BlockLogger,
-    ) -> Result<Receipts, AccountError> {
+    ) -> Result<Receipts, AccountsError> {
         assert!(self.is_complete(Some(txn)), "Tree must be complete");
         let mut receipts = Receipts::default();
 
         for transaction in transactions {
-            let receipt = self.commit_transaction(
-                txn,
-                transaction,
-                block_state,
-                block_logger.new_tx_log(transaction.hash()),
-            )?;
+            let receipt = self
+                .commit_transaction(
+                    txn,
+                    transaction,
+                    block_state,
+                    block_logger.new_tx_log(transaction.hash()),
+                )
+                .map_err(|error| AccountsError::InvalidTransaction(error, transaction.clone()))?;
             receipts.transactions.push(receipt);
         }
 
         for inherent in inherents {
-            let receipt = self.commit_inherent(
-                txn,
-                inherent,
-                block_state,
-                &mut block_logger.inherent_logger(),
-            )?;
+            let receipt = self
+                .commit_inherent(
+                    txn,
+                    inherent,
+                    block_state,
+                    &mut block_logger.inherent_logger(),
+                )
+                .map_err(|error| AccountsError::InvalidInherent(error, inherent.clone()))?;
             receipts.inherents.push(receipt);
         }
 
@@ -560,7 +564,7 @@ impl Accounts {
         block_state: &BlockState,
         revert_info: RevertInfo,
         block_logger: &mut BlockLogger,
-    ) -> Result<(), AccountError> {
+    ) -> Result<(), AccountsError> {
         match revert_info {
             RevertInfo::Receipts(receipts) => {
                 self.revert_batch(
@@ -584,7 +588,7 @@ impl Accounts {
         &self,
         txn: &mut WriteTransactionProxy,
         diff: RevertTrieDiff,
-    ) -> Result<(), AccountError> {
+    ) -> Result<(), AccountsError> {
         self.tree.revert_diff(txn, diff)?;
         Ok(())
     }
@@ -597,7 +601,7 @@ impl Accounts {
         block_state: &BlockState,
         receipts: Receipts,
         block_logger: &mut BlockLogger,
-    ) -> Result<(), AccountError> {
+    ) -> Result<(), AccountsError> {
         // Revert inherents in reverse order.
         assert_eq!(inherents.len(), receipts.inherents.len());
         let iter = inherents.iter().zip(receipts.inherents).rev();
@@ -608,7 +612,8 @@ impl Accounts {
                 block_state,
                 receipt,
                 &mut block_logger.inherent_logger(),
-            )?;
+            )
+            .map_err(|error| AccountsError::InvalidInherent(error, inherent.clone()))?;
         }
 
         // Revert transactions in reverse order.
@@ -621,7 +626,8 @@ impl Accounts {
                 block_state,
                 receipt,
                 block_logger.new_tx_log(transaction.hash()),
-            )?;
+            )
+            .map_err(|error| AccountsError::InvalidTransaction(error, transaction.clone()))?;
         }
 
         Ok(())

primitives/account/src/lib.rs

@@ -2,6 +2,10 @@
 #[macro_use]
 extern crate log;
 
+use nimiq_primitives::{account::AccountError, trie::error::MerkleRadixTrieError};
+use nimiq_transaction::{inherent::Inherent, Transaction};
+use thiserror::Error;
+
 #[cfg(feature = "accounts")]
 pub use crate::accounts::{Accounts, AccountsTrie};
 #[cfg(feature = "interaction-traits")]
@@ -30,3 +34,13 @@ mod interaction_traits;
 mod logs;
 mod receipts;
 mod reserved_balance;
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum AccountsError {
+    #[error("Invalid transaction: error={0}, transaction={1:?}")]
+    InvalidTransaction(AccountError, Transaction),
+    #[error("Invalid inherent: error={0}, inherent={1:?}")]
+    InvalidInherent(AccountError, Inherent),
+    #[error("Invalid diff: {0}")]
+    InvalidDiff(#[from] MerkleRadixTrieError),
+}

primitives/src/account.rs

@@ -27,7 +27,6 @@ pub enum AccountType {
     Vesting = 1,
     HTLC = 2,
     Staking = 3,
-    // HistoricTransaction = 0xff,
 }
 
 impl fmt::Display for AccountType {

test-utils/src/accounts_revert.rs

@@ -2,7 +2,8 @@ use std::{fmt::Debug, ops::Deref};
 
 use nimiq_account::{
     Account, AccountInherentInteraction, AccountReceipt, AccountTransactionInteraction, Accounts,
-    BlockLog, BlockLogger, BlockState, DataStore, InherentLogger, Receipts, TransactionLog,
+    AccountsError, BlockLog, BlockLogger, BlockState, DataStore, InherentLogger, Receipts,
+    TransactionLog,
 };
 use nimiq_database::{
     mdbx::MdbxDatabase,
@@ -132,7 +133,7 @@ impl TestCommitRevert {
         inherents: &[Inherent],
         block_state: &BlockState,
         block_logger: &mut BlockLogger,
-    ) -> Result<Receipts, AccountError> {
+    ) -> Result<Receipts, AccountsError> {
         self.commit_revert(transactions, inherents, block_state, block_logger, true)
     }
 
@@ -161,7 +162,7 @@ impl TestCommitRevert {
         block_state: &BlockState,
         block_logger: &mut BlockLogger,
         keep_commit: bool,
-    ) -> Result<Receipts, AccountError> {
+    ) -> Result<Receipts, AccountsError> {
         let mut raw_txn = self.accounts.env.write_transaction();
         let mut txn: WriteTransactionProxy = (&mut raw_txn).into();