no-std implementation

Cargo.toml

@@ -13,22 +13,37 @@ spec-tests = ["serde", "serde_yaml"]
 gen-spec = ["syn", "prettyplease", "quote"]
 gen-tests = ["walkdir", "convert_case"]
 
+std = [
+    "rand/std",
+    "sha2/std",
+    "multihash/std",
+    "bs58/std",
+    "getrandom/std",
+    "ssz-rs/std",
+    "serde/std"
+]
+
 [dependencies]
-ssz-rs = { git = "https://github.com/ralexstokes/ssz-rs", rev = "cb08f1" }
-blst = "0.3.6"
-rand = "0.8.4"
-thiserror = "1.0.30"
-sha2 = "0.9.8"
-integer-sqrt = "0.1.5"
-enr = "0.6.2"
+getrandom = { version = "0.2.8", default-features=false, features = ["js"] }
+ssz-rs = { git = "https://github.com/Snowfork/ssz_rs", branch="feat/contribution", default-features=false, features=["serde", "std"] }
+rand = {version = "0.8.4", default-features = false}
+thiserror = {version = "1.0.30"}
+error-chain={version = "0.12.4", default-features=false}
+sha2 = { version ="0.9.8", default-features = false }
+integer-sqrt = {version = "0.1.5", default-features = false }
+enr = {version = "0.6.2" }
 multihash = { version = "0.16", default-features = false, features = ["std", "multihash-impl", "identity", "sha2"] }
-multiaddr = "0.14.0"
+multiaddr = {version="0.14.0" }
+hashbrown = {version="0.13.1"}
 
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0.81", optional = true }
 serde_yaml = { version = "0.8", optional = true }
 hex = {version = "0.4.3", optional = true }
 
+blst = {version = "0.3.6", optional=true}
+milagro_bls = { git = "https://github.com/sigp/milagro_bls", default-features = false }
+
 tokio = { version =  "1.18.2", features = ["full"], optional = true }
 tokio-stream = { version = "0.1.8", optional = true }
 async-stream = { version = "0.3.3", optional = true }
@@ -39,7 +54,7 @@ quote = { version = "1.0.18", optional = true }
 
 walkdir = { version = "2.3.2", optional = true }
 convert_case = { version =  "0.5.0", optional = true }
-bs58 = "0.4.0"
+bs58 = {version="0.4.0", default-features = false }
 
 [dev-dependencies]
 serde_with = "1.13.0"

examples/state_transition_across_multiple_forks.rs

@@ -16,18 +16,18 @@ fn main() -> std::result::Result<(), Box<dyn Error>> {
 
     let mut block = phase0::SignedBeaconBlock::default();
     block.message.slot = 1;
-    executor.apply_block(&mut block.into())?;
+    executor.apply_block(&mut block.into()).unwrap();
 
     let mut block = altair::SignedBeaconBlock::default();
     block.message.slot = executor.context.altair_fork_epoch * executor.context.slots_per_epoch;
-    executor.apply_block(&mut block.into())?;
+    executor.apply_block(&mut block.into()).unwrap();
 
     let mut block = bellatrix::SignedBeaconBlock::default();
     block.message.slot = executor.context.bellatrix_fork_epoch * executor.context.slots_per_epoch;
-    executor.apply_block(&mut block.into())?;
+    executor.apply_block(&mut block.into()).unwrap();
 
     let mut state = executor.state.bellatrix().unwrap();
-    let state_root = state.hash_tree_root()?;
+    let state_root = state.hash_tree_root().unwrap();
     dbg!(state_root);
     Ok(())
 }

src/altair/beacon_block.rs

@@ -2,6 +2,7 @@ use crate::altair::SyncAggregate;
 use crate::phase0::{
     Attestation, AttesterSlashing, Deposit, Eth1Data, ProposerSlashing, SignedVoluntaryExit,
 };
+use crate::prelude::*;
 use crate::primitives::{BlsSignature, Bytes32, Root, Slot, ValidatorIndex};
 use ssz_rs::prelude::*;
 
@@ -39,9 +40,9 @@ pub struct BeaconBlock<
     const MAX_VOLUNTARY_EXITS: usize,
     const SYNC_COMMITTEE_SIZE: usize,
 > {
-    #[serde(with = "crate::serde::as_string")]
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde::as_string"))]
     pub slot: Slot,
-    #[serde(with = "crate::serde::as_string")]
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde::as_string"))]
     pub proposer_index: ValidatorIndex,
     pub parent_root: Root,
     pub state_root: Root,

src/altair/beacon_state.rs

@@ -2,6 +2,7 @@ use crate::altair::{
     BeaconBlockHeader, Checkpoint, Eth1Data, Fork, SyncCommittee, Validator,
     JUSTIFICATION_BITS_LENGTH,
 };
+use crate::prelude::*;
 use crate::primitives::{Bytes32, Gwei, ParticipationFlags, Root, Slot};
 use ssz_rs::prelude::*;
 
@@ -17,10 +18,10 @@ pub struct BeaconState<
     const MAX_VALIDATORS_PER_COMMITTEE: usize,
     const SYNC_COMMITTEE_SIZE: usize,
 > {
-    #[serde(with = "crate::serde::as_string")]
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde::as_string"))]
     pub genesis_time: u64,
     pub genesis_validators_root: Root,
-    #[serde(with = "crate::serde::as_string")]
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde::as_string"))]
     pub slot: Slot,
     pub fork: Fork,
     pub latest_block_header: BeaconBlockHeader,
@@ -29,23 +30,38 @@ pub struct BeaconState<
     pub historical_roots: List<Root, HISTORICAL_ROOTS_LIMIT>,
     pub eth1_data: Eth1Data,
     pub eth1_data_votes: List<Eth1Data, ETH1_DATA_VOTES_BOUND>,
-    #[serde(with = "crate::serde::as_string")]
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde::as_string"))]
     pub eth1_deposit_index: u64,
     pub validators: List<Validator, VALIDATOR_REGISTRY_LIMIT>,
-    #[serde(with = "crate::serde::collection_over_string")]
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde::collection_over_string")
+    )]
     pub balances: List<Gwei, VALIDATOR_REGISTRY_LIMIT>,
     pub randao_mixes: Vector<Bytes32, EPOCHS_PER_HISTORICAL_VECTOR>,
-    #[serde(with = "crate::serde::collection_over_string")]
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde::collection_over_string")
+    )]
     pub slashings: Vector<Gwei, EPOCHS_PER_SLASHINGS_VECTOR>,
-    #[serde(with = "crate::serde::collection_over_string")]
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde::collection_over_string")
+    )]
     pub previous_epoch_participation: List<ParticipationFlags, VALIDATOR_REGISTRY_LIMIT>,
-    #[serde(with = "crate::serde::collection_over_string")]
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde::collection_over_string")
+    )]
     pub current_epoch_participation: List<ParticipationFlags, VALIDATOR_REGISTRY_LIMIT>,
     pub justification_bits: Bitvector<JUSTIFICATION_BITS_LENGTH>,
     pub previous_justified_checkpoint: Checkpoint,
     pub current_justified_checkpoint: Checkpoint,
     pub finalized_checkpoint: Checkpoint,
-    #[serde(with = "crate::serde::collection_over_string")]
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde::collection_over_string")
+    )]
     pub inactivity_scores: List<u64, VALIDATOR_REGISTRY_LIMIT>,
     pub current_sync_committee: SyncCommittee<SYNC_COMMITTEE_SIZE>,
     pub next_sync_committee: SyncCommittee<SYNC_COMMITTEE_SIZE>,

src/altair/block_processing.rs

@@ -2,6 +2,8 @@ use crate::altair as spec;
 
 use crate::crypto::{eth_fast_aggregate_verify, verify_signature};
 use crate::domains::DomainType;
+use crate::prelude::*;
+use crate::prelude::*;
 use crate::primitives::{BlsPublicKey, ParticipationFlags, ValidatorIndex};
 use crate::signing::compute_signing_root;
 use crate::state_transition::{
@@ -20,8 +22,6 @@ use spec::{
     PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, SYNC_REWARD_WEIGHT, WEIGHT_DENOMINATOR,
 };
 use ssz_rs::prelude::*;
-use std::collections::{HashMap, HashSet};
-use std::iter::zip;
 
 pub fn process_attestation<
     const SLOTS_PER_HISTORICAL_ROOT: usize,
@@ -202,8 +202,9 @@ pub fn process_deposit<
 
     let public_key = &deposit.data.public_key;
     let amount = deposit.data.amount;
+    let cloned_validators = state.validators.clone();
     let validator_public_keys: HashSet<&BlsPublicKey> =
-        HashSet::from_iter(state.validators.iter().map(|v| &v.public_key));
+        cloned_validators.iter().map(|v| &v.public_key).collect();
     if !validator_public_keys.contains(public_key) {
         let mut deposit_message = DepositMessage {
             public_key: public_key.clone(),
@@ -315,9 +316,9 @@ pub fn process_sync_aggregate<
     let proposer_reward =
         participant_reward * PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
 
+    let cloned_validators = state.validators.clone();
     // Apply participant and proposer rewards
-    let all_public_keys = state
-        .validators
+    let all_public_keys = cloned_validators
         .iter()
         .enumerate()
         .map(|(i, v)| (&v.public_key, i))

src/altair/epoch_processing.rs

@@ -1,5 +1,6 @@
 use crate::altair as spec;
 
+use crate::prelude::*;
 use crate::primitives::{Gwei, ParticipationFlags, ValidatorIndex, GENESIS_EPOCH};
 use crate::state_transition::{Context, Result};
 use spec::{
@@ -12,7 +13,6 @@ use spec::{
     weigh_justification_and_finalization, BeaconState, PARTICIPATION_FLAG_WEIGHTS,
     TIMELY_TARGET_FLAG_INDEX,
 };
-use std::mem;
 
 // Return the base reward for the validator defined by `index` with respect to the current `state`
 pub fn get_base_reward<

src/altair/fork.rs

@@ -3,6 +3,7 @@ use crate::altair::{
     get_next_sync_committee, BeaconState, Fork,
 };
 use crate::phase0;
+use crate::prelude::*;
 use crate::state_transition::{Context, Result};
 use ssz_rs::prelude::*;
 

src/altair/genesis.rs

@@ -1,6 +1,7 @@
 use crate::altair as spec;
 
 use crate::phase0::DEPOSIT_DATA_LIST_BOUND;
+use crate::prelude::*;
 use crate::primitives::{Gwei, Hash32, GENESIS_EPOCH};
 use crate::state_transition::{Context, Result};
 use spec::{
@@ -65,7 +66,7 @@ pub fn initialize_beacon_state_from_eth1<
         ..Default::default()
     };
     let randao_mixes = Vector::from_iter(
-        std::iter::repeat(eth1_block_hash).take(context.epochs_per_historical_vector as usize),
+        repeat(eth1_block_hash).take(context.epochs_per_historical_vector as usize),
     );
     let mut state = BeaconState {
         genesis_time: eth1_timestamp + context.genesis_delay,

src/altair/helpers.rs

@@ -2,6 +2,7 @@ use crate::altair as spec;
 
 use crate::crypto::{eth_aggregate_public_keys, hash};
 use crate::domains::DomainType;
+use crate::prelude::*;
 use crate::primitives::{Epoch, Gwei, ParticipationFlags, ValidatorIndex};
 use crate::state_transition::{
     invalid_operation_error, Context, Error, InvalidAttestation, InvalidOperation, Result,
@@ -16,7 +17,6 @@ use spec::{
     TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX, TIMELY_TARGET_FLAG_INDEX, WEIGHT_DENOMINATOR,
 };
 use ssz_rs::Vector;
-use std::collections::HashSet;
 
 // Return a new ``ParticipationFlags`` adding ``flag_index`` to ``flags``
 pub fn add_flag(flags: ParticipationFlags, flag_index: usize) -> ParticipationFlags {

src/altair/light_client.rs

@@ -1,5 +1,6 @@
 use crate::altair::{SyncAggregate, SyncCommittee};
 use crate::phase0::BeaconBlockHeader;
+use crate::prelude::*;
 use crate::primitives::{Bytes32, Version};
 use ssz_rs::prelude::*;
 

src/altair/mod.rs

@@ -18,6 +18,7 @@ pub use state_transition::{
     block_processing::*, epoch_processing::*, helpers::*, slot_processing::*, *,
 };
 
+use crate::prelude::*;
 pub use beacon_block::*;
 pub use beacon_state::*;
 pub use fork::*;

src/altair/state_transition/block_processing.rs

@@ -4,6 +4,7 @@ pub use crate::altair::block_processing::process_attestation;
 pub use crate::altair::block_processing::process_block;
 pub use crate::altair::block_processing::process_deposit;
 pub use crate::altair::block_processing::process_sync_aggregate;
+use crate::prelude::*;
 use crate::primitives::{Bytes32, DomainType, Gwei, ValidatorIndex, FAR_FUTURE_EPOCH};
 use crate::signing::compute_signing_root;
 use ssz_rs::prelude::*;
@@ -22,7 +23,6 @@ use spec::{
     BeaconBlock, BeaconBlockBody, BeaconBlockHeader, BeaconState, Deposit, ProposerSlashing,
     SignedVoluntaryExit, Validator,
 };
-use std::collections::HashSet;
 pub fn get_validator_from_deposit(deposit: &Deposit, context: &Context) -> Validator {
     let amount = deposit.data.amount;
     let effective_balance = Gwei::min(
@@ -489,7 +489,7 @@ pub fn process_voluntary_exit<
         validator.activation_eligibility_epoch + context.shard_committee_period;
     if current_epoch < minimum_time_active {
         return Err(invalid_operation_error(InvalidOperation::VoluntaryExit(
-            InvalidVoluntaryExit::ValidatoIsNotActiveForLongEnough {
+            InvalidVoluntaryExit::ValidatorIsNotActiveForLongEnough {
                 current_epoch,
                 minimum_time_active,
             },

src/altair/state_transition/epoch_processing.rs

@@ -9,6 +9,7 @@ pub use crate::altair::epoch_processing::process_rewards_and_penalties;
 pub use crate::altair::epoch_processing::process_slashings;
 pub use crate::altair::epoch_processing::process_sync_committee_updates;
 
+use crate::prelude::*;
 use crate::primitives::{Epoch, Gwei, ValidatorIndex};
 use spec::{
     compute_activation_exit_epoch, get_block_root, get_current_epoch, get_previous_epoch,

src/altair/state_transition/helpers.rs

@@ -11,6 +11,7 @@ pub use crate::altair::helpers::get_unslashed_participating_indices;
 pub use crate::altair::helpers::has_flag;
 pub use crate::altair::helpers::slash_validator;
 use crate::crypto::{fast_aggregate_verify, hash, verify_signature};
+use crate::prelude::*;
 use crate::primitives::{
     Bytes32, CommitteeIndex, Domain, DomainType, Epoch, ForkDigest, Gwei, Root, Slot,
     ValidatorIndex, Version, FAR_FUTURE_EPOCH, GENESIS_EPOCH,
@@ -25,8 +26,7 @@ use spec::{
     Validator,
 };
 use ssz_rs::prelude::*;
-use std::cmp;
-use std::collections::HashSet;
+
 pub fn compute_activation_exit_epoch(epoch: Epoch, context: &Context) -> Epoch {
     epoch + 1 + context.max_seed_lookahead
 }
@@ -117,7 +117,12 @@ pub fn compute_proposer_index<
     loop {
         let shuffled_index = compute_shuffled_index((i % total) as usize, total, seed, context)?;
         let candidate_index = indices[shuffled_index];
-        let i_bytes: [u8; 8] = (i / 32).to_le_bytes();
+        #[cfg(not(feature = "serde"))]
+        let i_bytes: [u8; 4] = (i.saturating_div(32)).to_le_bytes();
+
+        #[cfg(feature = "serde")]
+        let i_bytes: [u8; 8] = (i.saturating_div(32)).to_le_bytes();
+
         hash_input[32..].copy_from_slice(&i_bytes);
         let random_byte = hash(hash_input).as_ref()[(i % 32)] as u64;
         let effective_balance = state.validators[candidate_index].effective_balance;
@@ -254,7 +259,7 @@ pub fn get_attesting_indices<
             },
         )));
     }
-    let mut indices = HashSet::with_capacity(bits.capacity());
+    let mut indices = HashSet::new();
     for (i, validator_index) in committee.iter().enumerate() {
         if bits[i] {
             indices.insert(*validator_index);

src/altair/sync.rs

@@ -1,3 +1,4 @@
+use crate::prelude::*;
 use crate::primitives::{BlsPublicKey, BlsSignature};
 use ssz_rs::prelude::*;
 
@@ -11,8 +12,8 @@ pub struct SyncAggregate<const SYNC_COMMITTEE_SIZE: usize> {
 #[derive(Default, Debug, SimpleSerialize, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SyncCommittee<const SYNC_COMMITTEE_SIZE: usize> {
-    #[serde(rename = "pubkeys")]
+    #[cfg_attr(feature = "serde", serde(rename = "pubkeys"))]
     pub public_keys: Vector<BlsPublicKey, SYNC_COMMITTEE_SIZE>,
-    #[serde(rename = "aggregate_pubkey")]
+    #[cfg_attr(feature = "serde", serde(rename = "aggregate_pubkey"))]
     pub aggregate_public_key: BlsPublicKey,
 }