Merge pull request #1681 from ChihChengLiang/add-beacon-chain-related-NewType

Add beacon chain related new type

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,10 @@
 )
 from eth.beacon._utils.hash import hash_eth2
 
+from eth.beacon.typing import (
+    BLSPubkey,
+    BLSSignature,
+)
 
 G2_cofactor = 305502333931268344200999753193121504214466019254188142667664032982267604182971884026507427359259977847832272839041616661285803823378372096355777062779109  # noqa: E501
 FQ2_order = q ** 2 - 1
@@ -134,7 +138,7 @@ def compress_G2(pt: Tuple[FQP, FQP, FQP]) -> Tuple[int, int]:
     )
 
 
-def decompress_G2(p: bytes) -> Tuple[FQP, FQP, FQP]:
+def decompress_G2(p: Tuple[int, int]) -> Tuple[FQP, FQP, FQP]:
     x1 = p[0] % 2**383
     y1_mod_2 = p[0] // 2**383
     x2 = p[1]
@@ -156,20 +160,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) -> BLSSignature:
+    return BLSSignature(
+        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 +193,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]) -> BLSSignature:
     o = Z2
     for s in signatures:
         o = FQP_point_to_FQ2_point(add(o, decompress_G2(s)))
-    return compress_G2(o)
+    return BLSSignature(compress_G2(o))
 
 
-def aggregate_pubkeys(pubkeys: Sequence[int]) -> int:
+def aggregate_pubkeys(pubkeys: Sequence[BLSPubkey]) -> BLSPubkey:
     o = Z1
     for p in pubkeys:
         o = add(o, decompress_G1(p))
-    return compress_G1(o)
+    return BLSPubkey(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,12 +11,19 @@
     set_voted,
 )
 from eth.beacon.enums import SignatureDomain
+from eth.beacon.typing import (
+    BLSPubkey,
+    BLSSignature,
+    Bitfield,
+    CommitteeIndex,
+)
 
 
 def verify_votes(
-        message: bytes,
-        votes: Iterable[Tuple[int, bytes, int]],
-        domain: SignatureDomain) -> Tuple[Tuple[bytes, ...], Tuple[int, ...]]:
+    message: bytes,
+    votes: Iterable[Tuple[CommitteeIndex, BLSSignature, BLSPubkey]],
+    domain: SignatureDomain
+) -> Tuple[Tuple[BLSSignature, ...], Tuple[CommitteeIndex, ...]]:
     """
     Verify the given votes.
 
@@ -37,10 +44,12 @@ 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[CommitteeIndex]
+) -> Tuple[Bitfield, BLSSignature]:
     """
     Aggregate the votes.
     """

eth/beacon/constants.py

@@ -1,3 +1,5 @@
+from eth.beacon.typing import BLSSignature
+
 #
 # 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 = BLSSignature((0, 0))

eth/beacon/deposit_helpers.py

@@ -27,25 +27,32 @@
 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[int],
-                                  current_slot: int,
-                                  zero_balance_validator_ttl: int) -> int:
+                                  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 index
+            return ValidatorIndex(index)
     raise MinEmptyValidatorIndexNotFound()
 
 
 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,8 +82,8 @@ def validate_proof_of_possession(state: BeaconState,
 
 def add_pending_validator(state: BeaconState,
                           validator: ValidatorRecord,
-                          deposit: int,
-                          zero_balance_validator_ttl: int) -> Tuple[BeaconState, int]:
+                          deposit: Gwei,
+                          zero_balance_validator_ttl: int) -> Tuple[BeaconState, ValidatorIndex]:
     """
     Add a validator to the existing minimum empty validator index or
     append to ``validator_registry``.
@@ -91,14 +98,13 @@ def add_pending_validator(state: BeaconState,
         )
     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 = len(state.validator_registry) - 1
+        index = ValidatorIndex(len(state.validator_registry) - 1)
     else:
         # Use the empty validator index
         state = state.update_validator(index, validator, deposit)
@@ -108,12 +114,12 @@ 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]:
+                    zero_balance_validator_ttl: int) -> Tuple[BeaconState, ValidatorIndex]:
     """
     Process a deposit from Ethereum 1.0.
     """
@@ -142,7 +148,7 @@ def process_deposit(*,
         )
     else:
         # Top-up - increase balance by deposit
-        index = validator_pubkeys.index(pubkey)
+        index = ValidatorIndex(validator_pubkeys.index(pubkey))
         validator = state.validator_registry[index]
 
         if validator.withdrawal_credentials != withdrawal_credentials: