General refactoring

Author: adiasg

src/dvspec/consensus.py

@@ -1,64 +1,17 @@
-import eth2spec.phase0.mainnet as eth2spec
-
-from .eth_node_interface import (
+from eth2spec.phase0.mainnet import (
     AttestationData,
     BeaconBlock,
 )
+
 from .utils.types import (
     AttestationDuty,
-    BLSPubkey,
     ProposerDuty,
     SlashingDB,
 )
-
-"""
-Helper Functions
-"""
-
-
-def is_slashable_attestation_data(slashing_db: SlashingDB,
-                                  attestation_data: AttestationData, pubkey: BLSPubkey) -> bool:
-    matching_slashing_db_data = [data for data in slashing_db.data if data.pubkey == pubkey]
-    if matching_slashing_db_data == []:
-        return True
-    assert len(matching_slashing_db_data) == 1
-    slashing_db_data = matching_slashing_db_data[0]
-    # Check for EIP-3076 conditions:
-    # https://eips.ethereum.org/EIPS/eip-3076#conditions
-    if slashing_db_data.signed_attestations != []:
-        min_target = min(attn.target_epoch for attn in slashing_db_data.signed_attestations)
-        min_source = min(attn.source_epoch for attn in slashing_db_data.signed_attestations)
-        if attestation_data.target.epoch <= min_target:
-            return True
-        if attestation_data.source.epoch < min_source:
-            return True
-    for past_attn in slashing_db_data.signed_attestations:
-        past_attn_data = AttestationData(source=past_attn.source_epoch, target=past_attn.target_epoch)
-        if eth2spec.is_slashable_attestation_data(past_attn_data, attestation_data):
-            return True
-    return False
-
-
-def is_slashable_block(slashing_db: SlashingDB, block: BeaconBlock, pubkey: BLSPubkey) -> bool:
-    matching_slashing_db_data = [data for data in slashing_db.data if data.pubkey == pubkey]
-    if matching_slashing_db_data == []:
-        return False
-    assert len(matching_slashing_db_data) == 1
-    slashing_db_data = matching_slashing_db_data[0]
-    # Check for EIP-3076 conditions:
-    # https://eips.ethereum.org/EIPS/eip-3076#conditions
-    if slashing_db_data.signed_blocks != []:
-        min_block = slashing_db_data.signed_blocks[0]
-        for b in slashing_db_data.signed_blocks[1:]:
-            if b.slot < min_block.slot:
-                min_block = b
-        if block.slot < min_block.slot:
-            return True
-    for past_block in slashing_db_data.signed_blocks:
-        if past_block.slot == block.slot:
-            if past_block.signing_root != block.hash_tree_root():
-                return True
-    return False
+from .utils.helpers import (
+    is_slashable_attestation_data,
+    is_slashable_block,
+)
 
 
 """
@@ -76,7 +29,7 @@ def consensus_is_valid_attestation_data(slashing_db: SlashingDB,
     return True
 
 
-def consensus_on_attestation(attestation_duty: AttestationDuty) -> AttestationData:
+def consensus_on_attestation(slashing_db: SlashingDB, attestation_duty: AttestationDuty) -> AttestationData:
     """Consensus protocol between distributed validator nodes for attestation values.
     Returns the decided value.
     If this DV is the leader, it must use `bn_produce_attestation_data` for the proposed value.
@@ -95,7 +48,7 @@ def consensus_is_valid_block(slashing_db: SlashingDB, block: BeaconBlock, propos
     return True
 
 
-def consensus_on_block(proposer_duty: ProposerDuty) -> AttestationData:
+def consensus_on_block(slashing_db: SlashingDB, proposer_duty: ProposerDuty) -> AttestationData:
     """Consensus protocol between distributed validator nodes for block values.
     Returns the decided value.
     If this DV is the leader, it must use `bn_produce_block` for the proposed value.

src/dvspec/eth_node_interface.py

@@ -76,7 +76,7 @@ def bn_submit_block(block: SignedBeaconBlock) -> None:
 - VC asks for its attestation, block proposal, or sync  duties using the following methods:
     - https://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/getAttesterDuties
     - https://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/getProposerDuties
-    - mhttps://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/getSyncCommitteeDuties
+    - https://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/getSyncCommitteeDuties
 - VC asks for new attestation data, block, or sync duty using the following methods:
     - https://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/produceAttestationData
     - https://ethereum.github.io/beacon-APIs/#/ValidatorRequiredApi/produceBlockV2

src/dvspec/spec.py

@@ -2,7 +2,16 @@
 from typing import (
     List,
 )
+from eth2spec.phase0.mainnet import (
+    AttestationData,
+    BeaconBlock,
+)
 
+from .utils.helpers import (
+    get_slashing_db_data_for_pubkey,
+    is_slashable_attestation_data,
+    is_slashable_block,
+)
 from .eth_node_interface import (
     AttestationDuty,
     ProposerDuty,
@@ -24,7 +33,9 @@
 from .utils.types import (
     BLSPubkey,
     SlashingDB,
-    UInt64
+    SlashingDBAttestation,
+    SlashingDBBlock,
+    ValidatorIndex
 )
 
 
@@ -35,7 +46,7 @@ class ValidatorIdentity:
     # Ethereum public key
     pubkey: BLSPubkey
     # Index of Ethereum validator
-    index: UInt64
+    index: ValidatorIndex
 
 
 @dataclass
@@ -47,7 +58,7 @@ class CoValidator:
     # Secret-shared public key
     pubkey: BLSPubkey
     # Index of the co-validator in the distributed validator protocol
-    index: UInt64
+    index: ValidatorIndex
 
 
 @dataclass
@@ -64,27 +75,52 @@ class State:
     distributed_validators: List[DistributedValidator]
 
 
-def serve_attestation_duty(attestation_duty: AttestationDuty) -> None:
+def update_attestation_slashing_db(slashing_db: SlashingDB,
+                                   attestation_data: AttestationData, pubkey: BLSPubkey) -> None:
+    """Update slashing DB for the validator with pubkey with new attestation data.
+    """
+    assert not is_slashable_attestation_data(slashing_db, attestation_data, pubkey)
+    slashing_db_data = get_slashing_db_data_for_pubkey(slashing_db, pubkey)
+    slashing_db_attestation = SlashingDBAttestation(source_epoch=attestation_data.source.epoch,
+                                                    target_epoch=attestation_data.target.epoch,
+                                                    signing_root=attestation_data.hash_tree_root())
+    slashing_db_data.signed_attestations.append(slashing_db_attestation)
+
+
+def update_block_slashing_db(slashing_db: SlashingDB, block: BeaconBlock, pubkey: BLSPubkey) -> None:
+    """Update slashing DB for the validator with pubkey with new block.
+    """
+    assert not is_slashable_block(slashing_db, block, pubkey)
+    slashing_db_data = get_slashing_db_data_for_pubkey(slashing_db, pubkey)
+    slashing_db_block = SlashingDBBlock(slot=block.slot,
+                                        signing_root=block.hash_tree_root())
+    slashing_db_data.signed_blocks.append(slashing_db_block)
+
+
+def serve_attestation_duty(slashing_db: SlashingDB, attestation_duty: AttestationDuty) -> None:
     """
     Attestation Production Process:
     1. At the start of every epoch, get attestation duties for epoch+1 by running
         bn_get_attestation_duties_for_epoch(validator_indices, epoch+1)
     2. For each attestation_duty received in Step 1, schedule
-        serve_attestation_duty(attestation_duty) at 1/3rd way through the slot
+        serve_attestation_duty(slashing_db, attestation_duty) at 1/3rd way through the slot
         attestation_duty.slot
     See notes here:
     https://github.com/ethereum/beacon-APIs/blob/05c1bc142e1a3fb2a63c79098743776241341d08/validator-flow.md#attestation
     """
+    # TODO: Is lock on consensus the best way to do this? Does lock on slashing DB work?
     # Obtain lock on consensus_on_attestation here.
     # Only a single consensus_on_attestation instance should be
     # running at any given time
-    attestation_data = consensus_on_attestation(attestation_duty)
+    attestation_data = consensus_on_attestation(slashing_db, attestation_duty)
     # Release lock on consensus_on_attestation here.
+    # Add attestation to slashing DB
+    update_attestation_slashing_db(slashing_db, attestation_data, attestation_duty)
     # Cache decided attestation data value to provide to VC
     cache_attestation_data_for_vc(attestation_data, attestation_duty)
 
 
-def serve_proposer_duty(proposer_duty: ProposerDuty) -> None:
+def serve_proposer_duty(slashing_db: SlashingDB, proposer_duty: ProposerDuty) -> None:
     """"
     Block Production Process:
     1. At the start of every epoch, get proposer duties for epoch+1 by running
@@ -94,11 +130,14 @@ def serve_proposer_duty(proposer_duty: ProposerDuty) -> None:
     See notes here:
     https://github.com/ethereum/beacon-APIs/blob/05c1bc142e1a3fb2a63c79098743776241341d08/validator-flow.md#block-proposing
     """
+    # TODO: Is lock on consensus the best way to do this? Does lock on slashing DB work?
     # Obtain lock on consensus_on_block here.
     # Only a single consensus_on_block instance should be
     # running at any given time
-    block = consensus_on_block(proposer_duty)
+    block = consensus_on_block(slashing_db, proposer_duty)
     # Release lock on consensus_on_block here.
+    # Add block to slashing DB
+    update_block_slashing_db(slashing_db, block, proposer_duty)
     # Cache decided block value to provide to VC
     cache_block_for_vc(block, proposer_duty)
 

src/dvspec/utils/helpers.py

@@ -0,0 +1,70 @@
+import eth2spec.phase0.mainnet as eth2spec
+from eth2spec.phase0.mainnet import (
+    AttestationData,
+    BeaconBlock,
+)
+
+from .types import (
+    BLSPubkey,
+    SlashingDB,
+    SlashingDBData,
+)
+
+
+"""
+Helper Functions
+"""
+
+
+def get_slashing_db_data_for_pubkey(slashing_db: SlashingDB, pubkey: BLSPubkey) -> SlashingDBData:
+    """Get SlashingDBData for the pubkey in the slashing_db.
+    Returns empty SlashingDBData for the pubkey if matching entry is not found in slashing_db.
+    """
+    matching_slashing_db_data = [data for data in slashing_db.data if data.pubkey == pubkey]
+    if matching_slashing_db_data == []:
+        # No matching SlashingDBData found. Returning empty SlashingDBData.
+        return SlashingDBData(pubkey=pubkey, signed_blocks=[], signed_attestations=[])
+    assert len(matching_slashing_db_data) == 1
+    slashing_db_data = matching_slashing_db_data[0]
+    return slashing_db_data
+
+
+def is_slashable_attestation_data(slashing_db: SlashingDB,
+                                  attestation_data: AttestationData, pubkey: BLSPubkey) -> bool:
+    """Checks if the attestation data is slashable according to the slashing DB.
+    """
+    slashing_db_data = get_slashing_db_data_for_pubkey(slashing_db, pubkey)
+    # Check for EIP-3076 conditions:
+    # https://eips.ethereum.org/EIPS/eip-3076#conditions
+    if slashing_db_data.signed_attestations != []:
+        min_target = min(attn.target_epoch for attn in slashing_db_data.signed_attestations)
+        min_source = min(attn.source_epoch for attn in slashing_db_data.signed_attestations)
+        if attestation_data.target.epoch <= min_target:
+            return True
+        if attestation_data.source.epoch < min_source:
+            return True
+    for past_attn in slashing_db_data.signed_attestations:
+        past_attn_data = AttestationData(source=past_attn.source_epoch, target=past_attn.target_epoch)
+        if eth2spec.is_slashable_attestation_data(past_attn_data, attestation_data):
+            return True
+    return False
+
+
+def is_slashable_block(slashing_db: SlashingDB, block: BeaconBlock, pubkey: BLSPubkey) -> bool:
+    """Checks if the block is slashable according to the slashing DB.
+    """
+    slashing_db_data = get_slashing_db_data_for_pubkey(slashing_db, pubkey)
+    # Check for EIP-3076 conditions:
+    # https://eips.ethereum.org/EIPS/eip-3076#conditions
+    if slashing_db_data.signed_blocks != []:
+        min_block = slashing_db_data.signed_blocks[0]
+        for b in slashing_db_data.signed_blocks[1:]:
+            if b.slot < min_block.slot:
+                min_block = b
+        if block.slot < min_block.slot:
+            return True
+    for past_block in slashing_db_data.signed_blocks:
+        if past_block.slot == block.slot:
+            if past_block.signing_root != block.hash_tree_root():
+                return True
+    return False

tests/helpers/eth_node_interface.py

@@ -0,0 +1,103 @@
+import random
+from eth2spec.phase0.mainnet import (
+    MAX_COMMITTEES_PER_SLOT,
+    SLOTS_PER_EPOCH,
+    TARGET_COMMITTEE_SIZE,
+    Attestation,
+    AttestationData,
+    BeaconBlock,
+    Checkpoint,
+    compute_epoch_at_slot,
+    compute_start_slot_at_epoch,
+)
+
+from dvspec.utils.types import (
+    AttestationDuty,
+    BLSPubkey,
+    BLSSignature,
+    Bytes32,
+    CommitteeIndex,
+    Epoch,
+    List,
+    ProposerDuty,
+    Slot,
+    ValidatorIndex,
+)
+from dvspec.spec import (
+    State,
+)
+
+VALIDATOR_SET_SIZE = SLOTS_PER_EPOCH
+
+"""
+Ethereum node interface methods
+"""
+
+
+def bn_get_attestation_duties_for_epoch(validator_indices: List[ValidatorIndex], epoch: Epoch) -> List[AttestationDuty]:
+    attestation_duties = []
+    for validator_index in validator_indices:
+        start_slot_at_epoch = compute_start_slot_at_epoch(epoch)
+        attestation_slot = start_slot_at_epoch + random.randrange(SLOTS_PER_EPOCH)
+        attestation_duty = AttestationDuty(pubkey=BLSPubkey(0x00),
+                                           validator_index=validator_index,
+                                           committee_index=random.randrange(MAX_COMMITTEES_PER_SLOT),
+                                           committee_length=TARGET_COMMITTEE_SIZE,
+                                           committees_at_slot=MAX_COMMITTEES_PER_SLOT,
+                                           validator_committee_index=random.randrange(TARGET_COMMITTEE_SIZE),
+                                           slot=attestation_slot)
+        attestation_duties.append(attestation_duty)
+    return attestation_duties
+
+
+def bn_produce_attestation_data(slot: Slot, committee_index: CommitteeIndex) -> AttestationData:
+    attestation_data = AttestationData(slot=slot,
+                                       index=committee_index,
+                                       source=Checkpoint(epoch=min(compute_epoch_at_slot(slot) - 1, 0)),
+                                       target=Checkpoint(epoch=compute_epoch_at_slot(slot)))
+    return attestation_data
+
+
+def bn_submit_attestation(attestation: Attestation) -> None:
+    pass
+
+
+def bn_get_proposer_duties_for_epoch(epoch: Epoch) -> List[ProposerDuty]:
+    proposer_duties = []
+    validator_indices = [x for x in range(VALIDATOR_SET_SIZE)]
+    random.shuffle(validator_indices)
+    for i in range(SLOTS_PER_EPOCH):
+        proposer_duties.append(ProposerDuty(pubkey=BLSPubkey(0x00), validator_index=validator_indices[i], slot=i))
+    return proposer_duties
+
+
+def bn_produce_block(slot: Slot, randao_reveal: BLSSignature, graffiti: Bytes32) -> BeaconBlock:
+    block = BeaconBlock()
+    block.slot = slot
+    block.body.randao_reveal = randao_reveal
+    block.body.graffiti = graffiti
+    return block
+
+
+"""
+Helpers for Ethereum node interaface methods
+"""
+
+
+def fill_attestation_duties_with_val_index(state: State, attestation_duties: List[AttestationDuty]) -> List[AttestationDuty]:
+    val_index_to_pubkey = {}
+    for dv in state.distributed_validators:
+        val_index_to_pubkey[dv.validator_identity.index] = dv.validator_identity.pubkey
+    for att_duty in attestation_duties:
+        att_duty.pubkey = val_index_to_pubkey[att_duty.validator_index]
+    return attestation_duties
+
+
+
+def fill_proposer_duties_with_val_index(state: State, proposer_duties: List[ProposerDuty]) -> List[ProposerDuty]:
+    val_index_to_pubkey = {}
+    for dv in state.distributed_validators:
+        val_index_to_pubkey[dv.validator_identity.index] = dv.validator_identity.pubkey
+    for pro_duty in proposer_duties:
+        pro_duty.pubkey = val_index_to_pubkey[pro_duty.validator_index]
+    return proposer_duties