Helpers cleanup

scripts/build_spec.py

@@ -12,7 +12,7 @@
 
 
 PHASE0_IMPORTS = '''from typing import (
-    Any, Callable, Dict, Set, Sequence, Tuple,
+    Any, Dict, Set, Sequence, Tuple,
 )
 
 from dataclasses import (
@@ -37,7 +37,7 @@
 from eth2spec.utils.hash_function import hash
 '''
 PHASE1_IMPORTS = '''from typing import (
-    Any, Callable, Dict, Optional, Set, Sequence, MutableSequence, Tuple,
+    Any, Dict, Optional, Set, Sequence, MutableSequence, Tuple,
 )
 
 from dataclasses import (

specs/core/0_fork-choice.md

@@ -124,7 +124,7 @@ def get_latest_attesting_balance(store: Store, root: Hash) -> Gwei:
 def get_head(store: Store) -> Hash:
     # Execute the LMD-GHOST fork choice
     head = store.justified_checkpoint.root
-    justified_slot = get_epoch_start_slot(store.justified_checkpoint.epoch)
+    justified_slot = epoch_first_slot(store.justified_checkpoint.epoch)
     while True:
         children = [
             root for root in store.blocks.keys()
@@ -162,7 +162,7 @@ def on_block(store: Store, block: BeaconBlock) -> None:
         store.finalized_checkpoint.root
     )
     # Check that block is later than the finalized epoch slot
-    assert block.slot > get_epoch_start_slot(store.finalized_checkpoint.epoch)
+    assert block.slot > epoch_first_slot(store.finalized_checkpoint.epoch)
     # Check the block is valid and compute the post-state
     state = state_transition(pre_state, block)
     # Add new state for this block to the store
@@ -190,11 +190,11 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
 
     # Attestations cannot be from future epochs. If they are, delay consideration until the epoch arrivesr
     base_state = store.block_states[target.root].copy()
-    assert store.time >= base_state.genesis_time + get_epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
+    assert store.time >= base_state.genesis_time + epoch_first_slot(target.epoch) * SECONDS_PER_SLOT
 
     # Store target checkpoint state if not yet seen
     if target not in store.checkpoint_states:
-        process_slots(base_state, get_epoch_start_slot(target.epoch))
+        process_slots(base_state, epoch_first_slot(target.epoch))
         store.checkpoint_states[target] = base_state
     target_state = store.checkpoint_states[target]
 
@@ -204,7 +204,7 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
     assert store.time >= (attestation_slot + 1) * SECONDS_PER_SLOT
 
     # Get state at the `target` to validate attestation and calculate the committees
-    indexed_attestation = convert_to_indexed(target_state, attestation)
+    indexed_attestation = get_indexed_attestation(target_state, attestation)
     validate_indexed_attestation(target_state, indexed_attestation)
 
     # Update latest messages

specs/core/1_custody-game.md

@@ -382,7 +382,7 @@ def process_custody_key_reveal(state: BeaconState, reveal: CustodyKeyReveal) ->
     revealer.next_custody_reveal_period += 1
 
     # Reward Block Preposer
-    proposer_index = get_beacon_proposer_index(state)
+    proposer_index = get_proposer_index(state)
     increase_balance(
         state,
         proposer_index,
@@ -452,7 +452,7 @@ def process_early_derived_secret_reveal(state: BeaconState, reveal: EarlyDerived
         )
 
         # Apply penalty
-        proposer_index = get_beacon_proposer_index(state)
+        proposer_index = get_proposer_index(state)
         whistleblower_index = reveal.masker_index
         whistleblowing_reward = Gwei(penalty // WHISTLEBLOWER_REWARD_QUOTIENT)
         proposer_reward = Gwei(whistleblowing_reward // PROPOSER_REWARD_QUOTIENT)
@@ -473,7 +473,7 @@ For each `challenge` in `block.body.custody_chunk_challenges`, run the following
 ```python
 def process_chunk_challenge(state: BeaconState, challenge: CustodyChunkChallenge) -> None:
     # Verify the attestation
-    validate_indexed_attestation(state, convert_to_indexed(state, challenge.attestation))
+    validate_indexed_attestation(state, get_indexed_attestation(state, challenge.attestation))
     # Verify it is not too late to challenge
     assert slot_to_epoch(challenge.attestation.data.slot) >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY
     responder = state.validators[challenge.responder_index]
@@ -493,7 +493,7 @@ def process_chunk_challenge(state: BeaconState, challenge: CustodyChunkChallenge
     # Add new chunk challenge record
     new_record = CustodyChunkChallengeRecord(
         challenge_index=state.custody_challenge_index,
-        challenger_index=get_beacon_proposer_index(state),
+        challenger_index=get_proposer_index(state),
         responder_index=challenge.responder_index,
         inclusion_epoch=get_current_epoch(state),
         data_root=challenge.attestation.data.crosslink.data_root,
@@ -526,7 +526,7 @@ def process_bit_challenge(state: BeaconState, challenge: CustodyBitChallenge) ->
     # Verify challenger is slashable
     assert is_slashable_validator(challenger, get_current_epoch(state))
     # Verify attestation
-    validate_indexed_attestation(state, convert_to_indexed(state, attestation))
+    validate_indexed_attestation(state, get_indexed_attestation(state, attestation))
     # Verify attestation is eligible for challenging
     responder = state.validators[challenge.responder_index]
     assert epoch + responder.max_reveal_lateness <= get_reveal_period(state, challenge.responder_index)
@@ -595,13 +595,13 @@ def process_chunk_challenge_response(state: BeaconState,
     # Verify chunk index
     assert response.chunk_index == challenge.chunk_index
     # Verify bit challenge data is null
-    assert response.chunk_bits_branch == [] and response.chunk_bits_leaf == ZERO_HASH
+    assert response.chunk_bits_branch == [] and response.chunk_bits_leaf == Hash()
     # Verify minimum delay
     assert get_current_epoch(state) >= challenge.inclusion_epoch + ACTIVATION_EXIT_DELAY
     # Verify the chunk matches the crosslink data root
-    assert verify_merkle_branch(
+    assert is_valid_merkle_branch(
         leaf=hash_tree_root(response.chunk),
-        proof=response.data_branch,
+        branch=response.data_branch,
         depth=challenge.depth,
         index=response.chunk_index,
         root=challenge.data_root,
@@ -610,7 +610,7 @@ def process_chunk_challenge_response(state: BeaconState,
     records = state.custody_chunk_challenge_records
     records[records.index(challenge)] = CustodyChunkChallengeRecord()
     # Reward the proposer
-    proposer_index = get_beacon_proposer_index(state)
+    proposer_index = get_proposer_index(state)
     increase_balance(state, proposer_index, Gwei(get_base_reward(state, proposer_index) // MINOR_REWARD_QUOTIENT))
 ```
 
@@ -624,17 +624,17 @@ def process_bit_challenge_response(state: BeaconState,
     responder = state.validators[challenge.responder_index]
     assert not responder.slashed
     # Verify the chunk matches the crosslink data root
-    assert verify_merkle_branch(
+    assert is_valid_merkle_branch(
         leaf=hash_tree_root(response.chunk),
-        proof=response.data_branch,
+        branch=response.data_branch,
         depth=ceillog2(challenge.chunk_count),
         index=response.chunk_index,
         root=challenge.data_root,
     )
     # Verify the chunk bit leaf matches the challenge data
-    assert verify_merkle_branch(
+    assert is_valid_merkle_branch(
         leaf=response.chunk_bits_leaf,
-        proof=response.chunk_bits_branch,
+        branch=response.chunk_bits_branch,
         depth=ceillog2(challenge.chunk_count) >> 8,
         index=response.chunk_index // 256,
         root=challenge.chunk_bits_merkle_root

specs/core/1_shard-data-chains.md

@@ -139,7 +139,7 @@ def get_period_committee(state: BeaconState,
     """
     return compute_committee(
         indices=get_active_validator_indices(state, epoch),
-        seed=generate_seed(state, epoch),
+        seed=get_seed(state, epoch),
         index=shard * count + index,
         count=SHARD_COUNT * count,
     )
@@ -150,7 +150,7 @@ def get_period_committee(state: BeaconState,
 ```python
 def get_switchover_epoch(state: BeaconState, epoch: Epoch, index: ValidatorIndex) -> int:
     earlier_start_epoch = Epoch(epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2)
-    return (bytes_to_int(hash(generate_seed(state, earlier_start_epoch) + int_to_bytes(index, length=3)[0:8]))
+    return (bytes_to_int(hash(get_seed(state, earlier_start_epoch) + int_to_bytes(index, length=3)[0:8]))
             % PERSISTENT_COMMITTEE_PERIOD)
 ```
 
@@ -309,11 +309,11 @@ def is_valid_shard_block(beacon_blocks: Sequence[BeaconBlock],
     assert beacon_block.slot <= candidate.slot
 
     # Check state root
-    assert candidate.state_root == ZERO_HASH  # [to be removed in phase 2]
+    assert candidate.state_root == Hash()  # [to be removed in phase 2]
 
     # Check parent block
     if candidate.slot == PHASE_1_FORK_SLOT:
-        assert candidate.parent_root == ZERO_HASH
+        assert candidate.parent_root == Hash()
     else:
         parent_block = next(
             (block for block in valid_shard_blocks if signing_root(block) == candidate.parent_root),
@@ -395,7 +395,7 @@ def is_valid_beacon_attestation(shard: Shard,
 
     # Check previous attestation
     if candidate.data.previous_crosslink.epoch <= PHASE_1_FORK_EPOCH:
-        assert candidate.data.previous_crosslink.data_root == ZERO_HASH
+        assert candidate.data.previous_crosslink.data_root == Hash()
     else:
         previous_attestation = next(
             (attestation for attestation in valid_attestations if

specs/light_client/sync_protocol.md

@@ -84,7 +84,7 @@ def get_period_data(block: ExtendedBeaconBlock, shard_id: Shard, later: bool) ->
     indices = get_period_committee(block.state, shard_id, period_start, 0, committee_count)
     return PeriodData(
         validator_count,
-        generate_seed(block.state, period_start),
+        get_seed(block.state, period_start),
         [block.state.validators[i] for i in indices],
     )
 ```

specs/validator/0_beacon-chain-validator.md

@@ -145,11 +145,11 @@ def get_committee_assignment(
     next_epoch = get_current_epoch(state) + 1
     assert epoch <= next_epoch
 
-    committees_per_slot = get_epoch_committee_count(state, epoch) // SLOTS_PER_EPOCH
-    epoch_start_slot = get_epoch_start_slot(epoch)
-    for slot in range(epoch_start_slot, epoch_start_slot + SLOTS_PER_EPOCH):
+    committees_per_slot = get_committee_count(state, epoch) // SLOTS_PER_EPOCH
+    start_slot = epoch_first_slot(epoch)
+    for slot in range(start_slot, start_slot + SLOTS_PER_EPOCH):
         offset = committees_per_slot * (slot % SLOTS_PER_EPOCH)
-        slot_start_shard = (get_epoch_start_shard(state, epoch) + offset) % SHARD_COUNT
+        slot_start_shard = (get_start_shard(state, epoch) + offset) % SHARD_COUNT
         for i in range(committees_per_slot):
             shard = (slot_start_shard + i) % SHARD_COUNT
             committee = get_crosslink_committee(state, epoch, shard)
@@ -162,7 +162,7 @@ A validator can use the following function to see if they are supposed to propos
 ```python
 def is_proposer(state: BeaconState,
                 validator_index: ValidatorIndex) -> bool:
-    return get_beacon_proposer_index(state) == validator_index
+    return get_proposer_index(state) == validator_index
 ```
 
 *Note*: To see if a validator is assigned to propose during the slot, the beacon state must be in the epoch in question. At the epoch boundaries, the validator must run an epoch transition into the epoch to successfully check the proposal assignment of the first slot.
@@ -307,8 +307,8 @@ Set `attestation_data.beacon_block_root = signing_root(head_block)`.
 * Set `attestation_data.target_root = epoch_boundary_block_root` where `epoch_boundary_block_root` is the root of block at the most recent epoch boundary.
 
 *Note*: `epoch_boundary_block_root` can be looked up in the state using:
-* Let `epoch_start_slot = get_epoch_start_slot(get_current_epoch(head_state))`.
-* Let `epoch_boundary_block_root = signing_root(head_block) if epoch_start_slot == head_state.slot else get_block_root(state, epoch_start_slot)`.
+* Let `start_slot = epoch_first_slot(get_current_epoch(head_state))`.
+* Let `epoch_boundary_block_root = signing_root(head_block) if start_slot == head_state.slot else get_block_root(state, start_slot)`.
 
 ##### Crosslink vote
 

test_generators/shuffling/main.py

@@ -10,7 +10,7 @@
 def shuffling_case(seed, count):
     yield 'seed', '0x' + seed.hex()
     yield 'count', count
-    yield 'shuffled', [spec.get_shuffled_index(i, count, seed) for i in range(count)]
+    yield 'shuffled', [spec.shuffle_index(i, count, seed) for i in range(count)]
 
 
 @to_tuple

test_libs/pyspec/eth2spec/test/fork_choice/test_on_attestation.py

@@ -14,7 +14,7 @@ def run_on_attestation(spec, state, store, attestation, valid=True):
         else:
             assert False
 
-    indexed_attestation = spec.convert_to_indexed(state, attestation)
+    indexed_attestation = spec.get_indexed_attestation(state, attestation)
     spec.on_attestation(store, attestation)
     assert (
         store.latest_messages[indexed_attestation.custody_bit_0_indices[0]] ==

test_libs/pyspec/eth2spec/test/helpers/attestations.py

@@ -15,15 +15,15 @@ def build_attestation_data(spec, state, slot, shard):
     else:
         block_root = spec.get_block_root_at_slot(state, slot)
 
-    current_epoch_start_slot = spec.get_epoch_start_slot(spec.get_current_epoch(state))
-    if slot < current_epoch_start_slot:
+    current_epoch_first_slot = spec.epoch_first_slot(spec.get_current_epoch(state))
+    if slot < current_epoch_first_slot:
         epoch_boundary_root = spec.get_block_root(state, spec.get_previous_epoch(state))
-    elif slot == current_epoch_start_slot:
+    elif slot == current_epoch_first_slot:
         epoch_boundary_root = block_root
     else:
         epoch_boundary_root = spec.get_block_root(state, spec.get_current_epoch(state))
 
-    if slot < current_epoch_start_slot:
+    if slot < current_epoch_first_slot:
         source_epoch = state.previous_justified_checkpoint.epoch
         source_root = state.previous_justified_checkpoint.root
     else:
@@ -43,7 +43,7 @@ def build_attestation_data(spec, state, slot, shard):
             shard=shard,
             start_epoch=parent_crosslink.end_epoch,
             end_epoch=min(spec.slot_to_epoch(slot), parent_crosslink.end_epoch + spec.MAX_EPOCHS_PER_CROSSLINK),
-            data_root=spec.ZERO_HASH,
+            data_root=spec.Hash(),
             parent_root=hash_tree_root(parent_crosslink),
         ),
     )
@@ -54,8 +54,8 @@ def get_valid_attestation(spec, state, slot=None, signed=False):
         slot = state.slot
 
     epoch = spec.slot_to_epoch(slot)
-    epoch_start_shard = spec.get_epoch_start_shard(state, epoch)
-    committees_per_slot = spec.get_epoch_committee_count(state, epoch) // spec.SLOTS_PER_EPOCH
+    epoch_start_shard = spec.get_start_shard(state, epoch)
+    committees_per_slot = spec.get_committee_count(state, epoch) // spec.SLOTS_PER_EPOCH
     shard = (epoch_start_shard + committees_per_slot * (slot % spec.SLOTS_PER_EPOCH)) % spec.SHARD_COUNT
 
     attestation_data = build_attestation_data(spec, state, slot, shard)

test_libs/pyspec/eth2spec/test/helpers/attester_slashings.py

@@ -13,6 +13,6 @@ def get_valid_attester_slashing(spec, state, signed_1=False, signed_2=False):
         sign_attestation(spec, state, attestation_2)
 
     return spec.AttesterSlashing(
-        attestation_1=spec.convert_to_indexed(state, attestation_1),
-        attestation_2=spec.convert_to_indexed(state, attestation_2),
+        attestation_1=spec.get_indexed_attestation(state, attestation_1),
+        attestation_2=spec.get_indexed_attestation(state, attestation_2),
     )

test_libs/pyspec/eth2spec/test/helpers/block.py

@@ -12,15 +12,15 @@ def sign_block(spec, state, block, proposer_index=None):
 
     if proposer_index is None:
         if block.slot == state.slot:
-            proposer_index = spec.get_beacon_proposer_index(state)
+            proposer_index = spec.get_proposer_index(state)
         else:
             if spec.slot_to_epoch(state.slot) + 1 > spec.slot_to_epoch(block.slot):
                 print("warning: block slot far away, and no proposer index manually given."
                       " Signing block is slow due to transition for proposer index calculation.")
             # use stub state to get proposer index of future slot
             stub_state = deepcopy(state)
             spec.process_slots(stub_state, block.slot)
-            proposer_index = spec.get_beacon_proposer_index(stub_state)
+            proposer_index = spec.get_proposer_index(stub_state)
 
     privkey = privkeys[proposer_index]
 
@@ -59,7 +59,7 @@ def build_empty_block(spec, state, slot=None, signed=False):
     empty_block.slot = slot
     empty_block.body.eth1_data.deposit_count = state.eth1_deposit_index
     previous_block_header = deepcopy(state.latest_block_header)
-    if previous_block_header.state_root == spec.ZERO_HASH:
+    if previous_block_header.state_root == spec.Hash():
         previous_block_header.state_root = state.hash_tree_root()
     empty_block.parent_root = signing_root(previous_block_header)
 

test_libs/pyspec/eth2spec/test/helpers/deposits.py

@@ -49,7 +49,7 @@ def build_deposit(spec,
     tree = calc_merkle_tree_from_leaves(tuple([d.hash_tree_root() for d in deposit_data_list]))
     proof = list(get_merkle_proof(tree, item_index=index)) + [(index + 1).to_bytes(32, 'little')]
     leaf = deposit_data.hash_tree_root()
-    assert spec.verify_merkle_branch(leaf, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH + 1, index, root)
+    assert spec.is_valid_merkle_branch(leaf, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH + 1, index, root)
     deposit = spec.Deposit(proof=proof, data=deposit_data)
 
     return deposit, root, deposit_data_list

test_libs/pyspec/eth2spec/test/helpers/genesis.py

@@ -27,7 +27,7 @@ def create_genesis_state(spec, num_validators):
         eth1_data=spec.Eth1Data(
             deposit_root=deposit_root,
             deposit_count=num_validators,
-            block_hash=spec.ZERO_HASH,
+            block_hash=spec.Hash(),
         ),
         latest_block_header=spec.BeaconBlockHeader(body_root=spec.hash_tree_root(spec.BeaconBlockBody())),
     )

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py

@@ -30,7 +30,7 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True)
         + attester_slashing.attestation_1.custody_bit_1_indices
     )
 
-    proposer_index = spec.get_beacon_proposer_index(state)
+    proposer_index = spec.get_proposer_index(state)
     pre_proposer_balance = get_balance(state, proposer_index)
     pre_slashings = {slashed_index: get_balance(state, slashed_index) for slashed_index in slashed_indices}
     pre_withdrawalable_epochs = {

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_block_header.py

@@ -75,7 +75,7 @@ def test_proposer_slashed(spec, state):
     # use stub state to get proposer index of next slot
     stub_state = deepcopy(state)
     next_slot(spec, stub_state)
-    proposer_index = spec.get_beacon_proposer_index(stub_state)
+    proposer_index = spec.get_proposer_index(stub_state)
 
     # set proposer to slashed
     state.validators[proposer_index].slashed = True

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_deposit.py

@@ -195,7 +195,7 @@ def test_bad_merkle_proof(spec, state):
     deposit = prepare_state_and_deposit(spec, state, validator_index, amount)
 
     # mess up merkle branch
-    deposit.proof[5] = spec.ZERO_HASH
+    deposit.proof[5] = spec.Hash()
 
     sign_deposit_data(spec, deposit.data, privkeys[validator_index], state=state)
 

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_transfer.py

@@ -21,7 +21,7 @@ def run_transfer_processing(spec, state, transfer, valid=True):
         yield 'post', None
         return
 
-    proposer_index = spec.get_beacon_proposer_index(state)
+    proposer_index = spec.get_proposer_index(state)
     pre_transfer_sender_balance = state.balances[transfer.sender]
     pre_transfer_recipient_balance = state.balances[transfer.recipient]
     pre_transfer_proposer_balance = state.balances[proposer_index]
@@ -360,7 +360,7 @@ def test_non_existent_recipient(spec, state):
 @spec_state_test
 def test_invalid_pubkey(spec, state):
     transfer = get_valid_transfer(spec, state, signed=True)
-    state.validators[transfer.sender].withdrawal_credentials = spec.ZERO_HASH
+    state.validators[transfer.sender].withdrawal_credentials = spec.Hash()
 
     # un-activate so validator can transfer
     state.validators[transfer.sender].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH