Merge pull request #1241 from ethereum/rename_misc

Renaming of functions in the `Misc` section

scripts/build_spec.py

@@ -97,7 +97,7 @@ def apply_constants_preset(preset: Dict[str, Any]) -> None:
         global_vars[k] = v
 
     # Deal with derived constants
-    global_vars['GENESIS_EPOCH'] = slot_to_epoch(GENESIS_SLOT)
+    global_vars['GENESIS_EPOCH'] = compute_epoch_of_slot(GENESIS_SLOT)
 
     # Initialize SSZ types again, to account for changed lengths
     init_SSZ_types()

specs/core/0_beacon-chain.md

@@ -64,15 +64,15 @@
             - [`is_active_validator`](#is_active_validator)
             - [`is_slashable_validator`](#is_slashable_validator)
             - [`is_slashable_attestation_data`](#is_slashable_attestation_data)
+            - [`is_valid_indexed_attestation`](#is_valid_indexed_attestation)
             - [`is_valid_merkle_branch`](#is_valid_merkle_branch)
         - [Misc](#misc-1)
-            - [`shuffle_index`](#shuffle_index)
+            - [`compute_shuffled_index`](#compute_shuffled_index)
             - [`compute_committee`](#compute_committee)
-            - [`validate_indexed_attestation`](#validate_indexed_attestation)
+            - [`compute_epoch_of_slot`](#compute_epoch_of_slot)
-            - [`slot_to_epoch`](#slot_to_epoch)
+            - [`compute_start_slot_of_epoch`](#compute_start_slot_of_epoch)
-            - [`epoch_start_slot`](#epoch_start_slot)
             - [`compute_activation_exit_epoch`](#compute_activation_exit_epoch)
-            - [`bls_domain`](#bls_domain)
+            - [`compute_domain`](#compute_domain)
         - [Beacon state accessors](#beacon-state-accessors)
             - [`get_current_epoch`](#get_current_epoch)
             - [`get_previous_epoch`](#get_previous_epoch)
@@ -645,6 +645,45 @@ def is_slashable_attestation_data(data_1: AttestationData, data_2: AttestationDa
     )
 ```
 
+#### `is_valid_indexed_attestation`
+
+```python
+def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
+    """
+    Verify validity of ``indexed_attestation``.
+    """
+    bit_0_indices = indexed_attestation.custody_bit_0_indices
+    bit_1_indices = indexed_attestation.custody_bit_1_indices
+
+    # Verify no index has custody bit equal to 1 [to be removed in phase 1]
+    if not len(bit_1_indices) == 0:
+        return False
+    # Verify max number of indices
+    if not len(bit_0_indices) + len(bit_1_indices) <= MAX_VALIDATORS_PER_COMMITTEE:
+        return False
+    # Verify index sets are disjoint
+    if not len(set(bit_0_indices).intersection(bit_1_indices)) == 0:
+        return False
+    # Verify indices are sorted
+    if not (bit_0_indices == sorted(bit_0_indices) and bit_1_indices == sorted(bit_1_indices)):
+        return False
+    # Verify aggregate signature
+    if not bls_verify_multiple(
+        pubkeys=[
+            bls_aggregate_pubkeys([state.validators[i].pubkey for i in bit_0_indices]),
+            bls_aggregate_pubkeys([state.validators[i].pubkey for i in bit_1_indices]),
+        ],
+        message_hashes=[
+            hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b0)),
+            hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b1)),
+        ],
+        signature=indexed_attestation.signature,
+        domain=get_domain(state, DOMAIN_ATTESTATION, indexed_attestation.data.target.epoch),
+    ):
+        return False
+    return True
+```
+
 #### `is_valid_merkle_branch`
 
 ```python
@@ -663,10 +702,10 @@ def is_valid_merkle_branch(leaf: Hash, branch: Sequence[Hash], depth: uint64, in
 
 ### Misc
 
-#### `shuffle_index`
+#### `compute_shuffled_index`
 
 ```python
-def shuffle_index(index: ValidatorIndex, index_count: uint64, seed: Hash) -> ValidatorIndex:
+def compute_shuffled_index(index: ValidatorIndex, index_count: uint64, seed: Hash) -> ValidatorIndex:
     """
     Return the shuffled validator index corresponding to ``seed`` (and ``index_count``).
     """
@@ -699,56 +738,23 @@ def compute_committee(indices: Sequence[ValidatorIndex],
     """
     start = (len(indices) * index) // count
     end = (len(indices) * (index + 1)) // count
-    return [indices[shuffle_index(ValidatorIndex(i), len(indices), seed)] for i in range(start, end)]
+    return [indices[compute_shuffled_index(ValidatorIndex(i), len(indices), seed)] for i in range(start, end)]
 ```
 
-#### `validate_indexed_attestation`
+#### `compute_epoch_of_slot`
 
 ```python
-def validate_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> None:
+def compute_epoch_of_slot(slot: Slot) -> Epoch:
-    """
-    Verify validity of ``indexed_attestation``.
-    """
-    bit_0_indices = indexed_attestation.custody_bit_0_indices
-    bit_1_indices = indexed_attestation.custody_bit_1_indices
-
-    # Verify no index has custody bit equal to 1 [to be removed in phase 1]
-    assert len(bit_1_indices) == 0
-    # Verify max number of indices
-    assert len(bit_0_indices) + len(bit_1_indices) <= MAX_VALIDATORS_PER_COMMITTEE
-    # Verify index sets are disjoint
-    assert len(set(bit_0_indices).intersection(bit_1_indices)) == 0
-    # Verify indices are sorted
-    assert bit_0_indices == sorted(bit_0_indices) and bit_1_indices == sorted(bit_1_indices)
-    # Verify aggregate signature
-    assert bls_verify_multiple(
-        pubkeys=[
-            bls_aggregate_pubkeys([state.validators[i].pubkey for i in bit_0_indices]),
-            bls_aggregate_pubkeys([state.validators[i].pubkey for i in bit_1_indices]),
-        ],
-        message_hashes=[
-            hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b0)),
-            hash_tree_root(AttestationDataAndCustodyBit(data=indexed_attestation.data, custody_bit=0b1)),
-        ],
-        signature=indexed_attestation.signature,
-        domain=get_domain(state, DOMAIN_ATTESTATION, indexed_attestation.data.target.epoch),
-    )
-```
-
-#### `slot_to_epoch`
-
-```python
-def slot_to_epoch(slot: Slot) -> Epoch:
     """
     Return the epoch number of ``slot``.
     """
     return Epoch(slot // SLOTS_PER_EPOCH)
 ```
 
-#### `epoch_start_slot`
+#### `compute_start_slot_of_epoch`
 
 ```python
-def epoch_start_slot(epoch: Epoch) -> Slot:
+def compute_start_slot_of_epoch(epoch: Epoch) -> Slot:
     """
     Return the start slot of ``epoch``.
     """
@@ -765,12 +771,12 @@ def compute_activation_exit_epoch(epoch: Epoch) -> Epoch:
     return Epoch(epoch + 1 + ACTIVATION_EXIT_DELAY)
 ```
 
-#### `bls_domain`
+#### `compute_domain`
 
 ```python
-def bls_domain(domain_type: uint64, fork_version: bytes=b'\x00' * 4) -> int:
+def compute_domain(domain_type: uint64, fork_version: bytes=b'\x00' * 4) -> int:
     """
-    Return the BLS domain for the ``domain_type`` and ``fork_version``.
+    Return the domain for the ``domain_type`` and ``fork_version``.
     """
     return bytes_to_int(int_to_bytes(domain_type, length=4) + fork_version)
 ```
@@ -784,7 +790,7 @@ def get_current_epoch(state: BeaconState) -> Epoch:
     """
     Return the current epoch.
     """
-    return slot_to_epoch(state.slot)
+    return compute_epoch_of_slot(state.slot)
 ```
 
 #### `get_previous_epoch`
@@ -805,7 +811,7 @@ def get_block_root(state: BeaconState, epoch: Epoch) -> Hash:
     """
     Return the block root at the start of a recent ``epoch``.
     """
-    return get_block_root_at_slot(state, epoch_start_slot(epoch))
+    return get_block_root_at_slot(state, compute_start_slot_of_epoch(epoch))
 ```
 
 #### `get_block_root_at_slot`
@@ -951,7 +957,7 @@ def get_attestation_data_slot(state: BeaconState, data: AttestationData) -> Slot
     """
     committee_count = get_committee_count(state, data.target.epoch)
     offset = (data.crosslink.shard + SHARD_COUNT - get_start_shard(state, data.target.epoch)) % SHARD_COUNT
-    return Slot(epoch_start_slot(data.target.epoch) + offset // (committee_count // SLOTS_PER_EPOCH))
+    return Slot(compute_start_slot_of_epoch(data.target.epoch) + offset // (committee_count // SLOTS_PER_EPOCH))
 ```
 
 #### `get_compact_committees_root`
@@ -1004,7 +1010,7 @@ def get_domain(state: BeaconState, domain_type: uint64, message_epoch: Epoch=Non
     """
     epoch = get_current_epoch(state) if message_epoch is None else message_epoch
     fork_version = state.fork.previous_version if epoch < state.fork.epoch else state.fork.current_version
-    return bls_domain(domain_type, fork_version)
+    return compute_domain(domain_type, fork_version)
 ```
 
 #### `get_indexed_attestation`
@@ -1588,14 +1594,15 @@ def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
 def process_proposer_slashing(state: BeaconState, proposer_slashing: ProposerSlashing) -> None:
     proposer = state.validators[proposer_slashing.proposer_index]
     # Verify that the epoch is the same
-    assert slot_to_epoch(proposer_slashing.header_1.slot) == slot_to_epoch(proposer_slashing.header_2.slot)
+    assert (compute_epoch_of_slot(proposer_slashing.header_1.slot)
+            == compute_epoch_of_slot(proposer_slashing.header_2.slot))
     # But the headers are different
     assert proposer_slashing.header_1 != proposer_slashing.header_2
     # Check proposer is slashable
     assert is_slashable_validator(proposer, get_current_epoch(state))
     # Signatures are valid
     for header in (proposer_slashing.header_1, proposer_slashing.header_2):
-        domain = get_domain(state, DOMAIN_BEACON_PROPOSER, slot_to_epoch(header.slot))
+        domain = get_domain(state, DOMAIN_BEACON_PROPOSER, compute_epoch_of_slot(header.slot))
         assert bls_verify(proposer.pubkey, signing_root(header), header.signature, domain)
 
     slash_validator(state, proposer_slashing.proposer_index)
@@ -1608,8 +1615,8 @@ def process_attester_slashing(state: BeaconState, attester_slashing: AttesterSla
     attestation_1 = attester_slashing.attestation_1
     attestation_2 = attester_slashing.attestation_2
     assert is_slashable_attestation_data(attestation_1.data, attestation_2.data)
-    validate_indexed_attestation(state, attestation_1)
+    assert is_valid_indexed_attestation(state, attestation_1)
-    validate_indexed_attestation(state, attestation_2)
+    assert is_valid_indexed_attestation(state, attestation_2)
 
     slashed_any = False
     attesting_indices_1 = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices
@@ -1655,7 +1662,7 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
     assert data.crosslink.data_root == Hash()  # [to be removed in phase 1]
 
     # Check signature
-    validate_indexed_attestation(state, get_indexed_attestation(state, attestation))
+    assert is_valid_indexed_attestation(state, get_indexed_attestation(state, attestation))
 ```
 
 ##### Deposits
@@ -1680,8 +1687,9 @@ def process_deposit(state: BeaconState, deposit: Deposit) -> None:
     if pubkey not in validator_pubkeys:
         # Verify the deposit signature (proof of possession) for new validators.
         # Note: The deposit contract does not check signatures.
-        # Note: Deposits are valid across forks, hence the deposit domain is retrieved directly from `bls_domain`
+        # Note: Deposits are valid across forks, thus the deposit domain is retrieved directly from `compute_domain`
-        if not bls_verify(pubkey, signing_root(deposit.data), deposit.data.signature, bls_domain(DOMAIN_DEPOSIT)):
+        domain = compute_domain(DOMAIN_DEPOSIT)
+        if not bls_verify(pubkey, signing_root(deposit.data), deposit.data.signature, domain):
             return
 
         # Add validator and balance entries

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 = epoch_start_slot(store.justified_checkpoint.epoch)
+    justified_slot = compute_start_slot_of_epoch(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 > epoch_start_slot(store.finalized_checkpoint.epoch)
+    assert block.slot > compute_start_slot_of_epoch(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 arrives
     base_state = store.block_states[target.root].copy()
-    assert store.time >= base_state.genesis_time + epoch_start_slot(target.epoch) * SECONDS_PER_SLOT
+    assert store.time >= base_state.genesis_time + compute_start_slot_of_epoch(target.epoch) * SECONDS_PER_SLOT
 
     # Store target checkpoint state if not yet seen
     if target not in store.checkpoint_states:
-        process_slots(base_state, epoch_start_slot(target.epoch))
+        process_slots(base_state, compute_start_slot_of_epoch(target.epoch))
         store.checkpoint_states[target] = base_state
     target_state = store.checkpoint_states[target]
 
@@ -205,7 +205,7 @@ def on_attestation(store: Store, attestation: Attestation) -> None:
 
     # Get state at the `target` to validate attestation and calculate the committees
     indexed_attestation = get_indexed_attestation(target_state, attestation)
-    validate_indexed_attestation(target_state, indexed_attestation)
+    assert is_valid_indexed_attestation(target_state, indexed_attestation)
 
     # Update latest messages
     for i in indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices:

specs/core/1_custody-game.md

@@ -474,9 +474,10 @@ 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, get_indexed_attestation(state, challenge.attestation))
+    assert is_valid_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
+    assert (compute_epoch_of_slot(challenge.attestation.data.slot)
+            >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY)
     responder = state.validators[challenge.responder_index]
     assert responder.exit_epoch >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY
     # Verify the responder participated in the attestation
@@ -517,7 +518,7 @@ For each `challenge` in `block.body.custody_bit_challenges`, run the following f
 ```python
 def process_bit_challenge(state: BeaconState, challenge: CustodyBitChallenge) -> None:
     attestation = challenge.attestation
-    epoch = slot_to_epoch(attestation.data.slot)
+    epoch = compute_epoch_of_slot(attestation.data.slot)
     shard = attestation.data.crosslink.shard
 
     # Verify challenge signature
@@ -527,7 +528,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, get_indexed_attestation(state, attestation))
+    assert is_valid_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)

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

@@ -164,7 +164,7 @@ def get_persistent_committee(state: BeaconState,
     """
     Return the persistent committee for the given ``shard`` at the given ``slot``.
     """
-    epoch = slot_to_epoch(slot)
+    epoch = compute_epoch_of_slot(slot)
     earlier_start_epoch = Epoch(epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2)
     later_start_epoch = Epoch(epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD)
 
@@ -241,7 +241,7 @@ def verify_shard_attestation_signature(state: BeaconState,
         pubkey=bls_aggregate_pubkeys(pubkeys),
         message_hash=data.shard_block_root,
         signature=attestation.aggregate_signature,
-        domain=get_domain(state, DOMAIN_SHARD_ATTESTER, slot_to_epoch(data.slot))
+        domain=get_domain(state, DOMAIN_SHARD_ATTESTER, compute_epoch_of_slot(data.slot))
     )
 ```
 
@@ -340,7 +340,7 @@ def is_valid_shard_block(beacon_blocks: Sequence[BeaconBlock],
         pubkey=beacon_state.validators[proposer_index].pubkey,
         message_hash=signing_root(candidate),
         signature=candidate.signature,
-        domain=get_domain(beacon_state, DOMAIN_SHARD_PROPOSER, slot_to_epoch(candidate.slot)),
+        domain=get_domain(beacon_state, DOMAIN_SHARD_PROPOSER, compute_epoch_of_slot(candidate.slot)),
     )
 
     return True
@@ -404,11 +404,12 @@ def is_valid_beacon_attestation(shard: Shard,
             None,
         )
         assert previous_attestation is not None
-        assert candidate.data.previous_attestation.epoch < slot_to_epoch(candidate.data.slot)
+        assert candidate.data.previous_attestation.epoch < compute_epoch_of_slot(candidate.data.slot)
 
     # Check crosslink data root
     start_epoch = beacon_state.crosslinks[shard].epoch
-    end_epoch = min(slot_to_epoch(candidate.data.slot) - CROSSLINK_LOOKBACK, start_epoch + MAX_EPOCHS_PER_CROSSLINK)
+    end_epoch = min(compute_epoch_of_slot(candidate.data.slot) - CROSSLINK_LOOKBACK,
+                    start_epoch + MAX_EPOCHS_PER_CROSSLINK)
     blocks = []
     for slot in range(start_epoch * SLOTS_PER_EPOCH, end_epoch * SLOTS_PER_EPOCH):
         blocks.append(shard_blocks[slot])

specs/light_client/sync_protocol.md

@@ -124,7 +124,7 @@ def compute_committee(header: BeaconBlockHeader,
     maximal_later_committee = validator_memory.later_period_data.committee
     earlier_start_epoch = get_earlier_start_epoch(header.slot)
     later_start_epoch = get_later_start_epoch(header.slot)
-    epoch = slot_to_epoch(header.slot)
+    epoch = compute_epoch_of_slot(header.slot)
 
     committee_count = max(
         earlier_validator_count // (SHARD_COUNT * TARGET_COMMITTEE_SIZE),
@@ -192,7 +192,7 @@ def verify_block_validity_proof(proof: BlockValidityProof, validator_memory: Val
         pubkey=group_public_key,
         message_hash=hash_tree_root(shard_parent_block),
         signature=proof.shard_aggregate_signature,
-        domain=get_domain(state, slot_to_epoch(shard_block.slot), DOMAIN_SHARD_ATTESTER),
+        domain=get_domain(state, compute_epoch_of_slot(shard_block.slot), DOMAIN_SHARD_ATTESTER),
     )
 ```
 

specs/test_formats/bls/msg_hash_g2_compressed.md

@@ -7,7 +7,7 @@ A BLS compressed-hash to G2.
 ```yaml
 input:
   message: bytes32,
-  domain: uint64 -- the BLS domain
+  domain: uint64 -- the domain
 output: List[bytes48] -- length of two
 ```
 

specs/test_formats/bls/msg_hash_g2_uncompressed.md

@@ -7,7 +7,7 @@ A BLS uncompressed-hash to G2.
 ```yaml
 input:
   message: bytes32
-  domain: uint64 -- the BLS domain
+  domain: uint64 -- the domain
 output: List[List[bytes48]] -- 3 lists, each a length of two
 ```
 

specs/test_formats/bls/sign_msg.md

@@ -8,7 +8,7 @@ Message signing with BLS should produce a signature.
 input:
   privkey: bytes32 -- the private key used for signing
   message: bytes32 -- input message to sign (a hash)
-  domain: uint64 -- the BLS domain
+  domain: uint64 -- the domain
 output: bytes96    -- expected signature
 ```
 

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

@@ -99,7 +99,7 @@ To submit a deposit:
 - Pack the validator's [initialization parameters](#initialization) into `deposit_data`, a [`DepositData`](../core/0_beacon-chain.md#depositdata) SSZ object.
 - Let `amount` be the amount in Gwei to be deposited by the validator where `MIN_DEPOSIT_AMOUNT <= amount <= MAX_EFFECTIVE_BALANCE`.
 - Set `deposit_data.amount = amount`.
-- Let `signature` be the result of `bls_sign` of the `signing_root(deposit_data)` with `domain=bls_domain(DOMAIN_DEPOSIT)`. (Deposits are valid regardless of fork version, `bls_domain` will default to zeroes there).
+- Let `signature` be the result of `bls_sign` of the `signing_root(deposit_data)` with `domain=compute_domain(DOMAIN_DEPOSIT)`. (Deposits are valid regardless of fork version, `compute_domain` will default to zeroes there).
 - Send a transaction on the Ethereum 1.0 chain to `DEPOSIT_CONTRACT_ADDRESS` executing `def deposit(pubkey: bytes[48], withdrawal_credentials: bytes[32], signature: bytes[96])` along with a deposit of `amount` Gwei.
 
 *Note*: Deposits made for the same `pubkey` are treated as for the same validator. A singular `Validator` will be added to `state.validators` with each additional deposit amount added to the validator's balance. A validator can only be activated when total deposits for the validator pubkey meet or exceed `MAX_EFFECTIVE_BALANCE`.
@@ -146,7 +146,7 @@ def get_committee_assignment(state: BeaconState,
     assert epoch <= next_epoch
 
     committees_per_slot = get_committee_count(state, epoch) // SLOTS_PER_EPOCH
-    start_slot = epoch_start_slot(epoch)
+    start_slot = compute_start_slot_of_epoch(epoch)
     for slot in range(start_slot, start_slot + SLOTS_PER_EPOCH):
         offset = committees_per_slot * (slot % SLOTS_PER_EPOCH)
         slot_start_shard = (get_start_shard(state, epoch) + offset) % SHARD_COUNT
@@ -210,10 +210,10 @@ Set `block.randao_reveal = epoch_signature` where `epoch_signature` is defined a
 ```python
 epoch_signature = bls_sign(
     privkey=validator.privkey,  # privkey stored locally, not in state
-    message_hash=hash_tree_root(slot_to_epoch(block.slot)),
+    message_hash=hash_tree_root(compute_epoch_of_slot(block.slot)),
     domain=get_domain(
         fork=fork,  # `fork` is the fork object at the slot `block.slot`
-        epoch=slot_to_epoch(block.slot),
+        epoch=compute_epoch_of_slot(block.slot),
         domain_type=DOMAIN_RANDAO,
     )
 )
@@ -252,7 +252,7 @@ block_signature = bls_sign(
     message_hash=signing_root(block),
     domain=get_domain(
         fork=fork,  # `fork` is the fork object at the slot `block.slot`
-        epoch=slot_to_epoch(block.slot),
+        epoch=compute_epoch_of_slot(block.slot),
         domain_type=DOMAIN_BEACON_BLOCK,
     )
 )
@@ -308,7 +308,7 @@ Set `attestation_data.beacon_block_root = signing_root(head_block)`.
 
 *Note*: `epoch_boundary_block_root` can be looked up in the state using:
 
-- Let `start_slot = epoch_start_slot(get_current_epoch(head_state))`.
+- Let `start_slot = compute_start_slot_of_epoch(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
@@ -358,7 +358,7 @@ signed_attestation_data = bls_sign(
     message_hash=attestation_message,
     domain=get_domain(
         fork=fork,  # `fork` is the fork object at the slot, `attestation_data.slot`
-        epoch=slot_to_epoch(attestation_data.slot),
+        epoch=compute_epoch_of_slot(attestation_data.slot),
         domain_type=DOMAIN_ATTESTATION,
     )
 )
@@ -378,7 +378,7 @@ To avoid "proposer slashings", a validator must not sign two conflicting [`Beaco
 
 Specifically, when signing a `BeaconBlock`, a validator should perform the following steps in the following order:
 
-1. Save a record to hard disk that a beacon block has been signed for the `epoch=slot_to_epoch(block.slot)`.
+1. Save a record to hard disk that a beacon block has been signed for the `epoch=compute_epoch_of_slot(block.slot)`.
 2. Generate and broadcast the block.
 
 If the software crashes at some point within this routine, then when the validator comes back online, the hard disk has the record of the *potentially* signed/broadcast block and can effectively avoid slashing.
@@ -389,7 +389,7 @@ To avoid "attester slashings", a validator must not sign two conflicting [`Attes
 
 Specifically, when signing an `Attestation`, a validator should perform the following steps in the following order:
 
-1. Save a record to hard disk that an attestation has been signed for source (i.e. `attestation_data.source_epoch`) and target (i.e. `slot_to_epoch(attestation_data.slot)`).
+1. Save a record to hard disk that an attestation has been signed for source (i.e. `attestation_data.source_epoch`) and target (i.e. `compute_epoch_of_slot(attestation_data.slot)`).
 2. Generate and broadcast attestation.
 
 If the software crashes at some point within this routine, then when the validator comes back online, the hard disk has the record of the *potentially* signed/broadcast attestation and can effectively avoid slashing.

test_generators/shuffling/main.py

@@ -10,7 +10,7 @@ from preset_loader import loader
 def shuffling_case(seed, count):
     yield 'seed', '0x' + seed.hex()
     yield 'count', count
-    yield 'shuffled', [int(spec.shuffled_index(i, count, seed)) for i in range(count)]
+    yield 'shuffled', [int(spec.compute_shuffled_index(i, count, seed)) for i in range(count)]
 
 
 @to_tuple

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

@@ -15,7 +15,7 @@ def build_attestation_data(spec, state, slot, shard):
     else:
         block_root = spec.get_block_root_at_slot(state, slot)
 
-    current_epoch_start_slot = spec.epoch_start_slot(spec.get_current_epoch(state))
+    current_epoch_start_slot = spec.compute_start_slot_of_epoch(spec.get_current_epoch(state))
     if slot < current_epoch_start_slot:
         epoch_boundary_root = spec.get_block_root(state, spec.get_previous_epoch(state))
     elif slot == current_epoch_start_slot:
@@ -30,7 +30,7 @@ def build_attestation_data(spec, state, slot, shard):
         source_epoch = state.current_justified_checkpoint.epoch
         source_root = state.current_justified_checkpoint.root
 
-    if spec.slot_to_epoch(slot) == spec.get_current_epoch(state):
+    if spec.compute_epoch_of_slot(slot) == spec.get_current_epoch(state):
         parent_crosslink = state.current_crosslinks[shard]
     else:
         parent_crosslink = state.previous_crosslinks[shard]
@@ -38,11 +38,11 @@ def build_attestation_data(spec, state, slot, shard):
     return spec.AttestationData(
         beacon_block_root=block_root,
         source=spec.Checkpoint(epoch=source_epoch, root=source_root),
-        target=spec.Checkpoint(epoch=spec.slot_to_epoch(slot), root=epoch_boundary_root),
+        target=spec.Checkpoint(epoch=spec.compute_epoch_of_slot(slot), root=epoch_boundary_root),
         crosslink=spec.Crosslink(
             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),
+            end_epoch=min(spec.compute_epoch_of_slot(slot), parent_crosslink.end_epoch + spec.MAX_EPOCHS_PER_CROSSLINK),
             data_root=spec.Hash(),
             parent_root=hash_tree_root(parent_crosslink),
         ),
@@ -53,7 +53,7 @@ def get_valid_attestation(spec, state, slot=None, signed=False):
     if slot is None:
         slot = state.slot
 
-    epoch = spec.slot_to_epoch(slot)
+    epoch = spec.compute_epoch_of_slot(slot)
     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

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

@@ -14,7 +14,7 @@ def sign_block(spec, state, block, proposer_index=None):
         if block.slot == state.slot:
             proposer_index = spec.get_beacon_proposer_index(state)
         else:
-            if spec.slot_to_epoch(state.slot) + 1 > spec.slot_to_epoch(block.slot):
+            if spec.compute_epoch_of_slot(state.slot) + 1 > spec.compute_epoch_of_slot(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
@@ -26,10 +26,10 @@ def sign_block(spec, state, block, proposer_index=None):
 
     block.body.randao_reveal = bls_sign(
         privkey=privkey,
-        message_hash=hash_tree_root(spec.slot_to_epoch(block.slot)),
+        message_hash=hash_tree_root(spec.compute_epoch_of_slot(block.slot)),
         domain=spec.get_domain(
             state,
-            message_epoch=spec.slot_to_epoch(block.slot),
+            message_epoch=spec.compute_epoch_of_slot(block.slot),
             domain_type=spec.DOMAIN_RANDAO,
         )
     )
@@ -39,7 +39,7 @@ def sign_block(spec, state, block, proposer_index=None):
         domain=spec.get_domain(
             state,
             spec.DOMAIN_BEACON_PROPOSER,
-            spec.slot_to_epoch(block.slot)))
+            spec.compute_epoch_of_slot(block.slot)))
 
 
 def apply_empty_block(spec, state):

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

@@ -19,7 +19,7 @@ def build_deposit_data(spec, pubkey, privkey, amount, withdrawal_credentials, st
 def sign_deposit_data(spec, deposit_data, privkey, state=None):
     if state is None:
         # Genesis
-        domain = spec.bls_domain(spec.DOMAIN_DEPOSIT)
+        domain = spec.compute_domain(spec.DOMAIN_DEPOSIT)
     else:
         domain = spec.get_domain(
             state,

test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py

@@ -9,7 +9,7 @@ def run_process_just_and_fin(spec, state):
 
 
 def get_shards_for_slot(spec, state, slot):
-    epoch = spec.slot_to_epoch(slot)
+    epoch = spec.compute_epoch_of_slot(slot)
     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
@@ -33,7 +33,7 @@ def add_mock_attestations(spec, state, epoch, source, target, sufficient_support
     total_balance = spec.get_total_active_balance(state)
     remaining_balance = total_balance * 2 // 3
 
-    start_slot = spec.epoch_start_slot(epoch)
+    start_slot = spec.compute_start_slot_of_epoch(epoch)
     for slot in range(start_slot, start_slot + spec.SLOTS_PER_EPOCH):
         for shard in get_shards_for_slot(spec, state, slot):
             # Check if we already have had sufficient balance. (and undone if we don't want it).
@@ -41,7 +41,7 @@ def add_mock_attestations(spec, state, epoch, source, target, sufficient_support
             if remaining_balance < 0:
                 return
 
-            committee = spec.get_crosslink_committee(state, spec.slot_to_epoch(slot), shard)
+            committee = spec.get_crosslink_committee(state, spec.compute_epoch_of_slot(slot), shard)
             # Create a bitfield filled with the given count per attestation,
             #  exactly on the right-most part of the committee field.
 
@@ -80,7 +80,7 @@ def get_checkpoints(spec, epoch):
 
 def put_checkpoints_in_block_roots(spec, state, checkpoints):
     for c in checkpoints:
-        state.block_roots[spec.epoch_start_slot(c.epoch) % spec.SLOTS_PER_HISTORICAL_ROOT] = c.root
+        state.block_roots[spec.compute_start_slot_of_epoch(c.epoch) % spec.SLOTS_PER_HISTORICAL_ROOT] = c.root
 
 
 def finalize_on_234(spec, state, epoch, sufficient_support):

test_libs/pyspec/eth2spec/test/test_finality.py

@@ -43,7 +43,7 @@ def next_epoch_with_attestations(spec,
         block = build_empty_block_for_next_slot(spec, post_state)
         if fill_cur_epoch and post_state.slot >= spec.MIN_ATTESTATION_INCLUSION_DELAY:
             slot_to_attest = post_state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1
-            if slot_to_attest >= spec.epoch_start_slot(spec.get_current_epoch(post_state)):
+            if slot_to_attest >= spec.compute_start_slot_of_epoch(spec.get_current_epoch(post_state)):
                 cur_attestation = get_valid_attestation(spec, post_state, slot_to_attest)
                 block.body.attestations.append(cur_attestation)