feat: Shadow tracking

chain/chain/src/test_utils/kv_runtime.rs

@@ -957,6 +957,25 @@ impl EpochManagerAdapter for MockEpochManager {
         Ok(true)
     }
 
+    fn cares_about_shard_in_epoch(
+        &self,
+        epoch_id: EpochId,
+        account_id: &AccountId,
+        shard_id: ShardId,
+    ) -> Result<bool, EpochError> {
+        // This `unwrap` here tests that in all code paths we check that the epoch exists before
+        //    we check if we care about a shard. Please do not remove the unwrap, fix the logic of
+        //    the calling function.
+        let epoch_valset = self.get_valset_for_epoch(&epoch_id).unwrap();
+        let chunk_producers = self.get_chunk_producers(epoch_valset, shard_id);
+        for validator in chunk_producers {
+            if validator.account_id() == account_id {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
     fn cares_about_shard_from_prev_block(
         &self,
         parent_hash: &CryptoHash,

chain/epoch-manager/src/adapter.rs

@@ -8,8 +8,7 @@ use near_primitives::block::Tip;
 use near_primitives::block_header::{Approval, ApprovalInner, BlockHeader};
 use near_primitives::epoch_manager::block_info::BlockInfo;
 use near_primitives::epoch_manager::epoch_info::EpochInfo;
-use near_primitives::epoch_manager::EpochConfig;
-use near_primitives::epoch_manager::ShardConfig;
+use near_primitives::epoch_manager::{EpochConfig, ShardConfig};
 use near_primitives::errors::EpochError;
 use near_primitives::hash::CryptoHash;
 use near_primitives::shard_layout::{account_id_to_shard_id, ShardLayout, ShardLayoutError};
@@ -422,6 +421,13 @@ pub trait EpochManagerAdapter: Send + Sync {
         partial_witness: &PartialEncodedStateWitness,
     ) -> Result<bool, Error>;
 
+    fn cares_about_shard_in_epoch(
+        &self,
+        epoch_id: EpochId,
+        account_id: &AccountId,
+        shard_id: ShardId,
+    ) -> Result<bool, EpochError>;
+
     fn cares_about_shard_from_prev_block(
         &self,
         parent_hash: &CryptoHash,
@@ -1142,4 +1148,14 @@ impl EpochManagerAdapter for EpochManagerHandle {
         let epoch_manager = self.read();
         Ok(epoch_manager.get_epoch_info(epoch_id)?.validators_iter().collect::<Vec<_>>())
     }
+
+    fn cares_about_shard_in_epoch(
+        &self,
+        epoch_id: EpochId,
+        account_id: &AccountId,
+        shard_id: ShardId,
+    ) -> Result<bool, EpochError> {
+        let epoch_manager = self.read();
+        epoch_manager.cares_about_shard_in_epoch(epoch_id, account_id, shard_id)
+    }
 }

chain/epoch-manager/src/lib.rs

@@ -1626,11 +1626,8 @@ impl EpochManager {
         let stake_divisor = { config.minimum_stake_divisor as Balance };
         Ok(seat_price / stake_divisor)
     }
-}
 
-/// Private utilities for EpochManager.
-impl EpochManager {
-    fn cares_about_shard_in_epoch(
+    pub fn cares_about_shard_in_epoch(
         &self,
         epoch_id: EpochId,
         account_id: &AccountId,
@@ -1648,7 +1645,10 @@ impl EpochManager {
         }
         Ok(false)
     }
+}
 
+/// Private utilities for EpochManager.
+impl EpochManager {
     #[inline]
     pub(crate) fn block_producer_from_info(
         epoch_info: &EpochInfo,

chain/epoch-manager/src/shard_tracker.rs

@@ -11,6 +11,7 @@ use near_primitives::types::{AccountId, EpochId, ShardId};
 #[derive(Clone)]
 pub enum TrackedConfig {
     Accounts(Vec<AccountId>),
+    Shadow(AccountId),
     AllShards,
     // Rotates between sets of shards to track.
     Schedule(Vec<Vec<ShardId>>),
@@ -26,6 +27,8 @@ impl TrackedConfig {
             TrackedConfig::AllShards
         } else if !config.tracked_shard_schedule.is_empty() {
             TrackedConfig::Schedule(config.tracked_shard_schedule.clone())
+        } else if let Some(account_id) = config.shadow_tracked.as_ref() {
+            TrackedConfig::Shadow(account_id.clone())
         } else {
             TrackedConfig::Accounts(config.tracked_accounts.clone())
         }
@@ -90,6 +93,9 @@ impl ShardTracker {
                 let subset = &schedule[index as usize];
                 Ok(subset.contains(&shard_id))
             }
+            TrackedConfig::Shadow(account_id) => {
+                self.epoch_manager.cares_about_shard_in_epoch(*epoch_id, account_id, shard_id)
+            }
         }
     }
 

core/chain-configs/src/client_config.rs

@@ -410,6 +410,8 @@ pub struct ClientConfig {
     pub gc: GCConfig,
     /// Accounts that this client tracks.
     pub tracked_accounts: Vec<AccountId>,
+    /// Track shards that should be tracked by given validator.
+    pub shadow_tracked: Option<AccountId>,
     /// Shards that this client tracks.
     pub tracked_shards: Vec<ShardId>,
     /// Rotate between these sets of tracked shards.
@@ -539,6 +541,7 @@ impl ClientConfig {
             block_header_fetch_horizon: 50,
             gc: GCConfig { gc_blocks_limit: 100, ..GCConfig::default() },
             tracked_accounts: vec![],
+            shadow_tracked: None,
             tracked_shards: vec![],
             tracked_shard_schedule: vec![],
             archive,

nearcore/src/config.rs

@@ -222,6 +222,7 @@ pub struct Config {
     pub network: near_network::config_json::Config,
     pub consensus: Consensus,
     pub tracked_accounts: Vec<AccountId>,
+    pub shadow_tracked: Option<AccountId>,
     pub tracked_shards: Vec<ShardId>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tracked_shard_schedule: Option<Vec<Vec<ShardId>>>,
@@ -337,6 +338,7 @@ impl Default for Config {
             network: Default::default(),
             consensus: Consensus::default(),
             tracked_accounts: vec![],
+            shadow_tracked: None,
             tracked_shards: vec![],
             tracked_shard_schedule: None,
             archive: false,
@@ -557,6 +559,7 @@ impl NearConfig {
                 doosmslug_step_period: config.consensus.doomslug_step_period,
                 tracked_accounts: config.tracked_accounts,
                 tracked_shards: config.tracked_shards,
+                shadow_tracked: config.shadow_tracked,
                 tracked_shard_schedule: config.tracked_shard_schedule.unwrap_or(vec![]),
                 archive: config.archive,
                 save_trie_changes: config.save_trie_changes.unwrap_or(!config.archive),

nearcore/src/config_duration_test.rs

@@ -1,7 +1,10 @@
+use std::str::FromStr;
+
 use crate::config::Config;
 use near_jsonrpc::RpcConfig;
 use near_network::config_json::{ExperimentalConfig, NetworkConfigOverrides};
 use near_o11y::testonly::init_test_logger;
+use near_primitives::types::AccountId;
 use near_store::StoreConfig;
 use serde::ser::{
     SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
@@ -40,6 +43,7 @@ fn test_config_duration_all_std() {
         rosetta_rpc: Some(Default::default()),
         save_trie_changes: Some(Default::default()),
         split_storage: Some(Default::default()),
+        shadow_tracked: Some(AccountId::from_str("test").unwrap()),
         tracked_shard_schedule: Some(Default::default()),
         transaction_pool_size_limit: Some(Default::default()),
         state_sync: Some(Default::default()),

pytest/tests/sanity/validator_switch_key_quick.py

@@ -26,7 +26,7 @@ def test_validator_switch_key_quick(self):
         # that it will be assigned to when becoming a validator.
         config_map = {
             2: {
-                "tracked_shards": [0],
+                "shadow_tracked": "test0",
                 "store.load_mem_tries_for_tracked_shards": True,
             }
         }
@@ -42,7 +42,7 @@ def test_validator_switch_key_quick(self):
                            ["block_producer_kickout_threshold", 10],
                            ["chunk_producer_kickout_threshold", 10]],
                           config_map)
-        wait_for_blocks(old_validator, count=2)
+        wait_for_blocks(old_validator, count=5)
 
         new_validator.reset_validator_key(other_validator.validator_key)
         other_validator.kill()