Merge pull request #1700 from hwwhww/rework_deposit_helpers

Sync ethereum/consensus-specs#374 part1: types, constants, deposit_helpers

Author: hwwhww

eth/beacon/constants.py

@@ -1,4 +1,8 @@
-from eth.beacon.typing import BLSSignature
+from eth.beacon.typing import (
+    BLSSignature,
+    SlotNumber,
+)
+
 
 #
 # shuffle function
@@ -14,3 +18,5 @@
 RAND_MAX = 2 ** (RAND_BYTES * 8) - 1
 
 EMPTY_SIGNATURE = BLSSignature((0, 0))
+GWEI_PER_ETH = 10**9
+FAR_FUTURE_SLOT = SlotNumber(2**64 - 1)

eth/beacon/deposit_helpers.py

@@ -1,8 +1,3 @@
-from typing import (
-    Sequence,
-    Tuple,
-)
-
 from eth_typing import (
     Hash32,
 )
@@ -18,38 +13,20 @@
 from eth.beacon.enums import (
     SignatureDomain,
 )
-from eth.beacon.exceptions import (
-    MinEmptyValidatorIndexNotFound,
-)
 from eth.beacon.types.deposit_input import DepositInput
 from eth.beacon.types.states import BeaconState
 from eth.beacon.types.validator_records import ValidatorRecord
 from eth.beacon.helpers import (
     get_domain,
 )
 from eth.beacon.typing import (
-    SlotNumber,
     BLSPubkey,
     BLSSignature,
     ValidatorIndex,
     Gwei,
 )
 
 
-def get_min_empty_validator_index(validators: Sequence[ValidatorRecord],
-                                  validator_balances: Sequence[Gwei],
-                                  current_slot: SlotNumber,
-                                  zero_balance_validator_ttl: int) -> ValidatorIndex:
-    for index, (validator, balance) in enumerate(zip(validators, validator_balances)):
-        is_empty = (
-            balance == 0 and
-            validator.latest_status_change_slot + zero_balance_validator_ttl <= current_slot
-        )
-        if is_empty:
-            return ValidatorIndex(index)
-    raise MinEmptyValidatorIndexNotFound()
-
-
 def validate_proof_of_possession(state: BeaconState,
                                  pubkey: BLSPubkey,
                                  proof_of_possession: BLSSignature,
@@ -84,72 +61,53 @@ def validate_proof_of_possession(state: BeaconState,
 
 def add_pending_validator(state: BeaconState,
                           validator: ValidatorRecord,
-                          deposit: Gwei,
-                          zero_balance_validator_ttl: int) -> Tuple[BeaconState, ValidatorIndex]:
+                          amount: Gwei) -> BeaconState:
     """
-    Add a validator to the existing minimum empty validator index or
-    append to ``validator_registry``.
+    Add a validator to ``state``.
     """
-    # Check if there's empty validator index in `validator_registry`
-    try:
-        index = get_min_empty_validator_index(
-            state.validator_registry,
-            state.validator_balances,
-            state.slot,
-            zero_balance_validator_ttl,
-        )
-    except MinEmptyValidatorIndexNotFound:
-        index = None
-        # Append to the validator_registry
-        validator_registry = state.validator_registry + (validator,)
-        state = state.copy(
-            validator_registry=validator_registry,
-            validator_balances=state.validator_balances + (deposit, )
-        )
-        index = ValidatorIndex(len(state.validator_registry) - 1)
-    else:
-        # Use the empty validator index
-        state = state.update_validator(index, validator, deposit)
+    state = state.copy(
+        validator_registry=state.validator_registry + (validator,),
+        validator_balances=state.validator_balances + (amount, ),
+    )
 
-    return state, index
+    return state
 
 
 def process_deposit(*,
                     state: BeaconState,
                     pubkey: BLSPubkey,
-                    deposit: Gwei,
+                    amount: Gwei,
                     proof_of_possession: BLSSignature,
                     withdrawal_credentials: Hash32,
                     randao_commitment: Hash32,
-                    custody_commitment: Hash32,
-                    zero_balance_validator_ttl: int) -> Tuple[BeaconState, ValidatorIndex]:
+                    custody_commitment: Hash32) -> BeaconState:
     """
     Process a deposit from Ethereum 1.0.
     """
     validate_proof_of_possession(
-        state,
-        pubkey,
-        proof_of_possession,
-        withdrawal_credentials,
-        randao_commitment,
-        custody_commitment,
+        state=state,
+        pubkey=pubkey,
+        proof_of_possession=proof_of_possession,
+        withdrawal_credentials=withdrawal_credentials,
+        randao_commitment=randao_commitment,
+        custody_commitment=custody_commitment,
     )
 
     validator_pubkeys = tuple(v.pubkey for v in state.validator_registry)
     if pubkey not in validator_pubkeys:
-        validator = ValidatorRecord.get_pending_validator(
+        validator = ValidatorRecord.create_pending_validator(
             pubkey=pubkey,
             withdrawal_credentials=withdrawal_credentials,
             randao_commitment=randao_commitment,
-            latest_status_change_slot=state.slot,
             custody_commitment=custody_commitment,
         )
 
-        state, index = add_pending_validator(
+        # Note: In phase 2 registry indices that has been withdrawn for a long time
+        # will be recycled.
+        state = add_pending_validator(
             state,
             validator,
-            deposit,
-            zero_balance_validator_ttl,
+            amount,
         )
     else:
         # Top-up - increase balance by deposit
@@ -166,10 +124,9 @@ def process_deposit(*,
             )
 
         # Update validator's balance and state
-        state = state.update_validator(
+        state = state.update_validator_balance(
             validator_index=index,
-            validator=validator,
-            balance=state.validator_balances[index] + deposit,
+            balance=state.validator_balances[index] + amount,
         )
 
-    return state, index
+    return state

eth/beacon/enums.py

@@ -1,12 +1,9 @@
 from enum import IntEnum
 
 
-class ValidatorStatusCode(IntEnum):
-    PENDING_ACTIVATION = 0
-    ACTIVE = 1
-    ACTIVE_PENDING_EXIT = 2
-    EXITED_WITHOUT_PENALTY = 3
-    EXITED_WITH_PENALTY = 4
+class ValidatorStatusFlags(IntEnum):
+    INITIATED_EXIT = 1
+    WITHDRAWABLE = 2
 
 
 class ValidatorRegistryDeltaFlag(IntEnum):

eth/beacon/exceptions.py

@@ -5,12 +5,12 @@
     TYPE_CHECKING,
 )
 
+import functools
+
 from eth_utils import (
-    denoms,
     to_tuple,
     ValidationError,
 )
-
 from eth_typing import (
     Hash32,
 )
@@ -23,26 +23,23 @@
 from eth._utils.numeric import (
     clamp,
 )
-
-from eth.beacon.types.validator_registry_delta_block import (
-    ValidatorRegistryDeltaBlock,
+from eth.beacon._utils.random import (
+    shuffle,
+    split,
 )
+
 from eth.beacon.block_committees_info import (
     BlockCommitteesInfo,
 )
+from eth.beacon.constants import (
+    GWEI_PER_ETH,
+)
 from eth.beacon.enums import (
     SignatureDomain,
-    ValidatorRegistryDeltaFlag,
 )
 from eth.beacon.types.shard_committees import (
     ShardCommittee,
 )
-from eth.beacon._utils.random import (
-    shuffle,
-    split,
-)
-import functools
-
 from eth.beacon.typing import (
     Bitfield,
     BLSPubkey,
@@ -157,14 +154,14 @@ def get_shard_committees_at_slot(state: 'BeaconState',
     )
 
 
-def get_active_validator_indices(
-        validators: Sequence['ValidatorRecord']) -> Tuple[ValidatorIndex, ...]:
+def get_active_validator_indices(validators: Sequence['ValidatorRecord'],
+                                 slot: SlotNumber) -> Tuple[ValidatorIndex, ...]:
     """
     Get indices of active validators from ``validators``.
     """
     return tuple(
-        ValidatorIndex(i) for i, v in enumerate(validators)
-        if v.is_active
+        ValidatorIndex(index) for index, validator in enumerate(validators)
+        if validator.is_active(slot)
     )
 
 
@@ -189,13 +186,14 @@ def _get_shards_committees_for_shard_indices(
 
 
 @to_tuple
-def get_new_shuffling(*,
-                      seed: Hash32,
-                      validators: Sequence['ValidatorRecord'],
-                      crosslinking_start_shard: ShardNumber,
-                      epoch_length: int,
-                      target_committee_size: int,
-                      shard_count: int) -> Iterable[Iterable[ShardCommittee]]:
+def get_shuffling(*,
+                  seed: Hash32,
+                  validators: Sequence['ValidatorRecord'],
+                  crosslinking_start_shard: ShardNumber,
+                  slot: SlotNumber,
+                  epoch_length: int,
+                  target_committee_size: int,
+                  shard_count: int) -> Iterable[Tuple[ShardCommittee]]:
     """
     Return shuffled ``shard_committee_for_slots`` (``[[ShardCommittee]]``) of
     the given active ``validators`` using ``seed`` as entropy.
@@ -238,7 +236,7 @@ def get_new_shuffling(*,
                 ],
             ]
     """
-    active_validators = get_active_validator_indices(validators)
+    active_validators = get_active_validator_indices(validators, slot)
     active_validators_size = len(active_validators)
     committees_per_slot = clamp(
         1,
@@ -390,23 +388,7 @@ def get_effective_balance(
     Return the effective balance (also known as "balance at stake") for a
     ``validator`` with the given ``index``.
     """
-    return min(validator_balances[index], max_deposit * denoms.gwei)
-
-
-def get_new_validator_registry_delta_chain_tip(current_validator_registry_delta_chain_tip: Hash32,
-                                               validator_index: ValidatorIndex,
-                                               pubkey: BLSPubkey,
-                                               flag: ValidatorRegistryDeltaFlag) -> Hash32:
-    """
-    Compute the next hash in the validator registry delta hash chain.
-    """
-    # TODO: switch to SSZ tree hashing
-    return ValidatorRegistryDeltaBlock(
-        latest_registry_delta_root=current_validator_registry_delta_chain_tip,
-        validator_index=validator_index,
-        pubkey=pubkey,
-        flag=flag,
-    ).root
+    return min(validator_balances[index], Gwei(max_deposit * GWEI_PER_ETH))
 
 
 def get_fork_version(fork_data: 'ForkData',

eth/beacon/helpers.py

@@ -22,10 +22,10 @@
         ('EJECTION_BALANCE', Ether),
         ('MAX_BALANCE_CHURN_QUOTIENT', int),
         ('BEACON_CHAIN_SHARD_NUMBER', ShardNumber),
-        ('BLS_WITHDRAWAL_PREFIX_BYTE', bytes),
         ('MAX_CASPER_VOTES', int),
         ('LATEST_BLOCK_ROOTS_LENGTH', int),
         ('LATEST_RANDAO_MIXES_LENGTH', int),
+        ('LATEST_PENALIZED_EXIT_LENGTH', int),
         # EMPTY_SIGNATURE is defined in constants.py
         # Deposit contract
         ('DEPOSIT_CONTRACT_ADDRESS', Address),
@@ -34,16 +34,17 @@
         ('MAX_DEPOSIT', Ether),
         # ZERO_HASH (ZERO_HASH32) is defined in constants.py
         # Initial values
-        ('INITIAL_FORK_VERSION', int),
-        ('INITIAL_SLOT_NUMBER', SlotNumber),
+        ('GENESIS_FORK_VERSION', int),
+        ('GENESIS_SLOT', SlotNumber),
+        ('BLS_WITHDRAWAL_PREFIX_BYTE', bytes),
         # Time parameters
         ('SLOT_DURATION', Second),
         ('MIN_ATTESTATION_INCLUSION_DELAY', int),
         ('EPOCH_LENGTH', int),
+        ('SEED_LOOKAHEAD', int),
+        ('ENTRY_EXIT_DELAY', int),
         ('POW_RECEIPT_ROOT_VOTING_PERIOD', int),
-        ('SHARD_PERSISTENT_COMMITTEE_CHANGE_PERIOD', int),
-        ('COLLECTIVE_PENALTY_CALCULATION_PERIOD', int),
-        ('ZERO_BALANCE_VALIDATOR_TTL', int),
+        ('MIN_VALIDATOR_WITHDRAWAL_TIME', int),
         # Reward and penalty quotients
         ('BASE_REWARD_QUOTIENT', int),
         ('WHISTLEBLOWER_REWARD_QUOTIENT', int),

eth/beacon/state_machines/configs.py

@@ -17,26 +17,27 @@
     EJECTION_BALANCE=Ether(2**4),  # (= 16) ETH
     MAX_BALANCE_CHURN_QUOTIENT=2**5,  # (= 32)
     BEACON_CHAIN_SHARD_NUMBER=ShardNumber(2**64 - 1),
-    BLS_WITHDRAWAL_PREFIX_BYTE=b'\x00',
     MAX_CASPER_VOTES=2**10,  # (= 1,024) votes
     LATEST_BLOCK_ROOTS_LENGTH=2**13,  # (= 8,192) block roots
     LATEST_RANDAO_MIXES_LENGTH=2**13,  # (= 8,192) randao mixes
+    LATEST_PENALIZED_EXIT_LENGTH=2**13,  # (= 8,192) randao mixes
     # Deposit contract
     DEPOSIT_CONTRACT_ADDRESS=ZERO_ADDRESS,  # TBD
     DEPOSIT_CONTRACT_TREE_DEPTH=2**5,  # (= 32)
     MIN_DEPOSIT=Ether(2**0),  # (= 1) ETH
     MAX_DEPOSIT=Ether(2**5),  # (= 32) ETH
     # Initial values
-    INITIAL_FORK_VERSION=0,
-    INITIAL_SLOT_NUMBER=SlotNumber(0),
+    GENESIS_FORK_VERSION=0,
+    GENESIS_SLOT=SlotNumber(0),
+    BLS_WITHDRAWAL_PREFIX_BYTE=b'\x00',
     # Time parameters
     SLOT_DURATION=Second(6),  # seconds
     MIN_ATTESTATION_INCLUSION_DELAY=2**2,  # (= 4) slots
     EPOCH_LENGTH=2**6,  # (= 64) slots
+    SEED_LOOKAHEAD=2**6,  # (= 64) slots
+    ENTRY_EXIT_DELAY=2**8,  # (= 256) slots
     POW_RECEIPT_ROOT_VOTING_PERIOD=2**10,  # (= 1,024) slots
-    SHARD_PERSISTENT_COMMITTEE_CHANGE_PERIOD=2**17,  # (= 131,072) slots
-    COLLECTIVE_PENALTY_CALCULATION_PERIOD=2**20,  # (= 1,048,576) slots
-    ZERO_BALANCE_VALIDATOR_TTL=2**22,  # (= 4,194,304) slots
+    MIN_VALIDATOR_WITHDRAWAL_TIME=2**14,  # (= 16,384) slots
     # Reward and penalty quotients
     BASE_REWARD_QUOTIENT=2**10,  # (= 1,024)
     WHISTLEBLOWER_REWARD_QUOTIENT=2**9,  # (= 512)