add beacon chain related NewTypes

Author: ChihChengLiang

eth/_utils/bitfield.py

@@ -10,31 +10,33 @@
 from itertools import (
     zip_longest,
 )
+from eth.beacon.typing import Bitfield
 
 
 @curry
-def has_voted(bitfield: bytes, index: int) -> bool:
+def has_voted(bitfield: Bitfield, index: int) -> bool:
     return bool(bitfield[index // 8] & (128 >> (index % 8)))
 
 
 @curry
-def set_voted(bitfield: bytes, index: int) -> bytes:
+def set_voted(bitfield: Bitfield, index: int) -> Bitfield:
     byte_index = index // 8
     bit_index = index % 8
     new_byte_value = bitfield[byte_index] | (128 >> bit_index)
-    return bitfield[:byte_index] + bytes([new_byte_value]) + bitfield[byte_index + 1:]
+    new_bitfield = bitfield[:byte_index] + bytes([new_byte_value]) + bitfield[byte_index + 1:]
+    return Bitfield(new_bitfield)
 
 
 def get_bitfield_length(bit_count: int) -> int:
     """Return the length of the bitfield for a given number of attesters in bytes."""
     return (bit_count + 7) // 8
 
 
-def get_empty_bitfield(bit_count: int) -> bytes:
-    return b"\x00" * get_bitfield_length(bit_count)
+def get_empty_bitfield(bit_count: int) -> Bitfield:
+    return Bitfield(b"\x00" * get_bitfield_length(bit_count))
 
 
-def get_vote_count(bitfield: bytes) -> int:
+def get_vote_count(bitfield: Bitfield) -> int:
     return len(
         tuple(
             index
@@ -44,10 +46,10 @@ def get_vote_count(bitfield: bytes) -> int:
     )
 
 
-def or_bitfields(bitfields: List[bytes]) -> bytes:
+def or_bitfields(bitfields: List[Bitfield]) -> Bitfield:
     byte_slices = zip_longest(*bitfields)
 
     if len(set((len(b) for b in bitfields))) != 1:
         raise ValueError("The bitfield sizes are different")
 
-    return bytes(map(reduce(operator.or_), byte_slices))
+    return Bitfield(bytes(map(reduce(operator.or_), byte_slices)))

eth/_utils/bls.py

@@ -33,6 +33,12 @@
 )
 from eth.beacon._utils.hash import hash_eth2
 
+from eth.beacon.typing import (
+    BLSPubkey,
+    BLSPubkeyAggregated,
+    BLSSignature,
+    BLSSignatureAggregated,
+)
 
 G2_cofactor = 305502333931268344200999753193121504214466019254188142667664032982267604182971884026507427359259977847832272839041616661285803823378372096355777062779109  # noqa: E501
 FQ2_order = q ** 2 - 1
@@ -156,20 +162,21 @@ def decompress_G2(p: bytes) -> Tuple[FQP, FQP, FQP]:
 #
 def sign(message: bytes,
          privkey: int,
-         domain: int) -> Tuple[int, int]:
-    return compress_G2(
-        multiply(
-            hash_to_G2(message, domain),
-            privkey
-        )
-    )
+         domain: int) -> BLSSignatureAggregated:
+    return BLSSignatureAggregated(
+        compress_G2(
+            multiply(
+                hash_to_G2(message, domain),
+                privkey
+            )
+        ))
 
 
-def privtopub(k: int) -> int:
-    return compress_G1(multiply(G1, k))
+def privtopub(k: int) -> BLSPubkey:
+    return BLSPubkey(compress_G1(multiply(G1, k)))
 
 
-def verify(message: bytes, pubkey: int, signature: bytes, domain: int) -> bool:
+def verify(message: bytes, pubkey: BLSPubkey, signature: BLSSignature, domain: int) -> bool:
     try:
         final_exponentiation = final_exponentiate(
             pairing(
@@ -188,23 +195,23 @@ def verify(message: bytes, pubkey: int, signature: bytes, domain: int) -> bool:
         return False
 
 
-def aggregate_signatures(signatures: Sequence[bytes]) -> Tuple[int, int]:
+def aggregate_signatures(signatures: Sequence[BLSSignature]) -> BLSSignatureAggregated:
     o = Z2
     for s in signatures:
         o = FQP_point_to_FQ2_point(add(o, decompress_G2(s)))
-    return compress_G2(o)
+    return BLSSignatureAggregated(compress_G2(o))
 
 
-def aggregate_pubkeys(pubkeys: Sequence[int]) -> int:
+def aggregate_pubkeys(pubkeys: Sequence[BLSPubkey]) -> BLSPubkeyAggregated:
     o = Z1
     for p in pubkeys:
         o = add(o, decompress_G1(p))
-    return compress_G1(o)
+    return BLSPubkeyAggregated(compress_G1(o))
 
 
-def verify_multiple(pubkeys: Sequence[int],
+def verify_multiple(pubkeys: Sequence[BLSPubkey],
                     messages: Sequence[bytes],
-                    signature: bytes,
+                    signature: BLSSignature,
                     domain: int) -> bool:
     len_msgs = len(messages)
 

eth/beacon/aggregation.py

@@ -11,11 +11,17 @@
     set_voted,
 )
 from eth.beacon.enums import SignatureDomain
+from eth.beacon.typing import (
+    BLSPubkey,
+    BLSSignature,
+    BLSSignatureAggregated,
+    Bitfield,
+)
 
 
 def verify_votes(
         message: bytes,
-        votes: Iterable[Tuple[int, bytes, int]],
+        votes: Iterable[Tuple[int, BLSSignature, BLSPubkey]],
         domain: SignatureDomain) -> Tuple[Tuple[bytes, ...], Tuple[int, ...]]:
     """
     Verify the given votes.
@@ -37,10 +43,10 @@ def verify_votes(
     return sigs, committee_indices
 
 
-def aggregate_votes(bitfield: bytes,
-                    sigs: Iterable[bytes],
-                    voting_sigs: Iterable[bytes],
-                    voting_committee_indices: Iterable[int]) -> Tuple[bytes, Tuple[int, int]]:
+def aggregate_votes(bitfield: Bitfield,
+                    sigs: Iterable[BLSSignature],
+                    voting_sigs: Iterable[BLSSignature],
+                    voting_committee_indices: Iterable[int]) -> Tuple[Bitfield, BLSSignatureAggregated]:
     """
     Aggregate the votes.
     """

eth/beacon/constants.py

@@ -1,3 +1,5 @@
+from eth.beacon.typing import BLSSignatureAggregated
+
 #
 # shuffle function
 #
@@ -11,4 +13,4 @@
 # The highest possible result of the RNG.
 RAND_MAX = 2 ** (RAND_BYTES * 8) - 1
 
-EMPTY_SIGNATURE = (0, 0)
+EMPTY_SIGNATURE = BLSSignatureAggregated((0, 0))

eth/beacon/deposit_helpers.py

@@ -27,6 +27,11 @@
 from eth.beacon.helpers import (
     get_domain,
 )
+from eth.beacon.typing import (
+    BLSPubkey,
+    BLSSignature,
+    Gwei,
+)
 
 
 def get_min_empty_validator_index(validators: Sequence[ValidatorRecord],
@@ -44,8 +49,8 @@ def get_min_empty_validator_index(validators: Sequence[ValidatorRecord],
 
 
 def validate_proof_of_possession(state: BeaconState,
-                                 pubkey: int,
-                                 proof_of_possession: bytes,
+                                 pubkey: BLSPubkey,
+                                 proof_of_possession: BLSSignature,
                                  withdrawal_credentials: Hash32,
                                  randao_commitment: Hash32) -> None:
     deposit_input = DepositInput(
@@ -75,7 +80,7 @@ def validate_proof_of_possession(state: BeaconState,
 
 def add_pending_validator(state: BeaconState,
                           validator: ValidatorRecord,
-                          deposit: int,
+                          deposit: Gwei,
                           zero_balance_validator_ttl: int) -> Tuple[BeaconState, int]:
     """
     Add a validator to the existing minimum empty validator index or
@@ -108,9 +113,9 @@ def add_pending_validator(state: BeaconState,
 
 def process_deposit(*,
                     state: BeaconState,
-                    pubkey: int,
-                    deposit: int,
-                    proof_of_possession: bytes,
+                    pubkey: BLSPubkey,
+                    deposit: Gwei,
+                    proof_of_possession: BLSSignature,
                     withdrawal_credentials: Hash32,
                     randao_commitment: Hash32,
                     zero_balance_validator_ttl: int) -> Tuple[BeaconState, int]:

eth/beacon/helpers.py

@@ -51,7 +51,10 @@
     from eth.beacon.types.fork_data import ForkData  # noqa: F401
     from eth.beacon.types.slashable_vote_data import SlashableVoteData  # noqa: F401
     from eth.beacon.types.validator_records import ValidatorRecord  # noqa: F401
-
+    from eth.beacon.typing import (
+        ShardNumber,
+        BLSPubkey,
+    )
 
 def _get_element_from_recent_list(
         target_list: Sequence[Any],
@@ -161,7 +164,7 @@ def _get_shards_committees_for_shard_indices(
     """
     for index, indices in enumerate(shard_indices):
         yield ShardCommittee(
-            shard=(start_shard + index) % shard_count,
+            shard=ShardNumber((start_shard + index) % shard_count),
             committee=indices,
             total_validator_count=total_validator_count,
         )
@@ -371,7 +374,7 @@ def get_effective_balance(validator_balances: Sequence[int], index: int, max_dep
 
 def get_new_validator_registry_delta_chain_tip(current_validator_registry_delta_chain_tip: Hash32,
                                                validator_index: int,
-                                               pubkey: int,
+                                               pubkey: BLSPubkey,
                                                flag: int) -> Hash32:
     """
     Compute the next hash in the validator registry delta hash chain.

eth/beacon/state_machines/configs.py

@@ -5,6 +5,12 @@
 from eth.typing import (
     Address,
 )
+from eth.beacon.typing import (
+    SlotNumber,
+    ShardNumber,
+    Ether,
+    Seconds,
+)
 
 
 BeaconConfig = NamedTuple(
@@ -13,9 +19,9 @@
         # Misc
         ('SHARD_COUNT', int),
         ('TARGET_COMMITTEE_SIZE', int),
-        ('EJECTION_BALANCE', int),
+        ('EJECTION_BALANCE', Ether),
         ('MAX_BALANCE_CHURN_QUOTIENT', int),
-        ('BEACON_CHAIN_SHARD_NUMBER', int),
+        ('BEACON_CHAIN_SHARD_NUMBER', ShardNumber),
         ('BLS_WITHDRAWAL_PREFIX_BYTE', bytes),
         ('MAX_CASPER_VOTES', int),
         ('LATEST_BLOCK_ROOTS_LENGTH', int),
@@ -24,14 +30,14 @@
         # Deposit contract
         ('DEPOSIT_CONTRACT_ADDRESS', Address),
         ('DEPOSIT_CONTRACT_TREE_DEPTH', int),
-        ('MIN_DEPOSIT', int),
-        ('MAX_DEPOSIT', int),
+        ('MIN_DEPOSIT', Ether),
+        ('MAX_DEPOSIT', Ether),
         # ZERO_HASH (ZERO_HASH32) is defined in constants.py
         # Initial values
         ('INITIAL_FORK_VERSION', int),
-        ('INITIAL_SLOT_NUMBER', int),
+        ('INITIAL_SLOT_NUMBER', SlotNumber),
         # Time parameters
-        ('SLOT_DURATION', int),
+        ('SLOT_DURATION', Seconds),
         ('MIN_ATTESTATION_INCLUSION_DELAY', int),
         ('EPOCH_LENGTH', int),
         ('POW_RECEIPT_ROOT_VOTING_PERIOD', int),

eth/beacon/state_machines/forks/serenity/configs.py

@@ -2,29 +2,35 @@
     ZERO_ADDRESS,
 )
 from eth.beacon.state_machines.configs import BeaconConfig
+from eth.beacon.typing import (
+    SlotNumber,
+    ShardNumber,
+    Ether,
+    Seconds,
+)
 
 
 SERENITY_CONFIG = BeaconConfig(
     # Misc
     SHARD_COUNT=2**10,  # (= 1,024) shards
     TARGET_COMMITTEE_SIZE=2**7,  # (= 128) validators
-    EJECTION_BALANCE=2**4,  # (= 16) ETH
+    EJECTION_BALANCE=Ether(2**4),  # (= 16) ETH
     MAX_BALANCE_CHURN_QUOTIENT=2**5,  # (= 32)
-    BEACON_CHAIN_SHARD_NUMBER=2**64 - 1,
+    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
     # Deposit contract
     DEPOSIT_CONTRACT_ADDRESS=ZERO_ADDRESS,  # TBD
     DEPOSIT_CONTRACT_TREE_DEPTH=2**5,  # (= 32)
-    MIN_DEPOSIT=2**0,  # (= 1) ETH
-    MAX_DEPOSIT=2**5,  # (= 32) ETH
+    MIN_DEPOSIT=Ether(2**0),  # (= 1) ETH
+    MAX_DEPOSIT=Ether(2**5),  # (= 32) ETH
     # Initial values
     INITIAL_FORK_VERSION=0,
-    INITIAL_SLOT_NUMBER=0,
+    INITIAL_SLOT_NUMBER=SlotNumber(0),
     # Time parameters
-    SLOT_DURATION=6,  # seconds
+    SLOT_DURATION=Seconds(6),  # seconds
     MIN_ATTESTATION_INCLUSION_DELAY=2**2,  # (= 4) slots
     EPOCH_LENGTH=2**6,  # (= 64) slots
     POW_RECEIPT_ROOT_VOTING_PERIOD=2**10,  # (= 1,024) slots

eth/beacon/state_machines/validation.py

@@ -23,10 +23,14 @@
     verify,
 )
 
+from eth.beacon.typing import (
+    ShardNumber,
+)
+
 
 def validate_proposer_signature(state: BeaconState,
                                 block: BaseBeaconBlock,
-                                beacon_chain_shard_number: int,
+                                beacon_chain_shard_number: ShardNumber,
                                 epoch_length: int) -> None:
     block_without_signature_root = block.block_without_signature_root
 

eth/beacon/types/attestation_data.py

@@ -8,6 +8,11 @@
     hash32,
 )
 
+from eth.beacon.typing import (
+    SlotNumber,
+    ShardNumber,
+)
+
 
 class AttestationData(rlp.Serializable):
     """
@@ -33,13 +38,13 @@ class AttestationData(rlp.Serializable):
     ]
 
     def __init__(self,
-                 slot: int,
-                 shard: int,
+                 slot: SlotNumber,
+                 shard: ShardNumber,
                  beacon_block_root: Hash32,
                  epoch_boundary_root: Hash32,
                  shard_block_root: Hash32,
                  latest_crosslink_root: Hash32,
-                 justified_slot: int,
+                 justified_slot: SlotNumber,
                  justified_block_root: Hash32) -> None:
         super().__init__(
             slot,