Implemented epoch change using internal trigger

bin/node-sassafras/node/src/chain_spec.rs

@@ -143,8 +143,7 @@ fn testnet_genesis(
 		},
 
 		sassafras: SassafrasConfig {
-			authorities: vec![], /* TODO-SASS: initial_authorities.iter().map(|x|
-			                      * (x.0.clone())).collect(), */
+			authorities: initial_authorities.iter().map(|x| (x.0.clone(), 0)).collect(),
 			epoch_config: Some(node_sassafras_runtime::SASSAFRAS_GENESIS_EPOCH_CONFIG),
 		},
 		grandpa: GrandpaConfig {

bin/node-sassafras/runtime/src/lib.rs

@@ -224,7 +224,7 @@ parameter_types! {
 impl pallet_sassafras::Config for Runtime {
 	type EpochDuration = EpochDuration;
 	type ExpectedBlockTime = ExpectedBlockTime;
-	type EpochChangeTrigger = pallet_sassafras::ExternalTrigger;
+	type EpochChangeTrigger = pallet_sassafras::SameAuthoritiesForever;
 	type MaxAuthorities = MaxAuthorities;
 }
 
@@ -251,7 +251,7 @@ impl pallet_grandpa::Config for Runtime {
 impl pallet_timestamp::Config for Runtime {
 	/// A timestamp: milliseconds since the unix epoch.
 	type Moment = u64;
-	type OnTimestampSet = (); // TODO-SASS
+	type OnTimestampSet = ();
 	type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
 	type WeightInfo = ();
 }

client/consensus/sassafras/Cargo.toml

@@ -24,7 +24,7 @@ log = "0.4.16"
 #num-traits = "0.2.8"
 parking_lot = "0.12.0"
 #rand = "0.7.2"
-#retain_mut = "0.1.4"
+retain_mut = "0.1.4"
 #schnorrkel = { version = "0.9.1", features = ["preaudit_deprecated"] }
 #serde = { version = "1.0.136", features = ["derive"] }
 thiserror = "1.0"

client/consensus/sassafras/src/aux_schema.rs

@@ -24,12 +24,18 @@ use scale_codec::{Decode, Encode};
 use sc_client_api::backend::AuxStore;
 use sc_consensus_epochs::{EpochChangesFor, SharedEpochChanges};
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_consensus_sassafras::SassafrasBlockWeight;
 use sp_runtime::traits::Block as BlockT;
 
 use crate::Epoch;
 
 const SASSAFRAS_EPOCH_CHANGES_KEY: &[u8] = b"sassafras_epoch_changes";
 
+/// The aux storage key used to store the block weight of the given block hash.
+fn block_weight_key<H: Encode>(block_hash: H) -> Vec<u8> {
+	(b"sassafras_block_weight", block_hash).encode()
+}
+
 fn load_decode<B, T>(backend: &B, key: &[u8]) -> ClientResult<Option<T>>
 where
 	B: AuxStore,
@@ -43,27 +49,54 @@ where
 	}
 }
 
+/// Update the epoch changes on disk after a change.
+pub(crate) fn write_epoch_changes<Block: BlockT, F, R>(
+	epoch_changes: &EpochChangesFor<Block, Epoch>,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(&'static [u8], &[u8])]) -> R,
+{
+	epoch_changes.using_encoded(|s| write_aux(&[(SASSAFRAS_EPOCH_CHANGES_KEY, s)]))
+}
+
 /// Load or initialize persistent epoch change data from backend.
-pub fn load_epoch_changes<B: BlockT, AS: AuxStore>(
+pub(crate) fn load_epoch_changes<B: BlockT, AS: AuxStore>(
 	backend: &AS,
 ) -> ClientResult<SharedEpochChanges<B, Epoch>> {
 	let maybe_epoch_changes =
 		load_decode::<_, EpochChangesFor<B, Epoch>>(backend, SASSAFRAS_EPOCH_CHANGES_KEY)?;
 
-	let epoch_changes =
-		SharedEpochChanges::<B, Epoch>::new(maybe_epoch_changes.unwrap_or_else(|| {
-			info!(
-				target: "sassafras",
-				"🍁 Creating empty Sassafras epoch changes on what appears to be first startup.",
-			);
-			EpochChangesFor::<B, Epoch>::default()
-		}));
+	let epoch_changes = SharedEpochChanges::<B, Epoch>::new(
+		maybe_epoch_changes.unwrap_or_else(|| EpochChangesFor::<B, Epoch>::default()),
+	);
 
-	// rebalance the tree after deserialization. this isn't strictly necessary
+	// Rebalance the tree after deserialization. this isn't strictly necessary
 	// since the tree is now rebalanced on every update operation. but since the
 	// tree wasn't rebalanced initially it's useful to temporarily leave it here
 	// to avoid having to wait until an import for rebalancing.
 	epoch_changes.shared_data().rebalance();
 
 	Ok(epoch_changes)
 }
+
+/// Write the cumulative chain-weight of a block ot aux storage.
+pub(crate) fn write_block_weight<H: Encode, F, R>(
+	block_hash: H,
+	block_weight: SassafrasBlockWeight,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(Vec<u8>, &[u8])]) -> R,
+{
+	let key = block_weight_key(block_hash);
+	block_weight.using_encoded(|s| write_aux(&[(key, s)]))
+}
+
+/// Load the cumulative chain-weight associated with a block.
+pub(crate) fn load_block_weight<H: Encode, B: AuxStore>(
+	backend: &B,
+	block_hash: H,
+) -> ClientResult<Option<SassafrasBlockWeight>> {
+	load_decode(backend, block_weight_key(block_hash).as_slice())
+}