Fetch Permissioned Stake Table from L1

contracts/rust/adapter/Cargo.toml

@@ -27,6 +27,9 @@ num-bigint = { version = "0.4", default-features = false }
 num-traits = { version = "0.2", default-features = false }
 serde = { workspace = true }
 
+[dev-dependencies]
+rand = { workspace = true }
+
 [[bin]]
 name = "eval-domain"
 path = "src/bin/eval_domain.rs"

contracts/rust/adapter/src/stake_table.rs

@@ -7,14 +7,21 @@ use ark_ec::{
 use ark_ed_on_bn254::EdwardsConfig;
 use ark_ff::{BigInteger, PrimeField};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use ark_std::rand::{Rng, RngCore};
 use contract_bindings::permissioned_stake_table::{self, EdOnBN254Point, NodeInfo};
 use diff_test_bn254::ParsedG2Point;
 use ethers::{
     abi::AbiDecode,
     prelude::{AbiError, EthAbiCodec, EthAbiType},
     types::U256,
 };
-use hotshot_types::{light_client::StateVerKey, network::PeerConfigKeys, signature_key::BLSPubKey};
+use hotshot_types::{
+    light_client::{StateKeyPair, StateVerKey},
+    network::PeerConfigKeys,
+    signature_key::BLSPubKey,
+    stake_table::StakeTableEntry,
+    traits::signature_key::SignatureKey as _,
+};
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
@@ -113,6 +120,21 @@ pub struct NodeInfoJf {
     pub da: bool,
 }
 
+impl NodeInfoJf {
+    pub fn random(rng: &mut impl RngCore) -> Self {
+        let mut seed = [0u8; 32];
+        rng.fill_bytes(&mut seed);
+
+        let (stake_table_key, _) = BLSPubKey::generated_from_seed_indexed(seed, 0);
+        let state_key_pair = StateKeyPair::generate_from_seed_indexed(seed, 0);
+        Self {
+            stake_table_key,
+            state_ver_key: state_key_pair.ver_key(),
+            da: rng.gen(),
+        }
+    }
+}
+
 impl From<NodeInfoJf> for NodeInfo {
     fn from(value: NodeInfoJf) -> Self {
         let NodeInfoJf {
@@ -135,6 +157,15 @@ impl From<NodeInfoJf> for NodeInfo {
     }
 }
 
+impl From<NodeInfoJf> for StakeTableEntry<BLSPubKey> {
+    fn from(value: NodeInfoJf) -> Self {
+        StakeTableEntry {
+            stake_key: value.stake_table_key,
+            stake_amount: U256::from(1), // dummy stake amount
+        }
+    }
+}
+
 impl From<NodeInfo> for NodeInfoJf {
     fn from(value: NodeInfo) -> Self {
         let NodeInfo {
@@ -193,27 +224,10 @@ impl From<PeerConfigKeys<BLSPubKey>> for NodeInfoJf {
 #[cfg(test)]
 mod test {
     use super::*;
-    use ark_std::rand::{Rng, RngCore};
-    use hotshot_types::{light_client::StateKeyPair, traits::signature_key::BuilderSignatureKey};
-
-    impl NodeInfoJf {
-        fn random(rng: &mut impl RngCore) -> Self {
-            let mut seed = [0u8; 32];
-            rng.fill_bytes(&mut seed);
-
-            let (stake_table_key, _) = BLSPubKey::generated_from_seed_indexed(seed, 0);
-            let state_key_pair = StateKeyPair::generate_from_seed_indexed(seed, 0);
-            Self {
-                stake_table_key,
-                state_ver_key: state_key_pair.ver_key(),
-                da: rng.gen(),
-            }
-        }
-    }
 
     #[test]
     fn test_node_info_round_trip() {
-        let mut rng = ark_std::rand::thread_rng();
+        let mut rng = rand::thread_rng();
         for _ in 0..20 {
             let jf = NodeInfoJf::random(&mut rng);
             let sol: NodeInfo = jf.clone().into();

data/v99/chain_config.json

@@ -4,5 +4,6 @@
   "chain_id": "35353",
   "fee_contract": "0x0000000000000000000000000000000000000000",
   "fee_recipient": "0x0000000000000000000000000000000000000000",
-  "max_block_size": "10240"
+  "max_block_size": "10240",
+  "stake_table_contract": "0x0000000000000000000000000000000000000000"
 }

data/v99/header.json

@@ -22,7 +22,8 @@
           "chain_id": "35353",
           "fee_contract": "0x0000000000000000000000000000000000000000",
           "fee_recipient": "0x0000000000000000000000000000000000000000",
-          "max_block_size": "10240"
+          "max_block_size": "10240",
+          "stake_table_contract": "0x0000000000000000000000000000000000000000"
         }
       }
     },

sequencer/src/api.rs

@@ -1,5 +1,3 @@
-use std::pin::Pin;
-
 use anyhow::{bail, Context};
 use async_lock::RwLock;
 use async_once_cell::Lazy;
@@ -9,8 +7,8 @@ use data_source::{CatchupDataSource, StakeTableDataSource, SubmitDataSource};
 use derivative::Derivative;
 use espresso_types::{
     retain_accounts, v0::traits::SequencerPersistence, v0_99::ChainConfig, AccountQueryData,
-    BlockMerkleTree, FeeAccount, FeeAccountProof, FeeMerkleTree, NodeState, PubKey, Transaction,
-    ValidatedState,
+    BlockMerkleTree, FeeAccount, FeeAccountProof, FeeMerkleTree, NodeState, PubKey,
+    StaticCommittee, Transaction, ValidatedState,
 };
 use futures::{
     future::{BoxFuture, Future, FutureExt},
@@ -34,6 +32,7 @@ use hotshot_types::{
 };
 use hotshot_types::{stake_table::StakeTableEntry, traits::election::Membership};
 use jf_merkle_tree::MerkleTreeScheme;
+use std::pin::Pin;
 use std::sync::Arc;
 
 use self::data_source::{
@@ -188,12 +187,10 @@ impl<N: ConnectedNetwork<PubKey>, V: Versions, P: SequencerPersistence>
             self.consensus().await.read().await.cur_epoch().await
         };
 
-        self.consensus()
-            .await
-            .read()
-            .await
-            .memberships
-            .stake_table(epoch)
+        <StaticCommittee as Membership<SeqTypes>>::stake_table(
+            &self.consensus().await.read().await.memberships,
+            epoch,
+        )
     }
 }
 

sequencer/src/context.rs

@@ -1,25 +1,19 @@
-use std::{fmt::Display, sync::Arc};
-
 use anyhow::Context;
 use async_lock::RwLock;
 use derivative::Derivative;
 use espresso_types::{
     v0::traits::{EventConsumer as PersistenceEventConsumer, SequencerPersistence},
-    NodeState, PubKey, Transaction, ValidatedState,
+    NodeState, PubKey, StaticCommittee, Transaction, ValidatedState,
 };
 use futures::{
     future::{join_all, Future},
     stream::{Stream, StreamExt},
 };
 use hotshot::{
-    traits::election::static_committee::StaticCommittee,
     types::{Event, EventType, SystemContextHandle},
     MarketplaceConfig, SystemContext,
 };
 use hotshot_events_service::events_source::{EventConsumer, EventsStreamer};
-use parking_lot::Mutex;
-use tokio::{spawn, task::JoinHandle};
-
 use hotshot_orchestrator::client::OrchestratorClient;
 use hotshot_types::{
     consensus::ConsensusMetricsValue,
@@ -32,7 +26,10 @@ use hotshot_types::{
     },
     PeerConfig, ValidatorConfig,
 };
+use parking_lot::Mutex;
 use std::fmt::Debug;
+use std::{fmt::Display, sync::Arc};
+use tokio::{spawn, task::JoinHandle};
 use tracing::{Instrument, Level};
 use url::Url;
 
@@ -83,7 +80,7 @@ impl<N: ConnectedNetwork<PubKey>, P: SequencerPersistence, V: Versions> Sequence
     pub async fn init(
         network_config: NetworkConfig<PubKey>,
         validator_config: ValidatorConfig<<SeqTypes as NodeType>::SignatureKey>,
-        membership: StaticCommittee<SeqTypes>,
+        membership: StaticCommittee,
         instance_state: NodeState,
         persistence: P,
         network: Arc<N>,

sequencer/src/genesis.rs

@@ -417,7 +417,8 @@ mod test {
                 base_fee: 1.into(),
                 fee_recipient: FeeAccount::default(),
                 fee_contract: Some(Address::default()),
-                bid_recipient: None
+                bid_recipient: None,
+                stake_table_contract: Some(Address::default())
             }
         );
         assert_eq!(
@@ -489,6 +490,7 @@ mod test {
                 fee_recipient: FeeAccount::default(),
                 bid_recipient: None,
                 fee_contract: None,
+                stake_table_contract: None,
             }
         );
         assert_eq!(

sequencer/src/lib.rs

@@ -15,12 +15,12 @@ mod message_compat_tests;
 use anyhow::Context;
 use catchup::StatePeers;
 use context::SequencerContext;
+use espresso_types::StaticCommittee;
 use espresso_types::{
     traits::EventConsumer, BackoffParams, L1ClientOptions, NodeState, PubKey, SeqTypes,
     SolverAuctionResultsProvider, ValidatedState,
 };
 use genesis::L1Finalized;
-use hotshot::traits::election::static_committee::StaticCommittee;
 use hotshot_types::traits::election::Membership;
 use proposal_fetcher::ProposalFetcherConfig;
 use std::sync::Arc;
@@ -391,12 +391,6 @@ pub async fn init_node<P: SequencerPersistence, V: Versions>(
         topics
     };
 
-    // Create the HotShot membership
-    let membership = StaticCommittee::new(
-        network_config.config.known_nodes_with_stake.clone(),
-        network_config.config.known_nodes_with_stake.clone(),
-    );
-
     // Initialize the push CDN network (and perform the initial connection)
     let cdn_network = PushCdnNetwork::new(
         network_params.cdn_endpoint,
@@ -439,6 +433,59 @@ pub async fn init_node<P: SequencerPersistence, V: Versions>(
         response_size_maximum: network_params.libp2p_max_direct_transmit_size,
     };
 
+    let l1_client = l1_params
+        .options
+        .with_metrics(metrics)
+        .connect(l1_params.url)
+        .await?;
+    l1_client.spawn_tasks().await;
+    let l1_genesis = match genesis.l1_finalized {
+        L1Finalized::Block(b) => b,
+        L1Finalized::Number { number } => l1_client.wait_for_finalized_block(number).await,
+        L1Finalized::Timestamp { timestamp } => {
+            l1_client
+                .wait_for_finalized_block_with_timestamp(timestamp.unix_timestamp().into())
+                .await
+        }
+    };
+
+    let mut genesis_state = ValidatedState {
+        chain_config: genesis.chain_config.into(),
+        ..Default::default()
+    };
+    for (address, amount) in genesis.accounts {
+        tracing::info!(%address, %amount, "Prefunding account for demo");
+        genesis_state.prefund_account(address, amount);
+    }
+
+    let instance_state = NodeState {
+        chain_config: genesis.chain_config,
+        l1_client,
+        genesis_header: genesis.header,
+        genesis_state,
+        l1_genesis: Some(l1_genesis),
+        peers: catchup::local_and_remote(
+            persistence.clone(),
+            StatePeers::<SequencerApiVersion>::from_urls(
+                network_params.state_peers,
+                network_params.catchup_backoff,
+                metrics,
+            ),
+        )
+        .await,
+        node_id: node_index,
+        upgrades: genesis.upgrades,
+        current_version: V::Base::VERSION,
+    };
+
+    // Create the HotShot membership
+    let membership = StaticCommittee::new_stake(
+        network_config.config.known_nodes_with_stake.clone(),
+        network_config.config.known_nodes_with_stake.clone(),
+        &instance_state,
+        Default::default(),
+    );
+
     // Initialize the Libp2p network
     let network = {
         let p2p_network = Libp2pNetwork::from_config(
@@ -479,50 +526,6 @@ pub async fn init_node<P: SequencerPersistence, V: Versions>(
         ))
     };
 
-    let mut genesis_state = ValidatedState {
-        chain_config: genesis.chain_config.into(),
-        ..Default::default()
-    };
-    for (address, amount) in genesis.accounts {
-        tracing::info!(%address, %amount, "Prefunding account for demo");
-        genesis_state.prefund_account(address, amount);
-    }
-
-    let l1_client = l1_params
-        .options
-        .with_metrics(metrics)
-        .connect(l1_params.url)
-        .await?;
-    l1_client.spawn_tasks().await;
-    let l1_genesis = match genesis.l1_finalized {
-        L1Finalized::Block(b) => b,
-        L1Finalized::Number { number } => l1_client.wait_for_finalized_block(number).await,
-        L1Finalized::Timestamp { timestamp } => {
-            l1_client
-                .wait_for_finalized_block_with_timestamp(timestamp.unix_timestamp().into())
-                .await
-        }
-    };
-    let instance_state = NodeState {
-        chain_config: genesis.chain_config,
-        l1_client,
-        genesis_header: genesis.header,
-        genesis_state,
-        l1_genesis: Some(l1_genesis),
-        peers: catchup::local_and_remote(
-            persistence.clone(),
-            StatePeers::<SequencerApiVersion>::from_urls(
-                network_params.state_peers,
-                network_params.catchup_backoff,
-                metrics,
-            ),
-        )
-        .await,
-        node_id: node_index,
-        upgrades: genesis.upgrades,
-        current_version: V::Base::VERSION,
-    };
-
     let mut ctx = SequencerContext::init(
         network_config,
         validator_config,

sequencer/src/message_compat_tests.rs

@@ -18,7 +18,6 @@ use std::path::Path;
 
 use committable::Committable;
 use espresso_types::{NodeState, PubKey, ValidatedState};
-use hotshot::traits::election::static_committee::StaticCommittee;
 use hotshot_types::{
     data::{
         DaProposal, EpochNumber, QuorumProposal, UpgradeProposal, VidDisperse, VidDisperseShare,
@@ -53,7 +52,7 @@ use vbs::{
 
 #[cfg(feature = "testing")]
 async fn test_message_compat<Ver: StaticVersionType>(_ver: Ver) {
-    use espresso_types::{Leaf, Payload, SeqTypes, Transaction};
+    use espresso_types::{Leaf, Payload, SeqTypes, StaticCommittee, Transaction};
     use hotshot_example_types::node_types::TestVersions;
     use hotshot_types::PeerConfig;