Merge pull request #710 from radixdlt/feature/round-updates

Feature: Epoch Round Updates

radix-engine-interface/src/api/api.rs

@@ -39,8 +39,9 @@ pub trait InvokableModel<E>:
     Invokable<ParsedScryptoInvocation, E>
     + Invokable<ScryptoInvocation, E>
     + Invokable<EpochManagerCreateInvocation, E>
-    + Invokable<EpochManagerSetEpochInvocation, E>
+    + Invokable<EpochManagerNextRoundInvocation, E>
     + Invokable<EpochManagerGetCurrentEpochInvocation, E>
+    + Invokable<EpochManagerSetEpochInvocation, E>
     + Invokable<ClockCreateInvocation, E>
     + Invokable<ClockSetCurrentTimeInvocation, E>
     + Invokable<ClockGetCurrentTimeInvocation, E>

radix-engine-interface/src/api/types/actor.rs

@@ -256,6 +256,7 @@ pub enum PackageMethod {
 #[strum(serialize_all = "snake_case")]
 pub enum EpochManagerMethod {
     GetCurrentEpoch,
+    NextRound,
     SetEpoch,
 }
 

radix-engine-interface/src/crypto/ecdsa_secp256k1.rs

@@ -12,7 +12,7 @@ use crate::scrypto_type;
 
 /// Represents an ECDSA public key.
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct EcdsaSecp256k1PublicKey(
     #[cfg_attr(feature = "serde", serde(with = "hex::serde"))] pub [u8; Self::LENGTH],
 );

radix-engine-interface/src/model/epoch_manager/invocations.rs

@@ -1,6 +1,6 @@
 use radix_engine_interface::crypto::EcdsaSecp256k1PublicKey;
+use sbor::rust::collections::HashSet;
 use sbor::rust::fmt::Debug;
-use sbor::rust::vec::Vec;
 use sbor::*;
 
 use crate::api::api::*;
@@ -11,7 +11,9 @@ use crate::wasm::*;
 #[derive(Debug, Clone, Eq, PartialEq)]
 #[scrypto(TypeId, Encode, Decode)]
 pub struct EpochManagerCreateInvocation {
-    pub validator_set: Vec<EcdsaSecp256k1PublicKey>,
+    pub validator_set: HashSet<EcdsaSecp256k1PublicKey>,
+    pub initial_epoch: u64,
+    pub rounds_per_epoch: u64,
 }
 
 impl Invocation for EpochManagerCreateInvocation {
@@ -68,3 +70,24 @@ impl Into<SerializedInvocation> for EpochManagerSetEpochInvocation {
         NativeInvocation::EpochManager(EpochManagerInvocation::SetEpoch(self)).into()
     }
 }
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+#[scrypto(TypeId, Encode, Decode)]
+pub struct EpochManagerNextRoundInvocation {
+    pub receiver: SystemAddress,
+    pub round: u64,
+}
+
+impl Invocation for EpochManagerNextRoundInvocation {
+    type Output = ();
+}
+
+impl SerializableInvocation for EpochManagerNextRoundInvocation {
+    type ScryptoOutput = ();
+}
+
+impl Into<SerializedInvocation> for EpochManagerNextRoundInvocation {
+    fn into(self) -> SerializedInvocation {
+        NativeInvocation::EpochManager(EpochManagerInvocation::NextRound(self)).into()
+    }
+}

radix-engine-interface/src/model/serialize.rs

@@ -98,6 +98,7 @@ pub enum EpochManagerInvocation {
     Create(EpochManagerCreateInvocation),
     GetCurrentEpoch(EpochManagerGetCurrentEpochInvocation),
     SetEpoch(EpochManagerSetEpochInvocation),
+    NextRound(EpochManagerNextRoundInvocation),
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -340,6 +341,9 @@ impl NativeInvocation {
                 EpochManagerInvocation::GetCurrentEpoch(invocation) => {
                     refs.insert(RENodeId::Global(GlobalAddress::System(invocation.receiver)));
                 }
+                EpochManagerInvocation::NextRound(invocation) => {
+                    refs.insert(RENodeId::Global(GlobalAddress::System(invocation.receiver)));
+                }
                 EpochManagerInvocation::SetEpoch(invocation) => {
                     refs.insert(RENodeId::Global(GlobalAddress::System(invocation.receiver)));
                 }

radix-engine-stores/src/memory_db.rs

@@ -1,10 +1,8 @@
-use radix_engine::engine::ScryptoInterpreter;
 use radix_engine::ledger::{
-    bootstrap, OutputValue, QueryableSubstateStore, ReadableSubstateStore, WriteableSubstateStore,
+    OutputValue, QueryableSubstateStore, ReadableSubstateStore, WriteableSubstateStore,
 };
 use radix_engine::model::PersistedSubstate;
 use radix_engine::types::*;
-use radix_engine::wasm::WasmEngine;
 use radix_engine_interface::api::types::RENodeId;
 
 /// A substate store that stores all typed substates in host memory.
@@ -19,12 +17,6 @@ impl SerializedInMemorySubstateStore {
             substates: HashMap::new(),
         }
     }
-
-    pub fn with_bootstrap<W: WasmEngine>(scrypto_interpreter: &ScryptoInterpreter<W>) -> Self {
-        let mut substate_store = Self::new();
-        bootstrap(&mut substate_store, scrypto_interpreter);
-        substate_store
-    }
 }
 
 impl Default for SerializedInMemorySubstateStore {

radix-engine/src/engine/track.rs

@@ -583,7 +583,7 @@ impl<'s> FinalizingTrack<'s> {
         // Commit/rollback application state changes
         let mut to_persist = HashMap::new();
         let mut application_logs = Vec::new();
-        let mut next_validator_set = None;
+        let mut next_epoch = None;
         let new_global_addresses = if is_success {
             for (id, loaded) in self.loaded_substates {
                 let old_version = match &loaded.metastate {
@@ -604,9 +604,10 @@ impl<'s> FinalizingTrack<'s> {
                                 state: ExistingMetaState::Updated(..),
                                 ..
                             } => {
-                                let validator_set =
-                                    loaded.substate.validator_set().validator_set.clone();
-                                next_validator_set = Some(validator_set);
+                                let validator_set = loaded.substate.validator_set();
+                                let epoch = validator_set.epoch;
+                                let validator_set = validator_set.validator_set.clone();
+                                next_epoch = Some((validator_set, epoch));
                             }
                             _ => {}
                         }
@@ -748,7 +749,7 @@ impl<'s> FinalizingTrack<'s> {
             entity_changes: EntityChanges::new(new_global_addresses),
             resource_changes: execution_trace_receipt.resource_changes,
             application_logs,
-            next_validator_set,
+            next_epoch,
         })
     }
 

radix-engine/src/fee/fee_table.rs

@@ -148,6 +148,7 @@ impl FeeTable {
             }
             NativeMethod::EpochManager(epoch_manager_method) => match epoch_manager_method {
                 EpochManagerMethod::GetCurrentEpoch => self.fixed_low,
+                EpochManagerMethod::NextRound => self.fixed_low,
                 EpochManagerMethod::SetEpoch => self.fixed_low,
             },
             NativeMethod::Clock(clock_method) => match clock_method {

radix-engine/src/ledger/bootstrap.rs

@@ -35,7 +35,11 @@ pub struct GenesisReceipt {
     pub eddsa_ed25519_token: ResourceAddress,
 }
 
-pub fn create_genesis(validator_set: Vec<EcdsaSecp256k1PublicKey>) -> SystemTransaction {
+pub fn create_genesis(
+    validator_set: HashSet<EcdsaSecp256k1PublicKey>,
+    initial_epoch: u64,
+    rounds_per_epoch: u64,
+) -> SystemTransaction {
     let mut blobs = Vec::new();
     let mut id_allocator = ManifestIdAllocator::new();
     let create_faucet_package = {
@@ -144,7 +148,11 @@ pub fn create_genesis(validator_set: Vec<EcdsaSecp256k1PublicKey>) -> SystemTran
     };
 
     let create_epoch_manager = NativeInvocation::EpochManager(EpochManagerInvocation::Create(
-        EpochManagerCreateInvocation { validator_set },
+        EpochManagerCreateInvocation {
+            validator_set,
+            initial_epoch,
+            rounds_per_epoch,
+        },
     ));
 
     let create_clock = NativeInvocation::Clock(ClockInvocation::Create(ClockCreateInvocation {}));
@@ -217,13 +225,21 @@ where
     S: ReadableSubstateStore + WriteableSubstateStore,
     W: WasmEngine,
 {
-    bootstrap_with_validator_set(substate_store, scrypto_interpreter, Vec::new())
+    bootstrap_with_validator_set(
+        substate_store,
+        scrypto_interpreter,
+        HashSet::new(),
+        1u64,
+        1u64,
+    )
 }
 
 pub fn bootstrap_with_validator_set<S, W>(
     substate_store: &mut S,
     scrypto_interpreter: &ScryptoInterpreter<W>,
-    validator_set: Vec<EcdsaSecp256k1PublicKey>,
+    validator_set: HashSet<EcdsaSecp256k1PublicKey>,
+    initial_epoch: u64,
+    rounds_per_epoch: u64,
 ) -> Option<TransactionReceipt>
 where
     S: ReadableSubstateStore + WriteableSubstateStore,
@@ -236,7 +252,7 @@ where
         ))
         .is_none()
     {
-        let genesis_transaction = create_genesis(validator_set);
+        let genesis_transaction = create_genesis(validator_set, initial_epoch, rounds_per_epoch);
 
         let transaction_receipt = execute_transaction(
             substate_store,
@@ -266,8 +282,9 @@ mod tests {
     fn bootstrap_receipt_should_match_constants() {
         let scrypto_interpreter = ScryptoInterpreter::<DefaultWasmEngine>::default();
         let substate_store = TypedInMemorySubstateStore::new();
-        let initial_validator_set = vec![EcdsaSecp256k1PublicKey([0; 33])];
-        let genesis_transaction = create_genesis(initial_validator_set.clone());
+        let mut initial_validator_set = HashSet::new();
+        initial_validator_set.insert(EcdsaSecp256k1PublicKey([0; 33]));
+        let genesis_transaction = create_genesis(initial_validator_set.clone(), 1u64, 1u64);
 
         let transaction_receipt = execute_transaction(
             &substate_store,
@@ -282,10 +299,10 @@ mod tests {
         let validator_set = transaction_receipt
             .result
             .expect_commit()
-            .next_validator_set
+            .next_epoch
             .as_ref()
             .expect("Should contain validator set");
-        assert_eq!(validator_set, &initial_validator_set);
+        assert_eq!(validator_set, &(initial_validator_set, 1u64));
 
         let genesis_receipt = genesis_result(&transaction_receipt);