Lr/variable stake table

crates/example-types/src/node_types.rs

@@ -52,6 +52,8 @@ use crate::{
 /// to select our traits
 pub struct TestTypes;
 impl NodeType for TestTypes {
+    const EPOCH_HEIGHT: u64 = 10;
+
     type AuctionResult = TestAuctionResult;
     type View = ViewNumber;
     type Epoch = EpochNumber;
@@ -82,6 +84,8 @@ impl NodeType for TestTypes {
 /// to select our traits
 pub struct TestTypesRandomizedLeader;
 impl NodeType for TestTypesRandomizedLeader {
+    const EPOCH_HEIGHT: u64 = 10;
+
     type AuctionResult = TestAuctionResult;
     type View = ViewNumber;
     type Epoch = EpochNumber;
@@ -115,6 +119,8 @@ pub struct TestTypesRandomizedCommitteeMembers<CONFIG: QuorumFilterConfig> {
 }
 
 impl<CONFIG: QuorumFilterConfig> NodeType for TestTypesRandomizedCommitteeMembers<CONFIG> {
+    const EPOCH_HEIGHT: u64 = 10;
+
     type AuctionResult = TestAuctionResult;
     type View = ViewNumber;
     type Epoch = EpochNumber;
@@ -146,6 +152,8 @@ impl<CONFIG: QuorumFilterConfig> NodeType for TestTypesRandomizedCommitteeMember
 /// to select our traits
 pub struct TestConsecutiveLeaderTypes;
 impl NodeType for TestConsecutiveLeaderTypes {
+    const EPOCH_HEIGHT: u64 = 10;
+
     type AuctionResult = TestAuctionResult;
     type View = ViewNumber;
     type Epoch = EpochNumber;
@@ -176,6 +184,8 @@ impl NodeType for TestConsecutiveLeaderTypes {
 /// to select our traits
 pub struct TestTwoStakeTablesTypes;
 impl NodeType for TestTwoStakeTablesTypes {
+    const EPOCH_HEIGHT: u64 = 10;
+
     type AuctionResult = TestAuctionResult;
     type View = ViewNumber;
     type Epoch = EpochNumber;

crates/example-types/src/storage_types.rs

@@ -16,6 +16,7 @@ use hotshot_types::{
     consensus::CommitmentMap,
     data::{
         DaProposal, DaProposal2, Leaf, Leaf2, QuorumProposal, QuorumProposal2, VidDisperseShare,
+        VidDisperseShare2,
     },
     event::HotShotAction,
     message::Proposal,
@@ -36,9 +37,15 @@ type VidShares<TYPES> = HashMap<
     <TYPES as NodeType>::View,
     HashMap<<TYPES as NodeType>::SignatureKey, Proposal<TYPES, VidDisperseShare<TYPES>>>,
 >;
+type VidShares2<TYPES> = HashMap<
+    <TYPES as NodeType>::View,
+    HashMap<<TYPES as NodeType>::SignatureKey, Proposal<TYPES, VidDisperseShare2<TYPES>>>,
+>;
+
 #[derive(Clone, Debug)]
 pub struct TestStorageState<TYPES: NodeType> {
     vids: VidShares<TYPES>,
+    vid2: VidShares2<TYPES>,
     das: HashMap<TYPES::View, Proposal<TYPES, DaProposal<TYPES>>>,
     da2s: HashMap<TYPES::View, Proposal<TYPES, DaProposal2<TYPES>>>,
     proposals: BTreeMap<TYPES::View, Proposal<TYPES, QuorumProposal<TYPES>>>,
@@ -53,6 +60,7 @@ impl<TYPES: NodeType> Default for TestStorageState<TYPES> {
     fn default() -> Self {
         Self {
             vids: HashMap::new(),
+            vid2: HashMap::new(),
             das: HashMap::new(),
             da2s: HashMap::new(),
             proposals: BTreeMap::new(),
@@ -131,6 +139,23 @@ impl<TYPES: NodeType> Storage<TYPES> for TestStorage<TYPES> {
         Ok(())
     }
 
+    async fn append_vid2(
+        &self,
+        proposal: &Proposal<TYPES, VidDisperseShare2<TYPES>>,
+    ) -> Result<()> {
+        if self.should_return_err {
+            bail!("Failed to append VID proposal to storage");
+        }
+        Self::run_delay_settings_from_config(&self.delay_config).await;
+        let mut inner = self.inner.write().await;
+        inner
+            .vid2
+            .entry(proposal.data.view_number)
+            .or_default()
+            .insert(proposal.data.recipient_key.clone(), proposal.clone());
+        Ok(())
+    }
+
     async fn append_da(
         &self,
         proposal: &Proposal<TYPES, DaProposal<TYPES>>,

crates/task-impls/src/consensus/handlers.rs

@@ -10,7 +10,7 @@ use async_broadcast::Sender;
 use chrono::Utc;
 use hotshot_types::{
     event::{Event, EventType},
-    simple_vote::{QuorumVote2, TimeoutData, TimeoutVote},
+    simple_vote::{QuorumVote2, TimeoutData2, TimeoutVote2},
     traits::{
         election::Membership,
         node_implementation::{ConsensusTime, NodeImplementation, NodeType},
@@ -79,7 +79,7 @@ pub(crate) async fn handle_timeout_vote_recv<
     I: NodeImplementation<TYPES>,
     V: Versions,
 >(
-    vote: &TimeoutVote<TYPES>,
+    vote: &TimeoutVote2<TYPES>,
     event: Arc<HotShotEvent<TYPES>>,
     sender: &Sender<Arc<HotShotEvent<TYPES>>>,
     task_state: &mut ConsensusTaskState<TYPES, I, V>,
@@ -301,8 +301,8 @@ pub(crate) async fn handle_timeout<TYPES: NodeType, I: NodeImplementation<TYPES>
         )
     );
 
-    let vote = TimeoutVote::create_signed_vote(
-        TimeoutData::<TYPES> {
+    let vote = TimeoutVote2::create_signed_vote(
+        TimeoutData2::<TYPES> {
             view: view_number,
             epoch,
         },

crates/task-impls/src/consensus/mod.rs

@@ -14,8 +14,8 @@ use hotshot_types::{
     consensus::OuterConsensus,
     event::Event,
     message::UpgradeLock,
-    simple_certificate::{QuorumCertificate2, TimeoutCertificate},
-    simple_vote::{QuorumVote2, TimeoutVote},
+    simple_certificate::{QuorumCertificate2, TimeoutCertificate2},
+    simple_vote::{QuorumVote2, TimeoutVote2},
     traits::{
         node_implementation::{ConsensusTime, NodeImplementation, NodeType, Versions},
         signature_key::SignatureKey,
@@ -57,7 +57,7 @@ pub struct ConsensusTaskState<TYPES: NodeType, I: NodeImplementation<TYPES>, V:
 
     /// A map of `TimeoutVote` collector tasks.
     pub timeout_vote_collectors:
-        VoteCollectorsMap<TYPES, TimeoutVote<TYPES>, TimeoutCertificate<TYPES>, V>,
+        VoteCollectorsMap<TYPES, TimeoutVote2<TYPES>, TimeoutCertificate2<TYPES>, V>,
 
     /// The view number that this node is currently executing in.
     pub cur_view: TYPES::View,

crates/task-impls/src/da.rs

@@ -15,8 +15,8 @@ use hotshot_types::{
     data::{DaProposal2, PackedBundle},
     event::{Event, EventType},
     message::{Proposal, UpgradeLock},
-    simple_certificate::DaCertificate,
-    simple_vote::{DaData, DaVote, HasEpoch},
+    simple_certificate::DaCertificate2,
+    simple_vote::{DaData2, DaVote2},
     traits::{
         block_contents::vid_commitment,
         election::Membership,
@@ -144,7 +144,7 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
             HotShotEvent::DaProposalValidated(proposal, sender) => {
                 let cur_view = self.consensus.read().await.cur_view();
                 let view_number = proposal.data.view_number();
-                let epoch_number = proposal.data.epoch_number;
+                let epoch_number = proposal.data.epoch;
 
                 ensure!(
                   cur_view <= view_number + 1,
@@ -168,18 +168,16 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                 )
                 .await;
 
-                let proposal_epoch = proposal.data.epoch();
                 ensure!(
-                    self.membership
-                        .has_da_stake(&self.public_key, proposal_epoch),
+                    self.membership.has_da_stake(&self.public_key, epoch_number),
                     debug!(
                         "We were not chosen for consensus committee for view {:?} in epoch {:?}",
                         view_number, epoch_number
                     )
                 );
 
                 let txns = Arc::clone(&proposal.data.encoded_transactions);
-                let num_nodes = self.membership.total_nodes(proposal_epoch);
+                let num_nodes = self.membership.total_nodes(epoch_number);
                 let payload_commitment =
                     spawn_blocking(move || vid_commitment(&txns, num_nodes)).await;
                 let payload_commitment = payload_commitment.unwrap();
@@ -195,7 +193,7 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                 let vote = DaVote2::create_signed_vote(
                     DaData2 {
                         payload_commit: payload_commitment,
-                        epoch: proposal_epoch,
+                        epoch: epoch_number,
                     },
                     view_number,
                     &self.public_key,
@@ -212,7 +210,7 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                 // Ensure this view is in the view map for garbage collection.
 
                 if let Err(e) =
-                    consensus_writer.update_da_view(view_number, proposal_epoch, payload_commitment)
+                    consensus_writer.update_da_view(view_number, epoch_number, payload_commitment)
                 {
                     tracing::trace!("{e:?}");
                 }
@@ -263,7 +261,7 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                 tracing::debug!("DA vote recv, Main Task {:?}", vote.view_number());
                 // Check if we are the leader and the vote is from the sender.
                 let view = vote.view_number();
-                let epoch = vote.data.epoch();
+                let epoch = vote.data.epoch;
 
                 ensure!(
                     self.membership.leader(view, epoch)? == self.public_key,
@@ -322,19 +320,18 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                     TYPES::SignatureKey::sign(&self.private_key, &encoded_transactions_hash)
                         .wrap()?;
 
-                let epoch = self.cur_epoch;
-                if self.membership.leader(view_number, epoch)? != self.public_key {
+                if self.membership.leader(view_number, *epoch_number)? != self.public_key {
                     tracing::debug!(
                         "We are not the leader in the current epoch. Do not send the DA proposal"
                     );
                     return Ok(());
                 }
-                let data: DaProposal<TYPES> = DaProposal {
+                let data: DaProposal2<TYPES> = DaProposal2 {
                     encoded_transactions: Arc::clone(encoded_transactions),
                     metadata: metadata.clone(),
                     // Upon entering a new view we want to send a DA Proposal for the next view -> Is it always the case that this is cur_view + 1?
                     view_number,
-                    epoch,
+                    epoch: *epoch_number,
                 };
 
                 let message = Proposal {

crates/task-impls/src/events.rs

@@ -12,18 +12,18 @@ use hotshot_task::task::TaskEvent;
 use hotshot_types::{
     data::{
         DaProposal2, Leaf2, PackedBundle, QuorumProposal2, UpgradeProposal, VidDisperse,
-        VidDisperseShare,
+        VidDisperseShare2,
     },
     message::Proposal,
     request_response::ProposalRequestPayload,
     simple_certificate::{
         DaCertificate2, QuorumCertificate, QuorumCertificate2, TimeoutCertificate,
-        UpgradeCertificate, ViewSyncCommitCertificate, ViewSyncFinalizeCertificate,
-        ViewSyncPreCommitCertificate,
+        TimeoutCertificate2, UpgradeCertificate, ViewSyncCommitCertificate2,
+        ViewSyncFinalizeCertificate2, ViewSyncPreCommitCertificate2,
     },
     simple_vote::{
-        DaVote2, QuorumVote2, TimeoutVote, UpgradeVote, ViewSyncCommitVote, ViewSyncFinalizeVote,
-        ViewSyncPreCommitVote,
+        DaVote2, QuorumVote2, TimeoutVote2, UpgradeVote, ViewSyncCommitVote2,
+        ViewSyncFinalizeVote2, ViewSyncPreCommitVote2,
     },
     traits::{
         block_contents::BuilderFee, network::DataRequest, node_implementation::NodeType,
@@ -76,9 +76,9 @@ pub enum HotShotEvent<TYPES: NodeType> {
     /// A quorum vote has been received from the network; handled by the consensus task
     QuorumVoteRecv(QuorumVote2<TYPES>),
     /// A timeout vote received from the network; handled by consensus task
-    TimeoutVoteRecv(TimeoutVote<TYPES>),
+    TimeoutVoteRecv(TimeoutVote2<TYPES>),
     /// Send a timeout vote to the network; emitted by consensus task replicas
-    TimeoutVoteSend(TimeoutVote<TYPES>),
+    TimeoutVoteSend(TimeoutVote2<TYPES>),
     /// A DA proposal has been received from the network; handled by the DA task
     DaProposalRecv(Proposal<TYPES, DaProposal2<TYPES>>, TYPES::SignatureKey),
     /// A DA proposal has been validated; handled by the DA task and VID task
@@ -123,7 +123,7 @@ pub enum HotShotEvent<TYPES: NodeType> {
     /// The next leader has collected enough votes to form a QC; emitted by the next leader in the consensus task; an internal event only
     QcFormed(Either<QuorumCertificate<TYPES>, TimeoutCertificate<TYPES>>),
     /// The next leader has collected enough votes to form a QC; emitted by the next leader in the consensus task; an internal event only
-    Qc2Formed(Either<QuorumCertificate2<TYPES>, TimeoutCertificate<TYPES>>),
+    Qc2Formed(Either<QuorumCertificate2<TYPES>, TimeoutCertificate2<TYPES>>),
     /// The DA leader has collected enough votes to form a DAC; emitted by the DA leader in the DA task; sent to the entire network via the networking task
     DacSend(DaCertificate2<TYPES>, TYPES::SignatureKey),
     /// The current view has changed; emitted by the replica in the consensus task or replica in the view sync task; received by almost all other tasks
@@ -132,32 +132,32 @@ pub enum HotShotEvent<TYPES: NodeType> {
     ViewSyncTimeout(TYPES::View, u64, ViewSyncPhase),
 
     /// Receive a `ViewSyncPreCommitVote` from the network; received by a relay in the view sync task
-    ViewSyncPreCommitVoteRecv(ViewSyncPreCommitVote<TYPES>),
+    ViewSyncPreCommitVoteRecv(ViewSyncPreCommitVote2<TYPES>),
     /// Receive a `ViewSyncCommitVote` from the network; received by a relay in the view sync task
-    ViewSyncCommitVoteRecv(ViewSyncCommitVote<TYPES>),
+    ViewSyncCommitVoteRecv(ViewSyncCommitVote2<TYPES>),
     /// Receive a `ViewSyncFinalizeVote` from the network; received by a relay in the view sync task
-    ViewSyncFinalizeVoteRecv(ViewSyncFinalizeVote<TYPES>),
+    ViewSyncFinalizeVoteRecv(ViewSyncFinalizeVote2<TYPES>),
 
     /// Send a `ViewSyncPreCommitVote` from the network; emitted by a replica in the view sync task
-    ViewSyncPreCommitVoteSend(ViewSyncPreCommitVote<TYPES>),
+    ViewSyncPreCommitVoteSend(ViewSyncPreCommitVote2<TYPES>),
     /// Send a `ViewSyncCommitVote` from the network; emitted by a replica in the view sync task
-    ViewSyncCommitVoteSend(ViewSyncCommitVote<TYPES>),
+    ViewSyncCommitVoteSend(ViewSyncCommitVote2<TYPES>),
     /// Send a `ViewSyncFinalizeVote` from the network; emitted by a replica in the view sync task
-    ViewSyncFinalizeVoteSend(ViewSyncFinalizeVote<TYPES>),
+    ViewSyncFinalizeVoteSend(ViewSyncFinalizeVote2<TYPES>),
 
     /// Receive a `ViewSyncPreCommitCertificate` from the network; received by a replica in the view sync task
-    ViewSyncPreCommitCertificateRecv(ViewSyncPreCommitCertificate<TYPES>),
+    ViewSyncPreCommitCertificateRecv(ViewSyncPreCommitCertificate2<TYPES>),
     /// Receive a `ViewSyncCommitCertificate` from the network; received by a replica in the view sync task
-    ViewSyncCommitCertificateRecv(ViewSyncCommitCertificate<TYPES>),
+    ViewSyncCommitCertificateRecv(ViewSyncCommitCertificate2<TYPES>),
     /// Receive a `ViewSyncFinalizeCertificate` from the network; received by a replica in the view sync task
-    ViewSyncFinalizeCertificateRecv(ViewSyncFinalizeCertificate<TYPES>),
+    ViewSyncFinalizeCertificateRecv(ViewSyncFinalizeCertificate2<TYPES>),
 
     /// Send a `ViewSyncPreCommitCertificate` from the network; emitted by a relay in the view sync task
-    ViewSyncPreCommitCertificateSend(ViewSyncPreCommitCertificate<TYPES>, TYPES::SignatureKey),
+    ViewSyncPreCommitCertificateSend(ViewSyncPreCommitCertificate2<TYPES>, TYPES::SignatureKey),
     /// Send a `ViewSyncCommitCertificate` from the network; emitted by a relay in the view sync task
-    ViewSyncCommitCertificateSend(ViewSyncCommitCertificate<TYPES>, TYPES::SignatureKey),
+    ViewSyncCommitCertificateSend(ViewSyncCommitCertificate2<TYPES>, TYPES::SignatureKey),
     /// Send a `ViewSyncFinalizeCertificate` from the network; emitted by a relay in the view sync task
-    ViewSyncFinalizeCertificateSend(ViewSyncFinalizeCertificate<TYPES>, TYPES::SignatureKey),
+    ViewSyncFinalizeCertificateSend(ViewSyncFinalizeCertificate2<TYPES>, TYPES::SignatureKey),
 
     /// Trigger the start of the view sync protocol; emitted by view sync task; internal trigger only
     ViewSyncTrigger(TYPES::View),
@@ -187,10 +187,10 @@ pub enum HotShotEvent<TYPES: NodeType> {
     /// Like [`HotShotEvent::DaProposalRecv`].
     VidShareRecv(
         TYPES::SignatureKey,
-        Proposal<TYPES, VidDisperseShare<TYPES>>,
+        Proposal<TYPES, VidDisperseShare2<TYPES>>,
     ),
     /// VID share data is validated.
-    VidShareValidated(Proposal<TYPES, VidDisperseShare<TYPES>>),
+    VidShareValidated(Proposal<TYPES, VidDisperseShare2<TYPES>>),
     /// Upgrade proposal has been received from the network
     UpgradeProposalRecv(Proposal<TYPES, UpgradeProposal<TYPES>>, TYPES::SignatureKey),
     /// Upgrade proposal has been sent to the network
@@ -229,13 +229,13 @@ pub enum HotShotEvent<TYPES: NodeType> {
         TYPES::SignatureKey,
         /// Recipient key
         TYPES::SignatureKey,
-        Proposal<TYPES, VidDisperseShare<TYPES>>,
+        Proposal<TYPES, VidDisperseShare2<TYPES>>,
     ),
 
     /// Receive a VID response from the network; received by the node that triggered the VID request.
     VidResponseRecv(
         TYPES::SignatureKey,
-        Proposal<TYPES, VidDisperseShare<TYPES>>,
+        Proposal<TYPES, VidDisperseShare2<TYPES>>,
     ),
 
     /// A replica send us a High QC