(#[case] _p: PhantomData) {}
+
#[derive(Clone, Debug, Default)]
struct EventCollector {
events: Arc>>,
@@ -145,8 +143,8 @@ mod persistence_tests {
}
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_voted_view() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_voted_view(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -188,8 +186,8 @@ mod persistence_tests {
);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_restart_view() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_restart_view(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -250,8 +248,9 @@ mod persistence_tests {
view2 + 1
);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_store_drb_input() {
+
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_store_drb_input(_p: PhantomData
) {
use hotshot_types::drb::DrbInput;
setup_test();
@@ -295,8 +294,8 @@ mod persistence_tests {
assert_eq!(storage.load_drb_input(10).await.unwrap(), drb_input_3);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_epoch_info() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_epoch_info(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
let storage = P::connect(&tmp).await;
@@ -408,8 +407,8 @@ mod persistence_tests {
}
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_append_and_decide() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_append_and_decide(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -789,8 +788,8 @@ mod persistence_tests {
);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_upgrade_certificate() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_upgrade_certificate(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -838,8 +837,8 @@ mod persistence_tests {
assert_eq!(view_number, new_view_number_for_certificate);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_next_epoch_quorum_certificate() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_next_epoch_quorum_certificate(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -900,8 +899,10 @@ mod persistence_tests {
assert_eq!(view_number, new_view_number_for_qc);
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_decide_with_failing_event_consumer() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_decide_with_failing_event_consumer(
+ _p: PhantomData
,
+ ) {
#[derive(Clone, Copy, Debug)]
struct FailConsumer;
@@ -1119,8 +1120,8 @@ mod persistence_tests {
}
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_pruning() {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_pruning(_p: PhantomData
) {
setup_test();
let tmp = P::tmp_storage().await;
@@ -1300,8 +1301,11 @@ mod persistence_tests {
// test for validating stake table event fetching from persistence,
// ensuring that persisted data matches the on-chain events and that event fetcher work correctly.
- #[tokio::test(flavor = "multi_thread")]
+ #[rstest_reuse::apply(persistence_types)]
pub async fn test_stake_table_fetching_from_persistence(
+ #[values(StakeTableContractVersion::V1, StakeTableContractVersion::V2)]
+ stake_table_version: StakeTableContractVersion,
+ _p: PhantomData
,
) -> anyhow::Result<()> {
setup_test();
@@ -1336,7 +1340,7 @@ mod persistence_tests {
.api_config(query_api_options)
.network_config(network_config.clone())
.persistences(persistence_options.clone())
- .pos_hook::(DelegationConfig::MultipleDelegators)
+ .pos_hook::(DelegationConfig::MultipleDelegators, stake_table_version)
.await
.expect("Pos deployment failed")
.build();
@@ -1425,9 +1429,15 @@ mod persistence_tests {
Ok(())
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_stake_table_background_fetching() -> anyhow::Result<()>
- {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_stake_table_background_fetching(
+ #[values(StakeTableContractVersion::V1, StakeTableContractVersion::V2)]
+ stake_table_version: StakeTableContractVersion,
+ _p: PhantomData
,
+ ) -> anyhow::Result<()> {
+ use espresso_types::v0_3::ChainConfig;
+ use hotshot_contract_adapter::stake_table::StakeTableContractVersion;
+
setup_test();
let blocks_per_epoch = 10;
@@ -1467,16 +1477,19 @@ mod persistence_tests {
.epoch_start_block(1)
.build()
.unwrap();
- args.deploy_all(&mut contracts)
- .await
- .expect("failed to deploy all contracts");
+
+ match stake_table_version {
+ StakeTableContractVersion::V1 => args.deploy_to_stake_table_v1(&mut contracts).await,
+ StakeTableContractVersion::V2 => args.deploy_all(&mut contracts).await,
+ }
+ .expect("contracts deployed");
let st_addr = contracts
.address(Contract::StakeTableProxy)
- .expect("StakeTableProxy address not found");
+ .expect("StakeTableProxy deployed");
let token_addr = contracts
.address(Contract::EspTokenProxy)
- .expect("EspTokenProxy address not found");
+ .expect("EspTokenProxy deployed");
let l1_url = network_config.l1_url().clone();
// new block every 1s
@@ -1575,8 +1588,10 @@ mod persistence_tests {
Ok(())
}
- #[tokio::test(flavor = "multi_thread")]
- pub async fn test_membership_persistence() -> anyhow::Result<()> {
+ #[rstest_reuse::apply(persistence_types)]
+ pub async fn test_membership_persistence(
+ _p: PhantomData
,
+ ) -> anyhow::Result<()> {
setup_test();
let tmp = P::tmp_storage().await;
diff --git a/sequencer/src/persistence/fs.rs b/sequencer/src/persistence/fs.rs
index 5cd91eedb8..cf406be546 100644
--- a/sequencer/src/persistence/fs.rs
+++ b/sequencer/src/persistence/fs.rs
@@ -1886,36 +1886,6 @@ fn epoch_files(
}))
}
-#[cfg(test)]
-mod testing {
- use tempfile::TempDir;
-
- use super::{super::testing::TestablePersistence, *};
-
- #[async_trait]
- impl TestablePersistence for Persistence {
- type Storage = TempDir;
-
- async fn tmp_storage() -> Self::Storage {
- TempDir::new().unwrap()
- }
-
- fn options(storage: &Self::Storage) -> impl PersistenceOptions {
- Options::new(storage.path().into())
- }
- }
-}
-
-#[cfg(test)]
-mod generic_tests {
- use super::{super::persistence_tests, Persistence};
- // For some reason this is the only way to import the macro defined in another module of this
- // crate.
- use crate::*;
-
- instantiate_persistence_tests!(Persistence);
-}
-
#[cfg(test)]
mod test {
use std::marker::PhantomData;
@@ -1936,10 +1906,24 @@ mod test {
use jf_vid::VidScheme;
use sequencer_utils::test_utils::setup_test;
use serde_json::json;
+ use tempfile::TempDir;
use vbs::version::StaticVersionType;
use super::*;
- use crate::{persistence::testing::TestablePersistence, BLSPubKey};
+ use crate::{persistence::tests::TestablePersistence, BLSPubKey};
+
+ #[async_trait]
+ impl TestablePersistence for Persistence {
+ type Storage = TempDir;
+
+ async fn tmp_storage() -> Self::Storage {
+ TempDir::new().unwrap()
+ }
+
+ fn options(storage: &Self::Storage) -> impl PersistenceOptions {
+ Options::new(storage.path().into())
+ }
+ }
#[test]
fn test_config_migrations_add_builder_urls() {
diff --git a/sequencer/src/persistence/sql.rs b/sequencer/src/persistence/sql.rs
index c476ed75e7..b050f51d12 100644
--- a/sequencer/src/persistence/sql.rs
+++ b/sequencer/src/persistence/sql.rs
@@ -2520,7 +2520,8 @@ async fn fetch_leaf_from_proposals(
mod testing {
use hotshot_query_service::data_source::storage::sql::testing::TmpDb;
- use super::{super::testing::TestablePersistence, *};
+ use super::*;
+ use crate::persistence::tests::TestablePersistence;
#[async_trait]
impl TestablePersistence for Persistence {
@@ -2555,16 +2556,6 @@ mod testing {
}
}
-#[cfg(test)]
-mod generic_tests {
- use super::{super::persistence_tests, Persistence};
- // For some reason this is the only way to import the macro defined in another module of this
- // crate.
- use crate::*;
-
- instantiate_persistence_tests!(Persistence);
-}
-
#[cfg(test)]
mod test {
@@ -2595,7 +2586,7 @@ mod test {
use vbs::version::StaticVersionType;
use super::*;
- use crate::{persistence::testing::TestablePersistence, BLSPubKey, PubKey};
+ use crate::{persistence::tests::TestablePersistence as _, BLSPubKey, PubKey};
#[tokio::test(flavor = "multi_thread")]
async fn test_quorum_proposals_leaf_hash_migration() {
diff --git a/staking-cli/Cargo.toml b/staking-cli/Cargo.toml
index a13b2ed56f..ced6e166b8 100644
--- a/staking-cli/Cargo.toml
+++ b/staking-cli/Cargo.toml
@@ -8,8 +8,7 @@ description = "A CLI to interact with the Espresso stake table contract"
[dependencies]
alloy = { workspace = true }
anyhow = { workspace = true }
-ark-ec = { workspace = true }
-ark-ed-on-bn254 = { workspace = true }
+ark-serialize = { workspace = true }
clap = { workspace = true }
clap-serde = "0.5.1"
clap-serde-derive = "0.2.1"
@@ -27,6 +26,8 @@ jf-signature = { workspace = true, features = ["bls", "schnorr"] }
portpicker = { workspace = true }
rand = { workspace = true }
rand_chacha = { workspace = true }
+rstest = { workspace = true }
+rstest_reuse = { workspace = true }
rust_decimal = "1.36.0"
sequencer-utils = { version = "0.1.0", path = "../utils" }
serde = { workspace = true }
diff --git a/staking-cli/src/demo.rs b/staking-cli/src/demo.rs
index b013dd7cfc..8e79a18739 100644
--- a/staking-cli/src/demo.rs
+++ b/staking-cli/src/demo.rs
@@ -143,7 +143,7 @@ pub async fn setup_stake_table_contract_for_test(
commission,
validator_address,
bls_key_pair,
- state_key_pair.ver_key(),
+ state_key_pair,
)
.await?;
assert!(receipt.status());
diff --git a/staking-cli/src/deploy.rs b/staking-cli/src/deploy.rs
index 23d29c16fe..946fd0627d 100644
--- a/staking-cli/src/deploy.rs
+++ b/staking-cli/src/deploy.rs
@@ -14,10 +14,20 @@ use alloy::{
signers::local::PrivateKeySigner,
};
use anyhow::Result;
-use espresso_contract_deployer::build_signer;
-use hotshot_contract_adapter::sol_types::{ERC1967Proxy, EspToken, StakeTable};
+use espresso_contract_deployer::{
+ build_signer, builder::DeployerArgsBuilder,
+ network_config::light_client_genesis_from_stake_table, Contract, Contracts,
+};
+use hotshot_contract_adapter::{
+ sol_types::{
+ EspToken::{self, EspTokenInstance},
+ StakeTable,
+ },
+ stake_table::StakeTableContractVersion,
+};
+use hotshot_state_prover::mock_ledger::STAKE_TABLE_CAPACITY_FOR_TEST;
use hotshot_types::light_client::StateKeyPair;
-use rand::{rngs::StdRng, CryptoRng, RngCore, SeedableRng as _};
+use rand::{rngs::StdRng, CryptoRng, Rng as _, RngCore, SeedableRng as _};
use url::Url;
use crate::{parse::Commission, registration::register_validator, BLSKeyPair, DEV_MNEMONIC};
@@ -28,8 +38,6 @@ type TestProvider = FillProvider<
Ethereum,
>;
-type SchnorrKeyPair = jf_signature::schnorr::KeyPair;
-
#[derive(Debug, Clone)]
pub struct TestSystem {
pub provider: TestProvider,
@@ -47,6 +55,12 @@ pub struct TestSystem {
impl TestSystem {
pub async fn deploy() -> Result {
+ Self::deploy_version(StakeTableContractVersion::V2).await
+ }
+
+ pub async fn deploy_version(
+ stake_table_contract_version: StakeTableContractVersion,
+ ) -> Result {
let exit_escrow_period = Duration::from_secs(1);
let port = portpicker::pick_unused_port().unwrap();
// Spawn anvil
@@ -64,45 +78,45 @@ impl TestSystem {
"Signer address mismatch"
);
- // `EspToken.sol`
- let token_impl = EspToken::deploy(provider.clone()).await?;
- let initial_supply = U256::from(3590000000u64);
- let token_name = "Espresso".to_string();
- let token_symbol = "ESP".to_string();
- let data = token_impl
- .initialize(
- deployer_address,
- deployer_address,
- initial_supply,
- token_name,
- token_symbol,
- )
- .calldata()
- .clone();
-
- let token_proxy =
- ERC1967Proxy::deploy(provider.clone(), *token_impl.address(), data).await?;
- let token = EspToken::new(*token_proxy.address(), provider.clone());
-
- // `StakeTable.sol`
- let stake_table_impl = StakeTable::deploy(provider.clone()).await?;
- let data = stake_table_impl
- .initialize(
- *token_proxy.address(),
- "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".parse()?, // fake LC address
- U256::from(exit_escrow_period.as_secs()),
- deployer_address,
- )
- .calldata()
- .clone();
-
- let st_proxy =
- ERC1967Proxy::deploy(provider.clone(), *stake_table_impl.address(), data).await?;
+ // Create a fake stake table to create a genesis state. This is fine because we don't
+ // currently use the light client contract. Will need to be updated once we implement
+ // slashing and call the light client contract from the stake table contract.
+ let blocks_per_epoch = 100;
+ let epoch_start_block = 1;
+ let (genesis_state, genesis_stake) = light_client_genesis_from_stake_table(
+ &Default::default(),
+ STAKE_TABLE_CAPACITY_FOR_TEST,
+ )
+ .unwrap();
+
+ let mut contracts = Contracts::new();
+ let args = DeployerArgsBuilder::default()
+ .deployer(provider.clone())
+ .mock_light_client(true)
+ .genesis_lc_state(genesis_state)
+ .genesis_st_state(genesis_stake)
+ .blocks_per_epoch(blocks_per_epoch)
+ .epoch_start_block(epoch_start_block)
+ .exit_escrow_period(U256::from(exit_escrow_period.as_secs()))
+ .build()
+ .unwrap();
+
+ match stake_table_contract_version {
+ StakeTableContractVersion::V1 => args.deploy_to_stake_table_v1(&mut contracts).await?,
+ StakeTableContractVersion::V2 => args.deploy_all(&mut contracts).await?,
+ };
+
+ let stake_table = contracts
+ .address(Contract::StakeTableProxy)
+ .expect("StakeTableProxy deployed");
+ let token = contracts
+ .address(Contract::EspTokenProxy)
+ .expect("EspTokenProxy deployed");
let approval_amount = parse_ether("1000000")?;
// Approve the stake table contract so it can transfer tokens to itself
- let receipt = token
- .approve(*st_proxy.address(), approval_amount)
+ let receipt = EspTokenInstance::new(token, &provider)
+ .approve(stake_table, approval_amount)
.send()
.await?
.get_receipt()
@@ -116,8 +130,8 @@ impl TestSystem {
provider,
signer,
deployer_address,
- token: *token_proxy.address(),
- stake_table: *st_proxy.address(),
+ token,
+ stake_table,
exit_escrow_period,
rpc_url,
bls_key_pair,
@@ -134,7 +148,7 @@ impl TestSystem {
(
PrivateKeySigner::random_with(rng),
BLSKeyPair::generate(rng),
- SchnorrKeyPair::generate(rng).into(),
+ StateKeyPair::generate_from_seed(rng.gen()),
)
}
@@ -145,7 +159,7 @@ impl TestSystem {
self.commission,
self.deployer_address,
self.bls_key_pair.clone(),
- self.state_key_pair.ver_key(),
+ self.state_key_pair.clone(),
)
.await?;
assert!(receipt.status());
diff --git a/staking-cli/src/lib.rs b/staking-cli/src/lib.rs
index bfd73fdff1..4aa3fe4d2b 100644
--- a/staking-cli/src/lib.rs
+++ b/staking-cli/src/lib.rs
@@ -11,10 +11,7 @@ use anyhow::{bail, Result};
use clap::{Parser, Subcommand};
use clap_serde_derive::ClapSerde;
use demo::DelegationConfig;
-pub(crate) use hotshot_types::{
- light_client::{StateSignKey, StateVerKey},
- signature_key::BLSPrivKey,
-};
+pub(crate) use hotshot_types::{light_client::StateSignKey, signature_key::BLSPrivKey};
pub(crate) use jf_signature::bls_over_bn254::KeyPair as BLSKeyPair;
use parse::Commission;
use sequencer_utils::logging;
diff --git a/staking-cli/src/main.rs b/staking-cli/src/main.rs
index a728790c85..8b544e03dd 100644
--- a/staking-cli/src/main.rs
+++ b/staking-cli/src/main.rs
@@ -14,6 +14,7 @@ use hotshot_contract_adapter::{
evm::DecodeRevert as _,
sol_types::EspToken::{self, EspTokenErrors},
};
+use hotshot_types::light_client::StateKeyPair;
use staking_cli::{
claim::{claim_validator_exit, claim_withdrawal},
delegation::{approve, delegate, undelegate},
@@ -252,7 +253,7 @@ pub async fn main() -> Result<()> {
commission,
account,
(consensus_private_key).into(),
- (&state_private_key).into(),
+ StateKeyPair::from_sign_key(state_private_key),
)
.await
},
@@ -266,7 +267,7 @@ pub async fn main() -> Result<()> {
stake_table_addr,
account,
(consensus_private_key).into(),
- (&state_private_key).into(),
+ StateKeyPair::from_sign_key(state_private_key),
)
.await
},
diff --git a/staking-cli/src/registration.rs b/staking-cli/src/registration.rs
index 360b7693c8..042df255cf 100644
--- a/staking-cli/src/registration.rs
+++ b/staking-cli/src/registration.rs
@@ -1,31 +1,40 @@
use alloy::{
- primitives::Address, providers::Provider, rpc::types::TransactionReceipt,
- sol_types::SolValue as _,
+ primitives::{Address, Bytes},
+ providers::Provider,
+ rpc::types::TransactionReceipt,
};
use anyhow::Result;
-use ark_ec::CurveGroup;
use hotshot_contract_adapter::{
evm::DecodeRevert as _,
sol_types::{
EdOnBN254PointSol, G1PointSol, G2PointSol,
- StakeTable::{self, StakeTableErrors},
+ StakeTableV2::{self, StakeTableV2Errors},
},
+ stake_table::{sign_address_bls, sign_address_schnorr, StakeTableContractVersion},
};
-use jf_signature::constants::CS_ID_BLS_BN254;
+use hotshot_types::{light_client::StateKeyPair, signature_key::BLSKeyPair};
-use crate::{parse::Commission, BLSKeyPair, StateVerKey};
+use crate::parse::Commission;
+/// The ver_key and signature as types that contract bindings expect
fn prepare_bls_payload(
bls_key_pair: &BLSKeyPair,
validator_address: Address,
) -> (G2PointSol, G1PointSol) {
- let bls_vk_sol: G2PointSol = bls_key_pair.ver_key().to_affine().into();
- let sig_sol: G1PointSol = bls_key_pair
- .sign(&validator_address.abi_encode(), CS_ID_BLS_BN254)
- .sigma
- .into_affine()
- .into();
- (bls_vk_sol, sig_sol)
+ (
+ bls_key_pair.ver_key().to_affine().into(),
+ sign_address_bls(bls_key_pair, validator_address),
+ )
+}
+
+// The ver_key and signature as types that contract bindings expect
+fn prepare_schnorr_payload(
+ schnorr_key_pair: &StateKeyPair,
+ validator_address: Address,
+) -> (EdOnBN254PointSol, Bytes) {
+ let schnorr_vk_sol: EdOnBN254PointSol = schnorr_key_pair.ver_key().to_affine().into();
+ let sig = sign_address_schnorr(schnorr_key_pair, validator_address);
+ (schnorr_vk_sol, sig)
}
pub async fn register_validator(
@@ -34,23 +43,45 @@ pub async fn register_validator(
commission: Commission,
validator_address: Address,
bls_key_pair: BLSKeyPair,
- schnorr_vk: StateVerKey,
+ schnorr_key_pair: StateKeyPair,
) -> Result {
- let stake_table = StakeTable::new(stake_table_addr, &provider);
- let (bls_vk_sol, sig_sol) = prepare_bls_payload(&bls_key_pair, validator_address);
- let schnorr_vk_sol: EdOnBN254PointSol = schnorr_vk.to_affine().into();
- Ok(stake_table
- .registerValidator(
- bls_vk_sol,
- schnorr_vk_sol,
- sig_sol.into(),
- commission.to_evm(),
- )
- .send()
- .await
- .maybe_decode_revert::()?
- .get_receipt()
- .await?)
+ // NOTE: the StakeTableV2 ABI is a superset of the V1 ABI because the V2 inherits from V1 so we
+ // can always use the V2 bindings for calling functions and decoding events, even if we are
+ // connected to the V1 contract.
+ let stake_table = StakeTableV2::new(stake_table_addr, &provider);
+ let (bls_vk, bls_sig) = prepare_bls_payload(&bls_key_pair, validator_address);
+ let (schnorr_vk, schnorr_sig) = prepare_schnorr_payload(&schnorr_key_pair, validator_address);
+
+ let version = stake_table.getVersion().call().await?.try_into()?;
+ // There is a race-condition here if the contract is upgraded while this transactions is waiting
+ // to be mined. We're very unlikely to hit this in practice, and since we only perform the
+ // upgrade on decaf this is acceptable.
+ Ok(match version {
+ StakeTableContractVersion::V1 => {
+ stake_table
+ .registerValidator(bls_vk, schnorr_vk, bls_sig.into(), commission.to_evm())
+ .send()
+ .await
+ .maybe_decode_revert::()?
+ .get_receipt()
+ .await?
+ },
+ StakeTableContractVersion::V2 => {
+ stake_table
+ .registerValidatorV2(
+ bls_vk,
+ schnorr_vk,
+ bls_sig.into(),
+ schnorr_sig,
+ commission.to_evm(),
+ )
+ .send()
+ .await
+ .maybe_decode_revert::()?
+ .get_receipt()
+ .await?
+ },
+ })
}
pub async fn update_consensus_keys(
@@ -58,36 +89,63 @@ pub async fn update_consensus_keys(
stake_table_addr: Address,
validator_address: Address,
bls_key_pair: BLSKeyPair,
- schnorr_vk: StateVerKey,
+ schnorr_key_pair: StateKeyPair,
) -> Result {
- let stake_table = StakeTable::new(stake_table_addr, &provider);
- let (bls_vk_sol, sig_sol) = prepare_bls_payload(&bls_key_pair, validator_address);
- let schnorr_vk_sol: EdOnBN254PointSol = schnorr_vk.to_affine().into();
- Ok(stake_table
- .updateConsensusKeys(bls_vk_sol, schnorr_vk_sol, sig_sol.into())
- .send()
- .await
- .maybe_decode_revert::()?
- .get_receipt()
- .await?)
+ // NOTE: the StakeTableV2 ABI is a superset of the V1 ABI because the V2 inherits from V1 so we
+ // can always use the V2 bindings for calling functions and decoding events, even if we are
+ // connected to the V1 contract.
+ let stake_table = StakeTableV2::new(stake_table_addr, &provider);
+ let (bls_vk, bls_sig) = prepare_bls_payload(&bls_key_pair, validator_address);
+ let (schnorr_vk, schnorr_sig) = prepare_schnorr_payload(&schnorr_key_pair, validator_address);
+
+ // There is a race-condition here if the contract is upgraded while this transactions is waiting
+ // to be mined. We're very unlikely to hit this in practice, and since we only perform the
+ // upgrade on decaf this is acceptable.
+ let version = stake_table.getVersion().call().await?.try_into()?;
+ Ok(match version {
+ StakeTableContractVersion::V1 => {
+ stake_table
+ .updateConsensusKeys(bls_vk, schnorr_vk, bls_sig.into())
+ .send()
+ .await
+ .maybe_decode_revert::()?
+ .get_receipt()
+ .await?
+ },
+ StakeTableContractVersion::V2 => {
+ stake_table
+ .updateConsensusKeysV2(bls_vk, schnorr_vk, bls_sig.into(), schnorr_sig)
+ .send()
+ .await
+ .maybe_decode_revert::()?
+ .get_receipt()
+ .await?
+ },
+ })
}
pub async fn deregister_validator(
provider: impl Provider,
stake_table_addr: Address,
) -> Result {
- let stake_table = StakeTable::new(stake_table_addr, &provider);
+ let stake_table = StakeTableV2::new(stake_table_addr, &provider);
Ok(stake_table
.deregisterValidator()
.send()
.await
- .maybe_decode_revert::()?
+ .maybe_decode_revert::()?
.get_receipt()
.await?)
}
#[cfg(test)]
mod test {
+ use alloy::providers::WalletProvider as _;
+ use espresso_contract_deployer::build_provider;
+ use espresso_types::{
+ v0_3::{StakeTableEvent, StakeTableFetcher},
+ L1Client,
+ };
use rand::{rngs::StdRng, SeedableRng as _};
use super::*;
@@ -106,21 +164,21 @@ mod test {
system.commission,
validator_address,
system.bls_key_pair,
- system.state_key_pair.ver_key(),
+ system.state_key_pair,
)
.await?;
assert!(receipt.status());
let event = receipt
- .decoded_log::()
+ .decoded_log::()
.unwrap();
assert_eq!(event.account, validator_address);
assert_eq!(event.commission, system.commission.to_evm());
- assert_eq!(event.blsVk, bls_vk_sol);
- assert_eq!(event.schnorrVk, schnorr_vk_sol);
+ assert_eq!(event.blsVK, bls_vk_sol);
+ assert_eq!(event.schnorrVK, schnorr_vk_sol);
- // TODO verify we can parse keys and verify signature
+ event.data.authenticate()?;
Ok(())
}
@@ -132,7 +190,9 @@ mod test {
let receipt = deregister_validator(&system.provider, system.stake_table).await?;
assert!(receipt.status());
- let event = receipt.decoded_log::().unwrap();
+ let event = receipt
+ .decoded_log::()
+ .unwrap();
assert_eq!(event.validator, system.deployer_address);
Ok(())
@@ -146,26 +206,158 @@ mod test {
let mut rng = StdRng::from_seed([43u8; 32]);
let (_, new_bls, new_schnorr) = TestSystem::gen_keys(&mut rng);
let (bls_vk_sol, _) = prepare_bls_payload(&new_bls, validator_address);
- let schnorr_vk_sol: EdOnBN254PointSol = new_schnorr.ver_key().to_affine().into();
+ let (schnorr_vk_sol, _) = prepare_schnorr_payload(&new_schnorr, validator_address);
let receipt = update_consensus_keys(
&system.provider,
system.stake_table,
validator_address,
new_bls,
- new_schnorr.ver_key(),
+ new_schnorr,
)
.await?;
assert!(receipt.status());
let event = receipt
- .decoded_log::()
+ .decoded_log::()
.unwrap();
assert_eq!(event.account, system.deployer_address);
assert_eq!(event.blsVK, bls_vk_sol);
assert_eq!(event.schnorrVK, schnorr_vk_sol);
+ event.data.authenticate()?;
+
+ Ok(())
+ }
+
+ /// The GCL must remove stake table events with incorrect signatures. This test verifies that a
+ /// validator registered event with incorrect schnorr signature is removed before the stake
+ /// table is computed.
+ #[tokio::test]
+ async fn test_integration_unauthenticated_validator_registered_events_removed() -> Result<()> {
+ let system = TestSystem::deploy().await?;
+
+ // register a validator with correct signature
+ system.register_validator().await?;
+
+ // NOTE: we can't register a validator with a bad BLS signature because the contract will revert
+
+ let provider = build_provider(
+ "test test test test test test test test test test test junk".to_string(),
+ 1,
+ system.rpc_url.clone(),
+ );
+ let validator_address = provider.default_signer_address();
+ let (_, bls_key_pair, schnorr_key_pair) =
+ TestSystem::gen_keys(&mut StdRng::from_seed([1u8; 32]));
+ let (_, _, other_schnorr_key_pair) =
+ TestSystem::gen_keys(&mut StdRng::from_seed([2u8; 32]));
+
+ let (bls_vk, bls_sig) = prepare_bls_payload(&bls_key_pair, validator_address);
+ let (schnorr_vk, _) = prepare_schnorr_payload(&schnorr_key_pair, validator_address);
+
+ // create a valid schnorr signature with the *wrong* key
+ let (_, schnorr_sig_other_key) =
+ prepare_schnorr_payload(&other_schnorr_key_pair, validator_address);
+
+ let stake_table = StakeTableV2::new(system.stake_table, provider);
+
+ // register a validator with the schnorr sig from another key
+ let receipt = stake_table
+ .registerValidatorV2(
+ bls_vk,
+ schnorr_vk,
+ bls_sig.into(),
+ schnorr_sig_other_key.clone(),
+ Commission::try_from("12.34")?.to_evm(),
+ )
+ .send()
+ .await
+ .maybe_decode_revert::()?
+ .get_receipt()
+ .await?;
+ assert!(receipt.status());
+
+ let l1 = L1Client::new(vec![system.rpc_url])?;
+ let events = StakeTableFetcher::fetch_events_from_contract(
+ l1,
+ system.stake_table,
+ Some(0),
+ receipt.block_number.unwrap(),
+ )
+ .await?
+ .sort_events()?;
+
+ // verify that we only have the first RegisterV2 event
+ assert_eq!(events.len(), 1);
+ match events[0].1.clone() {
+ StakeTableEvent::RegisterV2(event) => {
+ assert_eq!(event.account, system.deployer_address);
+ },
+ _ => panic!("expected RegisterV2 event"),
+ }
+ Ok(())
+ }
+
+ /// The GCL must remove stake table events with incorrect signatures. This test verifies that a
+ /// consensus keys update event with incorrect schnorr signature is removed before the stake
+ /// table is computed.
+ #[tokio::test]
+ async fn test_integration_unauthenticated_update_consensus_keys_events_removed() -> Result<()> {
+ let system = TestSystem::deploy().await?;
+
+ // register a validator with correct signature
+ system.register_validator().await?;
+ let validator_address = system.deployer_address;
+
+ // NOTE: we can't register a validator with a bad BLS signature because the contract will revert
+
+ let (_, new_bls_key_pair, new_schnorr_key_pair) =
+ TestSystem::gen_keys(&mut StdRng::from_seed([1u8; 32]));
+ let (_, _, other_schnorr_key_pair) =
+ TestSystem::gen_keys(&mut StdRng::from_seed([2u8; 32]));
+
+ let (bls_vk, bls_sig) = prepare_bls_payload(&new_bls_key_pair, validator_address);
+ let (schnorr_vk, _) = prepare_schnorr_payload(&new_schnorr_key_pair, validator_address);
+
+ // create a valid schnorr signature with the *wrong* key
+ let (_, schnorr_sig_other_key) =
+ prepare_schnorr_payload(&other_schnorr_key_pair, validator_address);
+
+ let stake_table = StakeTableV2::new(system.stake_table, system.provider);
+
+ // update consensus keys with the schnorr sig from another key
+ let receipt = stake_table
+ .updateConsensusKeysV2(bls_vk, schnorr_vk, bls_sig.into(), schnorr_sig_other_key)
+ .send()
+ .await
+ .maybe_decode_revert::