Method process_transactions

chain/src/blockchain.rs:118–205

(&mut self)

    }

    pub(crate) async fn process_transactions(&mut self) -> Result<()> {
        // Bulk drain the current queue to fit into the new block
        // This is not safe as we lose transactions if a panic occurs
        // or if the program is halted
        let transactions = self
            .transactions
            .lock()
            .await
            .mempool
            .drain(0..)
            .collect::<VecDeque<_>>();

        if !transactions.is_empty() {
            let mut receipts: Vec<TransactionReceipt> = vec![];
            let mut processed: Vec<Transaction> = vec![];

            tracing::info!("Processing {} transactions", transactions.len());

            for mut transaction in transactions.into_iter() {
                match self.process_transaction(&mut transaction) {
                    Ok((transaction, transaction_receipt)) => {
                        receipts.push(transaction_receipt);
                        processed.push(transaction.to_owned());
                    }
                    Err(error) => {
                        match error {
                            // The nonce is too high, add back to the mempool
                            ChainError::NonceTooHigh(_, _) => {
                                tracing::warn!(
                                    "Could not process transaction {:?}: {}",
                                    transaction,
                                    error
                                );
                                self.transactions
                                    .lock()
                                    .await
                                    .mempool
                                    .push_back(transaction);
                            }
                            _ => tracing::error!(
                                "Could not process transaction {:?}: {}",
                                transaction,
                                error
                            ),
                        }
                    }
                }
            }

            // update world state
            let state_trie = self.accounts.root_hash()?;
            self.world_state.update_state_trie(state_trie);

            tracing::info!("World State: state_trie {:?}", state_trie);

            let num_processed = processed.len();
            let block = self.new_block(processed, state_trie)?;