From 69e7667e67f7fb9dc14547bc866a9f42302912d6 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 13:26:04 -0800 Subject: [PATCH 01/13] Add additional test cases for parsing PbsConfig --- Cargo.lock | 1 + cb-config.toml | 7 ++ tests/Cargo.toml | 2 + tests/data/configs/pbs.happy.toml | 26 +++++ tests/tests/config.rs | 156 +++++++++++++++++++++++++++++- 5 files changed, 190 insertions(+), 2 deletions(-) create mode 100644 cb-config.toml create mode 100644 tests/data/configs/pbs.happy.toml diff --git a/Cargo.lock b/Cargo.lock index 798bb936..21275ff3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1412,6 +1412,7 @@ dependencies = [ "tracing", "tracing-subscriber", "tree_hash 0.8.0", + "url", ] [[package]] diff --git a/cb-config.toml b/cb-config.toml new file mode 100644 index 00000000..c55b9c18 --- /dev/null +++ b/cb-config.toml @@ -0,0 +1,7 @@ +chain = "Holesky" + +[pbs] +port = 18550 + +[[relays]] +url = "https://0xaa58208899c6105603b74396734a6263cc7d947f444f396a90f7b7d3e65d102aec7e5e5291b27e08d02c50a050825c2f@holesky.titanrelay.xyz" \ No newline at end of file diff --git a/tests/Cargo.toml b/tests/Cargo.toml index 04b66330..19175ebf 100644 --- a/tests/Cargo.toml +++ b/tests/Cargo.toml @@ -23,3 +23,5 @@ tracing-subscriber.workspace = true tree_hash.workspace = true eyre.workspace = true + +url.workspace = true \ No newline at end of file diff --git a/tests/data/configs/pbs.happy.toml b/tests/data/configs/pbs.happy.toml new file mode 100644 index 00000000..67f282b2 --- /dev/null +++ b/tests/data/configs/pbs.happy.toml @@ -0,0 +1,26 @@ +chain = "Holesky" + +[pbs] +docker_image = "ghcr.io/commit-boost/pbs:latest" +with_signer = false +host = "127.0.0.1" +port = 18550 +relay_check = true +wait_all_registrations = true +timeout_get_header_ms = 950 +timeout_get_payload_ms = 4000 +timeout_register_validator_ms = 3000 +skip_sigverify = false +min_bid_eth = 0.5 +relay_monitors = [] +late_in_slot_time_ms = 2000 +extra_validation_enabled = false +rpc_url = "https://ethereum-holesky-rpc.publicnode.com" + +[[relays]] +id = "example-relay" +url = "http://0xa1cec75a3f0661e99299274182938151e8433c61a19222347ea1313d839229cb4ce4e3e5aa2bdeb71c8fcf1b084963c2@abc.xyz" +headers = { X-MyCustomHeader = "MyCustomHeader" } +enable_timing_games = false +target_first_request_ms = 200 +frequency_get_header_ms = 300 \ No newline at end of file diff --git a/tests/tests/config.rs b/tests/tests/config.rs index 044a62c8..074b975c 100644 --- a/tests/tests/config.rs +++ b/tests/tests/config.rs @@ -1,8 +1,11 @@ -use cb_common::{config::CommitBoostConfig, types::Chain}; +use alloy::primitives::U256; +use cb_common::{config::CommitBoostConfig, types::Chain, utils::WEI_PER_ETH}; use eyre::Result; +use std::net::Ipv4Addr; +use url::Url; #[tokio::test] -async fn test_load_config() -> Result<()> { +async fn test_load_example_config() -> Result<()> { let config = CommitBoostConfig::from_file("../config.example.toml")?; config.validate().await?; assert_eq!(config.chain, Chain::Holesky); @@ -10,3 +13,152 @@ async fn test_load_config() -> Result<()> { Ok(()) } + +#[tokio::test] +async fn test_load_pbs_happy() -> Result<()> { + let config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.validate().await?; + + // Chain and existing header check + assert_eq!(config.chain, Chain::Holesky); + assert_eq!( + config.relays[0].headers.as_ref().unwrap().get("X-MyCustomHeader").unwrap(), + "MyCustomHeader" + ); + + // Docker and general settings + assert_eq!(config.pbs.docker_image, "ghcr.io/commit-boost/pbs:latest"); + assert_eq!(config.pbs.with_signer, false); + assert_eq!(config.pbs.pbs_config.host, "127.0.0.1".parse::().unwrap()); + assert_eq!(config.pbs.pbs_config.port, 18550); + assert_eq!(config.pbs.pbs_config.relay_check, true); + assert_eq!(config.pbs.pbs_config.wait_all_registrations, true); + + // Timeouts + assert_eq!(config.pbs.pbs_config.timeout_get_header_ms, 950); + assert_eq!(config.pbs.pbs_config.timeout_get_payload_ms, 4000); + assert_eq!(config.pbs.pbs_config.timeout_register_validator_ms, 3000); + + // Bid settings and validation + assert_eq!(config.pbs.pbs_config.skip_sigverify, false); + dbg!(&config.pbs.pbs_config.min_bid_wei); + dbg!(&U256::from(0.5)); + assert_eq!(config.pbs.pbs_config.min_bid_wei, U256::from((0.5 * WEI_PER_ETH as f64) as u64)); + assert!(config.pbs.pbs_config.relay_monitors.is_empty()); + assert_eq!(config.pbs.pbs_config.late_in_slot_time_ms, 2000); + assert_eq!(config.pbs.pbs_config.extra_validation_enabled, false); + assert_eq!( + config.pbs.pbs_config.rpc_url, + Some("https://ethereum-holesky-rpc.publicnode.com".parse::().unwrap()) + ); + + // Relay specific settings + let relay = &config.relays[0]; + assert_eq!(relay.id, Some("example-relay".to_string())); + assert_eq!(relay.entry.url, "http://0xa1cec75a3f0661e99299274182938151e8433c61a19222347ea1313d839229cb4ce4e3e5aa2bdeb71c8fcf1b084963c2@abc.xyz".parse::().unwrap()); + assert_eq!(relay.enable_timing_games, false); + assert_eq!(relay.target_first_request_ms, Some(200)); + assert_eq!(relay.frequency_get_header_ms, Some(300)); + + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_timeout_get_header_ms() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + + // Set invalid timeout + config.pbs.pbs_config.timeout_get_header_ms = 0; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("timeout_get_header_ms must be greater than 0")); + + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_timeout_get_payload_ms() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.timeout_get_payload_ms = 0; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("timeout_get_payload_ms must be greater than 0")); + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_timeout_register_validator_ms() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.timeout_register_validator_ms = 0; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("timeout_register_validator_ms must be greater than 0")); + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_late_in_slot_time_ms() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.late_in_slot_time_ms = 0; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("late_in_slot_time_ms must be greater than 0")); + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_timeout_header_vs_late() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.timeout_get_header_ms = 3000; + config.pbs.pbs_config.late_in_slot_time_ms = 2000; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("timeout_get_header_ms must be less than late_in_slot_time_ms")); + Ok(()) +} + +#[tokio::test] +async fn test_validate_bad_min_bid() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.min_bid_wei = U256::from(2 * WEI_PER_ETH); + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result.unwrap_err().to_string().contains("min bid is too high")); + Ok(()) +} + +#[tokio::test] +async fn test_validate_missing_rpc_url() -> Result<()> { + let mut config = CommitBoostConfig::from_file("./data/configs/pbs.happy.toml")?; + config.pbs.pbs_config.extra_validation_enabled = true; + config.pbs.pbs_config.rpc_url = None; + + let result = config.validate().await; + assert!(result.is_err()); + assert!(result + .unwrap_err() + .to_string() + .contains("rpc_url is required if extra_validation_enabled is true")); + Ok(()) +} From 5c1b6f33bf2033f9b35438c274f75e8a05ca7dc4 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 13:52:20 -0800 Subject: [PATCH 02/13] Add unhappy path tests for encoding/decoding payloads --- tests/tests/payloads.rs | 102 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) diff --git a/tests/tests/payloads.rs b/tests/tests/payloads.rs index 8a2c1a68..c76faf7e 100644 --- a/tests/tests/payloads.rs +++ b/tests/tests/payloads.rs @@ -1,8 +1,11 @@ use alloy::rpc::types::beacon::relay::ValidatorRegistration; +use serde_json::Value; use cb_common::{ pbs::{SignedBlindedBeaconBlock, SubmitBlindedBlockResponse}, utils::test_encode_decode, }; + +// Happy path tests #[test] fn test_registrations() { let data = include_str!("../data/registration_holesky.json"); @@ -20,3 +23,102 @@ fn test_submit_block_response() { let data = include_str!("../data/submit_block_response_holesky.json"); test_encode_decode::(&data); } + +// Unhappy path tests +fn test_missing_registration_field(field_name: &str) -> String { + let data = include_str!("../data/registration_holesky.json"); + let mut values: Value = serde_json::from_str(data).unwrap(); + + // Remove specified field from the first validator's message + if let Value::Array(arr) = &mut values { + if let Some(first_validator) = arr.get_mut(0) { + if let Some(message) = first_validator.get_mut("message") { + if let Value::Object(msg_obj) = message { + msg_obj.remove(field_name); + } + } + } + } + + // This should fail since the field is required + let result = serde_json::from_value::>(values); + assert!(result.is_err()); + result.unwrap_err().to_string() +} + +#[test] +fn test_registration_missing_fields() { + let fields = ["fee_recipient", "gas_limit", "timestamp", "pubkey"]; + + for field in fields { + let error = test_missing_registration_field(field); + assert!( + error.contains(&format!("missing field `{}`", field)), + "Expected error about missing {}, got: {}", + field, + error + ); + } +} + +fn test_missing_signed_blinded_block_field(field_name: &str) -> String { + let data = include_str!("../data/signed_blinded_block_holesky.json"); + let mut values: Value = serde_json::from_str(data).unwrap(); + + // Remove specified field from the message + if let Some(message) = values.get_mut("message") { + if let Value::Object(msg_obj) = message { + msg_obj.remove(field_name); + } + } + + // This should fail since the field is required + let result = serde_json::from_value::(values); + assert!(result.is_err()); + result.unwrap_err().to_string() +} + +#[test] +fn test_signed_blinded_block_missing_fields() { + let fields = ["slot", "proposer_index", "parent_root", "state_root", "body"]; + + for field in fields { + let error = test_missing_signed_blinded_block_field(field); + assert!( + error.contains(&format!("missing field `{}`", field)), + "Expected error about missing {}, got: {}", + field, + error + ); + } +} + +fn test_missing_submit_block_response_field(field_name: &str) -> String { + let data = include_str!("../data/submit_block_response_holesky.json"); + let mut values: Value = serde_json::from_str(data).unwrap(); + + // Remove specified field + if let Value::Object(obj) = &mut values { + obj.remove(field_name); + } + + // This should fail since the field is required + let result = serde_json::from_value::(values); + assert!(result.is_err()); + result.unwrap_err().to_string() +} + +#[test] +fn test_submit_block_response_missing_fields() { + let fields = ["version", "data"]; + + for field in fields { + let error = test_missing_submit_block_response_field(field); + assert!( + error.contains(&format!("missing field `{}`", field)), + "Expected error about missing {}, got: {}", + field, + error + ); + } +} \ No newline at end of file From c10e47eceff5a45c95f8f6246ddd6dc89fea9ffc Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 14:42:52 -0800 Subject: [PATCH 03/13] Refactor PBS integration tests into individual test modules for each builder API endpoint --- tests/tests/common/mod.rs | 47 +++++ tests/tests/pbs_get_header.rs | 49 +++++ tests/tests/pbs_get_status.rs | 51 +++++ tests/tests/pbs_integration.rs | 271 ------------------------- tests/tests/pbs_mux.rs | 88 ++++++++ tests/tests/pbs_post_blinded_blocks.rs | 78 +++++++ tests/tests/pbs_post_validators.rs | 49 +++++ 7 files changed, 362 insertions(+), 271 deletions(-) create mode 100644 tests/tests/common/mod.rs create mode 100644 tests/tests/pbs_get_header.rs create mode 100644 tests/tests/pbs_get_status.rs delete mode 100644 tests/tests/pbs_integration.rs create mode 100644 tests/tests/pbs_mux.rs create mode 100644 tests/tests/pbs_post_blinded_blocks.rs create mode 100644 tests/tests/pbs_post_validators.rs diff --git a/tests/tests/common/mod.rs b/tests/tests/common/mod.rs new file mode 100644 index 00000000..4d0d37ef --- /dev/null +++ b/tests/tests/common/mod.rs @@ -0,0 +1,47 @@ +use std::{ + net::{Ipv4Addr, SocketAddr}, + sync::Arc, + u64, +}; + +use alloy::primitives::U256; +use cb_common::{ + config::{PbsConfig, PbsModuleConfig}, + pbs::RelayClient, + types::Chain, +}; + +pub fn get_pbs_static_config(port: u16) -> PbsConfig { + PbsConfig { + host: Ipv4Addr::UNSPECIFIED, + port, + wait_all_registrations: true, + relay_check: true, + timeout_get_header_ms: u64::MAX, + timeout_get_payload_ms: u64::MAX, + timeout_register_validator_ms: u64::MAX, + skip_sigverify: false, + min_bid_wei: U256::ZERO, + late_in_slot_time_ms: u64::MAX, + relay_monitors: vec![], + extra_validation_enabled: false, + rpc_url: None, + } +} + +pub fn to_pbs_config( + chain: Chain, + pbs_config: PbsConfig, + relays: Vec, +) -> PbsModuleConfig { + PbsModuleConfig { + chain, + endpoint: SocketAddr::new(pbs_config.host.into(), pbs_config.port), + pbs_config: Arc::new(pbs_config), + signer_client: None, + event_publisher: None, + all_relays: relays.clone(), + relays, + muxes: None, + } +} diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs new file mode 100644 index 00000000..4e19ea24 --- /dev/null +++ b/tests/tests/pbs_get_header.rs @@ -0,0 +1,49 @@ +mod common; + +use std::{ + sync::Arc, + time::Duration, +}; + +use cb_common::{ + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, +}; +use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; +use cb_tests::{ + mock_relay::{start_mock_relay_service, MockRelayState}, + mock_validator::MockValidator, + utils::{generate_mock_relay, setup_test_env}, +}; +use eyre::Result; +use tracing::info; + +#[tokio::test] +async fn test_get_header() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3000; + + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + let mock_relay = generate_mock_relay(port + 1, *pubkey)?; + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + + let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), vec![mock_relay]); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending get header"); + let res = mock_validator.do_get_header(None).await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_get_header(), 1); + Ok(()) +} \ No newline at end of file diff --git a/tests/tests/pbs_get_status.rs b/tests/tests/pbs_get_status.rs new file mode 100644 index 00000000..201bff79 --- /dev/null +++ b/tests/tests/pbs_get_status.rs @@ -0,0 +1,51 @@ +mod common; + +use std::{ + sync::Arc, + time::Duration, +}; + +use cb_common::{ + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, +}; +use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; +use cb_tests::{ + mock_relay::{start_mock_relay_service, MockRelayState}, + mock_validator::MockValidator, + utils::{generate_mock_relay, setup_test_env}, +}; +use eyre::Result; +use tracing::info; + +#[tokio::test] +async fn test_get_status() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3100; + + let relays = + vec![generate_mock_relay(port + 1, *pubkey)?, generate_mock_relay(port + 2, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); + + let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending get status"); + let res = mock_validator.do_get_status().await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_get_status(), 2); + Ok(()) +} \ No newline at end of file diff --git a/tests/tests/pbs_integration.rs b/tests/tests/pbs_integration.rs deleted file mode 100644 index cc8f5d27..00000000 --- a/tests/tests/pbs_integration.rs +++ /dev/null @@ -1,271 +0,0 @@ -use std::{ - collections::HashMap, - net::{Ipv4Addr, SocketAddr}, - sync::Arc, - time::Duration, - u64, -}; - -use alloy::primitives::U256; -use cb_common::{ - config::{PbsConfig, PbsModuleConfig, RuntimeMuxConfig}, - pbs::RelayClient, - signer::{random_secret, BlsPublicKey}, - types::Chain, - utils::blst_pubkey_to_alloy, -}; -use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; -use cb_tests::{ - mock_relay::{start_mock_relay_service, MockRelayState}, - mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, -}; -use eyre::Result; -use tracing::info; - -fn get_pbs_static_config(port: u16) -> PbsConfig { - PbsConfig { - host: Ipv4Addr::UNSPECIFIED, - port, - wait_all_registrations: true, - relay_check: true, - timeout_get_header_ms: u64::MAX, - timeout_get_payload_ms: u64::MAX, - timeout_register_validator_ms: u64::MAX, - skip_sigverify: false, - min_bid_wei: U256::ZERO, - late_in_slot_time_ms: u64::MAX, - relay_monitors: vec![], - extra_validation_enabled: false, - rpc_url: None, - } -} - -fn to_pbs_config(chain: Chain, pbs_config: PbsConfig, relays: Vec) -> PbsModuleConfig { - PbsModuleConfig { - chain, - endpoint: SocketAddr::new(pbs_config.host.into(), pbs_config.port), - pbs_config: Arc::new(pbs_config), - signer_client: None, - event_publisher: None, - all_relays: relays.clone(), - relays, - muxes: None, - } -} - -#[tokio::test] -async fn test_get_header() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3000; - - let mock_state = Arc::new(MockRelayState::new(chain, signer)); - let mock_relay = generate_mock_relay(port + 1, *pubkey)?; - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - - let config = to_pbs_config(chain, get_pbs_static_config(port), vec![mock_relay]); - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending get header"); - let res = mock_validator.do_get_header(None).await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_get_header(), 1); - Ok(()) -} - -#[tokio::test] -async fn test_get_status() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3100; - - let relays = - vec![generate_mock_relay(port + 1, *pubkey)?, generate_mock_relay(port + 2, *pubkey)?]; - let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); - - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending get status"); - let res = mock_validator.do_get_status().await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_get_status(), 2); - Ok(()) -} - -#[tokio::test] -async fn test_register_validators() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3300; - - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; - let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending register validator"); - let res = mock_validator.do_register_validator().await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_register_validator(), 1); - Ok(()) -} - -#[tokio::test] -async fn test_submit_block() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3400; - - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; - let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending submit block"); - let res = mock_validator.do_submit_block().await; - - assert!(res.is_err()); - assert_eq!(mock_state.received_submit_block(), 1); - Ok(()) -} - -#[tokio::test] -async fn test_submit_block_too_large() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3500; - - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; - let mock_state = Arc::new(MockRelayState::new(chain, signer).with_large_body()); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending submit block"); - let res = mock_validator.do_submit_block().await; - - assert!(res.is_err()); - assert_eq!(mock_state.received_submit_block(), 1); - Ok(()) -} - -#[tokio::test] -async fn test_mux() -> Result<()> { - setup_test_env(); - let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); - - let chain = Chain::Holesky; - let port = 3600; - - let mux_relay_1 = generate_mock_relay(port + 1, *pubkey)?; - let mux_relay_2 = generate_mock_relay(port + 2, *pubkey)?; - let default_relay = generate_mock_relay(port + 3, *pubkey)?; - - let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 3)); - - let relays = vec![default_relay.clone()]; - let mut config = to_pbs_config(chain, get_pbs_static_config(port), relays); - config.all_relays = vec![mux_relay_1.clone(), mux_relay_2.clone(), default_relay.clone()]; - - let mux = RuntimeMuxConfig { - id: String::from("test"), - config: config.pbs_config.clone(), - relays: vec![mux_relay_1, mux_relay_2], - }; - - let validator_pubkey = blst_pubkey_to_alloy(&random_secret().sk_to_pk()); - - config.muxes = Some(HashMap::from([(validator_pubkey, mux)])); - - let state = PbsState::new(config); - tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); - - // leave some time to start servers - tokio::time::sleep(Duration::from_millis(100)).await; - - let mock_validator = MockValidator::new(port)?; - info!("Sending get header with default"); - let res = mock_validator.do_get_header(None).await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_get_header(), 1); // only default relay was used - - info!("Sending get header with mux"); - let res = mock_validator.do_get_header(Some(validator_pubkey)).await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_get_header(), 3); // two mux relays were used - - let res = mock_validator.do_get_status().await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_get_status(), 3); // default + 2 mux relays were used - - let res = mock_validator.do_register_validator().await; - - assert!(res.is_ok()); - assert_eq!(mock_state.received_register_validator(), 3); // default + 2 mux relays were used - - let res = mock_validator.do_submit_block().await; - - assert!(res.is_err()); - assert_eq!(mock_state.received_submit_block(), 3); // default + 2 mux relays were used - - Ok(()) -} diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs new file mode 100644 index 00000000..4c6d4cc1 --- /dev/null +++ b/tests/tests/pbs_mux.rs @@ -0,0 +1,88 @@ +mod common; + +use std::{ + collections::HashMap, + sync::Arc, + time::Duration, +}; + +use cb_common::{ + config::RuntimeMuxConfig, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy +}; +use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; +use cb_tests::{ + mock_relay::{start_mock_relay_service, MockRelayState}, + mock_validator::MockValidator, + utils::{generate_mock_relay, setup_test_env}, +}; +use eyre::Result; +use tracing::info; + +#[tokio::test] +async fn test_mux() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3600; + + let mux_relay_1 = generate_mock_relay(port + 1, *pubkey)?; + let mux_relay_2 = generate_mock_relay(port + 2, *pubkey)?; + let default_relay = generate_mock_relay(port + 3, *pubkey)?; + + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 3)); + + let relays = vec![default_relay.clone()]; + let mut config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + config.all_relays = vec![mux_relay_1.clone(), mux_relay_2.clone(), default_relay.clone()]; + + let mux = RuntimeMuxConfig { + id: String::from("test"), + config: config.pbs_config.clone(), + relays: vec![mux_relay_1, mux_relay_2], + }; + + let validator_pubkey = blst_pubkey_to_alloy(&random_secret().sk_to_pk()); + + config.muxes = Some(HashMap::from([(validator_pubkey, mux)])); + + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending get header with default"); + let res = mock_validator.do_get_header(None).await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_get_header(), 1); // only default relay was used + + info!("Sending get header with mux"); + let res = mock_validator.do_get_header(Some(validator_pubkey)).await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_get_header(), 3); // two mux relays were used + + let res = mock_validator.do_get_status().await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_get_status(), 3); // default + 2 mux relays were used + + let res = mock_validator.do_register_validator().await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_register_validator(), 3); // default + 2 mux relays were used + + let res = mock_validator.do_submit_block().await; + + assert!(res.is_err()); + assert_eq!(mock_state.received_submit_block(), 3); // default + 2 mux relays were used + + Ok(()) +} diff --git a/tests/tests/pbs_post_blinded_blocks.rs b/tests/tests/pbs_post_blinded_blocks.rs new file mode 100644 index 00000000..ea6742d5 --- /dev/null +++ b/tests/tests/pbs_post_blinded_blocks.rs @@ -0,0 +1,78 @@ +mod common; + +use std::{ + sync::Arc, + time::Duration, +}; + +use cb_common::{ + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, +}; +use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; +use cb_tests::{ + mock_relay::{start_mock_relay_service, MockRelayState}, + mock_validator::MockValidator, + utils::{generate_mock_relay, setup_test_env}, +}; +use eyre::Result; +use tracing::info; + +#[tokio::test] +async fn test_submit_block() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3400; + + let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + + let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending submit block"); + let res = mock_validator.do_submit_block().await; + + assert!(res.is_err()); + assert_eq!(mock_state.received_submit_block(), 1); + Ok(()) +} + +#[tokio::test] +async fn test_submit_block_too_large() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3500; + + let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer).with_large_body()); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + + let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending submit block"); + let res = mock_validator.do_submit_block().await; + + assert!(res.is_err()); + assert_eq!(mock_state.received_submit_block(), 1); + Ok(()) +} diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs new file mode 100644 index 00000000..93353b4e --- /dev/null +++ b/tests/tests/pbs_post_validators.rs @@ -0,0 +1,49 @@ +mod common; + +use std::{ + sync::Arc, + time::Duration, +}; + +use cb_common::{ + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, +}; +use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; +use cb_tests::{ + mock_relay::{start_mock_relay_service, MockRelayState}, + mock_validator::MockValidator, + utils::{generate_mock_relay, setup_test_env}, +}; +use eyre::Result; +use tracing::info; + +#[tokio::test] +async fn test_register_validators() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let port = 3300; + + let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + + let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(port)?; + info!("Sending register validator"); + let res = mock_validator.do_register_validator().await; + + assert!(res.is_ok()); + assert_eq!(mock_state.received_register_validator(), 1); + Ok(()) +} From 3dd111a027a90d58bda5a9582e2c118607628083 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 14:56:16 -0800 Subject: [PATCH 04/13] use tests/src/utils.rs instead of common.rs --- tests/src/utils.rs | 53 ++++++++++++++++++++++++-- tests/tests/common/mod.rs | 47 ----------------------- tests/tests/pbs_get_header.rs | 7 ++-- tests/tests/pbs_get_status.rs | 6 +-- tests/tests/pbs_mux.rs | 6 +-- tests/tests/pbs_post_blinded_blocks.rs | 8 ++-- tests/tests/pbs_post_validators.rs | 6 +-- 7 files changed, 61 insertions(+), 72 deletions(-) delete mode 100644 tests/tests/common/mod.rs diff --git a/tests/src/utils.rs b/tests/src/utils.rs index 5fdb425c..ebe71480 100644 --- a/tests/src/utils.rs +++ b/tests/src/utils.rs @@ -1,12 +1,21 @@ -use std::sync::Once; - -use alloy::rpc::types::beacon::BlsPublicKey; use cb_common::{ - config::RelayConfig, + config::{PbsConfig, PbsModuleConfig, RelayConfig}, pbs::{RelayClient, RelayEntry}, + types::Chain, }; use eyre::Result; +use std::{ + net::{Ipv4Addr, SocketAddr}, + sync::{Arc, Once}, + u64, +}; + +use alloy::{ + primitives::U256, + rpc::types::beacon::BlsPublicKey, +}; + pub fn get_local_address(port: u16) -> String { format!("http://0.0.0.0:{port}") } @@ -31,3 +40,39 @@ pub fn generate_mock_relay(port: u16, pubkey: BlsPublicKey) -> Result PbsConfig { + PbsConfig { + host: Ipv4Addr::UNSPECIFIED, + port, + wait_all_registrations: true, + relay_check: true, + timeout_get_header_ms: u64::MAX, + timeout_get_payload_ms: u64::MAX, + timeout_register_validator_ms: u64::MAX, + skip_sigverify: false, + min_bid_wei: U256::ZERO, + late_in_slot_time_ms: u64::MAX, + relay_monitors: vec![], + extra_validation_enabled: false, + rpc_url: None, + } +} + +pub fn to_pbs_config( + chain: Chain, + pbs_config: PbsConfig, + relays: Vec, +) -> PbsModuleConfig { + PbsModuleConfig { + chain, + endpoint: SocketAddr::new(pbs_config.host.into(), pbs_config.port), + pbs_config: Arc::new(pbs_config), + signer_client: None, + event_publisher: None, + all_relays: relays.clone(), + relays, + muxes: None, + } +} + diff --git a/tests/tests/common/mod.rs b/tests/tests/common/mod.rs deleted file mode 100644 index 4d0d37ef..00000000 --- a/tests/tests/common/mod.rs +++ /dev/null @@ -1,47 +0,0 @@ -use std::{ - net::{Ipv4Addr, SocketAddr}, - sync::Arc, - u64, -}; - -use alloy::primitives::U256; -use cb_common::{ - config::{PbsConfig, PbsModuleConfig}, - pbs::RelayClient, - types::Chain, -}; - -pub fn get_pbs_static_config(port: u16) -> PbsConfig { - PbsConfig { - host: Ipv4Addr::UNSPECIFIED, - port, - wait_all_registrations: true, - relay_check: true, - timeout_get_header_ms: u64::MAX, - timeout_get_payload_ms: u64::MAX, - timeout_register_validator_ms: u64::MAX, - skip_sigverify: false, - min_bid_wei: U256::ZERO, - late_in_slot_time_ms: u64::MAX, - relay_monitors: vec![], - extra_validation_enabled: false, - rpc_url: None, - } -} - -pub fn to_pbs_config( - chain: Chain, - pbs_config: PbsConfig, - relays: Vec, -) -> PbsModuleConfig { - PbsModuleConfig { - chain, - endpoint: SocketAddr::new(pbs_config.host.into(), pbs_config.port), - pbs_config: Arc::new(pbs_config), - signer_client: None, - event_publisher: None, - all_relays: relays.clone(), - relays, - muxes: None, - } -} diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index 4e19ea24..d7681873 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -1,5 +1,3 @@ -mod common; - use std::{ sync::Arc, time::Duration, @@ -14,7 +12,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, + utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; use tracing::info; @@ -32,7 +30,7 @@ async fn test_get_header() -> Result<()> { let mock_relay = generate_mock_relay(port + 1, *pubkey)?; tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), vec![mock_relay]); + let config = to_pbs_config(chain, get_pbs_static_config(port), vec![mock_relay]); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); @@ -42,6 +40,7 @@ async fn test_get_header() -> Result<()> { let mock_validator = MockValidator::new(port)?; info!("Sending get header"); let res = mock_validator.do_get_header(None).await; + dbg!(&res); assert!(res.is_ok()); assert_eq!(mock_state.received_get_header(), 1); diff --git a/tests/tests/pbs_get_status.rs b/tests/tests/pbs_get_status.rs index 201bff79..ff1d394d 100644 --- a/tests/tests/pbs_get_status.rs +++ b/tests/tests/pbs_get_status.rs @@ -1,5 +1,3 @@ -mod common; - use std::{ sync::Arc, time::Duration, @@ -14,7 +12,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, + utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; use tracing::info; @@ -34,7 +32,7 @@ async fn test_get_status() -> Result<()> { tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); - let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs index 4c6d4cc1..5179cd00 100644 --- a/tests/tests/pbs_mux.rs +++ b/tests/tests/pbs_mux.rs @@ -1,5 +1,3 @@ -mod common; - use std::{ collections::HashMap, sync::Arc, @@ -13,7 +11,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, + utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; use tracing::info; @@ -37,7 +35,7 @@ async fn test_mux() -> Result<()> { tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 3)); let relays = vec![default_relay.clone()]; - let mut config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let mut config = to_pbs_config(chain, get_pbs_static_config(port), relays); config.all_relays = vec![mux_relay_1.clone(), mux_relay_2.clone(), default_relay.clone()]; let mux = RuntimeMuxConfig { diff --git a/tests/tests/pbs_post_blinded_blocks.rs b/tests/tests/pbs_post_blinded_blocks.rs index ea6742d5..cae62ad0 100644 --- a/tests/tests/pbs_post_blinded_blocks.rs +++ b/tests/tests/pbs_post_blinded_blocks.rs @@ -1,5 +1,3 @@ -mod common; - use std::{ sync::Arc, time::Duration, @@ -14,7 +12,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, + utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; use tracing::info; @@ -32,7 +30,7 @@ async fn test_submit_block() -> Result<()> { let mock_state = Arc::new(MockRelayState::new(chain, signer)); tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); @@ -61,7 +59,7 @@ async fn test_submit_block_too_large() -> Result<()> { let mock_state = Arc::new(MockRelayState::new(chain, signer).with_large_body()); tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs index 93353b4e..31898f1c 100644 --- a/tests/tests/pbs_post_validators.rs +++ b/tests/tests/pbs_post_validators.rs @@ -1,5 +1,3 @@ -mod common; - use std::{ sync::Arc, time::Duration, @@ -14,7 +12,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env}, + utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; use tracing::info; @@ -32,7 +30,7 @@ async fn test_register_validators() -> Result<()> { let mock_state = Arc::new(MockRelayState::new(chain, signer)); tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - let config = common::to_pbs_config(chain, common::get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); From 2c37eac58de00b713bf41989e9c466d5b5202c5d Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 17:02:13 -0800 Subject: [PATCH 05/13] fix test_get_header() --- tests/src/mock_relay.rs | 2 +- tests/src/mock_validator.rs | 11 +++++++---- tests/tests/pbs_get_header.rs | 23 ++++++++++++++--------- 3 files changed, 22 insertions(+), 14 deletions(-) diff --git a/tests/src/mock_relay.rs b/tests/src/mock_relay.rs index 672ca806..5b205370 100644 --- a/tests/src/mock_relay.rs +++ b/tests/src/mock_relay.rs @@ -104,7 +104,7 @@ async fn handle_get_header( response.data.message.header.block_hash.0[0] = 1; response.data.message.value = U256::from(10); response.data.message.pubkey = blst_pubkey_to_alloy(&state.signer.sk_to_pk()); - response.data.message.header.timestamp = timestamp_of_slot_start_sec(0, state.chain); + response.data.message.header.timestamp = timestamp_of_slot_start_sec(1337, state.chain); let object_root = response.data.message.tree_hash_root().0; response.data.signature = sign_builder_root(state.chain, &state.signer, object_root); diff --git a/tests/src/mock_validator.rs b/tests/src/mock_validator.rs index a8f6a8a3..1ef6ca46 100644 --- a/tests/src/mock_validator.rs +++ b/tests/src/mock_validator.rs @@ -2,7 +2,7 @@ use alloy::{ primitives::B256, rpc::types::beacon::{relay::ValidatorRegistration, BlsPublicKey}, }; -use cb_common::pbs::{GetHeaderResponse, RelayClient, SignedBlindedBeaconBlock}; +use cb_common::pbs::{GetHeaderResponse, RelayClient, SignedBlindedBeaconBlock, SignedExecutionPayloadHeader, VersionedResponse}; use reqwest::Error; use crate::utils::generate_mock_relay; @@ -16,15 +16,18 @@ impl MockValidator { Ok(Self { comm_boost: generate_mock_relay(port, BlsPublicKey::default())? }) } - pub async fn do_get_header(&self, pubkey: Option) -> Result<(), Error> { + pub fn from_relay(relay: RelayClient) -> eyre::Result { + Ok(Self { comm_boost: relay }) + } + + pub async fn do_get_header(&self, pubkey: Option) -> eyre::Result> { let url = self .comm_boost .get_header_url(0, B256::ZERO, pubkey.unwrap_or(BlsPublicKey::ZERO)) .unwrap(); let res = self.comm_boost.client.get(url).send().await?.bytes().await?; - assert!(serde_json::from_slice::(&res).is_ok()); - Ok(()) + Ok(serde_json::from_slice::(&res)?) } pub async fn do_get_status(&self) -> Result<(), Error> { diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index d7681873..dae10792 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -3,10 +3,9 @@ use std::{ time::Duration, }; +use alloy::primitives::{B256, U256}; use cb_common::{ - signer::{random_secret, BlsPublicKey}, - types::Chain, - utils::blst_pubkey_to_alloy, + signature::sign_builder_root, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ @@ -16,6 +15,8 @@ use cb_tests::{ }; use eyre::Result; use tracing::info; +use cb_common::utils::timestamp_of_slot_start_sec; +use tree_hash::TreeHash; #[tokio::test] async fn test_get_header() -> Result<()> { @@ -30,19 +31,23 @@ async fn test_get_header() -> Result<()> { let mock_relay = generate_mock_relay(port + 1, *pubkey)?; tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - let config = to_pbs_config(chain, get_pbs_static_config(port), vec![mock_relay]); + let config = to_pbs_config(chain, get_pbs_static_config(port), vec![mock_relay.clone()]); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + let mock_validator = MockValidator::from_relay(mock_relay)?; info!("Sending get header"); - let res = mock_validator.do_get_header(None).await; - dbg!(&res); + let res = mock_validator.do_get_header(None).await.expect("failed to get header"); - assert!(res.is_ok()); assert_eq!(mock_state.received_get_header(), 1); + assert_eq!(res.data.message.header.block_hash.0[0], 1); + assert_eq!(res.data.message.header.parent_hash, B256::ZERO); + assert_eq!(res.data.message.value, U256::from(10)); + assert_eq!(res.data.message.pubkey, blst_pubkey_to_alloy(&mock_state.signer.sk_to_pk())); + assert_eq!(res.data.message.header.timestamp, timestamp_of_slot_start_sec(1337, chain)); + assert_eq!(res.data.signature, sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root().0)); Ok(()) -} \ No newline at end of file +} From 913d4c471f75808b4c24035fd511b36134af6b20 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 15 Jan 2025 19:18:59 -0800 Subject: [PATCH 06/13] Tidy up existing PBS integration tests --- tests/src/mock_relay.rs | 21 ++++----- tests/src/mock_validator.rs | 49 +++++++++++---------- tests/tests/pbs_get_header.rs | 15 ++++--- tests/tests/pbs_get_status.rs | 23 +++++----- tests/tests/pbs_mux.rs | 60 +++++++++++++------------- tests/tests/pbs_post_blinded_blocks.rs | 36 +++++++++------- tests/tests/pbs_post_validators.rs | 18 +++++--- 7 files changed, 118 insertions(+), 104 deletions(-) diff --git a/tests/src/mock_relay.rs b/tests/src/mock_relay.rs index 5b205370..402e2f8f 100644 --- a/tests/src/mock_relay.rs +++ b/tests/src/mock_relay.rs @@ -62,6 +62,9 @@ impl MockRelayState { pub fn received_submit_block(&self) -> u64 { self.received_submit_block.load(Ordering::Relaxed) } + pub fn large_body(&self) -> bool { + self.large_body + } } impl MockRelayState { @@ -104,11 +107,11 @@ async fn handle_get_header( response.data.message.header.block_hash.0[0] = 1; response.data.message.value = U256::from(10); response.data.message.pubkey = blst_pubkey_to_alloy(&state.signer.sk_to_pk()); - response.data.message.header.timestamp = timestamp_of_slot_start_sec(1337, state.chain); + response.data.message.header.timestamp = timestamp_of_slot_start_sec(0, state.chain); let object_root = response.data.message.tree_hash_root().0; response.data.signature = sign_builder_root(state.chain, &state.signer, object_root); - (StatusCode::OK, axum::Json(response)).into_response() + (StatusCode::OK, Json(response)).into_response() } async fn handle_get_status(State(state): State>) -> impl IntoResponse { @@ -125,14 +128,12 @@ async fn handle_register_validator( StatusCode::OK } -async fn handle_submit_block(State(state): State>) -> impl IntoResponse { +async fn handle_submit_block(State(state): State>) -> Response { state.received_submit_block.fetch_add(1, Ordering::Relaxed); - - let response = if state.large_body { - vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK] + if state.large_body() { + (StatusCode::BAD_REQUEST, Json(vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK])).into_response() } else { - serde_json::to_vec(&SubmitBlindedBlockResponse::default()).unwrap() - }; - - (StatusCode::OK, Json(response)).into_response() + let response = SubmitBlindedBlockResponse::default(); + (StatusCode::OK, Json(response)).into_response() + } } diff --git a/tests/src/mock_validator.rs b/tests/src/mock_validator.rs index 1ef6ca46..94d55e21 100644 --- a/tests/src/mock_validator.rs +++ b/tests/src/mock_validator.rs @@ -2,8 +2,11 @@ use alloy::{ primitives::B256, rpc::types::beacon::{relay::ValidatorRegistration, BlsPublicKey}, }; -use cb_common::pbs::{GetHeaderResponse, RelayClient, SignedBlindedBeaconBlock, SignedExecutionPayloadHeader, VersionedResponse}; -use reqwest::Error; +use cb_common::pbs::{ + GetHeaderResponse, RelayClient, SignedBlindedBeaconBlock, SignedExecutionPayloadHeader, + SubmitBlindedBlockResponse, VersionedResponse, +}; +use reqwest::{Error, Response}; use crate::utils::generate_mock_relay; @@ -16,51 +19,47 @@ impl MockValidator { Ok(Self { comm_boost: generate_mock_relay(port, BlsPublicKey::default())? }) } - pub fn from_relay(relay: RelayClient) -> eyre::Result { - Ok(Self { comm_boost: relay }) - } - - pub async fn do_get_header(&self, pubkey: Option) -> eyre::Result> { - let url = self - .comm_boost - .get_header_url(0, B256::ZERO, pubkey.unwrap_or(BlsPublicKey::ZERO)) - .unwrap(); + pub async fn do_get_header( + &self, + pubkey: Option, + ) -> eyre::Result { + let url = + self.comm_boost.get_header_url(0, B256::ZERO, pubkey.unwrap_or(BlsPublicKey::ZERO))?; let res = self.comm_boost.client.get(url).send().await?.bytes().await?; Ok(serde_json::from_slice::(&res)?) } - pub async fn do_get_status(&self) -> Result<(), Error> { - let url = self.comm_boost.get_status_url().unwrap(); - let _res = self.comm_boost.client.get(url).send().await?; - // assert!(res.status().is_success()); - - Ok(()) + pub async fn do_get_status(&self) -> eyre::Result { + let url = self.comm_boost.get_status_url()?; + Ok(self.comm_boost.client.get(url).send().await?) } - pub async fn do_register_validator(&self) -> Result<(), Error> { + pub async fn do_register_validator(&self) -> eyre::Result { let url = self.comm_boost.register_validator_url().unwrap(); let registration: Vec = vec![]; - self.comm_boost.client.post(url).json(®istration).send().await?.error_for_status()?; - - Ok(()) + Ok(self.comm_boost.client.post(url).json(®istration).send().await?.error_for_status()?) } - pub async fn do_submit_block(&self) -> Result<(), Error> { + pub async fn do_submit_block( + &self, + ) -> eyre::Result { let url = self.comm_boost.submit_block_url().unwrap(); let signed_blinded_block = SignedBlindedBeaconBlock::default(); - self.comm_boost + let res = self + .comm_boost .client .post(url) .json(&signed_blinded_block) .send() .await? - .error_for_status()?; + .bytes() + .await?; - Ok(()) + Ok(serde_json::from_slice::(&res)?) } } diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index dae10792..941f5390 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -25,20 +25,23 @@ async fn test_get_header() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3000; + let pbs_port = 3600; + let relay_port = pbs_port + 1; + // Run a mock relay let mock_state = Arc::new(MockRelayState::new(chain, signer)); - let mock_relay = generate_mock_relay(port + 1, *pubkey)?; - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + let mock_relay = generate_mock_relay(relay_port, *pubkey)?; + tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port)); - let config = to_pbs_config(chain, get_pbs_static_config(port), vec![mock_relay.clone()]); + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), vec![mock_relay.clone()]); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::from_relay(mock_relay)?; + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending get header"); let res = mock_validator.do_get_header(None).await.expect("failed to get header"); @@ -47,7 +50,7 @@ async fn test_get_header() -> Result<()> { assert_eq!(res.data.message.header.parent_hash, B256::ZERO); assert_eq!(res.data.message.value, U256::from(10)); assert_eq!(res.data.message.pubkey, blst_pubkey_to_alloy(&mock_state.signer.sk_to_pk())); - assert_eq!(res.data.message.header.timestamp, timestamp_of_slot_start_sec(1337, chain)); + assert_eq!(res.data.message.header.timestamp, timestamp_of_slot_start_sec(0, chain)); assert_eq!(res.data.signature, sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root().0)); Ok(()) } diff --git a/tests/tests/pbs_get_status.rs b/tests/tests/pbs_get_status.rs index ff1d394d..7e3ef9d6 100644 --- a/tests/tests/pbs_get_status.rs +++ b/tests/tests/pbs_get_status.rs @@ -15,6 +15,7 @@ use cb_tests::{ utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; +use reqwest::StatusCode; use tracing::info; #[tokio::test] @@ -24,26 +25,28 @@ async fn test_get_status() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3100; + let pbs_port = 3100; + let relay_0_port = pbs_port + 1; + let relay_1_port = pbs_port + 2; - let relays = - vec![generate_mock_relay(port + 1, *pubkey)?, generate_mock_relay(port + 2, *pubkey)?]; + let relays = vec![generate_mock_relay(relay_0_port, *pubkey)?, generate_mock_relay(relay_1_port, *pubkey)?]; let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_0_port)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_1_port)); - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays.clone()); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending get status"); - let res = mock_validator.do_get_status().await; + let res = mock_validator.do_get_status().await.expect("failed to get status"); + assert_eq!(res.status(), StatusCode::OK); - assert!(res.is_ok()); + // Expect two statuses since two relays in config assert_eq!(mock_state.received_get_status(), 2); Ok(()) -} \ No newline at end of file +} diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs index 5179cd00..6b1194a8 100644 --- a/tests/tests/pbs_mux.rs +++ b/tests/tests/pbs_mux.rs @@ -1,17 +1,16 @@ -use std::{ - collections::HashMap, - sync::Arc, - time::Duration, -}; +use std::{collections::HashMap, sync::Arc, time::Duration}; use cb_common::{ - config::RuntimeMuxConfig, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy + config::RuntimeMuxConfig, + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, + utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; use tracing::info; @@ -23,63 +22,64 @@ async fn test_mux() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3600; + let pbs_port = 3600; - let mux_relay_1 = generate_mock_relay(port + 1, *pubkey)?; - let mux_relay_2 = generate_mock_relay(port + 2, *pubkey)?; - let default_relay = generate_mock_relay(port + 3, *pubkey)?; + let mux_relay_1 = generate_mock_relay(pbs_port + 1, *pubkey)?; + let mux_relay_2 = generate_mock_relay(pbs_port + 2, *pubkey)?; + let default_relay = generate_mock_relay(pbs_port + 3, *pubkey)?; + // Run 3 mock relays let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 2)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 3)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 2)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 3)); + // Register all relays in PBS config let relays = vec![default_relay.clone()]; - let mut config = to_pbs_config(chain, get_pbs_static_config(port), relays); + let mut config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); config.all_relays = vec![mux_relay_1.clone(), mux_relay_2.clone(), default_relay.clone()]; + // Configure mux for two relays let mux = RuntimeMuxConfig { id: String::from("test"), config: config.pbs_config.clone(), relays: vec![mux_relay_1, mux_relay_2], }; + // Bind mux to a specific validator key let validator_pubkey = blst_pubkey_to_alloy(&random_secret().sk_to_pk()); - config.muxes = Some(HashMap::from([(validator_pubkey, mux)])); + // Run PBS service let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + // Send default request without specifying a validator key + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending get header with default"); - let res = mock_validator.do_get_header(None).await; + let _res = mock_validator.do_get_header(None).await.expect("failed to get header"); - assert!(res.is_ok()); assert_eq!(mock_state.received_get_header(), 1); // only default relay was used + // Send request specifying a validator key to use mux info!("Sending get header with mux"); - let res = mock_validator.do_get_header(Some(validator_pubkey)).await; + mock_validator.do_get_header(Some(validator_pubkey)).await.expect("failed to get header"); - assert!(res.is_ok()); assert_eq!(mock_state.received_get_header(), 3); // two mux relays were used - let res = mock_validator.do_get_status().await; - - assert!(res.is_ok()); + // Status requests should go to all relays + mock_validator.do_get_status().await.expect("failed to get status"); assert_eq!(mock_state.received_get_status(), 3); // default + 2 mux relays were used - let res = mock_validator.do_register_validator().await; - - assert!(res.is_ok()); + // Register requests should go to all relays + mock_validator.do_register_validator().await.expect("failed to register validator"); assert_eq!(mock_state.received_register_validator(), 3); // default + 2 mux relays were used - let res = mock_validator.do_submit_block().await; - - assert!(res.is_err()); + // Submit block requests should go to all relays + mock_validator.do_submit_block().await.expect("failed to submit block"); assert_eq!(mock_state.received_submit_block(), 3); // default + 2 mux relays were used Ok(()) diff --git a/tests/tests/pbs_post_blinded_blocks.rs b/tests/tests/pbs_post_blinded_blocks.rs index cae62ad0..482d2f7b 100644 --- a/tests/tests/pbs_post_blinded_blocks.rs +++ b/tests/tests/pbs_post_blinded_blocks.rs @@ -4,9 +4,7 @@ use std::{ }; use cb_common::{ - signer::{random_secret, BlsPublicKey}, - types::Chain, - utils::blst_pubkey_to_alloy, + pbs::SubmitBlindedBlockResponse, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ @@ -24,25 +22,29 @@ async fn test_submit_block() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3400; + let pbs_port = 3700; - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + // Run a mock relay + let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending submit block"); - let res = mock_validator.do_submit_block().await; + let res = mock_validator.do_submit_block().await.expect("failed to submit block"); - assert!(res.is_err()); assert_eq!(mock_state.received_submit_block(), 1); + + let expected_response = SubmitBlindedBlockResponse::default(); + assert_eq!(res.block_hash(), expected_response.block_hash()); Ok(()) } @@ -53,24 +55,26 @@ async fn test_submit_block_too_large() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3500; + let pbs_port = 3600; - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; let mock_state = Arc::new(MockRelayState::new(chain, signer).with_large_body()); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + dbg!(&mock_state.large_body()); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending submit block"); let res = mock_validator.do_submit_block().await; - + // dbg!(&res); assert!(res.is_err()); + assert_eq!(mock_state.received_submit_block(), 1); Ok(()) } diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs index 31898f1c..4366f6d5 100644 --- a/tests/tests/pbs_post_validators.rs +++ b/tests/tests/pbs_post_validators.rs @@ -15,6 +15,7 @@ use cb_tests::{ utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; +use reqwest::StatusCode; use tracing::info; #[tokio::test] @@ -24,24 +25,27 @@ async fn test_register_validators() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let port = 3300; + let pbs_port = 3600; - let relays = vec![generate_mock_relay(port + 1, *pubkey)?]; + // Run a mock relay + let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; let mock_state = Arc::new(MockRelayState::new(chain, signer)); - tokio::spawn(start_mock_relay_service(mock_state.clone(), port + 1)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); - let config = to_pbs_config(chain, get_pbs_static_config(port), relays); + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); let state = PbsState::new(config); tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); // leave some time to start servers tokio::time::sleep(Duration::from_millis(100)).await; - let mock_validator = MockValidator::new(port)?; + let mock_validator = MockValidator::new(pbs_port)?; info!("Sending register validator"); - let res = mock_validator.do_register_validator().await; + let res = mock_validator.do_register_validator().await.expect("failed to register validator"); - assert!(res.is_ok()); assert_eq!(mock_state.received_register_validator(), 1); + assert_eq!(res.status(), StatusCode::OK); + Ok(()) } From bfab351ecf058ed9dd9a1f59747a0b40788f6fa6 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Thu, 16 Jan 2025 12:01:34 -0800 Subject: [PATCH 07/13] clean mock_validator.rs and include more unhappy path tests --- tests/src/mock_relay.rs | 5 +- tests/src/mock_validator.rs | 35 ++--- tests/tests/pbs_get_header.rs | 87 ++++++++++++- tests/tests/pbs_get_status.rs | 47 ++++++- tests/tests/pbs_mux.rs | 21 +-- tests/tests/pbs_post_blinded_blocks.rs | 31 ++--- tests/tests/pbs_post_validators.rs | 170 ++++++++++++++++++++++++- 7 files changed, 332 insertions(+), 64 deletions(-) diff --git a/tests/src/mock_relay.rs b/tests/src/mock_relay.rs index 402e2f8f..eb699d89 100644 --- a/tests/src/mock_relay.rs +++ b/tests/src/mock_relay.rs @@ -16,8 +16,7 @@ use axum::{ }; use cb_common::{ pbs::{ - GetHeaderParams, GetHeaderResponse, SubmitBlindedBlockResponse, BUILDER_API_PATH, - GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH, + GetHeaderParams, GetHeaderResponse, SubmitBlindedBlockResponse, BUILDER_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH }, signature::sign_builder_root, signer::BlsSecretKey, @@ -131,7 +130,7 @@ async fn handle_register_validator( async fn handle_submit_block(State(state): State>) -> Response { state.received_submit_block.fetch_add(1, Ordering::Relaxed); if state.large_body() { - (StatusCode::BAD_REQUEST, Json(vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK])).into_response() + (StatusCode::OK, Json(vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK])).into_response() } else { let response = SubmitBlindedBlockResponse::default(); (StatusCode::OK, Json(response)).into_response() diff --git a/tests/src/mock_validator.rs b/tests/src/mock_validator.rs index 94d55e21..16c54b21 100644 --- a/tests/src/mock_validator.rs +++ b/tests/src/mock_validator.rs @@ -11,7 +11,7 @@ use reqwest::{Error, Response}; use crate::utils::generate_mock_relay; pub struct MockValidator { - comm_boost: RelayClient, + pub comm_boost: RelayClient, } impl MockValidator { @@ -19,15 +19,10 @@ impl MockValidator { Ok(Self { comm_boost: generate_mock_relay(port, BlsPublicKey::default())? }) } - pub async fn do_get_header( - &self, - pubkey: Option, - ) -> eyre::Result { + pub async fn do_get_header(&self, pubkey: Option) -> eyre::Result { let url = self.comm_boost.get_header_url(0, B256::ZERO, pubkey.unwrap_or(BlsPublicKey::ZERO))?; - let res = self.comm_boost.client.get(url).send().await?.bytes().await?; - - Ok(serde_json::from_slice::(&res)?) + Ok(self.comm_boost.client.get(url).send().await?) } pub async fn do_get_status(&self) -> eyre::Result { @@ -35,31 +30,29 @@ impl MockValidator { Ok(self.comm_boost.client.get(url).send().await?) } - pub async fn do_register_validator(&self) -> eyre::Result { + pub async fn do_register_validator( + &self, + validators: Option>, + ) -> eyre::Result { let url = self.comm_boost.register_validator_url().unwrap(); - let registration: Vec = vec![]; + let registrations = validators.unwrap_or_default(); - Ok(self.comm_boost.client.post(url).json(®istration).send().await?.error_for_status()?) + Ok(self.comm_boost.client.post(url).json(®istrations).send().await?) } pub async fn do_submit_block( &self, - ) -> eyre::Result { + signed_blinded_block: Option, + ) -> eyre::Result { let url = self.comm_boost.submit_block_url().unwrap(); - let signed_blinded_block = SignedBlindedBeaconBlock::default(); - - let res = self + Ok(self .comm_boost .client .post(url) - .json(&signed_blinded_block) + .json(&signed_blinded_block.unwrap_or(SignedBlindedBeaconBlock::default())) .send() - .await? - .bytes() - .await?; - - Ok(serde_json::from_slice::(&res)?) + .await?) } } diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index 941f5390..fc3ea520 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -5,7 +5,7 @@ use std::{ use alloy::primitives::{B256, U256}; use cb_common::{ - signature::sign_builder_root, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy + pbs::GetHeaderResponse, signature::sign_builder_root, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ @@ -14,6 +14,7 @@ use cb_tests::{ utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, }; use eyre::Result; +use reqwest::StatusCode; use tracing::info; use cb_common::utils::timestamp_of_slot_start_sec; use tree_hash::TreeHash; @@ -25,7 +26,7 @@ async fn test_get_header() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3600; + let pbs_port = 3200; let relay_port = pbs_port + 1; // Run a mock relay @@ -43,7 +44,10 @@ async fn test_get_header() -> Result<()> { let mock_validator = MockValidator::new(pbs_port)?; info!("Sending get header"); - let res = mock_validator.do_get_header(None).await.expect("failed to get header"); + let res = mock_validator.do_get_header(None).await?; + assert_eq!(res.status(), StatusCode::OK); + + let res = serde_json::from_slice::(&res.bytes().await?)?; assert_eq!(mock_state.received_get_header(), 1); assert_eq!(res.data.message.header.block_hash.0[0], 1); @@ -54,3 +58,80 @@ async fn test_get_header() -> Result<()> { assert_eq!(res.data.signature, sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root().0)); Ok(()) } + +#[tokio::test] +async fn test_get_header_returns_204_if_relay_down() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let pbs_port = 3300; + let relay_port = pbs_port + 1; + + // Create a mock relay client + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + let mock_relay = generate_mock_relay(relay_port, *pubkey)?; + + // Don't start the relay + // tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port)); + + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), vec![mock_relay.clone()]); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(pbs_port)?; + info!("Sending get header"); + let res = mock_validator.do_get_header(None).await?; + + assert_eq!(res.status(), StatusCode::NO_CONTENT); // 204 error + assert_eq!(mock_state.received_get_header(), 0); // no header received + Ok(()) +} + +#[tokio::test] +async fn test_get_header_returns_400_if_request_is_invalid() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let pbs_port = 3400; + let relay_port = pbs_port + 1; + + // Run a mock relay + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + let mock_relay = generate_mock_relay(relay_port, *pubkey)?; + tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port)); + + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), vec![mock_relay.clone()]); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + // Create an invalid URL by truncating the pubkey + let mut bad_url = mock_relay.get_header_url(0, B256::ZERO, *pubkey).unwrap(); + bad_url.set_path(&bad_url.path().replace(&pubkey.to_string(), &pubkey.to_string()[..10])); + + let mock_validator = MockValidator::new(pbs_port)?; + info!("Sending get header with invalid pubkey URL"); + // Use the bad_url in the request instead of the default + let res = mock_validator.comm_boost.client.get(bad_url).send().await?; + assert_eq!(res.status(), StatusCode::BAD_REQUEST); + + // Attempt again by truncating the parent hash + let mut bad_url = mock_relay.get_header_url(0, B256::ZERO, *pubkey).unwrap(); + bad_url.set_path(&bad_url.path().replace(&B256::ZERO.to_string(), &B256::ZERO.to_string()[..10])); + let res = mock_validator.comm_boost.client.get(bad_url).send().await?; + assert_eq!(res.status(), StatusCode::BAD_REQUEST); + + assert_eq!(mock_state.received_get_header(), 0); // no header received + Ok(()) +} diff --git a/tests/tests/pbs_get_status.rs b/tests/tests/pbs_get_status.rs index 7e3ef9d6..2dd06fd9 100644 --- a/tests/tests/pbs_get_status.rs +++ b/tests/tests/pbs_get_status.rs @@ -1,7 +1,4 @@ -use std::{ - sync::Arc, - time::Duration, -}; +use std::{sync::Arc, time::Duration}; use cb_common::{ signer::{random_secret, BlsPublicKey}, @@ -12,7 +9,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, + utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; use reqwest::StatusCode; @@ -25,11 +22,14 @@ async fn test_get_status() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3100; + let pbs_port = 3500; let relay_0_port = pbs_port + 1; let relay_1_port = pbs_port + 2; - let relays = vec![generate_mock_relay(relay_0_port, *pubkey)?, generate_mock_relay(relay_1_port, *pubkey)?]; + let relays = vec![ + generate_mock_relay(relay_0_port, *pubkey)?, + generate_mock_relay(relay_1_port, *pubkey)?, + ]; let mock_state = Arc::new(MockRelayState::new(chain, signer)); tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_0_port)); tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_1_port)); @@ -50,3 +50,36 @@ async fn test_get_status() -> Result<()> { assert_eq!(mock_state.received_get_status(), 2); Ok(()) } + +#[tokio::test] +async fn test_get_status_returns_502_if_relay_down() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let pbs_port = 3600; + let relay_port = pbs_port + 1; + + let relays = vec![generate_mock_relay(relay_port, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + + // Don't start the relay + // tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port)); + + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays.clone()); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(pbs_port)?; + info!("Sending get status"); + let res = mock_validator.do_get_status().await.expect("failed to get status"); + assert_eq!(res.status(), StatusCode::BAD_GATEWAY); // 502 error + + // Expect no statuses since relay is down + assert_eq!(mock_state.received_get_status(), 0); + Ok(()) +} diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs index 6b1194a8..ca14eb94 100644 --- a/tests/tests/pbs_mux.rs +++ b/tests/tests/pbs_mux.rs @@ -13,6 +13,7 @@ use cb_tests::{ utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; +use reqwest::StatusCode; use tracing::info; #[tokio::test] @@ -22,7 +23,7 @@ async fn test_mux() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3600; + let pbs_port = 3700; let mux_relay_1 = generate_mock_relay(pbs_port + 1, *pubkey)?; let mux_relay_2 = generate_mock_relay(pbs_port + 2, *pubkey)?; @@ -60,26 +61,30 @@ async fn test_mux() -> Result<()> { // Send default request without specifying a validator key let mock_validator = MockValidator::new(pbs_port)?; info!("Sending get header with default"); - let _res = mock_validator.do_get_header(None).await.expect("failed to get header"); - + assert_eq!(mock_validator.do_get_header(None).await?.status(), StatusCode::OK); assert_eq!(mock_state.received_get_header(), 1); // only default relay was used // Send request specifying a validator key to use mux info!("Sending get header with mux"); - mock_validator.do_get_header(Some(validator_pubkey)).await.expect("failed to get header"); - + assert_eq!( + mock_validator.do_get_header(Some(validator_pubkey)).await?.status(), + StatusCode::OK + ); assert_eq!(mock_state.received_get_header(), 3); // two mux relays were used // Status requests should go to all relays - mock_validator.do_get_status().await.expect("failed to get status"); + info!("Sending get status"); + assert_eq!(mock_validator.do_get_status().await?.status(), StatusCode::OK); assert_eq!(mock_state.received_get_status(), 3); // default + 2 mux relays were used // Register requests should go to all relays - mock_validator.do_register_validator().await.expect("failed to register validator"); + info!("Sending register validator"); + assert_eq!(mock_validator.do_register_validator(None).await?.status(), StatusCode::OK); assert_eq!(mock_state.received_register_validator(), 3); // default + 2 mux relays were used // Submit block requests should go to all relays - mock_validator.do_submit_block().await.expect("failed to submit block"); + info!("Sending submit block"); + assert_eq!(mock_validator.do_submit_block(None).await?.status(), StatusCode::OK); assert_eq!(mock_state.received_submit_block(), 3); // default + 2 mux relays were used Ok(()) diff --git a/tests/tests/pbs_post_blinded_blocks.rs b/tests/tests/pbs_post_blinded_blocks.rs index 482d2f7b..64255195 100644 --- a/tests/tests/pbs_post_blinded_blocks.rs +++ b/tests/tests/pbs_post_blinded_blocks.rs @@ -1,18 +1,19 @@ -use std::{ - sync::Arc, - time::Duration, -}; +use std::{sync::Arc, time::Duration}; use cb_common::{ - pbs::SubmitBlindedBlockResponse, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy + pbs::{SignedBlindedBeaconBlock, SubmitBlindedBlockResponse}, + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, + utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; +use reqwest::StatusCode; use tracing::info; #[tokio::test] @@ -22,7 +23,7 @@ async fn test_submit_block() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3700; + let pbs_port = 3800; // Run a mock relay let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; @@ -39,12 +40,13 @@ async fn test_submit_block() -> Result<()> { let mock_validator = MockValidator::new(pbs_port)?; info!("Sending submit block"); - let res = mock_validator.do_submit_block().await.expect("failed to submit block"); + let res = mock_validator.do_submit_block(Some(SignedBlindedBeaconBlock::default())).await?; + assert_eq!(res.status(), StatusCode::OK); assert_eq!(mock_state.received_submit_block(), 1); - let expected_response = SubmitBlindedBlockResponse::default(); - assert_eq!(res.block_hash(), expected_response.block_hash()); + let response_body = serde_json::from_slice::(&res.bytes().await?)?; + assert_eq!(response_body.block_hash(), SubmitBlindedBlockResponse::default().block_hash()); Ok(()) } @@ -55,11 +57,10 @@ async fn test_submit_block_too_large() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3600; + let pbs_port = 3900; let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; let mock_state = Arc::new(MockRelayState::new(chain, signer).with_large_body()); - dbg!(&mock_state.large_body()); tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); @@ -71,10 +72,10 @@ async fn test_submit_block_too_large() -> Result<()> { let mock_validator = MockValidator::new(pbs_port)?; info!("Sending submit block"); - let res = mock_validator.do_submit_block().await; - // dbg!(&res); - assert!(res.is_err()); + let res = mock_validator.do_submit_block(None).await; + // response size exceeds max size: max: 20971520 + assert_eq!(res.unwrap().status(), StatusCode::BAD_GATEWAY); assert_eq!(mock_state.received_submit_block(), 1); Ok(()) } diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs index 4366f6d5..27bd2138 100644 --- a/tests/tests/pbs_post_validators.rs +++ b/tests/tests/pbs_post_validators.rs @@ -1,10 +1,12 @@ -use std::{ - sync::Arc, - time::Duration, +use std::{sync::Arc, time::Duration}; + +use alloy::{ + primitives::Address, + rpc::types::beacon::relay::{ValidatorRegistration, ValidatorRegistrationMessage}, }; use cb_common::{ - signer::{random_secret, BlsPublicKey}, + signer::{random_secret, BlsPublicKey, BlsSignature}, types::Chain, utils::blst_pubkey_to_alloy, }; @@ -12,7 +14,7 @@ use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, + utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; use reqwest::StatusCode; @@ -25,7 +27,7 @@ async fn test_register_validators() -> Result<()> { let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); let chain = Chain::Holesky; - let pbs_port = 3600; + let pbs_port = 4000; // Run a mock relay let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; @@ -42,10 +44,164 @@ async fn test_register_validators() -> Result<()> { let mock_validator = MockValidator::new(pbs_port)?; info!("Sending register validator"); - let res = mock_validator.do_register_validator().await.expect("failed to register validator"); + + let registration: ValidatorRegistration = serde_json::from_str( + r#"{ + "message": { + "fee_recipient": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "gas_limit": "100000", + "timestamp": "1000000", + "pubkey": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + }, + "signature": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" + }"#, + )?; + + let registrations = vec![registration]; + let res = mock_validator.do_register_validator(Some(registrations)).await?; assert_eq!(mock_state.received_register_validator(), 1); assert_eq!(res.status(), StatusCode::OK); Ok(()) } + +#[tokio::test] +async fn test_register_validators_returns_422_if_request_is_malformed() -> Result<()> { + setup_test_env(); + let signer = random_secret(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + + let chain = Chain::Holesky; + let pbs_port = 4100; + + // Run a mock relay + let relays = vec![generate_mock_relay(pbs_port + 1, *pubkey)?]; + let mock_state = Arc::new(MockRelayState::new(chain, signer)); + tokio::spawn(start_mock_relay_service(mock_state.clone(), pbs_port + 1)); + + // Run the PBS service + let config = to_pbs_config(chain, get_pbs_static_config(pbs_port), relays); + let state = PbsState::new(config); + tokio::spawn(PbsService::run::<(), DefaultBuilderApi>(state)); + + // leave some time to start servers + tokio::time::sleep(Duration::from_millis(100)).await; + + let mock_validator = MockValidator::new(pbs_port)?; + let url = mock_validator.comm_boost.register_validator_url().unwrap(); + info!("Sending register validator"); + + // Bad fee recipient + let bad_json = r#"[{ + "message": { + "fee_recipient": "0xaa", + "gas_limit": "100000", + "timestamp": "1000000", + "pubkey": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + }, + "signature": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" + }]"#; + + let res = mock_validator + .comm_boost + .client + .post(url.clone()) + .header("Content-Type", "application/json") + .body(bad_json) + .send() + .await?; + + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); + + // Bad pubkey + let bad_json = r#"[{ + "message": { + "fee_recipient": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "gas_limit": "100000", + "timestamp": "1000000", + "pubkey": "0xbbb" + }, + "signature": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" + }]"#; + + let res = mock_validator + .comm_boost + .client + .post(url.clone()) + .header("Content-Type", "application/json") + .body(bad_json) + .send() + .await?; + + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); + + // Bad signature + let bad_json = r#"[{ + "message": { + "fee_recipient": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "gas_limit": "100000", + "timestamp": "1000000", + "pubkey": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + }, + "signature": "0xcccc" + }]"#; + + let res = mock_validator + .comm_boost + .client + .post(url.clone()) + .header("Content-Type", "application/json") + .body(bad_json) + .send() + .await?; + + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); + + // gas limit too high + let bad_json = r#"[{ + "message": { + "fee_recipient": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "gas_limit": "10000000000000000000000000000000000000000000000000000000", + "timestamp": "1000000", + "pubkey": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" + }, + "signature": "0xcccc" + }]"#; + + let res = mock_validator + .comm_boost + .client + .post(url.clone()) + .header("Content-Type", "application/json") + .body(bad_json) + .send() + .await?; + + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); + + // timestamp too high + let bad_json = r#"[{ + "message": { + "fee_recipient": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "gas_limit": "1000000", + "timestamp": "10000000000000000000000000000000000000000000000000000000", + "pubkey": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" + }, + "signature": "0xcccc" + }]"#; + + let res = mock_validator + .comm_boost + .client + .post(url.clone()) + .header("Content-Type", "application/json") + .body(bad_json) + .send() + .await?; + + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); + + assert_eq!(mock_state.received_register_validator(), 0); + Ok(()) +} From 449ae6c1283ad1e75e859c98b7797f0b8d22a6cb Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Fri, 17 Jan 2025 07:29:28 -0800 Subject: [PATCH 08/13] cargo fmt --- tests/src/mock_relay.rs | 3 ++- tests/src/utils.rs | 6 +----- tests/tests/payloads.rs | 16 ++++++++-------- tests/tests/pbs_get_header.rs | 25 +++++++++++++++---------- 4 files changed, 26 insertions(+), 24 deletions(-) diff --git a/tests/src/mock_relay.rs b/tests/src/mock_relay.rs index eb699d89..f2c87598 100644 --- a/tests/src/mock_relay.rs +++ b/tests/src/mock_relay.rs @@ -16,7 +16,8 @@ use axum::{ }; use cb_common::{ pbs::{ - GetHeaderParams, GetHeaderResponse, SubmitBlindedBlockResponse, BUILDER_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH + GetHeaderParams, GetHeaderResponse, SubmitBlindedBlockResponse, BUILDER_API_PATH, + GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH, }, signature::sign_builder_root, signer::BlsSecretKey, diff --git a/tests/src/utils.rs b/tests/src/utils.rs index ebe71480..80cf6934 100644 --- a/tests/src/utils.rs +++ b/tests/src/utils.rs @@ -11,10 +11,7 @@ use std::{ u64, }; -use alloy::{ - primitives::U256, - rpc::types::beacon::BlsPublicKey, -}; +use alloy::{primitives::U256, rpc::types::beacon::BlsPublicKey}; pub fn get_local_address(port: u16) -> String { format!("http://0.0.0.0:{port}") @@ -75,4 +72,3 @@ pub fn to_pbs_config( muxes: None, } } - diff --git a/tests/tests/payloads.rs b/tests/tests/payloads.rs index c76faf7e..60bb9ce8 100644 --- a/tests/tests/payloads.rs +++ b/tests/tests/payloads.rs @@ -1,9 +1,9 @@ use alloy::rpc::types::beacon::relay::ValidatorRegistration; -use serde_json::Value; use cb_common::{ pbs::{SignedBlindedBeaconBlock, SubmitBlindedBlockResponse}, utils::test_encode_decode, }; +use serde_json::Value; // Happy path tests #[test] @@ -28,7 +28,7 @@ fn test_submit_block_response() { fn test_missing_registration_field(field_name: &str) -> String { let data = include_str!("../data/registration_holesky.json"); let mut values: Value = serde_json::from_str(data).unwrap(); - + // Remove specified field from the first validator's message if let Value::Array(arr) = &mut values { if let Some(first_validator) = arr.get_mut(0) { @@ -49,7 +49,7 @@ fn test_missing_registration_field(field_name: &str) -> String { #[test] fn test_registration_missing_fields() { let fields = ["fee_recipient", "gas_limit", "timestamp", "pubkey"]; - + for field in fields { let error = test_missing_registration_field(field); assert!( @@ -64,7 +64,7 @@ fn test_registration_missing_fields() { fn test_missing_signed_blinded_block_field(field_name: &str) -> String { let data = include_str!("../data/signed_blinded_block_holesky.json"); let mut values: Value = serde_json::from_str(data).unwrap(); - + // Remove specified field from the message if let Some(message) = values.get_mut("message") { if let Value::Object(msg_obj) = message { @@ -81,7 +81,7 @@ fn test_missing_signed_blinded_block_field(field_name: &str) -> String { #[test] fn test_signed_blinded_block_missing_fields() { let fields = ["slot", "proposer_index", "parent_root", "state_root", "body"]; - + for field in fields { let error = test_missing_signed_blinded_block_field(field); assert!( @@ -96,7 +96,7 @@ fn test_signed_blinded_block_missing_fields() { fn test_missing_submit_block_response_field(field_name: &str) -> String { let data = include_str!("../data/submit_block_response_holesky.json"); let mut values: Value = serde_json::from_str(data).unwrap(); - + // Remove specified field if let Value::Object(obj) = &mut values { obj.remove(field_name); @@ -111,7 +111,7 @@ fn test_missing_submit_block_response_field(field_name: &str) -> String { #[test] fn test_submit_block_response_missing_fields() { let fields = ["version", "data"]; - + for field in fields { let error = test_missing_submit_block_response_field(field); assert!( @@ -121,4 +121,4 @@ fn test_submit_block_response_missing_fields() { error ); } -} \ No newline at end of file +} diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index fc3ea520..63a1ceaa 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -1,22 +1,23 @@ -use std::{ - sync::Arc, - time::Duration, -}; +use std::{sync::Arc, time::Duration}; use alloy::primitives::{B256, U256}; +use cb_common::utils::timestamp_of_slot_start_sec; use cb_common::{ - pbs::GetHeaderResponse, signature::sign_builder_root, signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy + pbs::GetHeaderResponse, + signature::sign_builder_root, + signer::{random_secret, BlsPublicKey}, + types::Chain, + utils::blst_pubkey_to_alloy, }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ mock_relay::{start_mock_relay_service, MockRelayState}, mock_validator::MockValidator, - utils::{generate_mock_relay, setup_test_env, to_pbs_config, get_pbs_static_config}, + utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config}, }; use eyre::Result; use reqwest::StatusCode; use tracing::info; -use cb_common::utils::timestamp_of_slot_start_sec; use tree_hash::TreeHash; #[tokio::test] @@ -55,7 +56,10 @@ async fn test_get_header() -> Result<()> { assert_eq!(res.data.message.value, U256::from(10)); assert_eq!(res.data.message.pubkey, blst_pubkey_to_alloy(&mock_state.signer.sk_to_pk())); assert_eq!(res.data.message.header.timestamp, timestamp_of_slot_start_sec(0, chain)); - assert_eq!(res.data.signature, sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root().0)); + assert_eq!( + res.data.signature, + sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root().0) + ); Ok(()) } @@ -72,7 +76,7 @@ async fn test_get_header_returns_204_if_relay_down() -> Result<()> { // Create a mock relay client let mock_state = Arc::new(MockRelayState::new(chain, signer)); let mock_relay = generate_mock_relay(relay_port, *pubkey)?; - + // Don't start the relay // tokio::spawn(start_mock_relay_service(mock_state.clone(), relay_port)); @@ -128,7 +132,8 @@ async fn test_get_header_returns_400_if_request_is_invalid() -> Result<()> { // Attempt again by truncating the parent hash let mut bad_url = mock_relay.get_header_url(0, B256::ZERO, *pubkey).unwrap(); - bad_url.set_path(&bad_url.path().replace(&B256::ZERO.to_string(), &B256::ZERO.to_string()[..10])); + bad_url + .set_path(&bad_url.path().replace(&B256::ZERO.to_string(), &B256::ZERO.to_string()[..10])); let res = mock_validator.comm_boost.client.get(bad_url).send().await?; assert_eq!(res.status(), StatusCode::BAD_REQUEST); From b25c6491891868413b19a00d82d59da2d0a970f0 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 22 Jan 2025 11:12:20 -0800 Subject: [PATCH 09/13] cargo +nightly fmt --all --- ...8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 | 1 + ...cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e | 1 + ...6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 | 1 + ...05840e15ad6be0655b694e7a8289ea5947e62e1b72be314d | 1 + tests/src/utils.rs | 13 ++++++------- tests/tests/config.rs | 3 ++- tests/tests/pbs_get_header.rs | 3 +-- tests/tests/pbs_post_validators.rs | 1 - 8 files changed, 13 insertions(+), 11 deletions(-) create mode 100644 proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 create mode 100644 proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e create mode 100644 proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 create mode 100644 proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d diff --git a/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 b/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 new file mode 100644 index 00000000..874eb60c --- /dev/null +++ b/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 @@ -0,0 +1 @@ +{"secret":"0x020312feeac6b0f2291e130d690b2b9982bb309ff4d942b0def46423c482f41f","delegation":{"message":{"delegator":"0xa9e9cff900de07e295a044789fd4bdb6785eb0651ad282f9e76d12afd87e75180bdd64caf2e315b815d7322bd31ab48a","proxy":"0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73"},"signature":"0x87a03eb4d7d965445f1de900847feba7a195488d6f4de417b842d1f456cae3220cee1f70e97b21991ae3b1fd48071a530175d9873ffa1d3e4d09f25b276ee0820b4075c670c81f3269eabd0e566af60ebc19d12a078d1654f794354133a1f682"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e b/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e new file mode 100644 index 00000000..d56b1f55 --- /dev/null +++ b/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e @@ -0,0 +1 @@ +{"secret":"0x6cff90f330f20ce430a13b0c0e31e387b5111a14fed7b178e6f3843a599102d4","delegation":{"message":{"delegator":"0xac5e059177afc33263e95d0be0690138b9a1d79a6e19018086a0362e0c30a50bf9e05a08cb44785724d0b2718c5c7118","proxy":"0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e"},"signature":"0xa16efcccb20db94a63a46c9d22380fef7bc6d7457e4327b3b1cabd513af2b0f70a05441d1a46fac2de650afad10b46b80052cc731e47accc379342fd8a78c4ce06fd2595f044a4d50d644c05618838d6e04e285360ef6a1aee289d757c4e261b"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 b/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 new file mode 100644 index 00000000..5e9dab81 --- /dev/null +++ b/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 @@ -0,0 +1 @@ +{"secret":"0x0be76d2b2baf95a580b42b4213966564195139435e812190d7fe4119caebfc90","delegation":{"message":{"delegator":"0xa9e9cff900de07e295a044789fd4bdb6785eb0651ad282f9e76d12afd87e75180bdd64caf2e315b815d7322bd31ab48a","proxy":"0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32"},"signature":"0xa1ec8f2f91396d1aabd8d1144db1ab42a9aa9720f8aa2d86ce2a42bd79205b03561c8f1b4b8bf4790ecba4f7aaf1a29613cc319b0f48a53fc280cfb30ca2b45488e4d71c06b16a3d5ef6c749153d99de138bdbc853f57f91236429025525fa46"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d b/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d new file mode 100644 index 00000000..f9a029f2 --- /dev/null +++ b/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d @@ -0,0 +1 @@ +{"secret":"0x5a1b36a12f25ed19c0969babbf00d3e0114e5f40d5b2aa50c6fa48885caa388d","delegation":{"message":{"delegator":"0xac5e059177afc33263e95d0be0690138b9a1d79a6e19018086a0362e0c30a50bf9e05a08cb44785724d0b2718c5c7118","proxy":"0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d"},"signature":"0xab1dda89fccbee1a8699710841d9afdd9a8300d141d4930e99b84635278f3b90bffc403302e5dc8b2adfee8146b148be146a7ce75100b1a9020609c8ce0da22ede4737dec55ee05ab128b1ce5048b4ef533f0b367d298767f0cb1366a98bae68"}} \ No newline at end of file diff --git a/tests/src/utils.rs b/tests/src/utils.rs index 80cf6934..e1ad05ee 100644 --- a/tests/src/utils.rs +++ b/tests/src/utils.rs @@ -1,10 +1,3 @@ -use cb_common::{ - config::{PbsConfig, PbsModuleConfig, RelayConfig}, - pbs::{RelayClient, RelayEntry}, - types::Chain, -}; -use eyre::Result; - use std::{ net::{Ipv4Addr, SocketAddr}, sync::{Arc, Once}, @@ -12,6 +5,12 @@ use std::{ }; use alloy::{primitives::U256, rpc::types::beacon::BlsPublicKey}; +use cb_common::{ + config::{PbsConfig, PbsModuleConfig, RelayConfig}, + pbs::{RelayClient, RelayEntry}, + types::Chain, +}; +use eyre::Result; pub fn get_local_address(port: u16) -> String { format!("http://0.0.0.0:{port}") diff --git a/tests/tests/config.rs b/tests/tests/config.rs index 074b975c..3d6ffd70 100644 --- a/tests/tests/config.rs +++ b/tests/tests/config.rs @@ -1,7 +1,8 @@ +use std::net::Ipv4Addr; + use alloy::primitives::U256; use cb_common::{config::CommitBoostConfig, types::Chain, utils::WEI_PER_ETH}; use eyre::Result; -use std::net::Ipv4Addr; use url::Url; #[tokio::test] diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index 63a1ceaa..898ea964 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -1,13 +1,12 @@ use std::{sync::Arc, time::Duration}; use alloy::primitives::{B256, U256}; -use cb_common::utils::timestamp_of_slot_start_sec; use cb_common::{ pbs::GetHeaderResponse, signature::sign_builder_root, signer::{random_secret, BlsPublicKey}, types::Chain, - utils::blst_pubkey_to_alloy, + utils::{blst_pubkey_to_alloy, timestamp_of_slot_start_sec}, }; use cb_pbs::{DefaultBuilderApi, PbsService, PbsState}; use cb_tests::{ diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs index 27bd2138..49803eb1 100644 --- a/tests/tests/pbs_post_validators.rs +++ b/tests/tests/pbs_post_validators.rs @@ -4,7 +4,6 @@ use alloy::{ primitives::Address, rpc::types::beacon::relay::{ValidatorRegistration, ValidatorRegistrationMessage}, }; - use cb_common::{ signer::{random_secret, BlsPublicKey, BlsSignature}, types::Chain, From 4034522ae8b39c00ab6b3bcbfe084937343cf5ab Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 22 Jan 2025 11:13:50 -0800 Subject: [PATCH 10/13] remove test proxy keys --- ...60233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 | 1 - ...5a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e | 1 - ...8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 | 1 - ...4dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d | 1 - 4 files changed, 4 deletions(-) delete mode 100644 proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 delete mode 100644 proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e delete mode 100644 proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 delete mode 100644 proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d diff --git a/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 b/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 deleted file mode 100644 index 874eb60c..00000000 --- a/proxies/DA_COMMIT/bls/0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73 +++ /dev/null @@ -1 +0,0 @@ -{"secret":"0x020312feeac6b0f2291e130d690b2b9982bb309ff4d942b0def46423c482f41f","delegation":{"message":{"delegator":"0xa9e9cff900de07e295a044789fd4bdb6785eb0651ad282f9e76d12afd87e75180bdd64caf2e315b815d7322bd31ab48a","proxy":"0xa1dacbf6a65d3f2147eefbd8af59f4f5c7560233417dee7a8c9629349d3eb13373f61f3b1ce5bb07369e7bbabac17b73"},"signature":"0x87a03eb4d7d965445f1de900847feba7a195488d6f4de417b842d1f456cae3220cee1f70e97b21991ae3b1fd48071a530175d9873ffa1d3e4d09f25b276ee0820b4075c670c81f3269eabd0e566af60ebc19d12a078d1654f794354133a1f682"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e b/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e deleted file mode 100644 index d56b1f55..00000000 --- a/proxies/DA_COMMIT/bls/0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e +++ /dev/null @@ -1 +0,0 @@ -{"secret":"0x6cff90f330f20ce430a13b0c0e31e387b5111a14fed7b178e6f3843a599102d4","delegation":{"message":{"delegator":"0xac5e059177afc33263e95d0be0690138b9a1d79a6e19018086a0362e0c30a50bf9e05a08cb44785724d0b2718c5c7118","proxy":"0xa8fb95b21627c7da89406c2850169a752c35a65b5b019426cb9d83eeea26bb1f98beae41bb7763761c15474a1b151b4e"},"signature":"0xa16efcccb20db94a63a46c9d22380fef7bc6d7457e4327b3b1cabd513af2b0f70a05441d1a46fac2de650afad10b46b80052cc731e47accc379342fd8a78c4ce06fd2595f044a4d50d644c05618838d6e04e285360ef6a1aee289d757c4e261b"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 b/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 deleted file mode 100644 index 5e9dab81..00000000 --- a/proxies/DA_COMMIT/ecdsa/0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32 +++ /dev/null @@ -1 +0,0 @@ -{"secret":"0x0be76d2b2baf95a580b42b4213966564195139435e812190d7fe4119caebfc90","delegation":{"message":{"delegator":"0xa9e9cff900de07e295a044789fd4bdb6785eb0651ad282f9e76d12afd87e75180bdd64caf2e315b815d7322bd31ab48a","proxy":"0x0227c8a7125dc6de4d6298be4eb9d2932ec98dc023d73c146a25ea1c8dbf76ff32"},"signature":"0xa1ec8f2f91396d1aabd8d1144db1ab42a9aa9720f8aa2d86ce2a42bd79205b03561c8f1b4b8bf4790ecba4f7aaf1a29613cc319b0f48a53fc280cfb30ca2b45488e4d71c06b16a3d5ef6c749153d99de138bdbc853f57f91236429025525fa46"}} \ No newline at end of file diff --git a/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d b/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d deleted file mode 100644 index f9a029f2..00000000 --- a/proxies/DA_COMMIT/ecdsa/0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d +++ /dev/null @@ -1 +0,0 @@ -{"secret":"0x5a1b36a12f25ed19c0969babbf00d3e0114e5f40d5b2aa50c6fa48885caa388d","delegation":{"message":{"delegator":"0xac5e059177afc33263e95d0be0690138b9a1d79a6e19018086a0362e0c30a50bf9e05a08cb44785724d0b2718c5c7118","proxy":"0x025494dc90d337931405840e15ad6be0655b694e7a8289ea5947e62e1b72be314d"},"signature":"0xab1dda89fccbee1a8699710841d9afdd9a8300d141d4930e99b84635278f3b90bffc403302e5dc8b2adfee8146b148be146a7ce75100b1a9020609c8ce0da22ede4737dec55ee05ab128b1ce5048b4ef533f0b367d298767f0cb1366a98bae68"}} \ No newline at end of file From d230e5f7352c539fce9fada61d6e63631dc1040f Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 22 Jan 2025 11:21:21 -0800 Subject: [PATCH 11/13] remove warnings for clippy --- tests/src/mock_validator.rs | 12 ++++-------- tests/src/utils.rs | 1 - 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/tests/src/mock_validator.rs b/tests/src/mock_validator.rs index 16c54b21..fdd65402 100644 --- a/tests/src/mock_validator.rs +++ b/tests/src/mock_validator.rs @@ -2,11 +2,8 @@ use alloy::{ primitives::B256, rpc::types::beacon::{relay::ValidatorRegistration, BlsPublicKey}, }; -use cb_common::pbs::{ - GetHeaderResponse, RelayClient, SignedBlindedBeaconBlock, SignedExecutionPayloadHeader, - SubmitBlindedBlockResponse, VersionedResponse, -}; -use reqwest::{Error, Response}; +use cb_common::pbs::{RelayClient, SignedBlindedBeaconBlock}; +use reqwest::Response; use crate::utils::generate_mock_relay; @@ -20,8 +17,7 @@ impl MockValidator { } pub async fn do_get_header(&self, pubkey: Option) -> eyre::Result { - let url = - self.comm_boost.get_header_url(0, B256::ZERO, pubkey.unwrap_or(BlsPublicKey::ZERO))?; + let url = self.comm_boost.get_header_url(0, B256::ZERO, pubkey.unwrap_or_default())?; Ok(self.comm_boost.client.get(url).send().await?) } @@ -51,7 +47,7 @@ impl MockValidator { .comm_boost .client .post(url) - .json(&signed_blinded_block.unwrap_or(SignedBlindedBeaconBlock::default())) + .json(&signed_blinded_block.unwrap_or_default()) .send() .await?) } diff --git a/tests/src/utils.rs b/tests/src/utils.rs index e1ad05ee..d3909c4e 100644 --- a/tests/src/utils.rs +++ b/tests/src/utils.rs @@ -1,7 +1,6 @@ use std::{ net::{Ipv4Addr, SocketAddr}, sync::{Arc, Once}, - u64, }; use alloy::{primitives::U256, rpc::types::beacon::BlsPublicKey}; From 6582fd03e97239a86305f2764d9ce1111dd688ab Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 22 Jan 2025 16:40:26 -0800 Subject: [PATCH 12/13] update from merge conflict --- tests/tests/pbs_mux.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs index ca14eb94..111fe27e 100644 --- a/tests/tests/pbs_mux.rs +++ b/tests/tests/pbs_mux.rs @@ -79,7 +79,7 @@ async fn test_mux() -> Result<()> { // Register requests should go to all relays info!("Sending register validator"); - assert_eq!(mock_validator.do_register_validator(None).await?.status(), StatusCode::OK); + assert_eq!(mock_validator.do_register_validator().await?.status(), StatusCode::OK); assert_eq!(mock_state.received_register_validator(), 3); // default + 2 mux relays were used // Submit block requests should go to all relays From e9a10917f2fb0a677f211547be36954b347180e5 Mon Sep 17 00:00:00 2001 From: JasonVranek Date: Wed, 22 Jan 2025 16:40:37 -0800 Subject: [PATCH 13/13] update from merge conflict --- tests/tests/pbs_post_validators.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/tests/tests/pbs_post_validators.rs b/tests/tests/pbs_post_validators.rs index 49803eb1..6db80d3d 100644 --- a/tests/tests/pbs_post_validators.rs +++ b/tests/tests/pbs_post_validators.rs @@ -1,11 +1,8 @@ use std::{sync::Arc, time::Duration}; -use alloy::{ - primitives::Address, - rpc::types::beacon::relay::{ValidatorRegistration, ValidatorRegistrationMessage}, -}; +use alloy::rpc::types::beacon::relay::ValidatorRegistration; use cb_common::{ - signer::{random_secret, BlsPublicKey, BlsSignature}, + signer::{random_secret, BlsPublicKey}, types::Chain, utils::blst_pubkey_to_alloy, }; @@ -57,7 +54,7 @@ async fn test_register_validators() -> Result<()> { )?; let registrations = vec![registration]; - let res = mock_validator.do_register_validator(Some(registrations)).await?; + let res = mock_validator.do_register_custom_validators(registrations).await?; assert_eq!(mock_state.received_register_validator(), 1); assert_eq!(res.status(), StatusCode::OK);