Runtime network selection

Makefile

@@ -62,15 +62,6 @@ build:
 release:
 	cargo build --release --bin forest
 
-interopnet:
-	cargo build --release --manifest-path=forest/Cargo.toml --no-default-features --features "rocksdb, interopnet"
-
-devnet:
-	cargo build  --manifest-path=forest/Cargo.toml --no-default-features --features "devnet, rocksdb"
-
-calibnet:
-	cargo build --release --manifest-path=forest/Cargo.toml --no-default-features --features "calibnet, rocksdb"
-
 docker-run:
 	docker build -t forest:latest -f ./Dockerfile . && docker run forest
 
@@ -81,7 +72,7 @@ pull-serialization-tests:
 run-serialization-vectors:
 	cargo test --release --manifest-path=$(SER_TESTS)/Cargo.toml --features "submodule_tests" -- --test-threads=$(RUST_TEST_THREADS)
 
-run-vectors: run-serialization-vectors run-conformance-vectors
+run-vectors: run-serialization-vectors
 
 test-vectors: pull-serialization-tests run-vectors
 
@@ -122,4 +113,4 @@ mdbook:
 mdbook-build:
 	mdbook build ./documentation
 
-.PHONY: clean clean-all lint build release test test-all test-release license test-vectors run-vectors pull-serialization-tests install docs run-serialization-vectors run-conformance-vectors
+.PHONY: clean clean-all lint build release test test-all test-release license test-vectors run-vectors pull-serialization-tests install docs run-serialization-vectors

README.md

@@ -121,19 +121,17 @@ make test-all
 
 ### Joining the testnet
 
-Build with the `interopnet` config with:
+Select the builtin calibnet configuration with the `--chain` option:
 
 ```bash
-make interopnet
-
 # Run and import past the state migrations to latest network version
-./target/release/forest --import-snapshot ./types/networks/src/interopnet/snapshot.car
+./target/release/forest --chain calibnet --import-snapshot snapshot.car
 ```
 
 Importing the snapshot only needs to happen during the first run. Following this, to restart the daemon run:
 
 ```bash
-./target/release/forest
+./target/release/forest --chain calibnet
 ```
 
 ### Interacting with Forest via CLI

blockchain/beacon/src/drand.rs

@@ -59,6 +59,11 @@ impl<T> BeaconSchedule<T>
 where
     T: Beacon,
 {
+    /// Constructs a new, empty BeaconSchedule<T> with the specified capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        BeaconSchedule(Vec::with_capacity(capacity))
+    }
+
     /// Returns the beacon entries for a given epoch.
     /// When the beacon for the given epoch is on a new beacon, randomness entries are taken
     /// from the last two rounds.

blockchain/chain/src/store/base_fee.rs

@@ -6,7 +6,6 @@ use clock::ChainEpoch;
 use encoding::Cbor;
 use ipld_blockstore::BlockStore;
 use message::Message;
-use networks::UPGRADE_SMOKE_HEIGHT;
 use num_bigint::{BigInt, Integer};
 use std::collections::HashSet;
 use types::BLOCK_GAS_LIMIT;
@@ -36,8 +35,9 @@ fn compute_next_base_fee(
     gas_limit_used: i64,
     no_of_blocks: usize,
     epoch: ChainEpoch,
+    smoke_height: ChainEpoch,
 ) -> BigInt {
-    let mut delta: i64 = if epoch > UPGRADE_SMOKE_HEIGHT {
+    let mut delta: i64 = if epoch > smoke_height {
         (gas_limit_used / no_of_blocks as i64) - BLOCK_GAS_TARGET
     } else {
         // Yes the denominator and numerator are intentionally flipped here. We are matching go.
@@ -65,7 +65,11 @@ fn compute_next_base_fee(
     next_base_fee
 }
 
-pub fn compute_base_fee<DB>(db: &DB, ts: &Tipset) -> Result<BigInt, crate::Error>
+pub fn compute_base_fee<DB>(
+    db: &DB,
+    ts: &Tipset,
+    smoke_height: ChainEpoch,
+) -> Result<BigInt, crate::Error>
 where
     DB: BlockStore,
 {
@@ -98,12 +102,14 @@ where
         total_limit,
         ts.blocks().len(),
         ts.epoch(),
+        smoke_height,
     ))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use networks::{ChainConfig, Height};
 
     fn construct_tests() -> Vec<(i64, i64, usize, i64, i64)> {
         // (base_fee, limit_used, no_of_blocks, output)
@@ -137,17 +143,28 @@ mod tests {
 
     #[test]
     fn run_base_fee_tests() {
+        let smoke_height = ChainConfig::default().epoch(Height::Smoke);
         let cases = construct_tests();
 
         for case in cases {
             // Pre smoke
-            let output =
-                compute_next_base_fee(&case.0.into(), case.1, case.2, UPGRADE_SMOKE_HEIGHT - 1);
+            let output = compute_next_base_fee(
+                &case.0.into(),
+                case.1,
+                case.2,
+                smoke_height - 1,
+                smoke_height,
+            );
             assert_eq!(BigInt::from(case.3), output);
 
             // Post smoke
-            let output =
-                compute_next_base_fee(&case.0.into(), case.1, case.2, UPGRADE_SMOKE_HEIGHT + 1);
+            let output = compute_next_base_fee(
+                &case.0.into(),
+                case.1,
+                case.2,
+                smoke_height + 1,
+                smoke_height,
+            );
             assert_eq!(BigInt::from(case.4), output);
         }
     }

blockchain/chain_sync/src/chain_muxer.rs

@@ -364,6 +364,7 @@ where
         mem_pool: Arc<MessagePool<M>>,
         genesis: Arc<Tipset>,
         message_processing_strategy: PubsubMessageProcessingStrategy,
+        block_delay: u64,
     ) -> Result<Option<(FullTipset, PeerId)>, ChainMuxerError> {
         let (tipset, source) = match event {
             NetworkEvent::HelloRequest { request, source } => {
@@ -454,6 +455,7 @@ where
                 chain_store.clone(),
                 bad_block_cache.clone(),
                 genesis.clone(),
+                block_delay,
             )
             .await
         {
@@ -490,6 +492,7 @@ where
         let bad_block_cache = self.bad_blocks.clone();
         let mem_pool = self.mpool.clone();
         let tipset_sample_size = self.sync_config.tipset_sample_size;
+        let block_delay = self.state_manager.chain_config.block_delay_secs;
 
         let evaluator = async move {
             let mut tipsets = vec![];
@@ -510,6 +513,7 @@ where
                     mem_pool.clone(),
                     genesis.clone(),
                     PubsubMessageProcessingStrategy::Process,
+                    block_delay,
                 )
                 .await
                 {
@@ -607,6 +611,7 @@ where
         let genesis = self.genesis.clone();
         let bad_block_cache = self.bad_blocks.clone();
         let mem_pool = self.mpool.clone();
+        let block_delay = self.state_manager.chain_config.block_delay_secs;
         let stream_processor: ChainMuxerFuture<(), ChainMuxerError> = Box::pin(async move {
             loop {
                 let event = match p2p_messages.recv().await {
@@ -625,6 +630,7 @@ where
                     mem_pool.clone(),
                     genesis.clone(),
                     PubsubMessageProcessingStrategy::DoNotProcess,
+                    block_delay,
                 )
                 .await
                 {
@@ -697,6 +703,7 @@ where
         let bad_block_cache = self.bad_blocks.clone();
         let mem_pool = self.mpool.clone();
         let tipset_sender = self.tipset_sender.clone();
+        let block_delay = self.state_manager.chain_config.block_delay_secs;
         let stream_processor: ChainMuxerFuture<UnexpectedReturnKind, ChainMuxerError> = Box::pin(
             async move {
                 // If a tipset has been provided, pass it to the tipset processor
@@ -723,6 +730,7 @@ where
                         mem_pool.clone(),
                         genesis.clone(),
                         PubsubMessageProcessingStrategy::Process,
+                        block_delay,
                     )
                     .await
                     {

blockchain/chain_sync/src/sync/peer_test.rs

@@ -12,6 +12,7 @@ use fil_types::verifier::MockVerifier;
 use forest_libp2p::hello::HelloRequest;
 use libp2p::core::PeerId;
 use message_pool::{test_provider::TestApi, MessagePool};
+use networks::ChainConfig;
 use state_manager::StateManager;
 use std::time::Duration;
 
@@ -26,6 +27,7 @@ fn peer_manager_update() {
         "test".to_string(),
         tx,
         Default::default(),
+        &ChainConfig::default(),
     ))
     .unwrap();
     let mpool = Arc::new(mpool);
@@ -49,7 +51,7 @@ fn peer_manager_update() {
         height: 0,
         beacon: Arc::new(MockBeacon::new(Duration::from_secs(1))),
     }]));
-    let state_manager = Arc::new(StateManager::new(chain_store));
+    let state_manager = Arc::new(StateManager::new(chain_store, config.chain));
     let cs = ChainSyncer::<_, _, MockVerifier, TestApi>::new(
         state_manager,
         beacon,

blockchain/chain_sync/src/tipset_syncer.rs

@@ -42,7 +42,7 @@ use forest_libp2p::chain_exchange::TipsetBundle;
 use interpreter::price_list_by_epoch;
 use ipld_blockstore::BlockStore;
 use message::{Message, UnsignedMessage};
-use networks::{get_network_version_default, BLOCK_DELAY_SECS, UPGRADE_SMOKE_HEIGHT};
+use networks::Height;
 use state_manager::Error as StateManagerError;
 use state_manager::StateManager;
 use state_tree::StateTree;
@@ -1242,8 +1242,10 @@ async fn validate_block<
         .map_err(|e| (*block_cid, e.into()))?;
 
     // Timestamp checks
+    let block_delay = state_manager.chain_config.block_delay_secs;
+    let smoke_height = state_manager.chain_config.epoch(Height::Smoke);
     let nulls = (header.epoch() - (base_tipset.epoch() + 1)) as u64;
-    let target_timestamp = base_tipset.min_timestamp() + BLOCK_DELAY_SECS * (nulls + 1);
+    let target_timestamp = base_tipset.min_timestamp() + block_delay * (nulls + 1);
     if target_timestamp != header.timestamp() {
         return Err((
             *block_cid,
@@ -1303,9 +1305,11 @@ async fn validate_block<
     let v_block = Arc::clone(&block);
     validations.push(task::spawn_blocking(move || {
         let base_fee =
-            chain::compute_base_fee(v_block_store.as_ref(), &v_base_tipset).map_err(|e| {
-                TipsetRangeSyncerError::Validation(format!("Could not compute base fee: {}", e))
-            })?;
+            chain::compute_base_fee(v_block_store.as_ref(), &v_base_tipset, smoke_height).map_err(
+                |e| {
+                    TipsetRangeSyncerError::Validation(format!("Could not compute base fee: {}", e))
+                },
+            )?;
         let parent_base_fee = v_block.header.parent_base_fee();
         if &base_fee != parent_base_fee {
             return Err(TipsetRangeSyncerError::Validation(format!(
@@ -1459,7 +1463,7 @@ async fn validate_block<
         let header = v_block.header();
         let mut miner_address_buf = header.miner_address().marshal_cbor()?;
 
-        if header.epoch() > UPGRADE_SMOKE_HEIGHT {
+        if header.epoch() > smoke_height {
             let vrf_proof = base_tipset
                 .min_ticket()
                 .ok_or(TipsetRangeSyncerError::TipsetWithoutTicket)?
@@ -1626,7 +1630,10 @@ fn check_block_messages<
     block: &Block,
     base_tipset: &Arc<Tipset>,
 ) -> Result<(), TipsetRangeSyncerError> {
-    let network_version = get_network_version_default(block.header.epoch());
+    let network_version = state_manager
+        .chain_config
+        .network_version(block.header.epoch());
+    let calico_height = state_manager.chain_config.epoch(Height::Calico);
 
     // Do the initial loop here
     // check block message and signatures in them
@@ -1663,7 +1670,7 @@ fn check_block_messages<
     } else {
         return Err(TipsetRangeSyncerError::BlockWithoutBlsAggregate);
     }
-    let price_list = price_list_by_epoch(base_tipset.epoch());
+    let price_list = price_list_by_epoch(base_tipset.epoch(), calico_height);
     let mut sum_gas_limit = 0;
 
     // Check messages for validity

blockchain/chain_sync/src/validation.rs

@@ -10,7 +10,6 @@ use cid::{Cid, Code::Blake2b256};
 use encoding::{Cbor, Error as EncodingError};
 use ipld_blockstore::BlockStore;
 use message::{SignedMessage, UnsignedMessage};
-use networks::BLOCK_DELAY_SECS;
 
 use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -59,14 +58,15 @@ impl<'a> TipsetValidator<'a> {
         chainstore: Arc<ChainStore<DB>>,
         bad_block_cache: Arc<BadBlockCache>,
         genesis_tipset: Arc<Tipset>,
+        block_delay: u64,
     ) -> Result<(), TipsetValidationError> {
         // No empty blocks
         if self.0.blocks().is_empty() {
             return Err(TipsetValidationError::NoBlocks);
         }
 
         // Tipset epoch must not be behind current max
-        self.validate_epoch(genesis_tipset)?;
+        self.validate_epoch(genesis_tipset, block_delay)?;
 
         // Validate each block in the tipset by:
         // 1. Calculating the message root using all of the messages to ensure it matches the mst root in the block header
@@ -81,13 +81,16 @@ impl<'a> TipsetValidator<'a> {
         Ok(())
     }
 
-    pub fn validate_epoch(&self, genesis_tipset: Arc<Tipset>) -> Result<(), TipsetValidationError> {
+    pub fn validate_epoch(
+        &self,
+        genesis_tipset: Arc<Tipset>,
+        block_delay: u64,
+    ) -> Result<(), TipsetValidationError> {
         let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap()
             .as_secs();
-        let max_epoch =
-            ((now - genesis_tipset.min_timestamp()) / BLOCK_DELAY_SECS) + MAX_HEIGHT_DRIFT;
+        let max_epoch = ((now - genesis_tipset.min_timestamp()) / block_delay) + MAX_HEIGHT_DRIFT;
         let too_far_ahead_in_time = self.0.epoch() as u64 > max_epoch;
         if too_far_ahead_in_time {
             Err(TipsetValidationError::EpochTooLarge)

blockchain/message_pool/Cargo.toml

@@ -11,6 +11,7 @@ blocks = { package = "forest_blocks", path = "../blocks" }
 message = { package = "forest_message", version = "0.7", features = ["proofs", "json", "blst"] }
 thiserror = "1.0"
 cid = { package = "forest_cid", version = "0.3" }
+clock = { package = "fil_clock", path = "../../node/clock" }
 encoding = { package = "forest_encoding", version = "0.2.1" }
 blockstore = { package = "ipld_blockstore", version = "0.1" }
 num-bigint = { path = "../../utils/bigint", package = "forest_bigint" }

blockchain/message_pool/src/msg_chain.rs

@@ -7,6 +7,7 @@ use crate::utils::{get_gas_perf, get_gas_reward};
 use address::Address;
 use async_std::sync::RwLock;
 use blocks::Tipset;
+use clock::ChainEpoch;
 use encoding::Cbor;
 use log::warn;
 use message::{Message, SignedMessage};
@@ -344,6 +345,7 @@ pub(crate) async fn create_message_chains<T>(
     base_fee: &BigInt,
     ts: &Tipset,
     chains: &mut Chains,
+    calico_height: ChainEpoch,
 ) -> Result<(), Error>
 where
     T: Provider,
@@ -387,7 +389,7 @@ where
         }
         cur_seq += 1;
 
-        let min_gas = interpreter::price_list_by_epoch(ts.epoch())
+        let min_gas = interpreter::price_list_by_epoch(ts.epoch(), calico_height)
             .on_chain_message(m.marshal_cbor()?.len())
             .total();