Add Deneb (EIP-4844) types and presets

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: CI suite
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+
+      - name: Read toolchain file
+        id: rust-toolchain
+        run: |
+          RUST_TOOLCHAIN=$(grep 'channel' rust-toolchain.toml | awk '{split($0,a," = "); print a[2]}' | tr -d '"')
+          echo "RUST_TOOLCHAIN=$RUST_TOOLCHAIN" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ steps.rust-toolchain.outputs.RUST_TOOLCHAIN }}
+
+      - name: Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+
+      - name: Build
+        run: cargo build --all-targets --all-features --verbose
+
+      - name: Run tests
+        run: cargo test --verbose
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt, clippy
+
+      - name: Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+
+      - name: Check format
+        run: cargo +nightly fmt --all --check
+
+      - name: Check clippy
+        run: cargo +nightly clippy --all-targets --all-features --verbose -- -D warnings

examples/bls.rs

@@ -12,5 +12,5 @@ fn main() {
     let sig = sk.sign(msg);
 
     let valid = verify_signature(&pk, msg, &sig).is_ok();
-    println!("Signature is valid: {:?}", valid);
+    println!("Signature is valid: {valid:?}");
 }

examples/serde.rs

@@ -28,7 +28,7 @@ fn main() {
         .push(SignedVoluntaryExit::default());
 
     let block_json = serde_json::to_string(&block).unwrap();
-    println!("{}", block_json);
+    println!("{block_json}");
     let _: SignedBeaconBlock = serde_json::from_str(&block_json).unwrap();
 
     let mut state = BeaconState::default();
@@ -37,7 +37,7 @@ fn main() {
         .push(PendingAttestation::default());
 
     let state_json = serde_json::to_string(&state).unwrap();
-    println!("{}", state_json);
+    println!("{state_json}");
     let _: BeaconState = serde_json::from_str(&state_json).unwrap();
 
     let sync_committee = SyncCommittee::default();

justfile

@@ -28,9 +28,9 @@ test:
     # partition much heavier "integration tests" to a separate command
     cargo test
 fmt:
-    cargo fmt
+    cargo +nightly fmt --all
 lint: fmt
-    cargo clippy --all-features
+    cargo +nightly clippy --all-targets --all-features
 build:
-    cargo build --all-features
+    cargo build --all-targets --all-features
 run-ci: lint build test

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.66"

src/bin/gen_spec.rs

@@ -158,8 +158,7 @@ impl VisitMut for GenericsEditor {
         }) {
             let generics = &mut node.generics;
             for bound in BELLATRIX_BEACON_STATE_BOUNDS {
-                let param: GenericParam =
-                    syn::parse_str(&format!("const {}: usize", bound)).unwrap();
+                let param: GenericParam = syn::parse_str(&format!("const {bound}: usize")).unwrap();
                 generics.params.push(param);
             }
         }
@@ -436,7 +435,7 @@ struct Spec {
 }
 
 fn load_modules(spec: Specs, modules: &[Modules]) -> HashMap<Modules, Module> {
-    let module_dir = PathBuf::from(format!("src/{}", spec));
+    let module_dir = PathBuf::from(format!("src/{spec}"));
     let mut loaded_modules = HashMap::new();
     for &m in modules {
         let module = Module::new(m, spec);

src/bin/gen_tests.rs

@@ -74,7 +74,7 @@ fn generate_module_decl_src<'a>(modules: impl Iterator<Item = &'a String>) -> St
         } else {
             module
         };
-        writeln!(src, "mod {};", module).unwrap();
+        writeln!(src, "mod {module};").unwrap();
     }
     src
 }
@@ -118,8 +118,7 @@ fn generate_suite_src(
 
     writeln!(
         src,
-        "use crate::spec_test_runners::{}::{};",
-        runner, test_case_type
+        "use crate::spec_test_runners::{runner}::{test_case_type};",
     )
     .unwrap();
 
@@ -152,7 +151,7 @@ fn generate_suite_src(
                     generics += ", usize"
                 }
             }
-            test_case_type = format!("{}::<{}>", test_case_type, generics);
+            test_case_type = format!("{test_case_type}::<{generics}>");
             if data.execution_handler.len() == 1 && data.execution_handler.contains_key(&Spec::All)
             {
                 execution_handler += &data.execution_handler[&Spec::All];
@@ -179,16 +178,15 @@ fn generate_suite_src(
     }
 
     if needs_spec_import {
-        writeln!(src, "use ethereum_consensus::{}::{} as spec;", fork, config).unwrap();
+        writeln!(src, "use ethereum_consensus::{fork}::{config} as spec;").unwrap();
         writeln!(src, "use ssz_rs::prelude::*;").unwrap();
     }
 
     // special case imports here...
     if matches!(runner, "transition") {
         writeln!(
             src,
-            "use ethereum_consensus::state_transition::{}::{{Executor, BeaconState}};",
-            config
+            "use ethereum_consensus::state_transition::{config}::{{Executor, BeaconState}};",
         )
         .unwrap();
         let pre_fork = match spec {
@@ -198,24 +196,22 @@ fn generate_suite_src(
         };
         writeln!(
             src,
-            "use ethereum_consensus::{}::{} as pre_spec;",
-            pre_fork, config
+            "use ethereum_consensus::{pre_fork}::{config} as pre_spec;",
         )
         .unwrap();
         writeln!(
             src,
-            "use ethereum_consensus::bellatrix::{}::NoOpExecutionEngine;",
-            config
+            "use ethereum_consensus::bellatrix::{config}::NoOpExecutionEngine;",
         )
         .unwrap();
     }
     if matches!(runner, "fork") {
         match spec {
             Spec::Altair => {
-                writeln!(src, "use ethereum_consensus::phase0::{} as phase0;", config).unwrap();
+                writeln!(src, "use ethereum_consensus::phase0::{config} as phase0;").unwrap();
             }
             Spec::Bellatrix => {
-                writeln!(src, "use ethereum_consensus::altair::{} as altair;", config).unwrap();
+                writeln!(src, "use ethereum_consensus::altair::{config} as altair;").unwrap();
             }
             _ => todo!("support other forks"),
         }
@@ -227,13 +223,12 @@ fn generate_suite_src(
         let test_src = format!(
             r#"
 #[test]
-fn test_{}() {{
-    let {} test_case = {}::from("{}");
-    {}
-    test_case.{};
+fn test_{test_case}() {{
+    let {mut_decl} test_case = {test_case_type}::from("{source_path}");
+    {preamble}
+    test_case.{execution_handler};
 }}
-"#,
-            test_case, mut_decl, test_case_type, source_path, preamble, execution_handler,
+"#
         );
         src += &test_src;
     }

src/bytes.rs

@@ -8,7 +8,7 @@ pub fn write_bytes_to_lower_hex<T: AsRef<[u8]>>(
         write!(f, "0x")?;
     }
     for i in data.as_ref() {
-        write!(f, "{:02x}", i)?;
+        write!(f, "{i:02x}")?;
     }
     Ok(())
 }

src/capella/mod.rs

@@ -15,6 +15,7 @@ pub use blinded_beacon_block::*;
 pub use bls_to_execution_change::*;
 pub use execution::*;
 pub use presets::Preset;
+pub use withdrawal::*;
 
 pub use crate::altair::{
     SyncAggregate, SyncAggregatorSelectionData, SyncCommittee, PARTICIPATION_FLAG_WEIGHTS,

src/crypto.rs

@@ -223,13 +223,13 @@ impl fmt::LowerHex for PublicKey {
 
 impl fmt::Debug for PublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PublicKey({:#x})", self)
+        write!(f, "PublicKey({self:#x})")
     }
 }
 
 impl fmt::Display for PublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:#x}", self)
+        write!(f, "{self:#x}")
     }
 }
 
@@ -345,13 +345,13 @@ impl fmt::LowerHex for Signature {
 
 impl fmt::Debug for Signature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Signature({:#x})", self)
+        write!(f, "Signature({self:#x})")
     }
 }
 
 impl fmt::Display for Signature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:#x}", self)
+        write!(f, "{self:#x}")
     }
 }