refactor: extract chunk producer logic from Client

chain/chain/src/chain.rs

@@ -2365,13 +2365,7 @@ impl Chain {
         prev_prev_hash: &CryptoHash,
         prev_hash: &CryptoHash,
     ) -> Result<bool, Error> {
-        // Needs to be used with care: for the first block of each epoch the semantic is slightly
-        // different, since the prev_block is in a different epoch. So for all the blocks but the
-        // first one in each epoch this method returns true if the block is ready to have state
-        // applied for the next epoch, while for the first block in a particular epoch this method
-        // returns true if the block is ready to have state applied for the current epoch (and
-        // otherwise should be orphaned)
-        Ok(!self.chain_store.get_blocks_to_catchup(prev_prev_hash)?.contains(prev_hash))
+        Ok(ChainStore::prev_block_is_caught_up(&self.chain_store, prev_prev_hash, prev_hash)?)
     }
 
     /// Check if any block with missing chunk is ready to be processed and start processing these blocks
@@ -2598,7 +2592,7 @@ impl Chain {
     pub fn transaction_validity_check<'a>(
         &'a self,
         prev_block_header: BlockHeader,
-    ) -> impl FnMut(&SignedTransaction) -> bool + 'a {
+    ) -> impl Fn(&SignedTransaction) -> bool + 'a {
         move |tx: &SignedTransaction| -> bool {
             self.chain_store()
                 .check_transaction_validity_period(&prev_block_header, tx.transaction.block_hash())

chain/chain/src/runtime/mod.rs

@@ -607,7 +607,7 @@ impl RuntimeAdapter for NightshadeRuntime {
         chunk: PrepareTransactionsChunkContext,
         prev_block: PrepareTransactionsBlockContext,
         transaction_groups: &mut dyn TransactionGroupIterator,
-        chain_validate: &mut dyn FnMut(&SignedTransaction) -> bool,
+        chain_validate: &dyn Fn(&SignedTransaction) -> bool,
         time_limit: Option<Duration>,
     ) -> Result<PreparedTransactions, Error> {
         let start_time = std::time::Instant::now();

chain/chain/src/stateless_validation/chunk_validation.rs

@@ -389,7 +389,7 @@ pub fn pre_validate_chunk_state_witness(
             } else {
                 let prev_block_header =
                     store.get_block_header(last_chunk_block.header().prev_hash())?;
-                let mut check = chain.transaction_validity_check(prev_block_header);
+                let check = chain.transaction_validity_check(prev_block_header);
                 state_witness.transactions.iter().map(|t| check(t)).collect::<Vec<_>>()
             }
         } else {

chain/chain/src/store/mod.rs

@@ -334,6 +334,22 @@ impl ChainStore {
             .collect()
     }
 
+    pub fn get_outgoing_receipts_for_shard(
+        &self,
+        epoch_manager: &dyn EpochManagerAdapter,
+        prev_block_hash: CryptoHash,
+        shard_id: ShardId,
+        last_included_height: BlockHeight,
+    ) -> Result<Vec<Receipt>, Error> {
+        Self::get_outgoing_receipts_for_shard_from_store(
+            &self.chain_store(),
+            epoch_manager,
+            prev_block_hash,
+            shard_id,
+            last_included_height,
+        )
+    }
+
     /// Get outgoing receipts that will be *sent* from shard `shard_id` from block whose prev block
     /// is `prev_block_hash`
     /// Note that the meaning of outgoing receipts here are slightly different from
@@ -352,8 +368,8 @@ impl ChainStore {
     /// But we need to implement a more theoretically correct algorithm if shard layouts will change
     /// more often in the future
     /// <https://github.com/near/nearcore/issues/4877>
-    pub fn get_outgoing_receipts_for_shard(
-        &self,
+    pub fn get_outgoing_receipts_for_shard_from_store(
+        chain_store: &ChainStoreAdapter,
         epoch_manager: &dyn EpochManagerAdapter,
         prev_block_hash: CryptoHash,
         shard_id: ShardId,
@@ -362,7 +378,7 @@ impl ChainStore {
         let shard_layout = epoch_manager.get_shard_layout_from_prev_block(&prev_block_hash)?;
         let mut receipts_block_hash = prev_block_hash;
         loop {
-            let block_header = self.get_block_header(&receipts_block_hash)?;
+            let block_header = chain_store.get_block_header(&receipts_block_hash)?;
 
             if block_header.height() != last_included_height {
                 receipts_block_hash = *block_header.prev_hash();
@@ -377,7 +393,7 @@ impl ChainStore {
                 shard_id
             };
 
-            let mut receipts = self
+            let mut receipts = chain_store
                 .get_outgoing_receipts(&receipts_block_hash, receipts_shard_id)
                 .map(|v| v.to_vec())
                 .unwrap_or_default();
@@ -849,6 +865,20 @@ impl ChainStore {
         }
         store_update.commit().map_err(|err| err.into())
     }
+
+    pub fn prev_block_is_caught_up(
+        chain_store: &ChainStoreAdapter,
+        prev_prev_hash: &CryptoHash,
+        prev_hash: &CryptoHash,
+    ) -> Result<bool, Error> {
+        // Needs to be used with care: for the first block of each epoch the semantic is slightly
+        // different, since the prev_block is in a different epoch. So for all the blocks but the
+        // first one in each epoch this method returns true if the block is ready to have state
+        // applied for the next epoch, while for the first block in a particular epoch this method
+        // returns true if the block is ready to have state applied for the current epoch (and
+        // otherwise should be orphaned)
+        Ok(!chain_store.get_blocks_to_catchup(prev_prev_hash)?.contains(prev_hash))
+    }
 }
 
 impl ChainStoreAccess for ChainStore {

chain/chain/src/test_utils/kv_runtime.rs

@@ -1011,7 +1011,7 @@ impl RuntimeAdapter for KeyValueRuntime {
         _chunk: PrepareTransactionsChunkContext,
         _prev_block: PrepareTransactionsBlockContext,
         transaction_groups: &mut dyn TransactionGroupIterator,
-        _chain_validate: &mut dyn FnMut(&SignedTransaction) -> bool,
+        _chain_validate: &dyn Fn(&SignedTransaction) -> bool,
         _time_limit: Option<Duration>,
     ) -> Result<PreparedTransactions, Error> {
         let mut res = vec![];

chain/chain/src/types.rs

@@ -453,7 +453,7 @@ pub trait RuntimeAdapter: Send + Sync {
         chunk: PrepareTransactionsChunkContext,
         prev_block: PrepareTransactionsBlockContext,
         transaction_groups: &mut dyn TransactionGroupIterator,
-        chain_validate: &mut dyn FnMut(&SignedTransaction) -> bool,
+        chain_validate: &dyn Fn(&SignedTransaction) -> bool,
         time_limit: Option<Duration>,
     ) -> Result<PreparedTransactions, Error>;