feat(crypto)!: track leanVM main (internalized XMSS + reworked aggregation)

Cargo.toml

@@ -81,8 +81,18 @@ prometheus = "0.14"
 
 clap = { version = "4.3", features = ["derive", "env"] }
 
-# XMSS signatures
-leansig = { git = "https://github.com/leanEthereum/leanSig", branch = "devnet4" }
+# XMSS signatures + recursive aggregation (leanVM).
+# leanVM's `main` internalized XMSS (dropping the external leanSig dependency)
+# and reworked the aggregation API (see "Xmss api rework").
+# Pinned to a `main` commit for reproducible builds; bump the revs to track main.
+xmss = { git = "https://github.com/leanEthereum/leanVM.git", rev = "a5909d18647de6aed38640c098d9177fab2bf36a" }
+lean-multisig = { git = "https://github.com/leanEthereum/leanVM.git", rev = "a5909d18647de6aed38640c098d9177fab2bf36a" }
+
+# SSZ codec used by leanVM's xmss pubkey/signature types (ethereum_ssz, not libssz).
+ssz = { package = "ethereum_ssz", version = "0.10" }
+
+# Secret-key (de)serialization for the leanVM xmss key format.
+postcard = { version = "1.1.3", features = ["alloc"] }
 
 # SSZ implementation
 libssz = "0.2.2"

bin/ethlambda/src/checkpoint_sync.rs

@@ -415,25 +415,25 @@ mod tests {
 
     fn create_test_validator() -> Validator {
         Validator {
-            attestation_pubkey: [1u8; 52],
-            proposal_pubkey: [11u8; 52],
+            attestation_pubkey: [1u8; 32],
+            proposal_pubkey: [11u8; 32],
             index: 0,
         }
     }
 
     fn create_different_validator() -> Validator {
         Validator {
-            attestation_pubkey: [2u8; 52],
-            proposal_pubkey: [22u8; 52],
+            attestation_pubkey: [2u8; 32],
+            proposal_pubkey: [22u8; 32],
             index: 0,
         }
     }
 
     fn create_validators_with_indices(count: usize) -> Vec<Validator> {
         (0..count)
             .map(|i| Validator {
-                attestation_pubkey: [i as u8 + 1; 52],
-                proposal_pubkey: [i as u8 + 101; 52],
+                attestation_pubkey: [i as u8 + 1; 32],
+                proposal_pubkey: [i as u8 + 101; 32],
                 index: i as u64,
             })
             .collect()

bin/ethlambda/src/cli.rs

@@ -97,6 +97,17 @@ pub(crate) struct CliOptions {
     /// coverage.
     #[arg(long, default_value = "false")]
     pub(crate) enable_proposer_aggregation: bool,
+    /// Prove on leanVM's bump arena instead of the system allocator.
+    ///
+    /// Buys proving throughput with memory: the arena never returns pages to
+    /// the OS, so RSS ratchets up to the process's allocation high-water mark
+    /// and stays there for the lifetime of the node. Off by default so a
+    /// long-lived node keeps bounded memory; worth enabling on hosts with
+    /// memory to spare where proving latency is the constraint.
+    ///
+    /// Read once at startup: the allocator is fixed before the first proof.
+    #[arg(long, default_value = "false")]
+    pub(crate) prover_arena: bool,
     /// Maximum number of distinct attestations to pack when building a block.
     ///
     /// Bounds how many distinct `AttestationData` entries the proposer includes

bin/ethlambda/src/main.rs

@@ -85,6 +85,14 @@ async fn main() -> eyre::Result<()> {
     #[cfg(feature = "shadow-integration")]
     init_shadow_cost(&options.shadow);
 
+    // Compiles the aggregation bytecode and fixes the prover's allocator. Ahead of the
+    // test-driver branch below, which verifies signatures, and of every consensus path.
+    info!(
+        arena = options.prover_arena,
+        "Initializing leanVM prover and verifier"
+    );
+    ethlambda_crypto::init_leanvm(options.prover_arena);
+
     // Initialize metrics
     ethlambda_blockchain::metrics::init();
     ethlambda_blockchain::metrics::set_node_info("ethlambda", version::CLIENT_VERSION);
@@ -479,8 +487,8 @@ fn read_bootnodes(bootnodes_path: impl AsRef<Path>) -> eyre::Result<Vec<Bootnode
 #[derive(Debug, Deserialize, Clone)]
 struct AnnotatedValidator {
     index: u64,
-    /// Parsed for hex-format validation only; not cross-checked against the
-    /// loaded secret key since leansig doesn't expose any pk getters.
+    /// Parsed for hex-format validation only; not currently cross-checked
+    /// against the loaded secret key's derived public key.
     #[serde(rename = "pubkey_hex", deserialize_with = "deser_pubkey_hex")]
     _pubkey_hex: ValidatorPubkeyBytes,
     privkey_file: PathBuf,
@@ -496,7 +504,12 @@ where
     let pubkey: ValidatorPubkeyBytes = hex::decode(&value)
         .map_err(|_| D::Error::custom("ValidatorPubkey value is not valid hex"))?
         .try_into()
-        .map_err(|_| D::Error::custom("ValidatorPubkey length != 52"))?;
+        .map_err(|_| {
+            D::Error::custom(format!(
+                "ValidatorPubkey length != {}",
+                ethlambda_types::state::PUBLIC_KEY_SIZE
+            ))
+        })?;
     Ok(pubkey)
 }
 

crates/blockchain/Cargo.toml

@@ -39,7 +39,6 @@ hex = { workspace = true }
 libssz.workspace = true
 libssz-types.workspace = true
 datatest-stable = "0.3.3"
-leansig.workspace = true
 rand.workspace = true
 
 [[test]]

crates/blockchain/src/aggregation.rs

@@ -792,31 +792,22 @@ mod tests {
     fn make_validators(n: usize) -> Vec<Validator> {
         (0..n)
             .map(|i| Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect()
     }
 
-    /// A cheap-but-real XMSS signature (tiny lifetime, cached) for tests that
-    /// only need `ValidatorSignature::from_bytes` to succeed. `resolve_job`
-    /// never checks signature validity, only that it clones and carries a
-    /// resolvable id — mirrors `ethlambda_storage::store::tests::make_dummy_sig`.
+    /// A structurally valid XMSS signature for tests that only need
+    /// `ValidatorSignature::from_bytes` to succeed. `resolve_job` never checks
+    /// signature validity, only that it clones and carries a resolvable id —
+    /// mirrors `ethlambda_storage::store::tests::make_dummy_sig`. An all-zero
+    /// blob decodes as a valid (unverifiable) signature.
     fn dummy_sig() -> ValidatorSignature {
-        use ethlambda_crypto::signature::LeanSignatureScheme;
-        use leansig::{serialization::Serializable, signature::SignatureScheme};
-        use rand::{SeedableRng, rngs::StdRng};
-
-        static CACHED_SIG: std::sync::LazyLock<Vec<u8>> = std::sync::LazyLock::new(|| {
-            let mut rng = StdRng::seed_from_u64(42);
-            let lifetime = 1 << 5; // small for speed
-            let (_pk, sk) = LeanSignatureScheme::key_gen(&mut rng, 0, lifetime);
-            let sig = LeanSignatureScheme::sign(&sk, 0, &[0u8; 32]).unwrap();
-            sig.to_bytes()
-        });
-
-        ValidatorSignature::from_bytes(&CACHED_SIG).expect("cached test signature")
+        use ethlambda_types::attestation::SIGNATURE_SIZE;
+        ValidatorSignature::from_bytes(&vec![0u8; SIGNATURE_SIZE])
+            .expect("all-zero test signature decodes")
     }
 
     /// A `HashedAttestationData` over default (all-zero) data for `resolve_job`

crates/blockchain/src/block_builder.rs

@@ -973,8 +973,8 @@ mod tests {
 
         let validators: Vec<_> = (0..NUM_VALIDATORS)
             .map(|i| ethlambda_types::state::Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect();
@@ -1133,8 +1133,8 @@ mod tests {
 
         let validators: Vec<_> = (0..NUM_VALIDATORS)
             .map(|i| ethlambda_types::state::Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect();
@@ -1262,8 +1262,8 @@ mod tests {
 
         let validators: Vec<_> = (0..NUM_VALIDATORS)
             .map(|i| ethlambda_types::state::Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect();
@@ -1566,8 +1566,8 @@ mod tests {
 
         let validators: Vec<_> = (0..NUM_VALIDATORS)
             .map(|i| ethlambda_types::state::Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect();
@@ -1693,8 +1693,8 @@ mod tests {
 
         let validators: Vec<_> = (0..NUM_VALIDATORS)
             .map(|i| ethlambda_types::state::Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect();

crates/blockchain/state_transition/src/lib.rs

@@ -623,8 +623,8 @@ mod tests {
     fn make_validators(n: usize) -> Vec<Validator> {
         (0..n)
             .map(|i| Validator {
-                attestation_pubkey: [i as u8; 52],
-                proposal_pubkey: [i as u8; 52],
+                attestation_pubkey: [i as u8; 32],
+                proposal_pubkey: [i as u8; 32],
                 index: i as u64,
             })
             .collect()

crates/blockchain/tests/signature_spectests.rs

@@ -20,6 +20,10 @@ const SUPPORTED_FIXTURE_FORMAT: &str = "verify_signatures_test";
 const SKIP_TESTS: &[&str] = &[];
 
 fn run(path: &Path) -> datatest_stable::Result<()> {
+    // These fixtures verify real signatures, so they need the backend a binary would set
+    // up at startup. Idempotent, so calling it per fixture costs nothing after the first.
+    ethlambda_crypto::init_leanvm(false);
+
     let tests = VerifySignaturesTestVector::from_file(path)?;
 
     for (name, test) in tests.tests {

crates/common/crypto/Cargo.toml

@@ -12,17 +12,18 @@ version.workspace = true
 [dependencies]
 ethlambda-types.workspace = true
 
+xmss.workspace = true
+lean-multisig.workspace = true
+ssz.workspace = true
+postcard.workspace = true
 
-lean-multisig = { git = "https://github.com/leanEthereum/leanVM.git", rev = "e2592df" }
-# leansig_wrapper provides XmssPublicKey/XmssSignature types used by lean-multisig's public API
-leansig_wrapper = { git = "https://github.com/leanEthereum/leanVM.git", rev = "e2592df" }
-
-leansig.workspace = true
 thiserror.workspace = true
 rand.workspace = true
+tracing.workspace = true
 
 [features]
 shadow-integration = []
 
 [dev-dependencies]
 hex.workspace = true
+ssz.workspace = true