Sync data structure

Author: hwwhww

eth/beacon/block_committees_info.py

@@ -5,7 +5,7 @@
 )
 
 if TYPE_CHECKING:
-    from eth.beacon.types.shard_and_committees import ShardAndCommittee  # noqa: F401
+    from eth.beacon.types.shard_committees import ShardCommittee  # noqa: F401
 
 
 BlockCommitteesInfo = NamedTuple(
@@ -15,6 +15,6 @@
         ('proposer_index_in_committee', int),
         ('proposer_shard_id', int),
         ('proposer_committee_size', int),
-        ('shards_and_committees', Tuple['ShardAndCommittee'])
+        ('shards_and_committees', Tuple['ShardCommittee'])
     )
 )

eth/beacon/helpers.py

@@ -26,8 +26,8 @@
 from eth.beacon.enums.validator_status_codes import (
     ValidatorStatusCode,
 )
-from eth.beacon.types.shard_and_committees import (
-    ShardAndCommittee,
+from eth.beacon.types.shard_committees import (
+    ShardCommittee,
 )
 from eth.beacon.utils.random import (
     shuffle,
@@ -173,22 +173,22 @@ def get_new_recent_block_hashes(old_block_hashes: Sequence[Hash32],
 def get_shards_and_committees_for_slot(
         crystallized_state: 'CrystallizedState',
         slot: int,
-        cycle_length: int) -> Iterable[ShardAndCommittee]:
+        cycle_length: int) -> Iterable[ShardCommittee]:
     """
     FIXME
     """
-    if len(crystallized_state.shard_and_committee_for_slots) != cycle_length * 2:
+    if len(crystallized_state.shard_committee_for_slots) != cycle_length * 2:
         raise ValueError(
-            "Length of shard_and_committee_for_slots != cycle_length * 2"
+            "Length of shard_committee_for_slots != cycle_length * 2"
             "\texpected: %s, found: %s" % (
-                cycle_length * 2, len(crystallized_state.shard_and_committee_for_slots)
+                cycle_length * 2, len(crystallized_state.shard_committee_for_slots)
             )
         )
 
     slot_relative_position = crystallized_state.last_state_recalc - cycle_length
 
     yield from _get_element_from_recent_list(
-        crystallized_state.shard_and_committee_for_slots,
+        crystallized_state.shard_committee_for_slots,
         slot,
         slot_relative_position,
     )
@@ -210,9 +210,9 @@ def get_attestation_indices(crystallized_state: 'CrystallizedState',
         cycle_length,
     )
 
-    for shard_and_committee in shards_and_committees_for_slot:
-        if shard_and_committee.shard_id == shard_id:
-            yield from shard_and_committee.committee
+    for shard_committee in shards_and_committees_for_slot:
+        if shard_committee.shard_id == shard_id:
+            yield from shard_committee.committee
 
 
 def get_active_validator_indices(validators: Sequence['ValidatorRecord']) -> Tuple[int, ...]:
@@ -232,12 +232,12 @@ def get_active_validator_indices(validators: Sequence['ValidatorRecord']) -> Tup
 def _get_shards_and_committees_for_shard_indices(
         shard_indices: Sequence[Sequence[int]],
         start_shard: int,
-        shard_count: int) -> Iterable[ShardAndCommittee]:
+        shard_count: int) -> Iterable[ShardCommittee]:
     """
-    Returns filled [ShardAndCommittee] tuple.
+    Returns filled [ShardCommittee] tuple.
     """
     for index, indices in enumerate(shard_indices):
-        yield ShardAndCommittee(
+        yield ShardCommittee(
             shard=(start_shard + index) % shard_count,
             committee=indices
         )
@@ -250,16 +250,16 @@ def get_new_shuffling(*,
                       crosslinking_start_shard: int,
                       cycle_length: int,
                       target_committee_size: int,
-                      shard_count: int) -> Iterable[Iterable[ShardAndCommittee]]:
+                      shard_count: int) -> Iterable[Iterable[ShardCommittee]]:
     """
-    Return shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
+    Return shuffled ``shard_committee_for_slots`` (``[[ShardCommittee]]``) of
     the given active ``validators`` using ``seed`` as entropy.
 
     Two-dimensional:
     The first layer is ``slot`` number
-        ``shard_and_committee_for_slots[slot] -> [ShardAndCommittee]``
+        ``shard_committee_for_slots[slot] -> [ShardCommittee]``
     The second layer is ``shard_indices`` number
-        ``shard_and_committee_for_slots[slot][shard_indices] -> ShardAndCommittee``
+        ``shard_committee_for_slots[slot][shard_indices] -> ShardCommittee``
 
     Example:
         validators:
@@ -278,18 +278,18 @@ def get_new_shuffling(*,
             [
                 # slot 0
                 [
-                    ShardAndCommittee(shard_id=0, committee=[6, 0]),
-                    ShardAndCommittee(shard_id=1, committee=[2, 12, 14]),
+                    ShardCommittee(shard_id=0, committee=[6, 0]),
+                    ShardCommittee(shard_id=1, committee=[2, 12, 14]),
                 ],
                 # slot 1
                 [
-                    ShardAndCommittee(shard_id=2, committee=[8, 10]),
-                    ShardAndCommittee(shard_id=3, committee=[4, 9, 1]),
+                    ShardCommittee(shard_id=2, committee=[8, 10]),
+                    ShardCommittee(shard_id=3, committee=[4, 9, 1]),
                 ],
                 # slot 2
                 [
-                    ShardAndCommittee(shard_id=4, committee=[5, 13, 15]),
-                    ShardAndCommittee(shard_id=5, committee=[7, 3, 11]),
+                    ShardCommittee(shard_id=4, committee=[5, 13, 15]),
+                    ShardCommittee(shard_id=5, committee=[7, 3, 11]),
                 ],
             ]
     """
@@ -331,14 +331,14 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
     FIXME
     Return the block committees and proposer info with BlockCommitteesInfo pack.
     """
-    # `proposer_index_in_committee` th attester in `shard_and_committee`
+    # `proposer_index_in_committee` th attester in `shard_committee`
     # is the proposer of the parent block.
     try:
-        shard_and_committee = shards_and_committees[0]
+        shard_committee = shards_and_committees[0]
     except IndexError:
         raise ValueError("shards_and_committees should not be empty.")
 
-    proposer_committee_size = len(shard_and_committee.committee)
+    proposer_committee_size = len(shard_committee.committee)
     if proposer_committee_size <= 0:
         raise ValueError(
             "The first committee should not be empty"
@@ -350,12 +350,12 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
     )
 
     # The index in CrystallizedState.validators
-    proposer_index = shard_and_committee.committee[proposer_index_in_committee]
+    proposer_index = shard_committee.committee[proposer_index_in_committee]
 
     return BlockCommitteesInfo(
         proposer_index=proposer_index,
         proposer_index_in_committee=proposer_index_in_committee,
-        proposer_shard_id=shard_and_committee.shard_id,
+        proposer_shard_id=shard_committee.shard_id,
         proposer_committee_size=proposer_committee_size,
         shards_and_committees=shards_and_committees,
     )

eth/beacon/types/attestation_signed_data.py renamed to eth/beacon/types/attestation_data.py

@@ -9,7 +9,7 @@
 )
 
 
-class AttestationSignedData(rlp.Serializable):
+class AttestationData(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """
@@ -18,36 +18,36 @@ class AttestationSignedData(rlp.Serializable):
         ('slot', uint64),
         # Shard number
         ('shard', uint64),
-        # Hash of the block we're signing
-        ('block_hash', hash32),
-        # Hash of the ancestor at the cycle boundary
-        ('cycle_boundary_hash', hash32),
+        # Hash of the signed beacon block
+        ('beacon_block_hash', hash32),
+        # Hash of the ancestor at the epoch boundary
+        ('epoch_boundary_hash', hash32),
         # Shard block hash being attested to
         ('shard_block_hash', hash32),
         # Last crosslink hash
-        ('last_crosslink_hash', hash32),
-        # Slot of last justified beacon block
+        ('latest_crosslink_hash', hash32),
+        # Slot of the last justified beacon block
         ('justified_slot', uint64),
-        # Hash of last justified beacon block
+        # Hash of the last justified beacon block
         ('justified_block_hash', hash32),
     ]
 
     def __init__(self,
                  slot: int,
                  shard: int,
-                 block_hash: Hash32,
-                 cycle_boundary_hash: Hash32,
+                 beacon_block_hash: Hash32,
+                 epoch_boundary_hash: Hash32,
                  shard_block_hash: Hash32,
-                 last_crosslink_hash: Hash32,
+                 latest_crosslink_hash: Hash32,
                  justified_slot: int,
                  justified_block_hash: Hash32) -> None:
         super().__init__(
             slot=slot,
             shard=shard,
-            block_hash=block_hash,
-            cycle_boundary_hash=cycle_boundary_hash,
+            beacon_block_hash=beacon_block_hash,
+            epoch_boundary_hash=epoch_boundary_hash,
             shard_block_hash=shard_block_hash,
-            last_crosslink_hash=last_crosslink_hash,
+            latest_crosslink_hash=latest_crosslink_hash,
             justified_slot=justified_slot,
             justified_block_hash=justified_block_hash,
         )

eth/beacon/types/attestation_records.py

@@ -13,8 +13,8 @@
 )
 
 
-from .attestation_signed_data import (
-    AttestationSignedData,
+from .attestation_data import (
+    AttestationData,
 )
 
 
@@ -23,7 +23,7 @@ class AttestationRecord(rlp.Serializable):
     Note: using RLP until we have standardized serialization format.
     """
     fields = [
-        ('data', AttestationSignedData),
+        ('data', AttestationData),
         # Attester participation bitfield
         ('attester_bitfield', binary),
         # Proof of custody bitfield
@@ -33,7 +33,7 @@ class AttestationRecord(rlp.Serializable):
     ]
 
     def __init__(self,
-                 data: AttestationSignedData,
+                 data: AttestationData,
                  attester_bitfield: bytes,
                  poc_bitfield: bytes,
                  aggregate_sig: Sequence[int]=None) -> None:

eth/beacon/types/deposit_parameters_records.py

@@ -0,0 +1,48 @@
+from typing import (
+    Sequence,
+)
+
+from eth_typing import (
+    Hash32,
+)
+import rlp
+from rlp.sedes import (
+    binary,
+    CountableList,
+)
+
+from eth.rlp.sedes import (
+    hash32,
+    uint256,
+)
+
+
+class DepositParametersRecord(rlp.Serializable):
+    """
+    Note: using RLP until we have standardized serialization format.
+    """
+    fields = [
+        # BLS pubkey
+        ('pubkey', uint256),
+        # BLS proof of possession (a BLS signature)
+        ('proof_of_possession', CountableList(uint256)),
+        # Withdrawal credentials
+        ('withdrawal_credentials', hash32),
+        # Initial RANDAO commitment
+        ('randao_commitment', hash32),
+    ]
+
+    def __init__(self,
+                 pubkey: int,
+                 withdrawal_credentials: Hash32,
+                 randao_commitment: Hash32,
+                 proof_of_possession: Sequence[int]=None) -> None:
+        if proof_of_possession is None:
+            proof_of_possession = (0, 0)
+
+        super().__init__(
+            pubkey=pubkey,
+            proof_of_possession=proof_of_possession,
+            withdrawal_credentials=withdrawal_credentials,
+            randao_commitment=randao_commitment,
+        )

eth/beacon/types/fork_data.py

@@ -15,15 +15,15 @@ class ForkData(rlp.Serializable):
         # Post fork version
         ('post_fork_version', uint64),
         # Fork slot number
-        ('fork_slot_number', uint64)
+        ('fork_slot', uint64)
     ]
 
     def __init__(self,
                  pre_fork_version: int,
                  post_fork_version: int,
-                 fork_slot_number: int) -> None:
+                 fork_slot: int) -> None:
         super().__init__(
             pre_fork_version=pre_fork_version,
             post_fork_version=post_fork_version,
-            fork_slot_number=fork_slot_number,
+            fork_slot=fork_slot,
         )

eth/beacon/types/processed_attestation.py renamed to eth/beacon/types/pending_attestation_records.py

@@ -8,34 +8,34 @@
 )
 
 
-from .attestation_signed_data import (
-    AttestationSignedData,
+from .attestation_data import (
+    AttestationData,
 )
 
 
-class ProcessedAttestation(rlp.Serializable):
+class PendingAttestationRecord(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """
     fields = [
         # Signed data
-        ('data', AttestationSignedData),
+        ('data', AttestationData),
         # Attester participation bitfield
-        ('attester_bitfield', binary),
+        ('participation_bitfield', binary),
         # Proof of custody bitfield
-        ('poc_bitfield', binary),
+        ('custody_bitfield', binary),
         # Slot in which it was included
         ('slot_included', uint64),
     ]
 
     def __init__(self,
-                 data: AttestationSignedData,
-                 attester_bitfield: bytes,
-                 poc_bitfield: bytes,
+                 data: AttestationData,
+                 participation_bitfield: bytes,
+                 custody_bitfield: bytes,
                  slot_included: int) -> None:
         super().__init__(
             data=data,
-            attester_bitfield=attester_bitfield,
-            poc_bitfield=poc_bitfield,
+            participation_bitfield=participation_bitfield,
+            custody_bitfield=custody_bitfield,
             slot_included=slot_included,
         )

eth/beacon/types/shard_and_committees.py renamed to eth/beacon/types/shard_committees.py

@@ -13,7 +13,7 @@
 )
 
 
-class ShardAndCommittee(rlp.Serializable):
+class ShardCommittee(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """