Stake Table Integration test

.github/workflows/test.yml

@@ -182,11 +182,14 @@ jobs:
     needs: [build-test-bins, build-test-artifacts-postgres]
     strategy:
       matrix:
-        version: [02,99]
+        version: [02,03,99]
         include:
           - version: 02
             compose: "-f process-compose.yaml -D"
-
+          - version: 03
+            env:
+              DEMO_GENESIS_FILE: data/genesis/demo-pos.toml 
+            compose: "-f process-compose.yaml -D"
           - version: 99
             compose: "-f process-compose.yaml -f process-compose-mp.yml -D"
     runs-on: ubuntu-latest

client/Cargo.toml

@@ -15,3 +15,4 @@ surf-disco = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 vbs = { workspace = true }
+hotshot-types = { workspace = true }

client/src/lib.rs

@@ -1,7 +1,8 @@
 use anyhow::Context;
-use espresso_types::{FeeAccount, FeeAmount, FeeMerkleTree, Header};
+use espresso_types::{FeeAccount, FeeAmount, FeeMerkleTree, Header, PubKey};
 use ethers::types::Address;
 use futures::{stream::BoxStream, StreamExt};
+use hotshot_types::stake_table::StakeTableEntry;
 use jf_merkle_tree::{
     prelude::{MerkleProof, Sha3Node},
     MerkleTreeScheme,
@@ -119,6 +120,22 @@ impl SequencerClient {
         let balance = proof.elem().copied().unwrap_or(0.into());
         Ok(balance)
     }
+
+    pub async fn current_epoch(&self) -> anyhow::Result<u64> {
+        self.0
+            .get::<u64>("node/current_epoch")
+            .send()
+            .await
+            .context("getting epoch value")
+    }
+
+    pub async fn stake_table(&self, epoch: u64) -> anyhow::Result<Vec<StakeTableEntry<PubKey>>> {
+        self.0
+            .get::<_>(&format!("node/stake-table/{epoch}"))
+            .send()
+            .await
+            .context("getting epoch value")
+    }
 }
 
 #[cfg(test)]

data/genesis/demo-pos-base.toml

@@ -0,0 +1,21 @@
+base_version = "0.3"
+upgrade_version = "0.0"
+
+[stake_table]
+capacity = 10
+
+[chain_config]
+chain_id = 999999999
+max_block_size = '1mb'
+base_fee = '1 wei'
+fee_recipient = "0x0000000000000000000000000000000000000000"
+bid_recipient = "0x0000000000000000000000000000000000000000"
+fee_contract = "0xa15bb66138824a1c7167f5e85b957d04dd34e468"
+stake_table_contract = "0x8ce361602b935680e8dec218b820ff5056beb7af"
+
+[header]
+timestamp = "1970-01-01T00:00:00Z"
+
+[l1_finalized]
+number = 0
+

data/genesis/demo-epoch.toml → data/genesis/demo-pos.toml

@@ -18,7 +18,7 @@ timestamp = "1970-01-01T00:00:00Z"
 number = 0
 
 [[upgrade]]
-version = "0.99"
+version = "0.3"
 start_proposing_view = 10
 stop_proposing_view = 60
 

justfile

@@ -29,6 +29,12 @@ build profile="test":
 demo-native-mp *args: build
     scripts/demo-native -f process-compose.yaml -f process-compose-mp.yml {{args}}
 
+demo-native-pos *args: build
+    DEMO_GENESIS_FILE=data/genesis/demo-pos.toml scripts/demo-native -f process-compose.yaml {{args}}
+
+demo-native-pos-base *args: build
+    DEMO_GENESIS_FILE=data/genesis/demo-pos-base.toml scripts/demo-native -f process-compose.yaml {{args}}
+
 demo-native-benchmark:
     cargo build --release --features benchmarking
     scripts/demo-native
@@ -71,10 +77,15 @@ test-all:
 test-integration:
 	@echo 'NOTE that demo-native must be running for this test to succeed.'
 	INTEGRATION_TEST_SEQUENCER_VERSION=2 cargo nextest run --all-features --nocapture --profile integration smoke
+
 test-integration-mp:
     @echo 'NOTE that demo-native-mp must be running for this test to succeed.'
     INTEGRATION_TEST_SEQUENCER_VERSION=99 cargo nextest run --all-features --nocapture --profile integration
 
+test-integration-pos:
+    @echo 'NOTE that demo-native-pos must be running for this test to succeed.'
+    INTEGRATION_TEST_SEQUENCER_VERSION=3 cargo nextest run --all-features --nocapture --profile integration smoke
+
 clippy:
     @echo 'features: "embedded-db"'
     cargo clippy --workspace --features embedded-db --all-targets -- -D warnings

process-compose.yaml

@@ -5,8 +5,8 @@ environment:
   - ESPRESSO_SEQUENCER_ORCHESTRATOR_URL=http://localhost:$ESPRESSO_ORCHESTRATOR_PORT
   - ESPRESSO_SEQUENCER_URL=http://localhost:$ESPRESSO_SEQUENCER_API_PORT
   - ESPRESSO_SEQUENCER_L1_PROVIDER=http://localhost:$ESPRESSO_SEQUENCER_L1_PORT
-  - ESPRESSO_SEQUENCER_GENESIS_FILE=data/genesis/demo.toml
-  - ESPRESSO_BUILDER_GENESIS_FILE=data/genesis/demo.toml
+  - ESPRESSO_SEQUENCER_GENESIS_FILE=$DEMO_GENESIS_FILE
+  - ESPRESSO_BUILDER_GENESIS_FILE=$DEMO_GENESIS_FILE
   - ESPRESSO_SEQUENCER_INITIAL_PERMISSIONED_STAKE_TABLE_PATH=data/initial_stake_table.toml
   - ESPRESSO_STATE_RELAY_SERVER_URL=http://localhost:$ESPRESSO_STATE_RELAY_SERVER_PORT
   - QUERY_SERVICE_URI=http://localhost:$ESPRESSO_SEQUENCER1_API_PORT/v0/

sequencer/api/node.toml

@@ -6,3 +6,7 @@ DOC = "Get the stake table for the current epoch"
 PATH = ["stake-table/:epoch_number"]
 ":epoch_number" = "Integer"
 DOC = "Get the stake table for the given epoch"
+
+[route.current_epoch]
+PATH = ["current_epoch"]
+DOC = "Get the current epoch"

sequencer/src/run.rs

@@ -9,7 +9,7 @@ use super::{
 };
 use clap::Parser;
 use espresso_types::{
-    traits::NullEventConsumer, FeeVersion, MarketplaceVersion, SequencerVersions,
+    traits::NullEventConsumer, EpochVersion, FeeVersion, MarketplaceVersion, SequencerVersions,
     SolverAuctionResultsProvider, V0_0,
 };
 use futures::future::FutureExt;
@@ -38,30 +38,30 @@ pub async fn main() -> anyhow::Result<()> {
     let upgrade = genesis.upgrade_version;
 
     match (base, upgrade) {
-        (FeeVersion::VERSION, MarketplaceVersion::VERSION) => {
+        (FeeVersion::VERSION, EpochVersion::VERSION) => {
             run(
                 genesis,
                 modules,
                 opt,
-                SequencerVersions::<FeeVersion, MarketplaceVersion>::new(),
+                SequencerVersions::<FeeVersion, EpochVersion>::new(),
             )
             .await
         }
-        (FeeVersion::VERSION, _) => {
+        (EpochVersion::VERSION, _) => {
             run(
                 genesis,
                 modules,
                 opt,
-                SequencerVersions::<FeeVersion, V0_0>::new(),
+                SequencerVersions::<EpochVersion, V0_0>::new(),
             )
             .await
         }
-        (MarketplaceVersion::VERSION, _) => {
+        (FeeVersion::VERSION, MarketplaceVersion::VERSION) => {
             run(
                 genesis,
                 modules,
                 opt,
-                SequencerVersions::<MarketplaceVersion, V0_0>::new(),
+                SequencerVersions::<FeeVersion, MarketplaceVersion>::new(),
             )
             .await
         }

tests/Cargo.toml

@@ -20,3 +20,4 @@ reqwest = { workspace = true, features = ["json"] }
 surf-disco = { workspace = true }
 tokio = { workspace = true }
 vbs = { workspace = true }
+sequencer-utils = { path = "../utils" }

tests/upgrades.rs

@@ -1,8 +1,14 @@
+use std::{path::Path, time::Duration};
+
 use crate::common::TestConfig;
 use anyhow::Result;
-use espresso_types::{FeeVersion, MarketplaceVersion};
+use client::SequencerClient;
+use dotenvy::var;
+use espresso_types::{EpochVersion, FeeVersion, MarketplaceVersion};
 use futures::{future::join_all, StreamExt};
-use vbs::version::StaticVersionType;
+use sequencer_utils::stake_table::{update_stake_table, PermissionedStakeTableUpdate};
+use tokio::time::sleep;
+use vbs::version::{StaticVersionType, Version};
 
 const SEQUENCER_BLOCKS_TIMEOUT: u64 = 200;
 
@@ -12,10 +18,10 @@ async fn test_upgrade() -> Result<()> {
 
     let testing = TestConfig::new().await.unwrap();
 
-    let versions = if testing.sequencer_version as u16 >= MarketplaceVersion::version().minor {
-        (FeeVersion::version(), MarketplaceVersion::version())
-    } else {
-        panic!("Invalid sequencer version provided for upgrade test.");
+    let (base, upgrade) = match testing.sequencer_version {
+        3 => (FeeVersion::version(), EpochVersion::version()),
+        version if version > 3 => (FeeVersion::version(), MarketplaceVersion::version()),
+        _ => panic!("Invalid sequencer version provided for upgrade test."),
     };
 
     println!("Waiting on readiness");
@@ -26,6 +32,23 @@ async fn test_upgrade() -> Result<()> {
 
     let clients = testing.sequencer_clients;
 
+    let height = test_header_version(clients.clone(), base, upgrade).await?;
+    // check that atleast 50 blocks are produced after the upgrade
+    test_blocks_production(clients.clone(), height, 50).await?;
+
+    if upgrade == EpochVersion::version() {
+        test_stake_table_update(clients).await?;
+    }
+
+    // TODO assert transactions are incrementing
+    Ok(())
+}
+
+async fn test_header_version(
+    clients: Vec<SequencerClient>,
+    base: Version,
+    upgrade: Version,
+) -> Result<u64> {
     // Test is limited to those sequencers with correct modules
     // enabled. It would be less fragile if we could discover them.
     let subscriptions = join_all(clients.iter().map(|c| c.subscribe_headers(0)))
@@ -34,7 +57,7 @@ async fn test_upgrade() -> Result<()> {
         .collect::<anyhow::Result<Vec<_>>>()?;
 
     let mut stream = futures::stream::iter(subscriptions).flatten_unordered(None);
-
+    let mut height = 0;
     while let Some(header) = stream.next().await {
         let header = header.unwrap();
         println!(
@@ -46,11 +69,12 @@ async fn test_upgrade() -> Result<()> {
         // TODO is it possible to discover the view at which upgrade should be finished?
         // First few views should be `Base` version.
         if header.height() <= 20 {
-            assert_eq!(header.version(), versions.0)
+            assert_eq!(header.version(), base)
         }
 
-        if header.version() == versions.1 {
+        if header.version() == upgrade {
             println!("header version matched! height={:?}", header.height());
+            height = header.height();
             break;
         }
 
@@ -59,6 +83,87 @@ async fn test_upgrade() -> Result<()> {
         }
     }
 
-    // TODO assert transactions are incrementing
+    Ok(height)
+}
+
+async fn test_blocks_production(clients: Vec<SequencerClient>, from: u64, num: u64) -> Result<()> {
+    let subscriptions = join_all(clients.iter().map(|c| c.subscribe_blocks(from)))
+        .await
+        .into_iter()
+        .collect::<anyhow::Result<Vec<_>>>()?;
+
+    let mut num_blocks = 0;
+
+    for mut node in subscriptions {
+        while let Some(block) = node.next().await {
+            let _block = block.unwrap();
+            num_blocks += 1;
+            if num_blocks == num {
+                break;
+            }
+        }
+
+        num_blocks = 0;
+    }
+
+    Ok(())
+}
+
+async fn test_stake_table_update(clients: Vec<SequencerClient>) -> Result<()> {
+    /*
+            EPOCH V3
+    */
+
+    let rpc_url = var("ESPRESSO_SEQUENCER_L1_PROVIDER")?;
+    let account_index = var("ESPRESSO_DEPLOYER_ACCOUNT_INDEX")?;
+    let contract_address = var("ESPRESSO_SEQUENCER_PERMISSIONED_STAKE_TABLE_ADDRESS")?;
+    let initial_stake_table_path = var("ESPRESSO_SEQUENCER_INITIAL_PERMISSIONED_STAKE_TABLE_PATH")?;
+
+    let permissioned_stake_table =
+        PermissionedStakeTableUpdate::from_toml_file(Path::new(&initial_stake_table_path))?;
+
+    // initial stake table has 5 new stakers
+
+    let new_stakers = permissioned_stake_table.new_stakers;
+    //lets remove one
+    let staker_removed = new_stakers[0].clone();
+
+    let st_with_one_removed =
+        PermissionedStakeTableUpdate::new(vec![staker_removed.clone()], vec![]);
+    let client = clients[0].clone();
+
+    let epoch_before_update = client.current_epoch().await?;
+
+    update_stake_table(
+        rpc_url.parse()?,
+        Duration::from_secs(7),
+        "test test test test test test test test test test test junk".to_string(),
+        account_index.parse()?,
+        contract_address.parse()?,
+        st_with_one_removed,
+    )
+    .await?;
+
+    loop {
+        sleep(Duration::from_secs(10)).await;
+        let epoch = clients[0].current_epoch().await?;
+
+        if epoch > epoch_before_update {
+            let stake_table = client.stake_table(epoch).await?;
+            assert_eq!(stake_table.len(), 4);
+
+            assert!(
+                stake_table
+                    .iter()
+                    .all(|st| st.stake_key != staker_removed.stake_table_key),
+                "Entry for {} already exists in the stake table",
+                staker_removed.stake_table_key
+            );
+
+            break;
+        }
+    }
+    // TODO: randomize this test
+
     Ok(())
 }

types/src/v0/impls/state.rs

@@ -667,7 +667,7 @@ fn validate_builder_fee(
         // TODO Marketplace signatures are placeholders for now. In
         // finished Marketplace signatures will cover the full
         // transaction.
-        if version.minor >= 3 {
+        if version.minor >= 99 {
             fee_info
                 .account()
                 .validate_sequencing_fee_signature_marketplace(