diff --git a/.gitignore b/.gitignore index 3dd86fc80..c6b39955f 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,4 @@ eth2.0-spec-tests/ # Dynamically built from Markdown spec test_libs/pyspec/eth2spec/phase0/spec.py +test_libs/pyspec/eth2spec/phase1/spec.py diff --git a/Makefile b/Makefile index 51cb1aaa3..5aeb8563f 100644 --- a/Makefile +++ b/Makefile @@ -13,10 +13,15 @@ YAML_TEST_TARGETS = $(patsubst $(GENERATOR_DIR)/%, $(YAML_TEST_DIR)/%, $(GENERAT GENERATOR_VENVS = $(patsubst $(GENERATOR_DIR)/%, $(GENERATOR_DIR)/%venv, $(GENERATORS)) PY_SPEC_PHASE_0_TARGETS = $(PY_SPEC_DIR)/eth2spec/phase0/spec.py -PY_SPEC_ALL_TARGETS = $(PY_SPEC_PHASE_0_TARGETS) +PY_SPEC_PHASE_0_DEPS = $(SPEC_DIR)/core/0_*.md + +PY_SPEC_PHASE_1_TARGETS = $(PY_SPEC_DIR)/eth2spec/phase1/spec.py +PY_SPEC_PHASE_1_DEPS = $(SPEC_DIR)/core/1_*.md + +PY_SPEC_ALL_TARGETS = $(PY_SPEC_PHASE_0_TARGETS) $(PY_SPEC_PHASE_1_TARGETS) -.PHONY: clean all test citest gen_yaml_tests pyspec phase0 install_test +.PHONY: clean all test citest gen_yaml_tests pyspec phase0 phase1 install_test all: $(PY_SPEC_ALL_TARGETS) $(YAML_TEST_DIR) $(YAML_TEST_TARGETS) @@ -37,22 +42,21 @@ test: $(PY_SPEC_ALL_TARGETS) cd $(PY_SPEC_DIR); . venv/bin/activate; python -m pytest eth2spec citest: $(PY_SPEC_ALL_TARGETS) - cd $(PY_SPEC_DIR); mkdir -p test-reports/eth2spec; . venv/bin/activate; python -m pytest --junitxml=test-reports/eth2spec/test_results.xml . + cd $(PY_SPEC_DIR); mkdir -p test-reports/eth2spec; . venv/bin/activate; \ + python -m pytest --junitxml=test-reports/eth2spec/test_results_phase0.xml eth2spec lint: $(PY_SPEC_ALL_TARGETS) cd $(PY_SPEC_DIR); . venv/bin/activate; \ - flake8 --ignore=E252,W504 --max-line-length=120 ./eth2spec; + flake8 --ignore=E252,W504,W503 --max-line-length=120 ./eth2spec; # "make pyspec" to create the pyspec for all phases. pyspec: $(PY_SPEC_ALL_TARGETS) -# "make phase0" to create pyspec for phase0 -phase0: $(PY_SPEC_PHASE_0_TARGETS) - - -$(PY_SPEC_DIR)/eth2spec/phase0/spec.py: - python3 $(SCRIPT_DIR)/phase0/build_spec.py $(SPEC_DIR)/core/0_beacon-chain.md $@ +$(PY_SPEC_PHASE_0_TARGETS): $(PY_SPEC_PHASE_0_DEPS) + python3 $(SCRIPT_DIR)/build_spec.py -p0 $(SPEC_DIR)/core/0_beacon-chain.md $@ +$(PY_SPEC_DIR)/eth2spec/phase1/spec.py: $(PY_SPEC_PHASE_1_DEPS) + python3 $(SCRIPT_DIR)/build_spec.py -p1 $(SPEC_DIR)/core/0_beacon-chain.md $(SPEC_DIR)/core/1_custody-game.md $(SPEC_DIR)/core/1_shard-data-chains.md $@ CURRENT_DIR = ${CURDIR} diff --git a/configs/constant_presets/minimal.yaml b/configs/constant_presets/minimal.yaml index caae4623b..73448c3c6 100644 --- a/configs/constant_presets/minimal.yaml +++ b/configs/constant_presets/minimal.yaml @@ -74,6 +74,8 @@ PERSISTENT_COMMITTEE_PERIOD: 2048 MAX_EPOCHS_PER_CROSSLINK: 64 # 2**2 (= 4) epochs 25.6 minutes MIN_EPOCHS_TO_INACTIVITY_PENALTY: 4 +# [customized] 2**12 (= 4,096) epochs 18 days +EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS: 4096 # State list lengths diff --git a/configs/fork_timelines/mainnet.yaml b/configs/fork_timelines/mainnet.yaml index 8d51d6582..0bb3c9db1 100644 --- a/configs/fork_timelines/mainnet.yaml +++ b/configs/fork_timelines/mainnet.yaml @@ -7,6 +7,6 @@ phase0: 67108864 # phase0_funny_fork_name: 67116000 # Example 2: -# Should be equal to PHASE_1_GENESIS_EPOCH +# Should be equal to PHASE_1_FORK_EPOCH # (placeholder in example value here) # phase1: 67163000 diff --git a/scripts/README.md b/scripts/README.md new file mode 100644 index 000000000..25b46decf --- /dev/null +++ b/scripts/README.md @@ -0,0 +1,32 @@ +# Building pyspecs from specs.md + +The benefit of the particular spec design is that the given markdown files can be converted to a `spec.py` file for the purposes of testing and linting. The result of this is that bugs are discovered and patched more quickly. + +Specs can be built from either a single markdown document or multiple files that must be combined in a given order. Given 2 spec objects, `build_spec.combine_spec_objects` will combine them into a single spec object which, subsequently, can be converted into a `specs.py`. + +## Usage + +For usage of the spec builder run `python3 -m build_spec --help`. + +## `@Labels` and inserts + +The functioning of the spec combiner is largely automatic in that given `spec0.md` and `spec1.md`, SSZ Objects will be extended and old functions will be overwritten. Extra functionality is provided for more granular control over how files are combined. In the event that only a small portion of code is to be added to an existing function, insert functionality is provided. This saves having to completely redefine the old function from `spec0.md` in `spec1.md`. This is done by marking where the change is to occur in the old file and marking which code is to be inserted in the new file. This is done as follows: + +* In the old file, a label is added as a python comment marking where the code is to be inserted. This would appear as follows in `spec0.md`: + +```python +def foo(x): + x << 1 + # @YourLabelHere + return x +``` + +* In spec1, the new code could then be inserted by having a code-block that looked as follows: + +```python +#begin insert @YourLabelHere + x += x +#end insert @YourLabelHere +``` + +**Note** that the code to be inserted has the **same level of indentation** as the surrounding code of its destination insert point. diff --git a/scripts/phase0/__init__.py b/scripts/__init__.py similarity index 100% rename from scripts/phase0/__init__.py rename to scripts/__init__.py diff --git a/scripts/build_spec.py b/scripts/build_spec.py new file mode 100644 index 000000000..7a51970e3 --- /dev/null +++ b/scripts/build_spec.py @@ -0,0 +1,277 @@ +import re +from function_puller import ( + get_spec, + SpecObject, +) +from argparse import ArgumentParser +from typing import ( + Dict, + List, + Optional, +) + + +PHASE0_IMPORTS = '''from typing import ( + Any, + Dict, + List, + NewType, + Tuple, +) + +from eth2spec.utils.ssz.ssz_impl import ( + hash_tree_root, + signing_root, +) +from eth2spec.utils.ssz.ssz_typing import ( + # unused: uint8, uint16, uint32, uint128, uint256, + uint64, Container, Vector, BytesN +) +from eth2spec.utils.bls import ( + bls_aggregate_pubkeys, + bls_verify, + bls_verify_multiple, +) +# Note: 'int' type defaults to being interpreted as a uint64 by SSZ implementation. + +from eth2spec.utils.hash_function import hash +''' +PHASE1_IMPORTS = '''from typing import ( + Any, + Dict, + List, + NewType, + Tuple, +) + +from eth2spec.utils.ssz.ssz_impl import ( + hash_tree_root, + signing_root, + serialize, + is_empty, +) +from eth2spec.utils.ssz.ssz_typing import ( + # unused: uint8, uint16, uint32, uint128, uint256, + uint64, Container, Vector, BytesN +) +from eth2spec.utils.bls import ( + bls_aggregate_pubkeys, + bls_verify, + bls_verify_multiple, +) + +from eth2spec.utils.hash_function import hash +''' +NEW_TYPES = { + 'Slot': 'int', + 'Epoch': 'int', + 'Shard': 'int', + 'ValidatorIndex': 'int', + 'Gwei': 'int', +} +BYTE_TYPES = [4, 32, 48, 96] +SUNDRY_FUNCTIONS = ''' +def get_ssz_type_by_name(name: str) -> Container: + return globals()[name] + + +# Monkey patch validator compute committee code +_compute_committee = compute_committee +committee_cache = {} + + +def compute_committee(indices: List[ValidatorIndex], seed: Bytes32, index: int, count: int) -> List[ValidatorIndex]: + param_hash = (hash_tree_root(indices), seed, index, count) + + if param_hash in committee_cache: + return committee_cache[param_hash] + else: + ret = _compute_committee(indices, seed, index, count) + committee_cache[param_hash] = ret + return ret + + +# Monkey patch hash cache +_hash = hash +hash_cache = {} + + +def hash(x): + if x in hash_cache: + return hash_cache[x] + else: + ret = _hash(x) + hash_cache[x] = ret + return ret + + +# Access to overwrite spec constants based on configuration +def apply_constants_preset(preset: Dict[str, Any]): + global_vars = globals() + for k, v in preset.items(): + global_vars[k] = v + + # Deal with derived constants + global_vars['GENESIS_EPOCH'] = slot_to_epoch(GENESIS_SLOT) + + # Initialize SSZ types again, to account for changed lengths + init_SSZ_types() +''' + + +def objects_to_spec(functions: Dict[str, str], + constants: Dict[str, str], + ssz_objects: Dict[str, str], + inserts: Dict[str, str], + imports: Dict[str, str], + new_types: Dict[str, str], + byte_types: List[int], + ) -> str: + """ + Given all the objects that constitute a spec, combine them into a single pyfile. + """ + new_type_definitions = \ + '\n'.join(['''%s = NewType('%s', %s)''' % (key, key, value) for key, value in new_types.items()]) + new_type_definitions += '\n' + '\n'.join(['Bytes%s = BytesN[%s]' % (n, n) for n in byte_types]) + functions_spec = '\n\n'.join(functions.values()) + constants_spec = '\n'.join(map(lambda x: '%s = %s' % (x, constants[x]), constants)) + ssz_objects_instantiation_spec = '\n\n'.join(ssz_objects.values()) + ssz_objects_reinitialization_spec = ( + 'def init_SSZ_types():\n global_vars = globals()\n\n ' + + '\n\n '.join([re.sub(r'(?!\n\n)\n', r'\n ', value[:-1]) for value in ssz_objects.values()]) + + '\n\n' + + '\n'.join(map(lambda x: ' global_vars[\'%s\'] = %s' % (x, x), ssz_objects.keys())) + ) + spec = ( + imports + + '\n' + new_type_definitions + + '\n\n' + constants_spec + + '\n\n\n' + ssz_objects_instantiation_spec + + '\n\n' + functions_spec + + '\n' + SUNDRY_FUNCTIONS + + '\n\n' + ssz_objects_reinitialization_spec + + '\n' + ) + # Handle @inserts + for key, value in inserts.items(): + spec = re.sub('[ ]*# %s\\n' % key, value, spec) + return spec + + +def combine_functions(old_functions: Dict[str, str], new_functions: Dict[str, str]) -> Dict[str, str]: + for key, value in new_functions.items(): + old_functions[key] = value + return old_functions + + +def combine_constants(old_constants: Dict[str, str], new_constants: Dict[str, str]) -> Dict[str, str]: + for key, value in new_constants.items(): + old_constants[key] = value + return old_constants + + +def dependency_order_ssz_objects(objects: Dict[str, str]) -> None: + """ + Determines which SSZ Object is depenedent on which other and orders them appropriately + """ + items = list(objects.items()) + for key, value in items: + dependencies = re.findall(r'(: [A-Z][\w[]*)', value) + dependencies = map(lambda x: re.sub(r'\W|Vector|List|Container|uint\d+|Bytes\d+|bytes', '', x), dependencies) + for dep in dependencies: + if dep in NEW_TYPES or len(dep) == 0: + continue + key_list = list(objects.keys()) + for item in [dep, key] + key_list[key_list.index(dep)+1:]: + objects[item] = objects.pop(item) + + +def combine_ssz_objects(old_objects: Dict[str, str], new_objects: Dict[str, str]) -> Dict[str, str]: + """ + Takes in old spec and new spec ssz objects, combines them, + and returns the newer versions of the objects in dependency order. + """ + for key, value in new_objects.items(): + if key in old_objects: + # remove trailing newline + old_objects[key] = old_objects[key] + # remove leading variable name + value = re.sub(r'^class [\w]*\(Container\):\n', '', value) + old_objects[key] = old_objects.get(key, '') + value + dependency_order_ssz_objects(old_objects) + return old_objects + + +# inserts are handeled the same way as functions +combine_inserts = combine_functions + + +def combine_spec_objects(spec0: SpecObject, spec1: SpecObject) -> SpecObject: + """ + Takes in two spec variants (as tuples of their objects) and combines them using the appropriate combiner function. + """ + functions0, constants0, ssz_objects0, inserts0 = spec0 + functions1, constants1, ssz_objects1, inserts1 = spec1 + functions = combine_functions(functions0, functions1) + constants = combine_constants(constants0, constants1) + ssz_objects = combine_ssz_objects(ssz_objects0, ssz_objects1) + inserts = combine_inserts(inserts0, inserts1) + return functions, constants, ssz_objects, inserts + + +def build_phase0_spec(sourcefile: str, outfile: str=None) -> Optional[str]: + functions, constants, ssz_objects, inserts = get_spec(sourcefile) + spec = objects_to_spec(functions, constants, ssz_objects, inserts, PHASE0_IMPORTS, NEW_TYPES, BYTE_TYPES) + if outfile is not None: + with open(outfile, 'w') as out: + out.write(spec) + return spec + + +def build_phase1_spec(phase0_sourcefile: str, + phase1_custody_sourcefile: str, + phase1_shard_sourcefile: str, + outfile: str=None) -> Optional[str]: + phase0_spec = get_spec(phase0_sourcefile) + phase1_custody = get_spec(phase1_custody_sourcefile) + phase1_shard_data = get_spec(phase1_shard_sourcefile) + spec_objects = phase0_spec + for value in [phase1_custody, phase1_shard_data]: + spec_objects = combine_spec_objects(spec_objects, value) + spec = objects_to_spec(*spec_objects, PHASE1_IMPORTS, NEW_TYPES, BYTE_TYPES) + if outfile is not None: + with open(outfile, 'w') as out: + out.write(spec) + return spec + + +if __name__ == '__main__': + description = ''' +Build the specs from the md docs. +If building phase 0: + 1st argument is input spec.md + 2nd argument is output spec.py + +If building phase 1: + 1st argument is input spec_phase0.md + 2nd argument is input spec_phase1_custody.md + 3rd argument is input spec_phase1_shard_data.md + 4th argument is output spec.py +''' + parser = ArgumentParser(description=description) + parser.add_argument("-p", "--phase", dest="phase", type=int, default=0, help="Build for phase #") + parser.add_argument(dest="files", help="Input and output files", nargs="+") + + args = parser.parse_args() + if args.phase == 0: + if len(args.files) == 2: + build_phase0_spec(*args.files) + else: + print(" Phase 0 requires an output as well as an input file.") + elif args.phase == 1: + if len(args.files) == 4: + build_phase1_spec(*args.files) + else: + print(" Phase 1 requires an output as well as 3 input files (phase0.md and phase1.md, phase1.md)") + else: + print("Invalid phase: {0}".format(args.phase)) diff --git a/scripts/function_puller.py b/scripts/function_puller.py new file mode 100644 index 000000000..303d4ec2f --- /dev/null +++ b/scripts/function_puller.py @@ -0,0 +1,83 @@ +import re +from typing import Dict, Tuple, NewType + + +FUNCTION_REGEX = r'^def [\w_]*' +BEGIN_INSERT_REGEX = r'# begin insert ' +END_INSERT_REGEX = r'# end insert' + +SpecObject = NewType('SpecObjects', Tuple[Dict[str, str], Dict[str, str], Dict[str, str], Dict[str, str]]) + + +def get_spec(file_name: str) -> SpecObject: + """ + Takes in the file name of a spec.md file, opens it and returns the following objects: + functions = {function_name: function_code} + constants= {constant_name: constant_code} + ssz_objects= {object_name: object} + inserts= {insert_tag: code to be inserted} + + Note: This function makes heavy use of the inherent ordering of dicts, + if this is not supported by your python version, it will not work. + """ + pulling_from = None # line number of start of latest object + current_name = None # most recent section title + insert_name = None # stores the label of the current insert object + functions = {} + constants = {} + ssz_objects = {} + inserts = {} + function_matcher = re.compile(FUNCTION_REGEX) + inserts_matcher = re.compile(BEGIN_INSERT_REGEX) + for linenum, line in enumerate(open(file_name).readlines()): + line = line.rstrip() + if pulling_from is None and len(line) > 0 and line[0] == '#' and line[-1] == '`': + current_name = line[line[:-1].rfind('`') + 1: -1] + if line[:9] == '```python': + assert pulling_from is None + pulling_from = linenum + 1 + elif line[:3] == '```': + pulling_from = None + elif inserts_matcher.match(line) is not None: + # Find @insert names + insert_name = re.search(r'@[\w]*', line).group(0) + elif insert_name is not None: + # In insert mode, either the next line is more code, or the end of the insert + if re.match(END_INSERT_REGEX, line) is not None: + insert_name = None + else: + inserts[insert_name] = inserts.get(insert_name, '') + line + '\n' + else: + # Handle function definitions & ssz_objects + if pulling_from is not None: + # SSZ Object + if len(line) > 18 and line[:6] == 'class ' and line[-12:] == '(Container):': + name = line[6:-12] + # Check consistency with markdown header + assert name == current_name + is_ssz = True + # function definition + elif function_matcher.match(line) is not None: + current_name = function_matcher.match(line).group(0) + is_ssz = False + if is_ssz: + ssz_objects[current_name] = ssz_objects.get(current_name, '') + line + '\n' + else: + functions[current_name] = functions.get(current_name, '') + line + '\n' + # Handle constant table entries + elif pulling_from is None and len(line) > 0 and line[0] == '|': + row = line[1:].split('|') + if len(row) >= 2: + for i in range(2): + row[i] = row[i].strip().strip('`') + if '`' in row[i]: + row[i] = row[i][:row[i].find('`')] + eligible = True + if row[0][0] not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_': + eligible = False + for c in row[0]: + if c not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789': + eligible = False + if eligible: + constants[row[0]] = row[1].replace('**TBD**', '0x1234567890123456789012345678901234567890') + return functions, constants, ssz_objects, inserts diff --git a/scripts/phase0/build_spec.py b/scripts/phase0/build_spec.py deleted file mode 100644 index 0d5f64094..000000000 --- a/scripts/phase0/build_spec.py +++ /dev/null @@ -1,99 +0,0 @@ -import sys -import function_puller - - -def build_phase0_spec(sourcefile, outfile): - code_lines = [] - code_lines.append(""" - -from typing import ( - Any, - Dict, - List, - NewType, - Tuple, -) -from eth2spec.utils.ssz.ssz_impl import ( - hash_tree_root, - signing_root, -) -from eth2spec.utils.ssz.ssz_typing import ( - # unused: uint8, uint16, uint32, uint128, uint256, - uint64, Container, Vector, BytesN -) -from eth2spec.utils.hash_function import hash -from eth2spec.utils.bls import ( - bls_aggregate_pubkeys, - bls_verify, - bls_verify_multiple, -) - -# Note: 'int' type defaults to being interpreted as a uint64 by SSZ implementation. -Slot = NewType('Slot', int) # uint64 -Epoch = NewType('Epoch', int) # uint64 -Shard = NewType('Shard', int) # uint64 -ValidatorIndex = NewType('ValidatorIndex', int) # uint64 -Gwei = NewType('Gwei', int) # uint64 - -Bytes4 = BytesN[4] -Bytes32 = BytesN[32] -Bytes48 = BytesN[48] -Bytes96 = BytesN[96] - -""") - - code_lines += function_puller.get_spec(sourcefile) - - code_lines.append(""" -# Monkey patch validator compute committee code -_compute_committee = compute_committee -committee_cache = {} - - -def compute_committee(indices: List[ValidatorIndex], seed: Bytes32, index: int, count: int) -> List[ValidatorIndex]: - param_hash = (hash_tree_root(indices), seed, index, count) - - if param_hash in committee_cache: - return committee_cache[param_hash] - else: - ret = _compute_committee(indices, seed, index, count) - committee_cache[param_hash] = ret - return ret - - -# Monkey patch hash cache -_hash = hash -hash_cache = {} - - -def hash(x): - if x in hash_cache: - return hash_cache[x] - else: - ret = _hash(x) - hash_cache[x] = ret - return ret - - -# Access to overwrite spec constants based on configuration -def apply_constants_preset(preset: Dict[str, Any]): - global_vars = globals() - for k, v in preset.items(): - global_vars[k] = v - - # Deal with derived constants - global_vars['GENESIS_EPOCH'] = slot_to_epoch(GENESIS_SLOT) - - # Initialize SSZ types again, to account for changed lengths - init_SSZ_types() -""") - - with open(outfile, 'w') as out: - out.write("\n".join(code_lines)) - - -if __name__ == '__main__': - if len(sys.argv) < 3: - print("Usage: ") - build_phase0_spec(sys.argv[1], sys.argv[2]) - diff --git a/scripts/phase0/function_puller.py b/scripts/phase0/function_puller.py deleted file mode 100644 index 0f4b21c0e..000000000 --- a/scripts/phase0/function_puller.py +++ /dev/null @@ -1,81 +0,0 @@ -from typing import List - - -def get_spec(file_name: str) -> List[str]: - code_lines = [] - pulling_from = None - current_name = None - # list of current type definition being parsed, or None otherwise - current_typedef = None - # list of (name, definition lines list) tuples. - type_defs = [] - for linenum, line in enumerate(open(file_name).readlines()): - line = line.rstrip() - if pulling_from is None and len(line) > 0 and line[0] == '#' and line[-1] == '`': - current_name = line[line[:-1].rfind('`') + 1: -1] - if line[:9] == '```python': - assert pulling_from is None - pulling_from = linenum + 1 - elif line[:3] == '```': - if pulling_from is None: - pulling_from = linenum - else: - pulling_from = None - if current_typedef is not None: - type_defs.append((current_name, current_typedef)) - current_typedef = None - else: - if pulling_from is not None: - # Add some whitespace between functions - if line[:3] == 'def' or line[:5] == 'class': - code_lines.append('') - code_lines.append('') - # Check for SSZ type definitions - if len(line) > 18 and line[:6] == 'class ' and line[-12:] == '(Container):': - name = line[6:-12] - # Check consistency with markdown header - assert name == current_name - current_typedef = [] - if current_typedef is not None: - current_typedef.append(line) - code_lines.append(line) - elif pulling_from is None and len(line) > 0 and line[0] == '|': - row = line[1:].split('|') - if len(row) >= 2: - for i in range(2): - row[i] = row[i].strip().strip('`') - if '`' in row[i]: - row[i] = row[i][:row[i].find('`')] - eligible = True - if row[0][0] not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_': - eligible = False - for c in row[0]: - if c not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789': - eligible = False - if eligible: - code_lines.append(row[0] + ' = ' + (row[1].replace('**TBD**', '0x1234567890123456789012345678901234567890'))) - # Build type-def re-initialization - code_lines.append('\n') - code_lines.append('ssz_types = [\n') - for (ssz_type_name, _) in type_defs: - code_lines.append(f' {ssz_type_name},') - code_lines.append(']') - code_lines.append('\n') - code_lines.append('def init_SSZ_types():') - code_lines.append(' global_vars = globals()') - for ssz_type_name, ssz_type in type_defs: - code_lines.append('') - for type_line in ssz_type: - if len(type_line) > 0: - code_lines.append(' ' + type_line) - for (ssz_type_name, _) in type_defs: - code_lines.append(f' global_vars["{ssz_type_name}"] = {ssz_type_name}') - code_lines.append(' global_vars["ssz_types"] = [') - for (ssz_type_name, _) in type_defs: - code_lines.append(f' "{ssz_type_name}",') - code_lines.append(' ]') - code_lines.append('\n') - code_lines.append('def get_ssz_type_by_name(name: str) -> Container:') - code_lines.append(' return globals()[name]') - code_lines.append('') - return code_lines diff --git a/specs/core/0_beacon-chain.md b/specs/core/0_beacon-chain.md index 42c5e8b71..a6d9d23c5 100644 --- a/specs/core/0_beacon-chain.md +++ b/specs/core/0_beacon-chain.md @@ -318,13 +318,13 @@ class Crosslink(Container): class AttestationData(Container): # LMD GHOST vote beacon_block_root: Bytes32 - + # FFG vote source_epoch: uint64 source_root: Bytes32 target_epoch: uint64 target_root: Bytes32 - + # Crosslink vote crosslink: Crosslink ``` @@ -1246,14 +1246,19 @@ def process_slot(state: BeaconState) -> None: ### Epoch processing +Note: the `# @LabelHere` lines below are placeholders to show that code will be inserted here in a future phase. + ```python def process_epoch(state: BeaconState) -> None: process_justification_and_finalization(state) process_crosslinks(state) process_rewards_and_penalties(state) process_registry_updates(state) + # @process_reveal_deadlines + # @process_challenge_deadlines process_slashings(state) process_final_updates(state) + # @after_process_final_updates ``` #### Helper functions diff --git a/specs/core/1_custody-game.md b/specs/core/1_custody-game.md index 568879b17..6c89ef853 100644 --- a/specs/core/1_custody-game.md +++ b/specs/core/1_custody-game.md @@ -31,8 +31,7 @@ - [`BeaconState`](#beaconstate) - [`BeaconBlockBody`](#beaconblockbody) - [Helpers](#helpers) - - [`typeof`](#typeof) - - [`empty`](#empty) + - [`ceillog2`](#ceillog2) - [`get_crosslink_chunk_count`](#get_crosslink_chunk_count) - [`get_custody_chunk_bit`](#get_custody_chunk_bit) - [`get_chunk_bits_root`](#get_chunk_bits_root) @@ -121,66 +120,61 @@ This document details the beacon chain additions and changes in Phase 1 of Ether #### `CustodyChunkChallenge` ```python -{ - 'responder_index': ValidatorIndex, - 'attestation': Attestation, - 'chunk_index': 'uint64', -} +class CustodyChunkChallenge(Container): + responder_index: ValidatorIndex + attestation: Attestation + chunk_index: uint64 ``` #### `CustodyBitChallenge` ```python -{ - 'responder_index': ValidatorIndex, - 'attestation': Attestation, - 'challenger_index': ValidatorIndex, - 'responder_key': BLSSignature, - 'chunk_bits': Bitfield, - 'signature': BLSSignature, -} +class CustodyBitChallenge(Container): + responder_index: ValidatorIndex + attestation: Attestation + challenger_index: ValidatorIndex + responder_key: Bytes96 + chunk_bits: bytes + signature: Bytes96 ``` #### `CustodyChunkChallengeRecord` ```python -{ - 'challenge_index': 'uint64', - 'challenger_index': ValidatorIndex, - 'responder_index': ValidatorIndex, - 'inclusion_epoch': Epoch, - 'data_root': Hash, - 'depth': 'uint64', - 'chunk_index': 'uint64', -} +class CustodyChunkChallengeRecord(Container): + challenge_index: uint64 + challenger_index: ValidatorIndex + responder_index: ValidatorIndex + inclusion_epoch: Epoch + data_root: Bytes32 + depth: uint64 + chunk_index: uint64 ``` #### `CustodyBitChallengeRecord` ```python -{ - 'challenge_index': 'uint64', - 'challenger_index': ValidatorIndex, - 'responder_index': ValidatorIndex, - 'inclusion_epoch': Epoch, - 'data_root': Hash, - 'chunk_count': 'uint64', - 'chunk_bits_merkle_root': Hash, - 'responder_key': BLSSignature, -} +class CustodyBitChallengeRecord(Container): + challenge_index: uint64 + challenger_index: ValidatorIndex + responder_index: ValidatorIndex + inclusion_epoch: Epoch + data_root: Bytes32 + chunk_count: uint64 + chunk_bits_merkle_root: Bytes32 + responder_key: Bytes96 ``` #### `CustodyResponse` ```python -{ - 'challenge_index': 'uint64', - 'chunk_index': 'uint64', - 'chunk': ['byte', BYTES_PER_CUSTODY_CHUNK], - 'data_branch': [Hash], - 'chunk_bits_branch': [Hash], - 'chunk_bits_leaf': Hash, -} +class CustodyResponse(Container): + challenge_index: uint64 + chunk_index: uint64 + chunk: Vector[bytes, BYTES_PER_CUSTODY_CHUNK] + data_branch: List[Bytes32] + chunk_bits_branch: List[Bytes32] + chunk_bits_leaf: Bytes32 ``` ### New beacon operations @@ -188,12 +182,11 @@ This document details the beacon chain additions and changes in Phase 1 of Ether #### `CustodyKeyReveal` ```python -{ +class CustodyKeyReveal(Container): # Index of the validator whose key is being revealed - 'revealer_index': 'uint64', + revealer_index: uint64 # Reveal (masked signature) - 'reveal': 'bytes96', -} + reveal: Bytes96 ``` #### `EarlyDerivedSecretReveal` @@ -201,18 +194,17 @@ This document details the beacon chain additions and changes in Phase 1 of Ether Represents an early (punishable) reveal of one of the derived secrets, where derived secrets are RANDAO reveals and custody reveals (both are part of the same domain). ```python -{ +class EarlyDerivedSecretReveal(Container): # Index of the validator whose key is being revealed - 'revealed_index': 'uint64', + revealed_index: uint64 # RANDAO epoch of the key that is being revealed - 'epoch': 'uint64', + epoch: uint64 # Reveal (masked signature) - 'reveal': 'bytes96', + reveal: Bytes96 # Index of the validator who revealed (whistleblower) - 'masker_index': 'uint64', + masker_index: uint64 # Mask used to hide the actual reveal signature (prevent reveal from being stolen) - 'mask': 'bytes32', -} + mask: Bytes32 ``` ### Phase 0 container updates @@ -222,44 +214,46 @@ Add the following fields to the end of the specified container objects. Fields w #### `Validator` ```python - # next_custody_reveal_period is initialized to the custody period +class Validator(Container): + # next_custody_reveal_period is initialised to the custody period # (of the particular validator) in which the validator is activated # = get_validators_custody_reveal_period(...) - 'next_custody_reveal_period': 'uint64', - 'max_reveal_lateness': 'uint64', + next_custody_reveal_period: uint64 + max_reveal_lateness: uint64 ``` #### `BeaconState` ```python - 'custody_chunk_challenge_records': [CustodyChunkChallengeRecord], - 'custody_bit_challenge_records': [CustodyBitChallengeRecord], - 'custody_challenge_index': 'uint64', +class BeaconState(Container): + custody_chunk_challenge_records: List[CustodyChunkChallengeRecord] + custody_bit_challenge_records: List[CustodyBitChallengeRecord] + custody_challenge_index: uint64 # Future derived secrets already exposed; contains the indices of the exposed validator # at RANDAO reveal period % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS - 'exposed_derived_secrets': [['uint64'], EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS], + exposed_derived_secrets: Vector[List[uint64], EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS] ``` #### `BeaconBlockBody` ```python - 'custody_chunk_challenges': [CustodyChunkChallenge], - 'custody_bit_challenges': [CustodyBitChallenge], - 'custody_responses': [CustodyResponse], - 'custody_key_reveals': [CustodyKeyReveal], - 'early_derived_secret_reveals': [EarlyDerivedSecretReveal], +class BeaconBlockBody(Container): + custody_chunk_challenges: List[CustodyChunkChallenge] + custody_bit_challenges: List[CustodyBitChallenge] + custody_responses: List[CustodyResponse] + custody_key_reveals: List[CustodyKeyReveal] + early_derived_secret_reveals: List[EarlyDerivedSecretReveal] ``` ## Helpers -### `typeof` +### `ceillog2` -The `typeof` function accepts and SSZ object as a single input and returns the corresponding SSZ type. - -### `empty` - -The `empty` function accepts and SSZ type as input and returns an object of that type with all fields initialized to default values. +```python +def ceillog2(x): + return x.bit_length() +``` ### `get_crosslink_chunk_count` @@ -273,19 +267,19 @@ def get_custody_chunk_count(crosslink: Crosslink) -> int: ### `get_custody_chunk_bit` ```python -def get_custody_chunk_bit(key: BLSSignature, chunk: bytes) -> bool: +def get_custody_chunk_bit(key: Bytes96, chunk: bytes) -> bool: # TODO: Replace with something MPC-friendly, e.g. the Legendre symbol - return get_bitfield_bit(hash(challenge.responder_key + chunk), 0) + return get_bitfield_bit(hash(key + chunk), 0) ``` ### `get_chunk_bits_root` ```python -def get_chunk_bits_root(chunk_bitfield: Bitfield) -> Bytes32: +def get_chunk_bits_root(chunk_bitfield: bytes) -> Bytes32: aggregated_bits = bytearray([0] * 32) for i in range(0, len(chunk_bitfield), 32): for j in range(32): - aggregated_bits[j] ^= chunk_bitfield[i+j] + aggregated_bits[j] ^= chunk_bitfield[i + j] return hash(aggregated_bits) ``` @@ -315,11 +309,10 @@ def get_validators_custody_reveal_period(state: BeaconState, ### `replace_empty_or_append` - ```python def replace_empty_or_append(list: List[Any], new_element: Any) -> int: for i in range(len(list)): - if list[i] == empty(typeof(new_element)): + if is_empty(list[i]): list[i] = new_element return i list.append(new_element) @@ -340,8 +333,7 @@ For each `reveal` in `block.body.custody_key_reveals`, run the following functio ```python def process_custody_key_reveal(state: BeaconState, - reveal: CustodyKeyReveal) -> None: - + reveal: CustodyKeyReveal) -> None: """ Process ``CustodyKeyReveal`` operation. Note that this function mutates ``state``. @@ -369,15 +361,18 @@ def process_custody_key_reveal(state: BeaconState, # Decrement max reveal lateness if response is timely if revealer.next_custody_reveal_period == get_validators_custody_reveal_period(state, reveal.revealer_index) - 2: - revealer.max_reveal_lateness -= MAX_REVEAL_LATENESS_DECREMENT - revealer.max_reveal_lateness = max(revealed_validator.max_reveal_lateness, get_validators_custody_reveal_period(state, reveal.revealed_index) - revealer.next_custody_reveal_period) + revealer.max_reveal_lateness -= MAX_REVEAL_LATENESS_DECREMENT + revealer.max_reveal_lateness = max( + revealer.max_reveal_lateness, + get_validators_custody_reveal_period(state, reveal.revealed_index) - revealer.next_custody_reveal_period + ) # Process reveal revealer.next_custody_reveal_period += 1 # Reward Block Preposer proposer_index = get_beacon_proposer_index(state) - increase_balance(state, proposer_index, base_reward(state, index) // MINOR_REWARD_QUOTIENT) + increase_balance(state, proposer_index, get_base_reward(state, reveal.revealer_index) // MINOR_REWARD_QUOTIENT) ``` #### Early derived secret reveals @@ -388,7 +383,7 @@ For each `reveal` in `block.body.early_derived_secret_reveals`, run the followin ```python def process_early_derived_secret_reveal(state: BeaconState, - reveal: EarlyDerivedSecretReveal) -> None: + reveal: EarlyDerivedSecretReveal) -> None: """ Process ``EarlyDerivedSecretReveal`` operation. Note that this function mutates ``state``. @@ -396,11 +391,12 @@ def process_early_derived_secret_reveal(state: BeaconState, revealed_validator = state.validator_registry[reveal.revealed_index] masker = state.validator_registry[reveal.masker_index] + derived_secret_location = reveal.epoch % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS assert reveal.epoch >= get_current_epoch(state) + RANDAO_PENALTY_EPOCHS assert reveal.epoch < get_current_epoch(state) + EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS assert revealed_validator.slashed is False - assert reveal.revealed_index not in state.exposed_derived_secrets[reveal.epoch % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS] + assert reveal.revealed_index not in state.exposed_derived_secrets[derived_secret_location] # Verify signature correctness masker = state.validator_registry[reveal.masker_index] @@ -432,12 +428,16 @@ def process_early_derived_secret_reveal(state: BeaconState, # Calculate penalty max_proposer_slot_reward = ( - get_base_reward(state, reveal.revealed_index) * - SLOTS_PER_EPOCH // - len(get_active_validator_indices(state, get_current_epoch(state))) // - PROPOSER_REWARD_QUOTIENT + get_base_reward(state, reveal.revealed_index) + * SLOTS_PER_EPOCH + // len(get_active_validator_indices(state, get_current_epoch(state))) + // PROPOSER_REWARD_QUOTIENT + ) + penalty = ( + max_proposer_slot_reward + * EARLY_DERIVED_SECRET_REVEAL_SLOT_REWARD_MULTIPLE + * (len(state.exposed_derived_secrets[derived_secret_location]) + 1) ) - penalty = max_proposer_slot_reward * EARLY_DERIVED_SECRET_REVEAL_SLOT_REWARD_MULTIPLE * (len(state.exposed_derived_secrets[reveal.epoch % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS]) + 1) # Apply penalty proposer_index = get_beacon_proposer_index(state) @@ -449,8 +449,7 @@ def process_early_derived_secret_reveal(state: BeaconState, decrease_balance(state, reveal.revealed_index, penalty) # Mark this derived secret as exposed so validator cannot be punished repeatedly - state.exposed_derived_secrets[reveal.epoch % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS].append(reveal.revealed_index) - + state.exposed_derived_secrets[derived_secret_location].append(reveal.revealed_index) ``` #### Chunk challenges @@ -463,13 +462,13 @@ For each `challenge` in `block.body.custody_chunk_challenges`, run the following def process_chunk_challenge(state: BeaconState, challenge: CustodyChunkChallenge) -> None: # Verify the attestation - assert verify_indexed_attestation(state, convert_to_indexed(state, challenge.attestation)) + validate_indexed_attestation(state, convert_to_indexed(state, challenge.attestation)) # Verify it is not too late to challenge assert slot_to_epoch(challenge.attestation.data.slot) >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY responder = state.validator_registry[challenge.responder_index] assert responder.exit_epoch >= get_current_epoch(state) - MAX_CHUNK_CHALLENGE_DELAY # Verify the responder participated in the attestation - attesters = get_attesting_indices(state, attestation.data, attestation.aggregation_bitfield) + attesters = get_attesting_indices(state, challenge.attestation.data, challenge.attestation.aggregation_bitfield) assert challenge.responder_index in attesters # Verify the challenge is not a duplicate for record in state.custody_chunk_challenge_records: @@ -478,13 +477,13 @@ def process_chunk_challenge(state: BeaconState, record.chunk_index != challenge.chunk_index ) # Verify depth - depth = math.log2(next_power_of_two(get_custody_chunk_count(challenge.attestation.data.crosslink))) + depth = ceillog2(get_custody_chunk_count(challenge.attestation.data.crosslink)) assert challenge.chunk_index < 2**depth # Add new chunk challenge record new_record = CustodyChunkChallengeRecord( challenge_index=state.custody_challenge_index, challenger_index=get_beacon_proposer_index(state), - responder_index=challenge.responder_index + responder_index=challenge.responder_index, inclusion_epoch=get_current_epoch(state), data_root=challenge.attestation.data.crosslink.data_root, depth=depth, @@ -518,10 +517,11 @@ def process_bit_challenge(state: BeaconState, assert is_slashable_validator(challenger, get_current_epoch(state)) # Verify the attestation - assert verify_indexed_attestation(state, convert_to_indexed(state, challenge.attestation)) + attestation = challenge.attestation + validate_indexed_attestation(state, convert_to_indexed(state, attestation)) # Verify the attestation is eligible for challenging responder = state.validator_registry[challenge.responder_index] - assert (slot_to_epoch(challenge.attestation.data.slot) + responder.max_reveal_lateness <= + assert (slot_to_epoch(attestation.data.slot) + responder.max_reveal_lateness <= get_validators_custody_reveal_period(state, challenge.responder_index)) # Verify the responder participated in the attestation @@ -537,7 +537,7 @@ def process_bit_challenge(state: BeaconState, get_validators_custody_reveal_period( state=state, index=challenge.responder_index, - epoch=slot_to_epoch(attestation.data.slot), + epoch=slot_to_epoch(attestation.data.slot)), challenge.responder_index ) assert bls_verify( @@ -552,10 +552,10 @@ def process_bit_challenge(state: BeaconState, ) # Verify the chunk count - chunk_count = get_custody_chunk_count(challenge.attestation.data.crosslink) + chunk_count = get_custody_chunk_count(attestation.data.crosslink) assert verify_bitfield(challenge.chunk_bits, chunk_count) # Verify the first bit of the hash of the chunk bits does not equal the custody bit - custody_bit = get_bitfield_bit(attestation.custody_bitfield, attesters.index(responder_index)) + custody_bit = get_bitfield_bit(attestation.custody_bitfield, attesters.index(challenge.responder_index)) assert custody_bit != get_bitfield_bit(get_chunk_bits_root(challenge.chunk_bits), 0) # Add new bit challenge record new_record = CustodyBitChallengeRecord( @@ -563,9 +563,9 @@ def process_bit_challenge(state: BeaconState, challenger_index=challenge.challenger_index, responder_index=challenge.responder_index, inclusion_epoch=get_current_epoch(state), - data_root=challenge.attestation.data.crosslink.data_root, + data_root=attestation.data.crosslink.data_root, chunk_count=chunk_count, - chunk_bits_merkle_root=merkle_root(pad_to_power_of_2((challenge.chunk_bits))), + chunk_bits_merkle_root=hash_tree_root(challenge.chunk_bits), responder_key=challenge.responder_key, ) replace_empty_or_append(state.custody_bit_challenge_records, new_record) @@ -584,11 +584,13 @@ For each `response` in `block.body.custody_responses`, run the following functio ```python def process_custody_response(state: BeaconState, response: CustodyResponse) -> None: - chunk_challenge = next(record for record in state.custody_chunk_challenge_records if record.challenge_index == response.challenge_index, None) + chunk_challenge = next((record for record in state.custody_chunk_challenge_records + if record.challenge_index == response.challenge_index), None) if chunk_challenge is not None: return process_chunk_challenge_response(state, response, chunk_challenge) - bit_challenge = next(record for record in state.custody_bit_challenge_records if record.challenge_index == response.challenge_index, None) + bit_challenge = next((record for record in state.custody_bit_challenge_records + if record.challenge_index == response.challenge_index), None) if bit_challenge is not None: return process_bit_challenge_response(state, response, bit_challenge) @@ -618,7 +620,7 @@ def process_chunk_challenge_response(state: BeaconState, records[records.index(challenge)] = CustodyChunkChallengeRecord() # Reward the proposer proposer_index = get_beacon_proposer_index(state) - increase_balance(state, proposer_index, base_reward(state, index) // MINOR_REWARD_QUOTIENT) + increase_balance(state, proposer_index, get_base_reward(state, proposer_index) // MINOR_REWARD_QUOTIENT) ``` ```python @@ -634,7 +636,7 @@ def process_bit_challenge_response(state: BeaconState, assert verify_merkle_branch( leaf=hash_tree_root(response.chunk), branch=response.data_branch, - depth=math.log2(next_power_of_two(challenge.chunk_count)), + depth=ceillog2(challenge.chunk_count), index=response.chunk_index, root=challenge.data_root, ) @@ -642,12 +644,13 @@ def process_bit_challenge_response(state: BeaconState, assert verify_merkle_branch( leaf=response.chunk_bits_leaf, branch=response.chunk_bits_branch, - depth=math.log2(next_power_of_two(challenge.chunk_count) // 256), + depth=ceillog2(challenge.chunk_count) >> 8, index=response.chunk_index // 256, root=challenge.chunk_bits_merkle_root ) # Verify the chunk bit does not match the challenge chunk bit - assert get_custody_chunk_bit(challenge.responder_key, response.chunk) != get_bitfield_bit(challenge.chunk_bits_leaf, response.chunk_index % 256) + assert (get_custody_chunk_bit(challenge.responder_key, response.chunk) + != get_bitfield_bit(challenge.chunk_bits_leaf, response.chunk_index % 256)) # Clear the challenge records = state.custody_bit_challenge_records records[records.index(challenge)] = CustodyBitChallengeRecord() @@ -659,20 +662,25 @@ def process_bit_challenge_response(state: BeaconState, ### Handling of custody-related deadlines - Run `process_reveal_deadlines(state)` immediately after `process_ejections(state)`: +Run `process_reveal_deadlines(state)` immediately after `process_registry_updates(state)`: - ```python +```python +# begin insert @process_reveal_deadlines + process_reveal_deadlines(state) +# end insert @process_reveal_deadlines def process_reveal_deadlines(state: BeaconState) -> None: for index, validator in enumerate(state.validator_registry): - if (validator.latest_custody_reveal_period + - (CUSTODY_RESPONSE_DEADLINE // EPOCHS_PER_CUSTODY_PERIOD) < - get_validators_custody_reveal_period(state, index)): - slash_validator(state, index) + deadline = validator.next_custody_reveal_period + (CUSTODY_RESPONSE_DEADLINE // EPOCHS_PER_CUSTODY_PERIOD) + if get_validators_custody_reveal_period(state, index) > deadline: + slash_validator(state, index) ``` Run `process_challenge_deadlines(state)` immediately after `process_reveal_deadlines(state)`: ```python +# begin insert @process_challenge_deadlines + process_challenge_deadlines(state) +# end insert @process_challenge_deadlines def process_challenge_deadlines(state: BeaconState) -> None: for challenge in state.custody_chunk_challenge_records: if get_current_epoch(state) > challenge.inclusion_epoch + CUSTODY_RESPONSE_DEADLINE: @@ -690,10 +698,15 @@ def process_challenge_deadlines(state: BeaconState) -> None: Append this to `process_final_updates(state)`: ```python +# begin insert @after_process_final_updates + after_process_final_updates(state) +# end insert @after_process_final_updates +def after_process_final_updates(state: BeaconState) -> None: + current_epoch = get_current_epoch(state) # Clean up exposed RANDAO key reveals state.exposed_derived_secrets[current_epoch % EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS] = [] # Reset withdrawable epochs if challenge records are empty - records = state.custody_chunk_challenge_records + state.bit_challenge_records + records = state.custody_chunk_challenge_records + state.custody_bit_challenge_records validator_indices_in_records = set( [record.challenger_index for record in records] + [record.responder_index for record in records] ) diff --git a/specs/core/1_shard-data-chains.md b/specs/core/1_shard-data-chains.md index 1d1186247..21e08e7c9 100644 --- a/specs/core/1_shard-data-chains.md +++ b/specs/core/1_shard-data-chains.md @@ -15,9 +15,9 @@ - [Signature domains](#signature-domains) - [Data structures](#data-structures) - [`ShardBlockBody`](#shardblockbody) + - [`ShardAttestation`](#shardattestation) - [`ShardBlock`](#shardblock) - [`ShardBlockHeader`](#shardblockheader) - - [`ShardAttestation`](#shardattestation) - [Helper functions](#helper-functions) - [`get_period_committee`](#get_period_committee) - [`get_switchover_epoch`](#get_switchover_epoch) @@ -46,8 +46,9 @@ This document describes the shard data layer and the shard fork choice rule in P | - | - | | `BYTES_PER_SHARD_BLOCK_BODY` | `2**14` (= 16,384) | | `MAX_SHARD_ATTESTIONS` | `2**4` (= 16) | -| `PHASE_1_GENESIS_EPOCH` | **TBD** | -| `PHASE_1_GENESIS_SLOT` | get_epoch_start_slot(PHASE_1_GENESIS_EPOCH) | +| `PHASE_1_FORK_EPOCH` | **TBD** | +| `PHASE_1_FORK_SLOT` | **TBD** | +| `GENESIS_SHARD_SLOT` | 0 | ### Time parameters @@ -55,6 +56,7 @@ This document describes the shard data layer and the shard fork choice rule in P | - | - | :-: | :-: | | `CROSSLINK_LOOKBACK` | `2**0` (= 1) | epochs | 6.2 minutes | | `PERSISTENT_COMMITTEE_PERIOD` | `2**11` (= 2,048) | epochs | ~9 days | +| `SECONDS_PER_SLOT` | `2**1 * 3**1` (= 6) | 6 seconds | ### Signature domains @@ -68,51 +70,48 @@ This document describes the shard data layer and the shard fork choice rule in P ### `ShardBlockBody` ```python -['byte', BYTES_PER_SHARD_BLOCK_BODY] -``` - -### `ShardBlock` - -```python -{ - 'slot': Slot, - 'shard': Shard, - 'beacon_chain_root': Hash, - 'parent_root': Hash, - 'data': ShardBlockBody, - 'state_root': Hash, - 'attestations': [ShardAttestation], - 'signature': BLSSignature, -} -``` - -### `ShardBlockHeader` - -```python -{ - 'slot': Slot, - 'shard': Shard, - 'beacon_chain_root': Hash, - 'parent_root': Hash, - 'body_root': Hash, - 'state_root': Hash, - 'attestations': [ShardAttestation], - 'signature': BLSSignature, -} +class ShardBlockBody(Container): + data: Vector[bytes, BYTES_PER_SHARD_BLOCK_BODY] ``` ### `ShardAttestation` ```python -{ - 'data': { - 'slot': Slot, - 'shard': Shard, - 'shard_block_root': Hash, - }, - 'aggregation_bitfield': Bitfield, - 'aggregate_signature': BLSSignature, -} +class ShardAttestation(Container): + class data(Container): + slot: uint64 + shard: uint64 + shard_block_root: Bytes32 + aggregation_bitfield: bytes + aggregate_signature: Bytes96 +``` + +### `ShardBlock` + +```python +class ShardBlock(Container): + slot: uint64 + shard: uint64 + beacon_chain_root: Bytes32 + parent_root: Bytes32 + data: ShardBlockBody + state_root: Bytes32 + attestations: List[ShardAttestation] + signature: Bytes96 +``` + +### `ShardBlockHeader` + +```python +class ShardBlockHeader(Container): + slot: uint64 + shard: uint64 + beacon_chain_root: Bytes32 + parent_root: Bytes32 + body_root: Bytes32 + state_root: Bytes32 + attestations: List[ShardAttestation] + signature: Bytes96 ``` ## Helper functions @@ -120,7 +119,11 @@ This document describes the shard data layer and the shard fork choice rule in P ### `get_period_committee` ```python -def get_period_committee(state: BeaconState, epoch: Epoch, shard: Shard, index: int, count: int) -> List[ValidatorIndex]: +def get_period_committee(state: BeaconState, + epoch: Epoch, + shard: Shard, + index: int, + count: int) -> List[ValidatorIndex]: """ Return committee for a period. Used to construct persistent committees. """ @@ -137,7 +140,8 @@ def get_period_committee(state: BeaconState, epoch: Epoch, shard: Shard, index: ```python def get_switchover_epoch(state: BeaconState, epoch: Epoch, index: ValidatorIndex): earlier_start_epoch = epoch - (epoch % PERSISTENT_COMMITTEE_PERIOD) - PERSISTENT_COMMITTEE_PERIOD * 2 - return bytes_to_int(hash(generate_seed(state, earlier_start_epoch) + bytes3(index))[0:8]) % PERSISTENT_COMMITTEE_PERIOD + return (bytes_to_int(hash(generate_seed(state, earlier_start_epoch) + int_to_bytes(index, length=3)[0:8])) + % PERSISTENT_COMMITTEE_PERIOD) ``` ### `get_persistent_committee` @@ -198,14 +202,14 @@ def get_shard_proposer_index(state: BeaconState, ```python def get_shard_header(block: ShardBlock) -> ShardBlockHeader: return ShardBlockHeader( - slot: block.slot, - shard: block.shard, - beacon_chain_root: block.beacon_chain_root, - parent_root: block.parent_root, - body_root: hash_tree_root(block.body), - state_root: block.state_root, - attestations: block.attestations, - signature: block.signature, + slot=block.slot, + shard=block.shard, + beacon_chain_root=block.beacon_chain_root, + parent_root=block.parent_root, + body_root=hash_tree_root(block.body), + state_root=block.state_root, + attestations=block.attestations, + signature=block.signature, ) ``` @@ -219,7 +223,7 @@ def verify_shard_attestation_signature(state: BeaconState, assert verify_bitfield(attestation.aggregation_bitfield, len(persistent_committee)) pubkeys = [] for i, index in enumerate(persistent_committee): - if get_bitfield_bit(attestation.aggregation_bitfield, i) == 0b1 + if get_bitfield_bit(attestation.aggregation_bitfield, i) == 0b1: validator = state.validator_registry[index] assert is_active_validator(validator, get_current_epoch(state)) pubkeys.append(validator.pubkey) @@ -234,7 +238,7 @@ def verify_shard_attestation_signature(state: BeaconState, ### `compute_crosslink_data_root` ```python -def compute_crosslink_data_root(blocks: List[ShardBlock]) -> Hash: +def compute_crosslink_data_root(blocks: List[ShardBlock]) -> Bytes32: def is_power_of_two(value: int) -> bool: return (value > 0) and (value & (value - 1) == 0) @@ -243,15 +247,20 @@ def compute_crosslink_data_root(blocks: List[ShardBlock]) -> Hash: values += [b'\x00' * BYTES_PER_SHARD_BLOCK_BODY] return values - def merkle_root_of_bytes(data: bytes) -> bytes: - return merkle_root([data[i:i + 32] for i in range(0, len(data), 32)]) + def hash_tree_root_of_bytes(data: bytes) -> bytes: + return hash_tree_root([data[i:i + 32] for i in range(0, len(data), 32)]) + + def zpad(data: bytes, length: int) -> bytes: + return data + b'\x00' * (length - len(data)) return hash( - merkle_root(pad_to_power_of_2([ - merkle_root_of_bytes(zpad(serialize(get_shard_header(block)), BYTES_PER_SHARD_BLOCK_BODY)) for block in blocks - ])) + - merkle_root(pad_to_power_of_2([ - merkle_root_of_bytes(block.body) for block in blocks + hash_tree_root(pad_to_power_of_2([ + hash_tree_root_of_bytes( + zpad(serialize(get_shard_header(block)), BYTES_PER_SHARD_BLOCK_BODY) + ) for block in blocks + ])) + + hash_tree_root(pad_to_power_of_2([ + hash_tree_root_of_bytes(block.body) for block in blocks ])) ) ``` @@ -265,23 +274,20 @@ Let: * `beacon_blocks` be the `BeaconBlock` list such that `beacon_blocks[slot]` is the canonical `BeaconBlock` at slot `slot` * `beacon_state` be the canonical `BeaconState` after processing `beacon_blocks[-1]` * `valid_shard_blocks` be the list of valid `ShardBlock`, recursively defined -* `unix_time` be the current unix time * `candidate` be a candidate `ShardBlock` for which validity is to be determined by running `is_valid_shard_block` ```python def is_valid_shard_block(beacon_blocks: List[BeaconBlock], beacon_state: BeaconState, valid_shard_blocks: List[ShardBlock], - unix_time: uint64, - candidate: ShardBlock) -> bool + candidate: ShardBlock) -> bool: # Check if block is already determined valid for _, block in enumerate(valid_shard_blocks): if candidate == block: return True # Check slot number - assert candidate.slot >= PHASE_1_GENESIS_SLOT - assert unix_time >= beacon_state.genesis_time + (block.slot - GENESIS_SLOT) * SECONDS_PER_SLOT + assert candidate.slot >= PHASE_1_FORK_SLOT # Check shard number assert candidate.shard <= SHARD_COUNT @@ -289,20 +295,20 @@ def is_valid_shard_block(beacon_blocks: List[BeaconBlock], # Check beacon block beacon_block = beacon_blocks[candidate.slot] assert candidate.beacon_block_root == signing_root(beacon_block) - assert beacon_block.slot <= candidate.slot: + assert beacon_block.slot <= candidate.slot # Check state root assert candidate.state_root == ZERO_HASH # [to be removed in phase 2] # Check parent block - if candidate.slot == PHASE_1_GENESIS_SLOT: + if candidate.slot == PHASE_1_FORK_SLOT: assert candidate.parent_root == ZERO_HASH else: parent_block = next( - block for block in valid_shard_blocks if - signing_root(block) == candidate.parent_root - , None) - assert parent_block != None + (block for block in valid_shard_blocks if signing_root(block) == candidate.parent_root), + None + ) + assert parent_block is not None assert parent_block.shard == candidate.shard assert parent_block.slot < candidate.slot assert signing_root(beacon_blocks[parent_block.slot]) == parent_block.beacon_chain_root @@ -319,10 +325,10 @@ def is_valid_shard_block(beacon_blocks: List[BeaconBlock], proposer_index = get_shard_proposer_index(beacon_state, candidate.shard, candidate.slot) assert proposer_index is not None assert bls_verify( - pubkey=validators[proposer_index].pubkey, + pubkey=beacon_state.validator_registry[proposer_index].pubkey, message_hash=signing_root(block), signature=candidate.signature, - domain=get_domain(beacon_state, slot_to_epoch(candidate.slot), DOMAIN_SHARD_PROPOSER) + domain=get_domain(beacon_state, slot_to_epoch(candidate.slot), DOMAIN_SHARD_PROPOSER), ) return True @@ -342,10 +348,10 @@ def is_valid_shard_attestation(valid_shard_blocks: List[ShardBlock], candidate: ShardAttestation) -> bool: # Check shard block shard_block = next( - block for block in valid_shard_blocks if - signing_root(block) == candidate.data.shard_block_root - , None) - assert shard_block != None + (block for block in valid_shard_blocks if signing_root(block) == candidate.data.shard_block_root), + None, + ) + assert shard_block is not None assert shard_block.slot == candidate.data.slot assert shard_block.shard == candidate.data.shard @@ -377,18 +383,19 @@ def is_valid_beacon_attestation(shard: Shard, return True # Check previous attestation - if candidate.data.previous_crosslink.epoch <= PHASE_1_GENESIS_EPOCH: + if candidate.data.previous_crosslink.epoch <= PHASE_1_FORK_EPOCH: assert candidate.data.previous_crosslink.data_root == ZERO_HASH else: previous_attestation = next( - attestation for attestation in valid_attestations if - attestation.data.crosslink.data_root == candidate.data.previous_crosslink.data_root - , None) - assert previous_attestation != None + (attestation for attestation in valid_attestations if + attestation.data.crosslink.data_root == candidate.data.previous_crosslink.data_root), + None, + ) + assert previous_attestation is not None assert candidate.data.previous_attestation.epoch < slot_to_epoch(candidate.data.slot) # Check crosslink data root - start_epoch = state.latest_crosslinks[shard].epoch + start_epoch = beacon_state.latest_crosslinks[shard].epoch end_epoch = min(slot_to_epoch(candidate.data.slot) - CROSSLINK_LOOKBACK, start_epoch + MAX_EPOCHS_PER_CROSSLINK) blocks = [] for slot in range(start_epoch * SLOTS_PER_EPOCH, end_epoch * SLOTS_PER_EPOCH): diff --git a/specs/simple-serialize.md b/specs/simple-serialize.md index 1cd2750a7..2adff2388 100644 --- a/specs/simple-serialize.md +++ b/specs/simple-serialize.md @@ -68,6 +68,10 @@ For convenience we alias: The default value of a type upon initialization is recursively defined using `0` for `"uintN"`, `False` for `"bool"`, and `[]` for lists. Unions default to the first type in the union (with type index zero), which is `"null"` if present in the union. +#### `is_empty` + +An SSZ object is called empty (and thus `is_empty(object)` returns true) if it is equal to the default value for that type. + ### Illegal types Empty vector types (i.e. `[subtype, 0]` for some `subtype`) are not legal. The `"null"` type is only legal as the first type in a union subtype (i.e., with type index zero). diff --git a/test_generators/epoch_processing/main.py b/test_generators/epoch_processing/main.py index 8f067e4a3..2ce895fc5 100644 --- a/test_generators/epoch_processing/main.py +++ b/test_generators/epoch_processing/main.py @@ -1,6 +1,7 @@ from typing import Callable, Iterable -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 from eth2spec.test.epoch_processing import ( test_process_crosslinks, test_process_registry_updates @@ -14,7 +15,8 @@ def create_suite(transition_name: str, config_name: str, get_cases: Callable[[], -> Callable[[str], gen_typing.TestSuiteOutput]: def suite_definition(configs_path: str) -> gen_typing.TestSuiteOutput: presets = loader.load_presets(configs_path, config_name) - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) return ("%s_%s" % (transition_name, config_name), transition_name, gen_suite.render_suite( title="%s epoch processing" % transition_name, diff --git a/test_generators/operations/main.py b/test_generators/operations/main.py index 0a487ae74..82e05b307 100644 --- a/test_generators/operations/main.py +++ b/test_generators/operations/main.py @@ -13,14 +13,16 @@ from eth2spec.test.block_processing import ( from gen_base import gen_runner, gen_suite, gen_typing from gen_from_tests.gen import generate_from_tests from preset_loader import loader -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 def create_suite(operation_name: str, config_name: str, get_cases: Callable[[], Iterable[gen_typing.TestCase]]) \ -> Callable[[str], gen_typing.TestSuiteOutput]: def suite_definition(configs_path: str) -> gen_typing.TestSuiteOutput: presets = loader.load_presets(configs_path, config_name) - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) return ("%s_%s" % (operation_name, config_name), operation_name, gen_suite.render_suite( title="%s operation" % operation_name, diff --git a/test_generators/sanity/main.py b/test_generators/sanity/main.py index bba6ed03d..a9c0fe160 100644 --- a/test_generators/sanity/main.py +++ b/test_generators/sanity/main.py @@ -5,14 +5,16 @@ from eth2spec.test.sanity import test_blocks, test_slots from gen_base import gen_runner, gen_suite, gen_typing from gen_from_tests.gen import generate_from_tests from preset_loader import loader -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 def create_suite(handler_name: str, config_name: str, get_cases: Callable[[], Iterable[gen_typing.TestCase]]) \ -> Callable[[str], gen_typing.TestSuiteOutput]: def suite_definition(configs_path: str) -> gen_typing.TestSuiteOutput: presets = loader.load_presets(configs_path, config_name) - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) return ("%sanity_s_%s" % (handler_name, config_name), handler_name, gen_suite.render_suite( title="sanity testing", diff --git a/test_generators/shuffling/main.py b/test_generators/shuffling/main.py index 711597189..862c4d910 100644 --- a/test_generators/shuffling/main.py +++ b/test_generators/shuffling/main.py @@ -1,4 +1,5 @@ -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 from eth_utils import ( to_dict, to_tuple ) @@ -22,7 +23,8 @@ def shuffling_test_cases(): def mini_shuffling_suite(configs_path: str) -> gen_typing.TestSuiteOutput: presets = loader.load_presets(configs_path, 'minimal') - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) return ("shuffling_minimal", "core", gen_suite.render_suite( title="Swap-or-Not Shuffling tests with minimal config", @@ -37,7 +39,8 @@ def mini_shuffling_suite(configs_path: str) -> gen_typing.TestSuiteOutput: def full_shuffling_suite(configs_path: str) -> gen_typing.TestSuiteOutput: presets = loader.load_presets(configs_path, 'mainnet') - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) return ("shuffling_full", "core", gen_suite.render_suite( title="Swap-or-Not Shuffling tests with mainnet config", diff --git a/test_libs/pyspec/eth2spec/test/block_processing/__init__.py b/test_libs/pyspec/__init__.py similarity index 100% rename from test_libs/pyspec/eth2spec/test/block_processing/__init__.py rename to test_libs/pyspec/__init__.py diff --git a/test_libs/pyspec/eth2spec/test/epoch_processing/__init__.py b/test_libs/pyspec/eth2spec/phase1/__init__.py similarity index 100% rename from test_libs/pyspec/eth2spec/test/epoch_processing/__init__.py rename to test_libs/pyspec/eth2spec/phase1/__init__.py diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_attestation.py b/test_libs/pyspec/eth2spec/test/block_processing/test_process_attestation.py deleted file mode 100644 index 700d68b53..000000000 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_attestation.py +++ /dev/null @@ -1,301 +0,0 @@ -from copy import deepcopy - -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_current_epoch, - process_attestation, - process_slots, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls -from eth2spec.test.helpers.attestations import ( - get_valid_attestation, - sign_attestation, -) -from eth2spec.test.helpers.state import ( - next_epoch, - next_slot, -) -from eth2spec.test.helpers.block import apply_empty_block - - -def run_attestation_processing(state, attestation, valid=True): - """ - Run ``process_attestation``, yielding: - - pre-state ('pre') - - attestation ('attestation') - - post-state ('post'). - If ``valid == False``, run expecting ``AssertionError`` - """ - # yield pre-state - yield 'pre', state - - yield 'attestation', attestation - - # If the attestation is invalid, processing is aborted, and there is no post-state. - if not valid: - expect_assertion_error(lambda: process_attestation(state, attestation)) - yield 'post', None - return - - current_epoch_count = len(state.current_epoch_attestations) - previous_epoch_count = len(state.previous_epoch_attestations) - - # process attestation - process_attestation(state, attestation) - - # Make sure the attestation has been processed - if attestation.data.target_epoch == get_current_epoch(state): - assert len(state.current_epoch_attestations) == current_epoch_count + 1 - else: - assert len(state.previous_epoch_attestations) == previous_epoch_count + 1 - - # yield post-state - yield 'post', state - - -@spec_state_test -def test_success(state): - attestation = get_valid_attestation(state, signed=True) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - yield from run_attestation_processing(state, attestation) - - -@spec_state_test -def test_success_previous_epoch(state): - attestation = get_valid_attestation(state, signed=True) - next_epoch(state) - apply_empty_block(state) - - yield from run_attestation_processing(state, attestation) - - -@spec_state_test -def test_success_since_max_epochs_per_crosslink(state): - for _ in range(spec.MAX_EPOCHS_PER_CROSSLINK + 2): - next_epoch(state) - apply_empty_block(state) - - attestation = get_valid_attestation(state, signed=True) - data = attestation.data - # test logic sanity check: make sure the attestation only includes MAX_EPOCHS_PER_CROSSLINK epochs - assert data.crosslink.end_epoch - data.crosslink.start_epoch == spec.MAX_EPOCHS_PER_CROSSLINK - - for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): - next_slot(state) - apply_empty_block(state) - - yield from run_attestation_processing(state, attestation) - - -@always_bls -@spec_state_test -def test_invalid_attestation_signature(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_before_inclusion_delay(state): - attestation = get_valid_attestation(state, signed=True) - # do not increment slot to allow for inclusion delay - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_after_epoch_slots(state): - attestation = get_valid_attestation(state, signed=True) - # increment past latest inclusion slot - process_slots(state, state.slot + spec.SLOTS_PER_EPOCH + 1) - apply_empty_block(state) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_old_source_epoch(state): - state.slot = spec.SLOTS_PER_EPOCH * 5 - state.finalized_epoch = 2 - state.previous_justified_epoch = 3 - state.current_justified_epoch = 4 - attestation = get_valid_attestation(state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1) - - # test logic sanity check: make sure the attestation is pointing to oldest known source epoch - assert attestation.data.source_epoch == state.previous_justified_epoch - - # Now go beyond that, it will be invalid - attestation.data.source_epoch -= 1 - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_wrong_shard(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.data.crosslink.shard += 1 - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_new_source_epoch(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.data.source_epoch += 1 - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_source_root_is_target_root(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.data.source_root = attestation.data.target_root - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_invalid_current_source_root(state): - state.slot = spec.SLOTS_PER_EPOCH * 5 - state.finalized_epoch = 2 - - state.previous_justified_epoch = 3 - state.previous_justified_root = b'\x01' * 32 - - state.current_justified_epoch = 4 - state.current_justified_root = b'\xff' * 32 - - attestation = get_valid_attestation(state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - # Test logic sanity checks: - assert state.current_justified_root != state.previous_justified_root - assert attestation.data.source_root == state.previous_justified_root - - # Make attestation source root invalid: should be previous justified, not current one - attestation.data.source_root = state.current_justified_root - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_bad_source_root(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.data.source_root = b'\x42' * 32 - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_non_zero_crosslink_data_root(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.data.crosslink.data_root = b'\x42' * 32 - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_bad_parent_crosslink(state): - next_epoch(state) - apply_empty_block(state) - - attestation = get_valid_attestation(state, signed=True) - for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): - next_slot(state) - apply_empty_block(state) - - attestation.data.crosslink.parent_root = b'\x27' * 32 - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_bad_crosslink_start_epoch(state): - next_epoch(state) - apply_empty_block(state) - - attestation = get_valid_attestation(state, signed=True) - for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): - next_slot(state) - apply_empty_block(state) - - attestation.data.crosslink.start_epoch += 1 - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_bad_crosslink_end_epoch(state): - next_epoch(state) - apply_empty_block(state) - - attestation = get_valid_attestation(state, signed=True) - for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): - next_slot(state) - apply_empty_block(state) - - attestation.data.crosslink.end_epoch += 1 - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_inconsistent_bitfields(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.custody_bitfield = deepcopy(attestation.aggregation_bitfield) + b'\x00' - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_non_empty_custody_bitfield(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.custody_bitfield = deepcopy(attestation.aggregation_bitfield) - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation, False) - - -@spec_state_test -def test_empty_aggregation_bitfield(state): - attestation = get_valid_attestation(state) - state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY - - attestation.aggregation_bitfield = b'\x00' * len(attestation.aggregation_bitfield) - - sign_attestation(state, attestation) - - yield from run_attestation_processing(state, attestation) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_attester_slashing.py b/test_libs/pyspec/eth2spec/test/block_processing/test_process_attester_slashing.py deleted file mode 100644 index 28e232277..000000000 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_attester_slashing.py +++ /dev/null @@ -1,149 +0,0 @@ -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_beacon_proposer_index, - process_attester_slashing, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls -from eth2spec.test.helpers.attestations import sign_indexed_attestation -from eth2spec.test.helpers.attester_slashings import get_valid_attester_slashing -from eth2spec.test.helpers.block import apply_empty_block -from eth2spec.test.helpers.state import ( - get_balance, - next_epoch, -) - - -def run_attester_slashing_processing(state, attester_slashing, valid=True): - """ - Run ``process_attester_slashing``, yielding: - - pre-state ('pre') - - attester_slashing ('attester_slashing') - - post-state ('post'). - If ``valid == False``, run expecting ``AssertionError`` - """ - - yield 'pre', state - yield 'attester_slashing', attester_slashing - - if not valid: - expect_assertion_error(lambda: process_attester_slashing(state, attester_slashing)) - yield 'post', None - return - - slashed_index = attester_slashing.attestation_1.custody_bit_0_indices[0] - pre_slashed_balance = get_balance(state, slashed_index) - - proposer_index = get_beacon_proposer_index(state) - pre_proposer_balance = get_balance(state, proposer_index) - - # Process slashing - process_attester_slashing(state, attester_slashing) - - slashed_validator = state.validator_registry[slashed_index] - - # Check slashing - assert slashed_validator.slashed - assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH - assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH - - if slashed_index != proposer_index: - # lost whistleblower reward - assert get_balance(state, slashed_index) < pre_slashed_balance - # gained whistleblower reward - assert get_balance(state, proposer_index) > pre_proposer_balance - else: - # gained rewards for all slashings, which may include others. And only lost that of themselves. - # Netto at least 0, if more people where slashed, a balance increase. - assert get_balance(state, slashed_index) >= pre_slashed_balance - - yield 'post', state - - -@spec_state_test -def test_success_double(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=True) - - yield from run_attester_slashing_processing(state, attester_slashing) - - -@spec_state_test -def test_success_surround(state): - next_epoch(state) - apply_empty_block(state) - - state.current_justified_epoch += 1 - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True) - - # set attestion1 to surround attestation 2 - attester_slashing.attestation_1.data.source_epoch = attester_slashing.attestation_2.data.source_epoch - 1 - attester_slashing.attestation_1.data.target_epoch = attester_slashing.attestation_2.data.target_epoch + 1 - - sign_indexed_attestation(state, attester_slashing.attestation_1) - - yield from run_attester_slashing_processing(state, attester_slashing) - - -@always_bls -@spec_state_test -def test_invalid_sig_1(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True) - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@always_bls -@spec_state_test -def test_invalid_sig_2(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=False) - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@always_bls -@spec_state_test -def test_invalid_sig_1_and_2(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=False) - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@spec_state_test -def test_same_data(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True) - - attester_slashing.attestation_1.data = attester_slashing.attestation_2.data - sign_indexed_attestation(state, attester_slashing.attestation_1) - - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@spec_state_test -def test_no_double_or_surround(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True) - - attester_slashing.attestation_1.data.target_epoch += 1 - sign_indexed_attestation(state, attester_slashing.attestation_1) - - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@spec_state_test -def test_participants_already_slashed(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=True) - - # set all indices to slashed - attestation_1 = attester_slashing.attestation_1 - validator_indices = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices - for index in validator_indices: - state.validator_registry[index].slashed = True - - yield from run_attester_slashing_processing(state, attester_slashing, False) - - -@spec_state_test -def test_custody_bit_0_and_1(state): - attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True) - - attester_slashing.attestation_1.custody_bit_1_indices = ( - attester_slashing.attestation_1.custody_bit_0_indices - ) - sign_indexed_attestation(state, attester_slashing.attestation_1) - - yield from run_attester_slashing_processing(state, attester_slashing, False) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_block_header.py b/test_libs/pyspec/eth2spec/test/block_processing/test_process_block_header.py deleted file mode 100644 index 8a67be741..000000000 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_block_header.py +++ /dev/null @@ -1,85 +0,0 @@ -from copy import deepcopy - -from eth2spec.phase0.spec import ( - get_beacon_proposer_index, - process_slots, - process_block_header, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls -from eth2spec.test.helpers.block import ( - build_empty_block_for_next_slot, - sign_block -) -from eth2spec.test.helpers.state import next_slot - - -def prepare_state_for_header_processing(state): - process_slots(state, state.slot + 1) - - -def run_block_header_processing(state, block, valid=True): - """ - Run ``process_block_header``, yielding: - - pre-state ('pre') - - block ('block') - - post-state ('post'). - If ``valid == False``, run expecting ``AssertionError`` - """ - prepare_state_for_header_processing(state) - - yield 'pre', state - yield 'block', block - - if not valid: - expect_assertion_error(lambda: process_block_header(state, block)) - yield 'post', None - return - - process_block_header(state, block) - yield 'post', state - - -@spec_state_test -def test_success_block_header(state): - block = build_empty_block_for_next_slot(state, signed=True) - yield from run_block_header_processing(state, block) - - -@always_bls -@spec_state_test -def test_invalid_sig_block_header(state): - block = build_empty_block_for_next_slot(state) - yield from run_block_header_processing(state, block, valid=False) - - -@spec_state_test -def test_invalid_slot_block_header(state): - block = build_empty_block_for_next_slot(state) - block.slot = state.slot + 2 # invalid slot - sign_block(state, block) - - yield from run_block_header_processing(state, block, valid=False) - - -@spec_state_test -def test_invalid_parent_root(state): - block = build_empty_block_for_next_slot(state) - block.parent_root = b'\12' * 32 # invalid prev root - sign_block(state, block) - - yield from run_block_header_processing(state, block, valid=False) - - -@spec_state_test -def test_proposer_slashed(state): - # use stub state to get proposer index of next slot - stub_state = deepcopy(state) - next_slot(stub_state) - proposer_index = get_beacon_proposer_index(stub_state) - - # set proposer to slashed - state.validator_registry[proposer_index].slashed = True - - block = build_empty_block_for_next_slot(state, signed=True) - - yield from run_block_header_processing(state, block, valid=False) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_proposer_slashing.py b/test_libs/pyspec/eth2spec/test/block_processing/test_process_proposer_slashing.py deleted file mode 100644 index 07ccc25f1..000000000 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_proposer_slashing.py +++ /dev/null @@ -1,137 +0,0 @@ -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_current_epoch, - process_proposer_slashing, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls -from eth2spec.test.helpers.block_header import sign_block_header -from eth2spec.test.helpers.keys import privkeys -from eth2spec.test.helpers.proposer_slashings import get_valid_proposer_slashing -from eth2spec.test.helpers.state import get_balance - - -def run_proposer_slashing_processing(state, proposer_slashing, valid=True): - """ - Run ``process_proposer_slashing``, yielding: - - pre-state ('pre') - - proposer_slashing ('proposer_slashing') - - post-state ('post'). - If ``valid == False``, run expecting ``AssertionError`` - """ - - yield 'pre', state - yield 'proposer_slashing', proposer_slashing - - if not valid: - expect_assertion_error(lambda: process_proposer_slashing(state, proposer_slashing)) - yield 'post', None - return - - pre_proposer_balance = get_balance(state, proposer_slashing.proposer_index) - - process_proposer_slashing(state, proposer_slashing) - yield 'post', state - - # check if slashed - slashed_validator = state.validator_registry[proposer_slashing.proposer_index] - assert slashed_validator.slashed - assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH - assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH - - # lost whistleblower reward - assert ( - get_balance(state, proposer_slashing.proposer_index) < - pre_proposer_balance - ) - - -@spec_state_test -def test_success(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) - - yield from run_proposer_slashing_processing(state, proposer_slashing) - - -@always_bls -@spec_state_test -def test_invalid_sig_1(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=False, signed_2=True) - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@always_bls -@spec_state_test -def test_invalid_sig_2(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=False) - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@always_bls -@spec_state_test -def test_invalid_sig_1_and_2(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=False, signed_2=False) - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_invalid_proposer_index(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) - # Index just too high (by 1) - proposer_slashing.proposer_index = len(state.validator_registry) - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_epochs_are_different(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=False) - - # set slots to be in different epochs - proposer_slashing.header_2.slot += spec.SLOTS_PER_EPOCH - sign_block_header(state, proposer_slashing.header_2, privkeys[proposer_slashing.proposer_index]) - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_headers_are_same(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=False) - - # set headers to be the same - proposer_slashing.header_2 = proposer_slashing.header_1 - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_proposer_is_not_activated(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) - - # set proposer to be not active yet - state.validator_registry[proposer_slashing.proposer_index].activation_epoch = get_current_epoch(state) + 1 - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_proposer_is_slashed(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) - - # set proposer to slashed - state.validator_registry[proposer_slashing.proposer_index].slashed = True - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) - - -@spec_state_test -def test_proposer_is_withdrawn(state): - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) - - # move 1 epoch into future, to allow for past withdrawable epoch - state.slot += spec.SLOTS_PER_EPOCH - # set proposer withdrawable_epoch in past - current_epoch = get_current_epoch(state) - proposer_index = proposer_slashing.proposer_index - state.validator_registry[proposer_index].withdrawable_epoch = current_epoch - 1 - - yield from run_proposer_slashing_processing(state, proposer_slashing, False) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_transfer.py b/test_libs/pyspec/eth2spec/test/block_processing/test_process_transfer.py deleted file mode 100644 index bd435d67a..000000000 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_transfer.py +++ /dev/null @@ -1,178 +0,0 @@ -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_active_validator_indices, - get_beacon_proposer_index, - get_current_epoch, - process_transfer, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls -from eth2spec.test.helpers.state import next_epoch -from eth2spec.test.helpers.block import apply_empty_block -from eth2spec.test.helpers.transfers import get_valid_transfer - - -def run_transfer_processing(state, transfer, valid=True): - """ - Run ``process_transfer``, yielding: - - pre-state ('pre') - - transfer ('transfer') - - post-state ('post'). - If ``valid == False``, run expecting ``AssertionError`` - """ - - proposer_index = get_beacon_proposer_index(state) - pre_transfer_sender_balance = state.balances[transfer.sender] - pre_transfer_recipient_balance = state.balances[transfer.recipient] - pre_transfer_proposer_balance = state.balances[proposer_index] - - yield 'pre', state - yield 'transfer', transfer - - if not valid: - expect_assertion_error(lambda: process_transfer(state, transfer)) - yield 'post', None - return - - process_transfer(state, transfer) - yield 'post', state - - sender_balance = state.balances[transfer.sender] - recipient_balance = state.balances[transfer.recipient] - assert sender_balance == pre_transfer_sender_balance - transfer.amount - transfer.fee - assert recipient_balance == pre_transfer_recipient_balance + transfer.amount - assert state.balances[proposer_index] == pre_transfer_proposer_balance + transfer.fee - - -@spec_state_test -def test_success_non_activated(state): - transfer = get_valid_transfer(state, signed=True) - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer) - - -@spec_state_test -def test_success_withdrawable(state): - next_epoch(state) - apply_empty_block(state) - - transfer = get_valid_transfer(state, signed=True) - - # withdrawable_epoch in past so can transfer - state.validator_registry[transfer.sender].withdrawable_epoch = get_current_epoch(state) - 1 - - yield from run_transfer_processing(state, transfer) - - -@spec_state_test -def test_success_active_above_max_effective(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 - transfer = get_valid_transfer(state, sender_index=sender_index, amount=1, fee=0, signed=True) - - yield from run_transfer_processing(state, transfer) - - -@spec_state_test -def test_success_active_above_max_effective_fee(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 - transfer = get_valid_transfer(state, sender_index=sender_index, amount=0, fee=1, signed=True) - - yield from run_transfer_processing(state, transfer) - - -@always_bls -@spec_state_test -def test_invalid_signature(state): - transfer = get_valid_transfer(state) - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_active_but_transfer_past_effective_balance(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - amount = spec.MAX_EFFECTIVE_BALANCE // 32 - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE - transfer = get_valid_transfer(state, sender_index=sender_index, amount=amount, fee=0, signed=True) - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_incorrect_slot(state): - transfer = get_valid_transfer(state, slot=state.slot + 1, signed=True) - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_insufficient_balance_for_fee(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE - transfer = get_valid_transfer(state, sender_index=sender_index, amount=0, fee=1, signed=True) - - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_insufficient_balance(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE - transfer = get_valid_transfer(state, sender_index=sender_index, amount=1, fee=0, signed=True) - - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_no_dust_sender(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - balance = state.balances[sender_index] - transfer = get_valid_transfer( - state, - sender_index=sender_index, - amount=balance - spec.MIN_DEPOSIT_AMOUNT + 1, - fee=0, - signed=True, - ) - - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_no_dust_recipient(state): - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] - state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 - transfer = get_valid_transfer(state, sender_index=sender_index, amount=1, fee=0, signed=True) - state.balances[transfer.recipient] = 0 - - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) - - -@spec_state_test -def test_invalid_pubkey(state): - transfer = get_valid_transfer(state, signed=True) - state.validator_registry[transfer.sender].withdrawal_credentials = spec.ZERO_HASH - - # un-activate so validator can transfer - state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH - - yield from run_transfer_processing(state, transfer, False) diff --git a/test_libs/pyspec/eth2spec/test/conftest.py b/test_libs/pyspec/eth2spec/test/conftest.py index 5e8ec708a..5713c3470 100644 --- a/test_libs/pyspec/eth2spec/test/conftest.py +++ b/test_libs/pyspec/eth2spec/test/conftest.py @@ -1,4 +1,5 @@ -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 # We import pytest only when it's present, i.e. when we are running tests. # The test-cases themselves can be generated without installing pytest. @@ -34,4 +35,5 @@ def config(request): config_name = request.config.getoption("--config") from preset_loader import loader presets = loader.load_presets('../../configs/', config_name) - spec.apply_constants_preset(presets) + spec_phase0.apply_constants_preset(presets) + spec_phase1.apply_constants_preset(presets) diff --git a/test_libs/pyspec/eth2spec/test/context.py b/test_libs/pyspec/eth2spec/test/context.py index 2be9322de..cbc594cd8 100644 --- a/test_libs/pyspec/eth2spec/test/context.py +++ b/test_libs/pyspec/eth2spec/test/context.py @@ -1,12 +1,20 @@ -from eth2spec.phase0 import spec +from eth2spec.phase0 import spec as spec_phase0 +from eth2spec.phase1 import spec as spec_phase1 from eth2spec.utils import bls from .helpers.genesis import create_genesis_state -from .utils import spectest, with_args, with_tags +from .utils import spectest, with_tags -# Provides a genesis state as first argument to the function decorated with this -with_state = with_args(lambda: [create_genesis_state(spec.SLOTS_PER_EPOCH * 8)]) + +def with_state(fn): + def entry(*args, **kw): + try: + kw['state'] = create_genesis_state(spec=kw['spec'], num_validators=spec_phase0.SLOTS_PER_EPOCH * 8) + except KeyError: + raise TypeError('Spec decorator must come before state decorator to inject spec into state.') + return fn(*args, **kw) + return entry # BLS is turned off by default *for performance purposes during TESTING*. @@ -80,3 +88,40 @@ def bls_switch(fn): bls.bls_active = old_state return out return entry + + +all_phases = ['phase0', 'phase1'] + + +def with_all_phases(fn): + """ + A decorator for running a test wil every phase + """ + return with_phases(all_phases)(fn) + + +def with_all_phases_except(exclusion_phases): + """ + A decorator factory for running a tests with every phase except the ones listed + """ + def decorator(fn): + return with_phases([phase for phase in all_phases if phase not in exclusion_phases])(fn) + return decorator + + +def with_phases(phases): + """ + Decorator factory that returns a decorator that runs a test for the appropriate phases + """ + def decorator(fn): + def run_with_spec_version(spec, *args, **kw): + kw['spec'] = spec + fn(*args, **kw) + + def wrapper(*args, **kw): + if 'phase0' in phases: + run_with_spec_version(spec_phase0, *args, **kw) + if 'phase1' in phases: + run_with_spec_version(spec_phase1, *args, **kw) + return wrapper + return decorator diff --git a/test_libs/pyspec/eth2spec/test/helpers/attestations.py b/test_libs/pyspec/eth2spec/test/helpers/attestations.py index 45ee10c3e..4c8b5c7eb 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/attestations.py +++ b/test_libs/pyspec/eth2spec/test/helpers/attestations.py @@ -1,17 +1,5 @@ from typing import List -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - Attestation, - AttestationData, - AttestationDataAndCustodyBit, - Crosslink, - get_epoch_start_slot, get_block_root, get_current_epoch, get_previous_epoch, slot_to_epoch, - get_crosslink_committee, get_domain, IndexedAttestation, get_attesting_indices, BeaconState, get_block_root_at_slot, - get_epoch_start_shard, get_epoch_committee_count, - state_transition, process_slots, -) from eth2spec.test.helpers.bitfields import set_bitfield_bit from eth2spec.test.helpers.block import build_empty_block_for_next_slot, sign_block from eth2spec.test.helpers.keys import privkeys @@ -19,21 +7,21 @@ from eth2spec.utils.bls import bls_sign, bls_aggregate_signatures from eth2spec.utils.ssz.ssz_impl import hash_tree_root -def build_attestation_data(state, slot, shard): +def build_attestation_data(spec, state, slot, shard): assert state.slot >= slot if slot == state.slot: - block_root = build_empty_block_for_next_slot(state).parent_root + block_root = build_empty_block_for_next_slot(spec, state).parent_root else: - block_root = get_block_root_at_slot(state, slot) + block_root = spec.get_block_root_at_slot(state, slot) - current_epoch_start_slot = get_epoch_start_slot(get_current_epoch(state)) + current_epoch_start_slot = spec.get_epoch_start_slot(spec.get_current_epoch(state)) if slot < current_epoch_start_slot: - epoch_boundary_root = get_block_root(state, get_previous_epoch(state)) + epoch_boundary_root = spec.get_block_root(state, spec.get_previous_epoch(state)) elif slot == current_epoch_start_slot: epoch_boundary_root = block_root else: - epoch_boundary_root = get_block_root(state, get_current_epoch(state)) + epoch_boundary_root = spec.get_block_root(state, spec.get_current_epoch(state)) if slot < current_epoch_start_slot: justified_epoch = state.previous_justified_epoch @@ -42,39 +30,39 @@ def build_attestation_data(state, slot, shard): justified_epoch = state.current_justified_epoch justified_block_root = state.current_justified_root - if slot_to_epoch(slot) == get_current_epoch(state): + if spec.slot_to_epoch(slot) == spec.get_current_epoch(state): parent_crosslink = state.current_crosslinks[shard] else: parent_crosslink = state.previous_crosslinks[shard] - return AttestationData( + return spec.AttestationData( beacon_block_root=block_root, source_epoch=justified_epoch, source_root=justified_block_root, - target_epoch=slot_to_epoch(slot), + target_epoch=spec.slot_to_epoch(slot), target_root=epoch_boundary_root, - crosslink=Crosslink( + crosslink=spec.Crosslink( shard=shard, start_epoch=parent_crosslink.end_epoch, - end_epoch=min(slot_to_epoch(slot), parent_crosslink.end_epoch + spec.MAX_EPOCHS_PER_CROSSLINK), + end_epoch=min(spec.slot_to_epoch(slot), parent_crosslink.end_epoch + spec.MAX_EPOCHS_PER_CROSSLINK), data_root=spec.ZERO_HASH, parent_root=hash_tree_root(parent_crosslink), ), ) -def get_valid_attestation(state, slot=None, signed=False): +def get_valid_attestation(spec, state, slot=None, signed=False): if slot is None: slot = state.slot - epoch = slot_to_epoch(slot) - epoch_start_shard = get_epoch_start_shard(state, epoch) - committees_per_slot = get_epoch_committee_count(state, epoch) // spec.SLOTS_PER_EPOCH + epoch = spec.slot_to_epoch(slot) + epoch_start_shard = spec.get_epoch_start_shard(state, epoch) + committees_per_slot = spec.get_epoch_committee_count(state, epoch) // spec.SLOTS_PER_EPOCH shard = (epoch_start_shard + committees_per_slot * (slot % spec.SLOTS_PER_EPOCH)) % spec.SHARD_COUNT - attestation_data = build_attestation_data(state, slot, shard) + attestation_data = build_attestation_data(spec, state, slot, shard) - crosslink_committee = get_crosslink_committee( + crosslink_committee = spec.get_crosslink_committee( state, attestation_data.target_epoch, attestation_data.crosslink.shard @@ -84,25 +72,26 @@ def get_valid_attestation(state, slot=None, signed=False): bitfield_length = (committee_size + 7) // 8 aggregation_bitfield = b'\x00' * bitfield_length custody_bitfield = b'\x00' * bitfield_length - attestation = Attestation( + attestation = spec.Attestation( aggregation_bitfield=aggregation_bitfield, data=attestation_data, custody_bitfield=custody_bitfield, ) - fill_aggregate_attestation(state, attestation) + fill_aggregate_attestation(spec, state, attestation) if signed: - sign_attestation(state, attestation) + sign_attestation(spec, state, attestation) return attestation -def sign_aggregate_attestation(state: BeaconState, data: AttestationData, participants: List[int]): +def sign_aggregate_attestation(spec, state, attestation_data, participants: List[int]): signatures = [] for validator_index in participants: privkey = privkeys[validator_index] signatures.append( get_attestation_signature( + spec, state, - data, + attestation_data, privkey ) ) @@ -110,23 +99,23 @@ def sign_aggregate_attestation(state: BeaconState, data: AttestationData, partic return bls_aggregate_signatures(signatures) -def sign_indexed_attestation(state, indexed_attestation: IndexedAttestation): +def sign_indexed_attestation(spec, state, indexed_attestation): participants = indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices - indexed_attestation.signature = sign_aggregate_attestation(state, indexed_attestation.data, participants) + indexed_attestation.signature = sign_aggregate_attestation(spec, state, indexed_attestation.data, participants) -def sign_attestation(state, attestation: Attestation): - participants = get_attesting_indices( +def sign_attestation(spec, state, attestation): + participants = spec.get_attesting_indices( state, attestation.data, attestation.aggregation_bitfield, ) - attestation.signature = sign_aggregate_attestation(state, attestation.data, participants) + attestation.signature = sign_aggregate_attestation(spec, state, attestation.data, participants) -def get_attestation_signature(state, attestation_data, privkey, custody_bit=0b0): - message_hash = AttestationDataAndCustodyBit( +def get_attestation_signature(spec, state, attestation_data, privkey, custody_bit=0b0): + message_hash = spec.AttestationDataAndCustodyBit( data=attestation_data, custody_bit=custody_bit, ).hash_tree_root() @@ -134,7 +123,7 @@ def get_attestation_signature(state, attestation_data, privkey, custody_bit=0b0) return bls_sign( message_hash=message_hash, privkey=privkey, - domain=get_domain( + domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_ATTESTATION, message_epoch=attestation_data.target_epoch, @@ -142,8 +131,8 @@ def get_attestation_signature(state, attestation_data, privkey, custody_bit=0b0) ) -def fill_aggregate_attestation(state, attestation): - crosslink_committee = get_crosslink_committee( +def fill_aggregate_attestation(spec, state, attestation): + crosslink_committee = spec.get_crosslink_committee( state, attestation.data.target_epoch, attestation.data.crosslink.shard, @@ -152,10 +141,10 @@ def fill_aggregate_attestation(state, attestation): attestation.aggregation_bitfield = set_bitfield_bit(attestation.aggregation_bitfield, i) -def add_attestation_to_state(state, attestation, slot): - block = build_empty_block_for_next_slot(state) +def add_attestation_to_state(spec, state, attestation, slot): + block = build_empty_block_for_next_slot(spec, state) block.slot = slot block.body.attestations.append(attestation) - process_slots(state, block.slot) - sign_block(state, block) - state_transition(state, block) + spec.process_slots(state, block.slot) + sign_block(spec, state, block) + spec.state_transition(state, block) diff --git a/test_libs/pyspec/eth2spec/test/helpers/attester_slashings.py b/test_libs/pyspec/eth2spec/test/helpers/attester_slashings.py index d19b41dfe..9fd34520c 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/attester_slashings.py +++ b/test_libs/pyspec/eth2spec/test/helpers/attester_slashings.py @@ -1,19 +1,18 @@ from copy import deepcopy -from eth2spec.phase0.spec import AttesterSlashing, convert_to_indexed from eth2spec.test.helpers.attestations import get_valid_attestation, sign_attestation -def get_valid_attester_slashing(state, signed_1=False, signed_2=False): - attestation_1 = get_valid_attestation(state, signed=signed_1) +def get_valid_attester_slashing(spec, state, signed_1=False, signed_2=False): + attestation_1 = get_valid_attestation(spec, state, signed=signed_1) attestation_2 = deepcopy(attestation_1) attestation_2.data.target_root = b'\x01' * 32 if signed_2: - sign_attestation(state, attestation_2) + sign_attestation(spec, state, attestation_2) - return AttesterSlashing( - attestation_1=convert_to_indexed(state, attestation_1), - attestation_2=convert_to_indexed(state, attestation_2), + return spec.AttesterSlashing( + attestation_1=spec.convert_to_indexed(state, attestation_1), + attestation_2=spec.convert_to_indexed(state, attestation_2), ) diff --git a/test_libs/pyspec/eth2spec/test/helpers/block.py b/test_libs/pyspec/eth2spec/test/helpers/block.py index 28fd1229f..5c7cb02a0 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/block.py +++ b/test_libs/pyspec/eth2spec/test/helpers/block.py @@ -1,11 +1,5 @@ from copy import deepcopy -from eth2spec.phase0 import spec -from eth2spec.phase0.spec import ( - BeaconBlock, - get_beacon_proposer_index, slot_to_epoch, get_domain, - process_slots, state_transition, -) from eth2spec.test.helpers.keys import privkeys from eth2spec.utils.bls import bls_sign, only_with_bls from eth2spec.utils.ssz.ssz_impl import signing_root, hash_tree_root @@ -13,55 +7,55 @@ from eth2spec.utils.ssz.ssz_impl import signing_root, hash_tree_root # Fully ignore the function if BLS is off, beacon-proposer index calculation is slow. @only_with_bls() -def sign_block(state, block, proposer_index=None): +def sign_block(spec, state, block, proposer_index=None): assert state.slot <= block.slot if proposer_index is None: if block.slot == state.slot: - proposer_index = get_beacon_proposer_index(state) + proposer_index = spec.get_beacon_proposer_index(state) else: - if slot_to_epoch(state.slot) + 1 > slot_to_epoch(block.slot): + if spec.slot_to_epoch(state.slot) + 1 > spec.slot_to_epoch(block.slot): print("warning: block slot far away, and no proposer index manually given." " Signing block is slow due to transition for proposer index calculation.") # use stub state to get proposer index of future slot stub_state = deepcopy(state) - process_slots(stub_state, block.slot) - proposer_index = get_beacon_proposer_index(stub_state) + spec.process_slots(stub_state, block.slot) + proposer_index = spec.get_beacon_proposer_index(stub_state) privkey = privkeys[proposer_index] block.body.randao_reveal = bls_sign( privkey=privkey, - message_hash=hash_tree_root(slot_to_epoch(block.slot)), - domain=get_domain( + message_hash=hash_tree_root(spec.slot_to_epoch(block.slot)), + domain=spec.get_domain( state, - message_epoch=slot_to_epoch(block.slot), + message_epoch=spec.slot_to_epoch(block.slot), domain_type=spec.DOMAIN_RANDAO, ) ) block.signature = bls_sign( message_hash=signing_root(block), privkey=privkey, - domain=get_domain( + domain=spec.get_domain( state, spec.DOMAIN_BEACON_PROPOSER, - slot_to_epoch(block.slot))) + spec.slot_to_epoch(block.slot))) -def apply_empty_block(state): +def apply_empty_block(spec, state): """ Transition via an empty block (on current slot, assuming no block has been applied yet). :return: the empty block that triggered the transition. """ - block = build_empty_block(state, signed=True) - state_transition(state, block) + block = build_empty_block(spec, state, signed=True) + spec.state_transition(state, block) return block -def build_empty_block(state, slot=None, signed=False): +def build_empty_block(spec, state, slot=None, signed=False): if slot is None: slot = state.slot - empty_block = BeaconBlock() + empty_block = spec.BeaconBlock() empty_block.slot = slot empty_block.body.eth1_data.deposit_count = state.deposit_index previous_block_header = deepcopy(state.latest_block_header) @@ -70,10 +64,10 @@ def build_empty_block(state, slot=None, signed=False): empty_block.parent_root = signing_root(previous_block_header) if signed: - sign_block(state, empty_block) + sign_block(spec, state, empty_block) return empty_block -def build_empty_block_for_next_slot(state, signed=False): - return build_empty_block(state, state.slot + 1, signed=signed) +def build_empty_block_for_next_slot(spec, state, signed=False): + return build_empty_block(spec, state, state.slot + 1, signed=signed) diff --git a/test_libs/pyspec/eth2spec/test/helpers/block_header.py b/test_libs/pyspec/eth2spec/test/helpers/block_header.py index ad3fbc166..456414112 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/block_header.py +++ b/test_libs/pyspec/eth2spec/test/helpers/block_header.py @@ -1,13 +1,9 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import get_domain from eth2spec.utils.bls import bls_sign from eth2spec.utils.ssz.ssz_impl import signing_root -def sign_block_header(state, header, privkey): - domain = get_domain( +def sign_block_header(spec, state, header, privkey): + domain = spec.get_domain( state=state, domain_type=spec.DOMAIN_BEACON_PROPOSER, ) diff --git a/test_libs/pyspec/eth2spec/test/helpers/custody.py b/test_libs/pyspec/eth2spec/test/helpers/custody.py new file mode 100644 index 000000000..67df12fcd --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/helpers/custody.py @@ -0,0 +1,38 @@ +from eth2spec.test.helpers.keys import privkeys +from eth2spec.utils.bls import bls_sign + + +def get_valid_early_derived_secret_reveal(spec, state, epoch=None): + current_epoch = spec.get_current_epoch(state) + revealed_index = spec.get_active_validator_indices(state, current_epoch)[-1] + masker_index = spec.get_active_validator_indices(state, current_epoch)[0] + + if epoch is None: + epoch = current_epoch + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING + + reveal = bls_sign( + message_hash=spec.hash_tree_root(epoch), + privkey=privkeys[revealed_index], + domain=spec.get_domain( + state=state, + domain_type=spec.DOMAIN_RANDAO, + message_epoch=epoch, + ), + ) + mask = bls_sign( + message_hash=spec.hash_tree_root(epoch), + privkey=privkeys[masker_index], + domain=spec.get_domain( + state=state, + domain_type=spec.DOMAIN_RANDAO, + message_epoch=epoch, + ), + ) + + return spec.EarlyDerivedSecretReveal( + revealed_index=revealed_index, + epoch=epoch, + reveal=reveal, + masker_index=masker_index, + mask=mask, + ) diff --git a/test_libs/pyspec/eth2spec/test/helpers/deposits.py b/test_libs/pyspec/eth2spec/test/helpers/deposits.py index 3080eba7f..c85d265eb 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/deposits.py +++ b/test_libs/pyspec/eth2spec/test/helpers/deposits.py @@ -1,29 +1,25 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import get_domain, DepositData, verify_merkle_branch, Deposit, ZERO_HASH from eth2spec.test.helpers.keys import pubkeys, privkeys from eth2spec.utils.bls import bls_sign from eth2spec.utils.merkle_minimal import calc_merkle_tree_from_leaves, get_merkle_root, get_merkle_proof from eth2spec.utils.ssz.ssz_impl import signing_root -def build_deposit_data(state, pubkey, privkey, amount, withdrawal_credentials, signed=False): - deposit_data = DepositData( +def build_deposit_data(spec, state, pubkey, privkey, amount, withdrawal_credentials, signed=False): + deposit_data = spec.DepositData( pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, ) if signed: - sign_deposit_data(state, deposit_data, privkey) + sign_deposit_data(spec, state, deposit_data, privkey) return deposit_data -def sign_deposit_data(state, deposit_data, privkey): +def sign_deposit_data(spec, state, deposit_data, privkey): signature = bls_sign( message_hash=signing_root(deposit_data), privkey=privkey, - domain=get_domain( + domain=spec.get_domain( state, spec.DOMAIN_DEPOSIT, ) @@ -31,14 +27,15 @@ def sign_deposit_data(state, deposit_data, privkey): deposit_data.signature = signature -def build_deposit(state, +def build_deposit(spec, + state, deposit_data_leaves, pubkey, privkey, amount, withdrawal_credentials, signed): - deposit_data = build_deposit_data(state, pubkey, privkey, amount, withdrawal_credentials, signed) + deposit_data = build_deposit_data(spec, state, pubkey, privkey, amount, withdrawal_credentials, signed) item = deposit_data.hash_tree_root() index = len(deposit_data_leaves) @@ -46,9 +43,9 @@ def build_deposit(state, tree = calc_merkle_tree_from_leaves(tuple(deposit_data_leaves)) root = get_merkle_root((tuple(deposit_data_leaves))) proof = list(get_merkle_proof(tree, item_index=index)) - assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, index, root) + assert spec.verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, index, root) - deposit = Deposit( + deposit = spec.Deposit( proof=list(proof), index=index, data=deposit_data, @@ -57,13 +54,13 @@ def build_deposit(state, return deposit, root, deposit_data_leaves -def prepare_state_and_deposit(state, validator_index, amount, withdrawal_credentials=None, signed=False): +def prepare_state_and_deposit(spec, state, validator_index, amount, withdrawal_credentials=None, signed=False): """ Prepare the state for the deposit, and create a deposit for the given validator, depositing the given amount. """ pre_validator_count = len(state.validator_registry) # fill previous deposits with zero-hash - deposit_data_leaves = [ZERO_HASH] * pre_validator_count + deposit_data_leaves = [spec.ZERO_HASH] * pre_validator_count pubkey = pubkeys[validator_index] privkey = privkeys[validator_index] @@ -73,6 +70,7 @@ def prepare_state_and_deposit(state, validator_index, amount, withdrawal_credent withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX_BYTE + spec.hash(pubkey)[1:] deposit, root, deposit_data_leaves = build_deposit( + spec, state, deposit_data_leaves, pubkey, diff --git a/test_libs/pyspec/eth2spec/test/helpers/genesis.py b/test_libs/pyspec/eth2spec/test/helpers/genesis.py index 489791907..83af56621 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/genesis.py +++ b/test_libs/pyspec/eth2spec/test/helpers/genesis.py @@ -1,12 +1,8 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import Eth1Data, ZERO_HASH, get_active_validator_indices from eth2spec.test.helpers.keys import pubkeys from eth2spec.utils.ssz.ssz_impl import hash_tree_root -def build_mock_validator(i: int, balance: int): +def build_mock_validator(spec, i: int, balance: int): pubkey = pubkeys[i] # insecurely use pubkey as withdrawal key as well withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX_BYTE + spec.hash(pubkey)[1:] @@ -21,22 +17,22 @@ def build_mock_validator(i: int, balance: int): ) -def create_genesis_state(num_validators): +def create_genesis_state(spec, num_validators): deposit_root = b'\x42' * 32 state = spec.BeaconState( genesis_time=0, deposit_index=num_validators, - latest_eth1_data=Eth1Data( + latest_eth1_data=spec.Eth1Data( deposit_root=deposit_root, deposit_count=num_validators, - block_hash=ZERO_HASH, + block_hash=spec.ZERO_HASH, )) # We "hack" in the initial validators, # as it is much faster than creating and processing genesis deposits for every single test case. state.balances = [spec.MAX_EFFECTIVE_BALANCE] * num_validators - state.validator_registry = [build_mock_validator(i, state.balances[i]) for i in range(num_validators)] + state.validator_registry = [build_mock_validator(spec, i, state.balances[i]) for i in range(num_validators)] # Process genesis activations for validator in state.validator_registry: @@ -44,7 +40,7 @@ def create_genesis_state(num_validators): validator.activation_eligibility_epoch = spec.GENESIS_EPOCH validator.activation_epoch = spec.GENESIS_EPOCH - genesis_active_index_root = hash_tree_root(get_active_validator_indices(state, spec.GENESIS_EPOCH)) + genesis_active_index_root = hash_tree_root(spec.get_active_validator_indices(state, spec.GENESIS_EPOCH)) for index in range(spec.LATEST_ACTIVE_INDEX_ROOTS_LENGTH): state.latest_active_index_roots[index] = genesis_active_index_root diff --git a/test_libs/pyspec/eth2spec/test/helpers/proposer_slashings.py b/test_libs/pyspec/eth2spec/test/helpers/proposer_slashings.py index 02629f7da..86c6acf47 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/proposer_slashings.py +++ b/test_libs/pyspec/eth2spec/test/helpers/proposer_slashings.py @@ -1,19 +1,16 @@ from copy import deepcopy -from eth2spec.phase0.spec import ( - get_current_epoch, get_active_validator_indices, BeaconBlockHeader, ProposerSlashing -) from eth2spec.test.helpers.block_header import sign_block_header from eth2spec.test.helpers.keys import pubkey_to_privkey -def get_valid_proposer_slashing(state, signed_1=False, signed_2=False): - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[-1] +def get_valid_proposer_slashing(spec, state, signed_1=False, signed_2=False): + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[-1] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] slot = state.slot - header_1 = BeaconBlockHeader( + header_1 = spec.BeaconBlockHeader( slot=slot, parent_root=b'\x33' * 32, state_root=b'\x44' * 32, @@ -24,11 +21,11 @@ def get_valid_proposer_slashing(state, signed_1=False, signed_2=False): header_2.slot = slot + 1 if signed_1: - sign_block_header(state, header_1, privkey) + sign_block_header(spec, state, header_1, privkey) if signed_2: - sign_block_header(state, header_2, privkey) + sign_block_header(spec, state, header_2, privkey) - return ProposerSlashing( + return spec.ProposerSlashing( proposer_index=validator_index, header_1=header_1, header_2=header_2, diff --git a/test_libs/pyspec/eth2spec/test/helpers/state.py b/test_libs/pyspec/eth2spec/test/helpers/state.py index 1137561f1..63aa27d70 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/state.py +++ b/test_libs/pyspec/eth2spec/test/helpers/state.py @@ -1,29 +1,23 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import process_slots - - def get_balance(state, index): return state.balances[index] -def next_slot(state): +def next_slot(spec, state): """ Transition to the next slot. """ - process_slots(state, state.slot + 1) + spec.process_slots(state, state.slot + 1) -def next_epoch(state): +def next_epoch(spec, state): """ Transition to the start slot of the next epoch """ slot = state.slot + spec.SLOTS_PER_EPOCH - (state.slot % spec.SLOTS_PER_EPOCH) - process_slots(state, slot) + spec.process_slots(state, slot) -def get_state_root(state, slot) -> bytes: +def get_state_root(spec, state, slot) -> bytes: """ Return the state root at a recent ``slot``. """ diff --git a/test_libs/pyspec/eth2spec/test/helpers/transfers.py b/test_libs/pyspec/eth2spec/test/helpers/transfers.py index 91f8ea60e..e619c5569 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/transfers.py +++ b/test_libs/pyspec/eth2spec/test/helpers/transfers.py @@ -1,20 +1,16 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import get_current_epoch, get_active_validator_indices, Transfer, get_domain from eth2spec.test.helpers.keys import pubkeys, privkeys from eth2spec.test.helpers.state import get_balance from eth2spec.utils.bls import bls_sign from eth2spec.utils.ssz.ssz_impl import signing_root -def get_valid_transfer(state, slot=None, sender_index=None, amount=None, fee=None, signed=False): +def get_valid_transfer(spec, state, slot=None, sender_index=None, amount=None, fee=None, signed=False): if slot is None: slot = state.slot - current_epoch = get_current_epoch(state) + current_epoch = spec.get_current_epoch(state) if sender_index is None: - sender_index = get_active_validator_indices(state, current_epoch)[-1] - recipient_index = get_active_validator_indices(state, current_epoch)[0] + sender_index = spec.get_active_validator_indices(state, current_epoch)[-1] + recipient_index = spec.get_active_validator_indices(state, current_epoch)[0] transfer_pubkey = pubkeys[-1] transfer_privkey = privkeys[-1] @@ -23,7 +19,7 @@ def get_valid_transfer(state, slot=None, sender_index=None, amount=None, fee=Non if amount is None: amount = get_balance(state, sender_index) - fee - transfer = Transfer( + transfer = spec.Transfer( sender=sender_index, recipient=recipient_index, amount=amount, @@ -32,7 +28,7 @@ def get_valid_transfer(state, slot=None, sender_index=None, amount=None, fee=Non pubkey=transfer_pubkey, ) if signed: - sign_transfer(state, transfer, transfer_privkey) + sign_transfer(spec, state, transfer, transfer_privkey) # ensure withdrawal_credentials reproducible state.validator_registry[transfer.sender].withdrawal_credentials = ( @@ -42,14 +38,14 @@ def get_valid_transfer(state, slot=None, sender_index=None, amount=None, fee=Non return transfer -def sign_transfer(state, transfer, privkey): +def sign_transfer(spec, state, transfer, privkey): transfer.signature = bls_sign( message_hash=signing_root(transfer), privkey=privkey, - domain=get_domain( + domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_TRANSFER, - message_epoch=get_current_epoch(state), + message_epoch=spec.get_current_epoch(state), ) ) return transfer diff --git a/test_libs/pyspec/eth2spec/test/helpers/voluntary_exits.py b/test_libs/pyspec/eth2spec/test/helpers/voluntary_exits.py index e4a815877..120a9f600 100644 --- a/test_libs/pyspec/eth2spec/test/helpers/voluntary_exits.py +++ b/test_libs/pyspec/eth2spec/test/helpers/voluntary_exits.py @@ -1,26 +1,22 @@ -# Access constants from spec pkg reference. -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import VoluntaryExit, get_domain from eth2spec.utils.bls import bls_sign from eth2spec.utils.ssz.ssz_impl import signing_root -def build_voluntary_exit(state, epoch, validator_index, privkey, signed=False): - voluntary_exit = VoluntaryExit( +def build_voluntary_exit(spec, state, epoch, validator_index, privkey, signed=False): + voluntary_exit = spec.VoluntaryExit( epoch=epoch, validator_index=validator_index, ) if signed: - sign_voluntary_exit(state, voluntary_exit, privkey) + sign_voluntary_exit(spec, state, voluntary_exit, privkey) return voluntary_exit -def sign_voluntary_exit(state, voluntary_exit, privkey): +def sign_voluntary_exit(spec, state, voluntary_exit, privkey): voluntary_exit.signature = bls_sign( message_hash=signing_root(voluntary_exit), privkey=privkey, - domain=get_domain( + domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_VOLUNTARY_EXIT, message_epoch=voluntary_exit.epoch, diff --git a/test_libs/pyspec/eth2spec/test/phase_0/__init__.py b/test_libs/pyspec/eth2spec/test/phase_0/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/__init__.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py new file mode 100644 index 000000000..2b34ab405 --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py @@ -0,0 +1,314 @@ +from copy import deepcopy + +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases, with_phases +from eth2spec.test.helpers.attestations import ( + get_valid_attestation, + sign_attestation, +) +from eth2spec.test.helpers.state import ( + next_epoch, + next_slot, +) +from eth2spec.test.helpers.block import apply_empty_block + + +def run_attestation_processing(spec, state, attestation, valid=True): + """ + Run ``process_attestation``, yielding: + - pre-state ('pre') + - attestation ('attestation') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + # yield pre-state + yield 'pre', state + + yield 'attestation', attestation + + # If the attestation is invalid, processing is aborted, and there is no post-state. + if not valid: + expect_assertion_error(lambda: spec.process_attestation(state, attestation)) + yield 'post', None + return + + current_epoch_count = len(state.current_epoch_attestations) + previous_epoch_count = len(state.previous_epoch_attestations) + + # process attestation + spec.process_attestation(state, attestation) + + # Make sure the attestation has been processed + if attestation.data.target_epoch == spec.get_current_epoch(state): + assert len(state.current_epoch_attestations) == current_epoch_count + 1 + else: + assert len(state.previous_epoch_attestations) == previous_epoch_count + 1 + + # yield post-state + yield 'post', state + + +@with_all_phases +@spec_state_test +def test_success(spec, state): + attestation = get_valid_attestation(spec, state, signed=True) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + yield from run_attestation_processing(spec, state, attestation) + + +@with_all_phases +@spec_state_test +def test_success_previous_epoch(spec, state): + attestation = get_valid_attestation(spec, state, signed=True) + next_epoch(spec, state) + apply_empty_block(spec, state) + + yield from run_attestation_processing(spec, state, attestation) + + +@with_all_phases +@spec_state_test +def test_success_since_max_epochs_per_crosslink(spec, state): + for _ in range(spec.MAX_EPOCHS_PER_CROSSLINK + 2): + next_epoch(spec, state) + apply_empty_block(spec, state) + + attestation = get_valid_attestation(spec, state, signed=True) + data = attestation.data + # test logic sanity check: make sure the attestation only includes MAX_EPOCHS_PER_CROSSLINK epochs + assert data.crosslink.end_epoch - data.crosslink.start_epoch == spec.MAX_EPOCHS_PER_CROSSLINK + + for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): + next_slot(spec, state) + apply_empty_block(spec, state) + + yield from run_attestation_processing(spec, state, attestation) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_attestation_signature(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_before_inclusion_delay(spec, state): + attestation = get_valid_attestation(spec, state, signed=True) + # do not increment slot to allow for inclusion delay + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_after_epoch_slots(spec, state): + attestation = get_valid_attestation(spec, state, signed=True) + # increment past latest inclusion slot + spec.process_slots(state, state.slot + spec.SLOTS_PER_EPOCH + 1) + apply_empty_block(spec, state) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_old_source_epoch(spec, state): + state.slot = spec.SLOTS_PER_EPOCH * 5 + state.finalized_epoch = 2 + state.previous_justified_epoch = 3 + state.current_justified_epoch = 4 + attestation = get_valid_attestation(spec, state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1) + + # test logic sanity check: make sure the attestation is pointing to oldest known source epoch + assert attestation.data.source_epoch == state.previous_justified_epoch + + # Now go beyond that, it will be invalid + attestation.data.source_epoch -= 1 + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_wrong_shard(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.data.crosslink.shard += 1 + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_new_source_epoch(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.data.source_epoch += 1 + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_source_root_is_target_root(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.data.source_root = attestation.data.target_root + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_invalid_current_source_root(spec, state): + state.slot = spec.SLOTS_PER_EPOCH * 5 + state.finalized_epoch = 2 + + state.previous_justified_epoch = 3 + state.previous_justified_root = b'\x01' * 32 + + state.current_justified_epoch = 4 + state.current_justified_root = b'\xff' * 32 + + attestation = get_valid_attestation(spec, state, slot=(spec.SLOTS_PER_EPOCH * 3) + 1) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + # Test logic sanity checks: + assert state.current_justified_root != state.previous_justified_root + assert attestation.data.source_root == state.previous_justified_root + + # Make attestation source root invalid: should be previous justified, not current one + attestation.data.source_root = state.current_justified_root + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_bad_source_root(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.data.source_root = b'\x42' * 32 + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_phases(['phase0']) +@spec_state_test +def test_non_zero_crosslink_data_root(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.data.crosslink.data_root = b'\x42' * 32 + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_bad_parent_crosslink(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + + attestation = get_valid_attestation(spec, state, signed=True) + for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): + next_slot(spec, state) + apply_empty_block(spec, state) + + attestation.data.crosslink.parent_root = b'\x27' * 32 + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_bad_crosslink_start_epoch(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + + attestation = get_valid_attestation(spec, state, signed=True) + for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): + next_slot(spec, state) + apply_empty_block(spec, state) + + attestation.data.crosslink.start_epoch += 1 + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_bad_crosslink_end_epoch(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + + attestation = get_valid_attestation(spec, state, signed=True) + for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY): + next_slot(spec, state) + apply_empty_block(spec, state) + + attestation.data.crosslink.end_epoch += 1 + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_inconsistent_bitfields(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.custody_bitfield = deepcopy(attestation.aggregation_bitfield) + b'\x00' + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_phases(['phase0']) +@spec_state_test +def test_non_empty_custody_bitfield(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.custody_bitfield = deepcopy(attestation.aggregation_bitfield) + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation, False) + + +@with_all_phases +@spec_state_test +def test_empty_aggregation_bitfield(spec, state): + attestation = get_valid_attestation(spec, state) + state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY + + attestation.aggregation_bitfield = b'\x00' * len(attestation.aggregation_bitfield) + + sign_attestation(spec, state, attestation) + + yield from run_attestation_processing(spec, state, attestation) diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py new file mode 100644 index 000000000..6c7637d59 --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py @@ -0,0 +1,153 @@ +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases +from eth2spec.test.helpers.attestations import sign_indexed_attestation +from eth2spec.test.helpers.attester_slashings import get_valid_attester_slashing +from eth2spec.test.helpers.block import apply_empty_block +from eth2spec.test.helpers.state import ( + get_balance, + next_epoch, +) + + +def run_attester_slashing_processing(spec, state, attester_slashing, valid=True): + """ + Run ``process_attester_slashing``, yielding: + - pre-state ('pre') + - attester_slashing ('attester_slashing') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + + yield 'pre', state + yield 'attester_slashing', attester_slashing + + if not valid: + expect_assertion_error(lambda: spec.process_attester_slashing(state, attester_slashing)) + yield 'post', None + return + + slashed_index = attester_slashing.attestation_1.custody_bit_0_indices[0] + pre_slashed_balance = get_balance(state, slashed_index) + + proposer_index = spec.get_beacon_proposer_index(state) + pre_proposer_balance = get_balance(state, proposer_index) + + # Process slashing + spec.process_attester_slashing(state, attester_slashing) + + slashed_validator = state.validator_registry[slashed_index] + + # Check slashing + assert slashed_validator.slashed + assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH + assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH + + if slashed_index != proposer_index: + # lost whistleblower reward + assert get_balance(state, slashed_index) < pre_slashed_balance + # gained whistleblower reward + assert get_balance(state, proposer_index) > pre_proposer_balance + else: + # gained rewards for all slashings, which may include others. And only lost that of themselves. + # Netto at least 0, if more people where slashed, a balance increase. + assert get_balance(state, slashed_index) >= pre_slashed_balance + + yield 'post', state + + +@with_all_phases +@spec_state_test +def test_success_double(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) + + yield from run_attester_slashing_processing(spec, state, attester_slashing) + + +@with_all_phases +@spec_state_test +def test_success_surround(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + + state.current_justified_epoch += 1 + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) + + # set attestion1 to surround attestation 2 + attester_slashing.attestation_1.data.source_epoch = attester_slashing.attestation_2.data.source_epoch - 1 + attester_slashing.attestation_1.data.target_epoch = attester_slashing.attestation_2.data.target_epoch + 1 + + sign_indexed_attestation(spec, state, attester_slashing.attestation_1) + + yield from run_attester_slashing_processing(spec, state, attester_slashing) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_1(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_2(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_1_and_2(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=False) + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@spec_state_test +def test_same_data(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) + + attester_slashing.attestation_1.data = attester_slashing.attestation_2.data + sign_indexed_attestation(spec, state, attester_slashing.attestation_1) + + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@spec_state_test +def test_no_double_or_surround(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) + + attester_slashing.attestation_1.data.target_epoch += 1 + sign_indexed_attestation(spec, state, attester_slashing.attestation_1) + + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@spec_state_test +def test_participants_already_slashed(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) + + # set all indices to slashed + attestation_1 = attester_slashing.attestation_1 + validator_indices = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices + for index in validator_indices: + state.validator_registry[index].slashed = True + + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) + + +@with_all_phases +@spec_state_test +def test_custody_bit_0_and_1(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True) + + attester_slashing.attestation_1.custody_bit_1_indices = ( + attester_slashing.attestation_1.custody_bit_0_indices + ) + sign_indexed_attestation(spec, state, attester_slashing.attestation_1) + + yield from run_attester_slashing_processing(spec, state, attester_slashing, False) diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_block_header.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_block_header.py new file mode 100644 index 000000000..f3c017982 --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_block_header.py @@ -0,0 +1,85 @@ +from copy import deepcopy + +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases +from eth2spec.test.helpers.block import ( + build_empty_block_for_next_slot, + sign_block +) +from eth2spec.test.helpers.state import next_slot + + +def prepare_state_for_header_processing(spec, state): + spec.process_slots(state, state.slot + 1) + + +def run_block_header_processing(spec, state, block, valid=True): + """ + Run ``process_block_header``, yielding: + - pre-state ('pre') + - block ('block') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + prepare_state_for_header_processing(spec, state) + + yield 'pre', state + yield 'block', block + + if not valid: + expect_assertion_error(lambda: spec.process_block_header(state, block)) + yield 'post', None + return + + spec.process_block_header(state, block) + yield 'post', state + + +@with_all_phases +@spec_state_test +def test_success_block_header(spec, state): + block = build_empty_block_for_next_slot(spec, state, signed=True) + yield from run_block_header_processing(spec, state, block) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_block_header(spec, state): + block = build_empty_block_for_next_slot(spec, state) + yield from run_block_header_processing(spec, state, block, valid=False) + + +@with_all_phases +@spec_state_test +def test_invalid_slot_block_header(spec, state): + block = build_empty_block_for_next_slot(spec, state) + block.slot = state.slot + 2 # invalid slot + sign_block(spec, state, block) + + yield from run_block_header_processing(spec, state, block, valid=False) + + +@with_all_phases +@spec_state_test +def test_invalid_parent_root(spec, state): + block = build_empty_block_for_next_slot(spec, state) + block.parent_root = b'\12' * 32 # invalid prev root + sign_block(spec, state, block) + + yield from run_block_header_processing(spec, state, block, valid=False) + + +@with_all_phases +@spec_state_test +def test_proposer_slashed(spec, state): + # use stub state to get proposer index of next slot + stub_state = deepcopy(state) + next_slot(spec, stub_state) + proposer_index = spec.get_beacon_proposer_index(stub_state) + + # set proposer to slashed + state.validator_registry[proposer_index].slashed = True + + block = build_empty_block_for_next_slot(spec, state, signed=True) + + yield from run_block_header_processing(spec, state, block, valid=False) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_deposit.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_deposit.py similarity index 65% rename from test_libs/pyspec/eth2spec/test/block_processing/test_process_deposit.py rename to test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_deposit.py index b12ec6bd9..c50b11f2e 100644 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_deposit.py +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_deposit.py @@ -1,6 +1,4 @@ -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import process_deposit -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases from eth2spec.test.helpers.deposits import ( build_deposit, prepare_state_and_deposit, @@ -10,7 +8,7 @@ from eth2spec.test.helpers.state import get_balance from eth2spec.test.helpers.keys import privkeys, pubkeys -def run_deposit_processing(state, deposit, validator_index, valid=True, effective=True): +def run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True): """ Run ``process_deposit``, yielding: - pre-state ('pre') @@ -27,11 +25,11 @@ def run_deposit_processing(state, deposit, validator_index, valid=True, effectiv yield 'deposit', deposit if not valid: - expect_assertion_error(lambda: process_deposit(state, deposit)) + expect_assertion_error(lambda: spec.process_deposit(state, deposit)) yield 'post', None return - process_deposit(state, deposit) + spec.process_deposit(state, deposit) yield 'post', state @@ -54,52 +52,58 @@ def run_deposit_processing(state, deposit, validator_index, valid=True, effectiv assert state.deposit_index == state.latest_eth1_data.deposit_count +@with_all_phases @spec_state_test -def test_new_deposit(state): +def test_new_deposit(spec, state): # fresh deposit = next validator index = validator appended to registry validator_index = len(state.validator_registry) amount = spec.MAX_EFFECTIVE_BALANCE - deposit = prepare_state_and_deposit(state, validator_index, amount, signed=True) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) - yield from run_deposit_processing(state, deposit, validator_index) + yield from run_deposit_processing(spec, state, deposit, validator_index) +@with_all_phases @always_bls @spec_state_test -def test_invalid_sig_new_deposit(state): +def test_invalid_sig_new_deposit(spec, state): # fresh deposit = next validator index = validator appended to registry validator_index = len(state.validator_registry) amount = spec.MAX_EFFECTIVE_BALANCE - deposit = prepare_state_and_deposit(state, validator_index, amount) - yield from run_deposit_processing(state, deposit, validator_index, valid=True, effective=False) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount) + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=False) +@with_all_phases @spec_state_test -def test_success_top_up(state): +def test_success_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 - deposit = prepare_state_and_deposit(state, validator_index, amount, signed=True) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) - yield from run_deposit_processing(state, deposit, validator_index) + yield from run_deposit_processing(spec, state, deposit, validator_index) +@with_all_phases @always_bls @spec_state_test -def test_invalid_sig_top_up(state): +def test_invalid_sig_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 - deposit = prepare_state_and_deposit(state, validator_index, amount) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount) # invalid signatures, in top-ups, are allowed! - yield from run_deposit_processing(state, deposit, validator_index, valid=True, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True) +@with_all_phases @spec_state_test -def test_invalid_withdrawal_credentials_top_up(state): +def test_invalid_withdrawal_credentials_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 withdrawal_credentials = spec.BLS_WITHDRAWAL_PREFIX_BYTE + spec.hash(b"junk")[1:] deposit = prepare_state_and_deposit( + spec, state, validator_index, amount, @@ -107,32 +111,35 @@ def test_invalid_withdrawal_credentials_top_up(state): ) # inconsistent withdrawal credentials, in top-ups, are allowed! - yield from run_deposit_processing(state, deposit, validator_index, valid=True, effective=True) + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=True, effective=True) +@with_all_phases @spec_state_test -def test_wrong_index(state): +def test_wrong_index(spec, state): validator_index = len(state.validator_registry) amount = spec.MAX_EFFECTIVE_BALANCE - deposit = prepare_state_and_deposit(state, validator_index, amount) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount) # mess up deposit_index deposit.index = state.deposit_index + 1 - sign_deposit_data(state, deposit.data, privkeys[validator_index]) + sign_deposit_data(spec, state, deposit.data, privkeys[validator_index]) - yield from run_deposit_processing(state, deposit, validator_index, valid=False) + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=False) +@with_all_phases @spec_state_test -def test_wrong_deposit_for_deposit_count(state): +def test_wrong_deposit_for_deposit_count(spec, state): deposit_data_leaves = [spec.ZERO_HASH] * len(state.validator_registry) # build root for deposit_1 index_1 = len(deposit_data_leaves) pubkey_1 = pubkeys[index_1] privkey_1 = privkeys[index_1] - deposit_1, root_1, deposit_data_leaves = build_deposit( + _, _, deposit_data_leaves = build_deposit( + spec, state, deposit_data_leaves, pubkey_1, @@ -148,6 +155,7 @@ def test_wrong_deposit_for_deposit_count(state): pubkey_2 = pubkeys[index_2] privkey_2 = privkeys[index_2] deposit_2, root_2, deposit_data_leaves = build_deposit( + spec, state, deposit_data_leaves, pubkey_2, @@ -161,21 +169,22 @@ def test_wrong_deposit_for_deposit_count(state): state.latest_eth1_data.deposit_root = root_2 state.latest_eth1_data.deposit_count = deposit_count_1 - yield from run_deposit_processing(state, deposit_2, index_2, valid=False) + yield from run_deposit_processing(spec, state, deposit_2, index_2, valid=False) # TODO: test invalid signature +@with_all_phases @spec_state_test -def test_bad_merkle_proof(state): +def test_bad_merkle_proof(spec, state): validator_index = len(state.validator_registry) amount = spec.MAX_EFFECTIVE_BALANCE - deposit = prepare_state_and_deposit(state, validator_index, amount) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount) # mess up merkle branch deposit.proof[-1] = spec.ZERO_HASH - sign_deposit_data(state, deposit.data, privkeys[validator_index]) + sign_deposit_data(spec, state, deposit.data, privkeys[validator_index]) - yield from run_deposit_processing(state, deposit, validator_index, valid=False) + yield from run_deposit_processing(spec, state, deposit, validator_index, valid=False) diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py new file mode 100644 index 000000000..b35241859 --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_proposer_slashing.py @@ -0,0 +1,142 @@ +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases +from eth2spec.test.helpers.block_header import sign_block_header +from eth2spec.test.helpers.keys import privkeys +from eth2spec.test.helpers.proposer_slashings import get_valid_proposer_slashing +from eth2spec.test.helpers.state import get_balance + + +def run_proposer_slashing_processing(spec, state, proposer_slashing, valid=True): + """ + Run ``process_proposer_slashing``, yielding: + - pre-state ('pre') + - proposer_slashing ('proposer_slashing') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + + yield 'pre', state + yield 'proposer_slashing', proposer_slashing + + if not valid: + expect_assertion_error(lambda: spec.process_proposer_slashing(state, proposer_slashing)) + yield 'post', None + return + + pre_proposer_balance = get_balance(state, proposer_slashing.proposer_index) + + spec.process_proposer_slashing(state, proposer_slashing) + yield 'post', state + + # check if slashed + slashed_validator = state.validator_registry[proposer_slashing.proposer_index] + assert slashed_validator.slashed + assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH + assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH + + # lost whistleblower reward + assert ( + get_balance(state, proposer_slashing.proposer_index) < + pre_proposer_balance + ) + + +@with_all_phases +@spec_state_test +def test_success(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_1(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=False, signed_2=True) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_2(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_sig_1_and_2(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=False, signed_2=False) + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_invalid_proposer_index(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) + # Index just too high (by 1) + proposer_slashing.proposer_index = len(state.validator_registry) + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_epochs_are_different(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) + + # set slots to be in different epochs + proposer_slashing.header_2.slot += spec.SLOTS_PER_EPOCH + sign_block_header(spec, state, proposer_slashing.header_2, privkeys[proposer_slashing.proposer_index]) + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_headers_are_same(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=False) + + # set headers to be the same + proposer_slashing.header_2 = proposer_slashing.header_1 + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_proposer_is_not_activated(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) + + # set proposer to be not active yet + state.validator_registry[proposer_slashing.proposer_index].activation_epoch = spec.get_current_epoch(state) + 1 + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_proposer_is_slashed(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) + + # set proposer to slashed + state.validator_registry[proposer_slashing.proposer_index].slashed = True + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) + + +@with_all_phases +@spec_state_test +def test_proposer_is_withdrawn(spec, state): + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) + + # move 1 epoch into future, to allow for past withdrawable epoch + state.slot += spec.SLOTS_PER_EPOCH + # set proposer withdrawable_epoch in past + current_epoch = spec.get_current_epoch(state) + proposer_index = proposer_slashing.proposer_index + state.validator_registry[proposer_index].withdrawable_epoch = current_epoch - 1 + + yield from run_proposer_slashing_processing(spec, state, proposer_slashing, False) diff --git a/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_transfer.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_transfer.py new file mode 100644 index 000000000..1294ca84a --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_transfer.py @@ -0,0 +1,184 @@ +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases +from eth2spec.test.helpers.state import next_epoch +from eth2spec.test.helpers.block import apply_empty_block +from eth2spec.test.helpers.transfers import get_valid_transfer + + +def run_transfer_processing(spec, state, transfer, valid=True): + """ + Run ``process_transfer``, yielding: + - pre-state ('pre') + - transfer ('transfer') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + + proposer_index = spec.get_beacon_proposer_index(state) + pre_transfer_sender_balance = state.balances[transfer.sender] + pre_transfer_recipient_balance = state.balances[transfer.recipient] + pre_transfer_proposer_balance = state.balances[proposer_index] + + yield 'pre', state + yield 'transfer', transfer + + if not valid: + expect_assertion_error(lambda: spec.process_transfer(state, transfer)) + yield 'post', None + return + + spec.process_transfer(state, transfer) + yield 'post', state + + sender_balance = state.balances[transfer.sender] + recipient_balance = state.balances[transfer.recipient] + assert sender_balance == pre_transfer_sender_balance - transfer.amount - transfer.fee + assert recipient_balance == pre_transfer_recipient_balance + transfer.amount + assert state.balances[proposer_index] == pre_transfer_proposer_balance + transfer.fee + + +@with_all_phases +@spec_state_test +def test_success_non_activated(spec, state): + transfer = get_valid_transfer(spec, state, signed=True) + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer) + + +@with_all_phases +@spec_state_test +def test_success_withdrawable(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + + transfer = get_valid_transfer(spec, state, signed=True) + + # withdrawable_epoch in past so can transfer + state.validator_registry[transfer.sender].withdrawable_epoch = spec.get_current_epoch(state) - 1 + + yield from run_transfer_processing(spec, state, transfer) + + +@with_all_phases +@spec_state_test +def test_success_active_above_max_effective(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=1, fee=0, signed=True) + + yield from run_transfer_processing(spec, state, transfer) + + +@with_all_phases +@spec_state_test +def test_success_active_above_max_effective_fee(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=0, fee=1, signed=True) + + yield from run_transfer_processing(spec, state, transfer) + + +@with_all_phases +@always_bls +@spec_state_test +def test_invalid_signature(spec, state): + transfer = get_valid_transfer(spec, state) + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_active_but_transfer_past_effective_balance(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + amount = spec.MAX_EFFECTIVE_BALANCE // 32 + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=amount, fee=0, signed=True) + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_incorrect_slot(spec, state): + transfer = get_valid_transfer(spec, state, slot=state.slot + 1, signed=True) + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_insufficient_balance_for_fee(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=0, fee=1, signed=True) + + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_insufficient_balance(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=1, fee=0, signed=True) + + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_no_dust_sender(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + balance = state.balances[sender_index] + transfer = get_valid_transfer( + spec, + state, + sender_index=sender_index, + amount=balance - spec.MIN_DEPOSIT_AMOUNT + 1, + fee=0, + signed=True, + ) + + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_no_dust_recipient(spec, state): + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] + state.balances[sender_index] = spec.MAX_EFFECTIVE_BALANCE + 1 + transfer = get_valid_transfer(spec, state, sender_index=sender_index, amount=1, fee=0, signed=True) + state.balances[transfer.recipient] = 0 + + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) + + +@with_all_phases +@spec_state_test +def test_invalid_pubkey(spec, state): + transfer = get_valid_transfer(spec, state, signed=True) + state.validator_registry[transfer.sender].withdrawal_credentials = spec.ZERO_HASH + + # un-activate so validator can transfer + state.validator_registry[transfer.sender].activation_epoch = spec.FAR_FUTURE_EPOCH + + yield from run_transfer_processing(spec, state, transfer, False) diff --git a/test_libs/pyspec/eth2spec/test/block_processing/test_process_voluntary_exit.py b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_voluntary_exit.py similarity index 61% rename from test_libs/pyspec/eth2spec/test/block_processing/test_process_voluntary_exit.py rename to test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_voluntary_exit.py index 53fb4e3f7..3359c5e78 100644 --- a/test_libs/pyspec/eth2spec/test/block_processing/test_process_voluntary_exit.py +++ b/test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_voluntary_exit.py @@ -1,16 +1,9 @@ -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_active_validator_indices, - get_churn_limit, - get_current_epoch, - process_voluntary_exit, -) -from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls +from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases from eth2spec.test.helpers.keys import pubkey_to_privkey from eth2spec.test.helpers.voluntary_exits import build_voluntary_exit, sign_voluntary_exit -def run_voluntary_exit_processing(state, voluntary_exit, valid=True): +def run_voluntary_exit_processing(spec, state, voluntary_exit, valid=True): """ Run ``process_voluntary_exit``, yielding: - pre-state ('pre') @@ -24,13 +17,13 @@ def run_voluntary_exit_processing(state, voluntary_exit, valid=True): yield 'voluntary_exit', voluntary_exit if not valid: - expect_assertion_error(lambda: process_voluntary_exit(state, voluntary_exit)) + expect_assertion_error(lambda: spec.process_voluntary_exit(state, voluntary_exit)) yield 'post', None return pre_exit_epoch = state.validator_registry[validator_index].exit_epoch - process_voluntary_exit(state, voluntary_exit) + spec.process_voluntary_exit(state, voluntary_exit) yield 'post', state @@ -38,50 +31,54 @@ def run_voluntary_exit_processing(state, voluntary_exit, valid=True): assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH +@with_all_phases @spec_state_test -def test_success(state): +def test_success(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] - voluntary_exit = build_voluntary_exit(state, current_epoch, validator_index, privkey, signed=True) + voluntary_exit = build_voluntary_exit(spec, state, current_epoch, validator_index, privkey, signed=True) - yield from run_voluntary_exit_processing(state, voluntary_exit) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit) +@with_all_phases @always_bls @spec_state_test -def test_invalid_signature(state): +def test_invalid_signature(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] - voluntary_exit = build_voluntary_exit(state, current_epoch, validator_index, privkey) + voluntary_exit = build_voluntary_exit(spec, state, current_epoch, validator_index, privkey) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) +@with_all_phases @spec_state_test -def test_success_exit_queue(state): +def test_success_exit_queue(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) + current_epoch = spec.get_current_epoch(state) # exit `MAX_EXITS_PER_EPOCH` - initial_indices = get_active_validator_indices(state, current_epoch)[:get_churn_limit(state)] + initial_indices = spec.get_active_validator_indices(state, current_epoch)[:spec.get_churn_limit(state)] # Prepare a bunch of exits, based on the current state exit_queue = [] for index in initial_indices: privkey = pubkey_to_privkey[state.validator_registry[index].pubkey] exit_queue.append(build_voluntary_exit( + spec, state, current_epoch, index, @@ -92,13 +89,14 @@ def test_success_exit_queue(state): # Now run all the exits for voluntary_exit in exit_queue: # the function yields data, but we are just interested in running it here, ignore yields. - for _ in run_voluntary_exit_processing(state, voluntary_exit): + for _ in run_voluntary_exit_processing(spec, state, voluntary_exit): continue # exit an additional validator - validator_index = get_active_validator_indices(state, current_epoch)[-1] + validator_index = spec.get_active_validator_indices(state, current_epoch)[-1] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -108,7 +106,7 @@ def test_success_exit_queue(state): # This is the interesting part of the test: on a pre-state with a full exit queue, # when processing an additional exit, it results in an exit in a later epoch - yield from run_voluntary_exit_processing(state, voluntary_exit) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit) assert ( state.validator_registry[validator_index].exit_epoch == @@ -116,16 +114,18 @@ def test_success_exit_queue(state): ) +@with_all_phases @spec_state_test -def test_validator_exit_in_future(state): +def test_validator_exit_in_future(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -133,21 +133,23 @@ def test_validator_exit_in_future(state): signed=False, ) voluntary_exit.epoch += 1 - sign_voluntary_exit(state, voluntary_exit, privkey) + sign_voluntary_exit(spec, state, voluntary_exit, privkey) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) +@with_all_phases @spec_state_test -def test_validator_invalid_validator_index(state): +def test_validator_invalid_validator_index(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -155,21 +157,23 @@ def test_validator_invalid_validator_index(state): signed=False, ) voluntary_exit.validator_index = len(state.validator_registry) - sign_voluntary_exit(state, voluntary_exit, privkey) + sign_voluntary_exit(spec, state, voluntary_exit, privkey) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) +@with_all_phases @spec_state_test -def test_validator_not_active(state): - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] +def test_validator_not_active(spec, state): + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] state.validator_registry[validator_index].activation_epoch = spec.FAR_FUTURE_EPOCH # build and test voluntary exit voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -177,22 +181,24 @@ def test_validator_not_active(state): signed=True, ) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) +@with_all_phases @spec_state_test -def test_validator_already_exited(state): +def test_validator_already_exited(spec, state): # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow validator able to exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] # but validator already has exited state.validator_registry[validator_index].exit_epoch = current_epoch + 2 voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -200,16 +206,18 @@ def test_validator_already_exited(state): signed=True, ) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) +@with_all_phases @spec_state_test -def test_validator_not_active_long_enough(state): - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[0] +def test_validator_not_active_long_enough(spec, state): + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[0] privkey = pubkey_to_privkey[state.validator_registry[validator_index].pubkey] voluntary_exit = build_voluntary_exit( + spec, state, current_epoch, validator_index, @@ -222,4 +230,4 @@ def test_validator_not_active_long_enough(state): spec.PERSISTENT_COMMITTEE_PERIOD ) - yield from run_voluntary_exit_processing(state, voluntary_exit, False) + yield from run_voluntary_exit_processing(spec, state, voluntary_exit, False) diff --git a/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/__init__.py b/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_libs/pyspec/eth2spec/test/epoch_processing/test_process_crosslinks.py b/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_crosslinks.py similarity index 53% rename from test_libs/pyspec/eth2spec/test/epoch_processing/test_process_crosslinks.py rename to test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_crosslinks.py index bb308a9f0..65d958678 100644 --- a/test_libs/pyspec/eth2spec/test/epoch_processing/test_process_crosslinks.py +++ b/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_crosslinks.py @@ -1,14 +1,6 @@ from copy import deepcopy -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import ( - process_slot, - get_crosslink_deltas, - process_crosslinks, - state_transition, -) -from eth2spec.test.context import spec_state_test +from eth2spec.test.context import spec_state_test, with_all_phases from eth2spec.test.helpers.state import ( next_epoch, next_slot @@ -18,13 +10,12 @@ from eth2spec.test.helpers.attestations import ( add_attestation_to_state, build_empty_block_for_next_slot, fill_aggregate_attestation, - get_crosslink_committee, get_valid_attestation, sign_attestation, ) -def run_process_crosslinks(state, valid=True): +def run_process_crosslinks(spec, state, valid=True): """ Run ``process_crosslinks``, yielding: - pre-state ('pre') @@ -33,117 +24,127 @@ def run_process_crosslinks(state, valid=True): """ # transition state to slot before state transition slot = state.slot + (spec.SLOTS_PER_EPOCH - state.slot % spec.SLOTS_PER_EPOCH) - 1 - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.slot = slot - sign_block(state, block) - state_transition(state, block) + sign_block(spec, state, block) + spec.state_transition(state, block) # cache state before epoch transition - process_slot(state) + spec.process_slot(state) yield 'pre', state - process_crosslinks(state) + spec.process_crosslinks(state) yield 'post', state +@with_all_phases @spec_state_test -def test_no_attestations(state): - yield from run_process_crosslinks(state) +def test_no_attestations(spec, state): + yield from run_process_crosslinks(spec, state) for shard in range(spec.SHARD_COUNT): assert state.previous_crosslinks[shard] == state.current_crosslinks[shard] +@with_all_phases @spec_state_test -def test_single_crosslink_update_from_current_epoch(state): - next_epoch(state) +def test_single_crosslink_update_from_current_epoch(spec, state): + next_epoch(spec, state) - attestation = get_valid_attestation(state, signed=True) + attestation = get_valid_attestation(spec, state, signed=True) - fill_aggregate_attestation(state, attestation) - add_attestation_to_state(state, attestation, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY) + fill_aggregate_attestation(spec, state, attestation) + add_attestation_to_state(spec, state, attestation, state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY) assert len(state.current_epoch_attestations) == 1 shard = attestation.data.crosslink.shard pre_crosslink = deepcopy(state.current_crosslinks[shard]) - yield from run_process_crosslinks(state) + yield from run_process_crosslinks(spec, state) assert state.previous_crosslinks[shard] != state.current_crosslinks[shard] assert pre_crosslink != state.current_crosslinks[shard] +@with_all_phases @spec_state_test -def test_single_crosslink_update_from_previous_epoch(state): - next_epoch(state) +def test_single_crosslink_update_from_previous_epoch(spec, state): + next_epoch(spec, state) - attestation = get_valid_attestation(state, signed=True) + attestation = get_valid_attestation(spec, state, signed=True) - fill_aggregate_attestation(state, attestation) - add_attestation_to_state(state, attestation, state.slot + spec.SLOTS_PER_EPOCH) + fill_aggregate_attestation(spec, state, attestation) + add_attestation_to_state(spec, state, attestation, state.slot + spec.SLOTS_PER_EPOCH) assert len(state.previous_epoch_attestations) == 1 shard = attestation.data.crosslink.shard pre_crosslink = deepcopy(state.current_crosslinks[shard]) - crosslink_deltas = get_crosslink_deltas(state) + crosslink_deltas = spec.get_crosslink_deltas(state) - yield from run_process_crosslinks(state) + yield from run_process_crosslinks(spec, state) assert state.previous_crosslinks[shard] != state.current_crosslinks[shard] assert pre_crosslink != state.current_crosslinks[shard] # ensure rewarded - for index in get_crosslink_committee(state, attestation.data.target_epoch, attestation.data.crosslink.shard): + for index in spec.get_crosslink_committee( + state, + attestation.data.target_epoch, + attestation.data.crosslink.shard): assert crosslink_deltas[0][index] > 0 assert crosslink_deltas[1][index] == 0 +@with_all_phases @spec_state_test -def test_double_late_crosslink(state): +def test_double_late_crosslink(spec, state): if spec.get_epoch_committee_count(state, spec.get_current_epoch(state)) < spec.SHARD_COUNT: print("warning: ignoring test, test-assumptions are incompatible with configuration") return - next_epoch(state) + next_epoch(spec, state) state.slot += 4 - attestation_1 = get_valid_attestation(state, signed=True) - fill_aggregate_attestation(state, attestation_1) + attestation_1 = get_valid_attestation(spec, state, signed=True) + fill_aggregate_attestation(spec, state, attestation_1) # add attestation_1 to next epoch - next_epoch(state) - add_attestation_to_state(state, attestation_1, state.slot + 1) + next_epoch(spec, state) + add_attestation_to_state(spec, state, attestation_1, state.slot + 1) - for slot in range(spec.SLOTS_PER_EPOCH): - attestation_2 = get_valid_attestation(state) + for _ in range(spec.SLOTS_PER_EPOCH): + attestation_2 = get_valid_attestation(spec, state) if attestation_2.data.crosslink.shard == attestation_1.data.crosslink.shard: - sign_attestation(state, attestation_2) + sign_attestation(spec, state, attestation_2) break - next_slot(state) - apply_empty_block(state) + next_slot(spec, state) + apply_empty_block(spec, state) - fill_aggregate_attestation(state, attestation_2) + fill_aggregate_attestation(spec, state, attestation_2) # add attestation_2 in the next epoch after attestation_1 has # already updated the relevant crosslink - next_epoch(state) - add_attestation_to_state(state, attestation_2, state.slot + 1) + next_epoch(spec, state) + add_attestation_to_state(spec, state, attestation_2, state.slot + 1) assert len(state.previous_epoch_attestations) == 1 assert len(state.current_epoch_attestations) == 0 - crosslink_deltas = get_crosslink_deltas(state) + crosslink_deltas = spec.get_crosslink_deltas(state) - yield from run_process_crosslinks(state) + yield from run_process_crosslinks(spec, state) shard = attestation_2.data.crosslink.shard # ensure that the current crosslinks were not updated by the second attestation assert state.previous_crosslinks[shard] == state.current_crosslinks[shard] # ensure no reward, only penalties for the failed crosslink - for index in get_crosslink_committee(state, attestation_2.data.target_epoch, attestation_2.data.crosslink.shard): + for index in spec.get_crosslink_committee( + state, + attestation_2.data.target_epoch, + attestation_2.data.crosslink.shard): assert crosslink_deltas[0][index] == 0 assert crosslink_deltas[1][index] > 0 diff --git a/test_libs/pyspec/eth2spec/test/epoch_processing/test_process_registry_updates.py b/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py similarity index 65% rename from test_libs/pyspec/eth2spec/test/epoch_processing/test_process_registry_updates.py rename to test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py index 8f6e35088..e6679f844 100644 --- a/test_libs/pyspec/eth2spec/test/epoch_processing/test_process_registry_updates.py +++ b/test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_registry_updates.py @@ -1,17 +1,10 @@ -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import ( - get_current_epoch, - is_active_validator, - process_registry_updates -) from eth2spec.phase0.spec import state_transition from eth2spec.test.helpers.block import build_empty_block_for_next_slot, sign_block from eth2spec.test.helpers.state import next_epoch -from eth2spec.test.context import spec_state_test +from eth2spec.test.context import spec_state_test, with_all_phases -def run_process_registry_updates(state, valid=True): +def run_process_registry_updates(spec, state, valid=True): """ Run ``process_crosslinks``, yielding: - pre-state ('pre') @@ -20,9 +13,9 @@ def run_process_registry_updates(state, valid=True): """ # transition state to slot before state transition slot = state.slot + (spec.SLOTS_PER_EPOCH - state.slot % spec.SLOTS_PER_EPOCH) - 1 - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.slot = slot - sign_block(state, block) + sign_block(spec, state, block) state_transition(state, block) # cache state before epoch transition @@ -34,50 +27,52 @@ def run_process_registry_updates(state, valid=True): spec.process_rewards_and_penalties(state) yield 'pre', state - process_registry_updates(state) + spec.process_registry_updates(state) yield 'post', state +@with_all_phases @spec_state_test -def test_activation(state): +def test_activation(spec, state): index = 0 - assert is_active_validator(state.validator_registry[index], get_current_epoch(state)) + assert spec.is_active_validator(state.validator_registry[index], spec.get_current_epoch(state)) # Mock a new deposit state.validator_registry[index].activation_eligibility_epoch = spec.FAR_FUTURE_EPOCH state.validator_registry[index].activation_epoch = spec.FAR_FUTURE_EPOCH state.validator_registry[index].effective_balance = spec.MAX_EFFECTIVE_BALANCE - assert not is_active_validator(state.validator_registry[index], get_current_epoch(state)) + assert not spec.is_active_validator(state.validator_registry[index], spec.get_current_epoch(state)) for _ in range(spec.ACTIVATION_EXIT_DELAY + 1): - next_epoch(state) + next_epoch(spec, state) - yield from run_process_registry_updates(state) + yield from run_process_registry_updates(spec, state) assert state.validator_registry[index].activation_eligibility_epoch != spec.FAR_FUTURE_EPOCH assert state.validator_registry[index].activation_epoch != spec.FAR_FUTURE_EPOCH - assert is_active_validator( + assert spec.is_active_validator( state.validator_registry[index], - get_current_epoch(state), + spec.get_current_epoch(state), ) +@with_all_phases @spec_state_test -def test_ejection(state): +def test_ejection(spec, state): index = 0 - assert is_active_validator(state.validator_registry[index], get_current_epoch(state)) + assert spec.is_active_validator(state.validator_registry[index], spec.get_current_epoch(state)) assert state.validator_registry[index].exit_epoch == spec.FAR_FUTURE_EPOCH # Mock an ejection state.validator_registry[index].effective_balance = spec.EJECTION_BALANCE for _ in range(spec.ACTIVATION_EXIT_DELAY + 1): - next_epoch(state) + next_epoch(spec, state) - yield from run_process_registry_updates(state) + yield from run_process_registry_updates(spec, state) assert state.validator_registry[index].exit_epoch != spec.FAR_FUTURE_EPOCH - assert not is_active_validator( + assert not spec.is_active_validator( state.validator_registry[index], - get_current_epoch(state), + spec.get_current_epoch(state), ) diff --git a/test_libs/pyspec/eth2spec/test/phase_1/__init__.py b/test_libs/pyspec/eth2spec/test/phase_1/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_libs/pyspec/eth2spec/test/phase_1/block_processing/__init__.py b/test_libs/pyspec/eth2spec/test/phase_1/block_processing/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/test_libs/pyspec/eth2spec/test/phase_1/block_processing/test_process_early_derived_secret_reveal.py b/test_libs/pyspec/eth2spec/test/phase_1/block_processing/test_process_early_derived_secret_reveal.py new file mode 100644 index 000000000..110231d77 --- /dev/null +++ b/test_libs/pyspec/eth2spec/test/phase_1/block_processing/test_process_early_derived_secret_reveal.py @@ -0,0 +1,128 @@ +from eth2spec.test.helpers.custody import get_valid_early_derived_secret_reveal +from eth2spec.test.helpers.block import apply_empty_block +from eth2spec.test.helpers.state import next_epoch, get_balance +from eth2spec.test.context import with_all_phases_except, spec_state_test, expect_assertion_error + + +def run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, valid=True): + """ + Run ``process_randao_key_reveal``, yielding: + - pre-state ('pre') + - randao_key_reveal ('randao_key_reveal') + - post-state ('post'). + If ``valid == False``, run expecting ``AssertionError`` + """ + yield 'pre', state + yield 'randao_key_reveal', randao_key_reveal + + if not valid: + expect_assertion_error(lambda: spec.process_early_derived_secret_reveal(state, randao_key_reveal)) + yield 'post', None + return + + pre_slashed_balance = get_balance(state, randao_key_reveal.revealed_index) + + spec.process_early_derived_secret_reveal(state, randao_key_reveal) + + slashed_validator = state.validator_registry[randao_key_reveal.revealed_index] + + if randao_key_reveal.epoch >= spec.get_current_epoch(state) + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING: + assert slashed_validator.slashed + assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH + assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH + + assert get_balance(state, randao_key_reveal.revealed_index) < pre_slashed_balance + yield 'post', state + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_success(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal(spec, state) + + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_reveal_from_current_epoch(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal(spec, state, spec.get_current_epoch(state)) + + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, False) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_reveal_from_past_epoch(spec, state): + next_epoch(spec, state) + apply_empty_block(spec, state) + randao_key_reveal = get_valid_early_derived_secret_reveal(spec, state, spec.get_current_epoch(state) - 1) + + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, False) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_reveal_with_custody_padding(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal( + spec, + state, + spec.get_current_epoch(state) + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING, + ) + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, True) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_reveal_with_custody_padding_minus_one(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal( + spec, + state, + spec.get_current_epoch(state) + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING - 1, + ) + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, True) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_double_reveal(spec, state): + randao_key_reveal1 = get_valid_early_derived_secret_reveal( + spec, + state, + spec.get_current_epoch(state) + spec.RANDAO_PENALTY_EPOCHS + 1, + ) + res = dict(run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal1)) + pre_state = res['pre'] + yield 'pre', pre_state + intermediate_state = res['post'] + + randao_key_reveal2 = get_valid_early_derived_secret_reveal( + spec, + intermediate_state, + spec.get_current_epoch(pre_state) + spec.RANDAO_PENALTY_EPOCHS + 1, + ) + res = dict(run_early_derived_secret_reveal_processing(spec, intermediate_state, randao_key_reveal2, False)) + post_state = res['post'] + yield 'randao_key_reveal', [randao_key_reveal1, randao_key_reveal2] + yield 'post', post_state + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_revealer_is_slashed(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal(spec, state, spec.get_current_epoch(state)) + state.validator_registry[randao_key_reveal.revealed_index].slashed = True + + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, False) + + +@with_all_phases_except(['phase0']) +@spec_state_test +def test_far_future_epoch(spec, state): + randao_key_reveal = get_valid_early_derived_secret_reveal( + spec, + state, + spec.get_current_epoch(state) + spec.EARLY_DERIVED_SECRET_PENALTY_MAX_FUTURE_EPOCHS, + ) + + yield from run_early_derived_secret_reveal_processing(spec, state, randao_key_reveal, False) diff --git a/test_libs/pyspec/eth2spec/test/sanity/test_blocks.py b/test_libs/pyspec/eth2spec/test/sanity/test_blocks.py index 11ae4918e..587c37742 100644 --- a/test_libs/pyspec/eth2spec/test/sanity/test_blocks.py +++ b/test_libs/pyspec/eth2spec/test/sanity/test_blocks.py @@ -1,21 +1,9 @@ from copy import deepcopy from typing import List -import eth2spec.phase0.spec as spec +from eth2spec.utils.ssz.ssz_impl import signing_root from eth2spec.utils.bls import bls_sign -from eth2spec.utils.ssz.ssz_impl import signing_root -from eth2spec.phase0.spec import ( - # SSZ - VoluntaryExit, - # functions - get_active_validator_indices, - get_beacon_proposer_index, - get_block_root_at_slot, - get_current_epoch, - get_domain, - state_transition, -) from eth2spec.test.helpers.state import get_balance from eth2spec.test.helpers.transfers import get_valid_transfer from eth2spec.test.helpers.block import build_empty_block_for_next_slot, sign_block @@ -25,89 +13,94 @@ from eth2spec.test.helpers.proposer_slashings import get_valid_proposer_slashing from eth2spec.test.helpers.attestations import get_valid_attestation from eth2spec.test.helpers.deposits import prepare_state_and_deposit -from eth2spec.test.context import spec_state_test, never_bls +from eth2spec.test.context import spec_state_test, never_bls, with_all_phases +@with_all_phases @never_bls @spec_state_test -def test_empty_block_transition(state): +def test_empty_block_transition(spec, state): pre_slot = state.slot pre_eth1_votes = len(state.eth1_data_votes) yield 'pre', state - block = build_empty_block_for_next_slot(state, signed=True) + block = build_empty_block_for_next_slot(spec, state, signed=True) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state assert len(state.eth1_data_votes) == pre_eth1_votes + 1 - assert get_block_root_at_slot(state, pre_slot) == block.parent_root + assert spec.get_block_root_at_slot(state, pre_slot) == block.parent_root +@with_all_phases @never_bls @spec_state_test -def test_skipped_slots(state): +def test_skipped_slots(spec, state): pre_slot = state.slot yield 'pre', state - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.slot += 3 - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state assert state.slot == block.slot for slot in range(pre_slot, state.slot): - assert get_block_root_at_slot(state, slot) == block.parent_root + assert spec.get_block_root_at_slot(state, slot) == block.parent_root +@with_all_phases @spec_state_test -def test_empty_epoch_transition(state): +def test_empty_epoch_transition(spec, state): pre_slot = state.slot yield 'pre', state - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.slot += spec.SLOTS_PER_EPOCH - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state assert state.slot == block.slot for slot in range(pre_slot, state.slot): - assert get_block_root_at_slot(state, slot) == block.parent_root + assert spec.get_block_root_at_slot(state, slot) == block.parent_root +# @with_all_phases # @spec_state_test -# def test_empty_epoch_transition_not_finalizing(state): +# def test_empty_epoch_transition_not_finalizing(spec, state): # # copy for later balance lookups. # pre_state = deepcopy(state) # yield 'pre', state -# -# block = build_empty_block_for_next_slot(state) + +# block = build_empty_block_for_next_slot(spec, state) # block.slot += spec.SLOTS_PER_EPOCH * 5 -# sign_block(state, block, proposer_index=0) +# sign_block(spec, state, block, proposer_index=0) # yield 'blocks', [block], List[spec.BeaconBlock] -# -# state_transition(state, block) + +# spec.state_transition(state, block) # yield 'post', state -# + # assert state.slot == block.slot -# assert state.finalized_epoch < get_current_epoch(state) - 4 +# assert state.finalized_epoch < spec.get_current_epoch(state) - 4 # for index in range(len(state.validator_registry)): # assert get_balance(state, index) < get_balance(pre_state, index) +@with_all_phases @spec_state_test -def test_proposer_slashing(state): +def test_proposer_slashing(spec, state): # copy for later balance lookups. pre_state = deepcopy(state) - proposer_slashing = get_valid_proposer_slashing(state, signed_1=True, signed_2=True) + proposer_slashing = get_valid_proposer_slashing(spec, state, signed_1=True, signed_2=True) validator_index = proposer_slashing.proposer_index assert not state.validator_registry[validator_index].slashed @@ -117,12 +110,12 @@ def test_proposer_slashing(state): # # Add to state via block transition # - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.body.proposer_slashings.append(proposer_slashing) - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state # check if slashed @@ -134,12 +127,13 @@ def test_proposer_slashing(state): assert get_balance(state, validator_index) < get_balance(pre_state, validator_index) +@with_all_phases @spec_state_test -def test_attester_slashing(state): +def test_attester_slashing(spec, state): # copy for later balance lookups. pre_state = deepcopy(state) - attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=True) + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) validator_index = (attester_slashing.attestation_1.custody_bit_0_indices + attester_slashing.attestation_1.custody_bit_1_indices)[0] @@ -150,12 +144,12 @@ def test_attester_slashing(state): # # Add to state via block transition # - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.body.attester_slashings.append(attester_slashing) - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state slashed_validator = state.validator_registry[validator_index] @@ -165,7 +159,7 @@ def test_attester_slashing(state): # lost whistleblower reward assert get_balance(state, validator_index) < get_balance(pre_state, validator_index) - proposer_index = get_beacon_proposer_index(state) + proposer_index = spec.get_beacon_proposer_index(state) # gained whistleblower reward assert ( get_balance(state, proposer_index) > @@ -175,24 +169,25 @@ def test_attester_slashing(state): # TODO update functions below to be like above, i.e. with @spec_state_test and yielding data to put into the test vector +@with_all_phases @spec_state_test -def test_deposit_in_block(state): +def test_deposit_in_block(spec, state): initial_registry_len = len(state.validator_registry) initial_balances_len = len(state.balances) validator_index = len(state.validator_registry) amount = spec.MAX_EFFECTIVE_BALANCE - deposit = prepare_state_and_deposit(state, validator_index, amount, signed=True) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True) yield 'pre', state - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.body.deposits.append(deposit) - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state assert len(state.validator_registry) == initial_registry_len + 1 @@ -201,11 +196,12 @@ def test_deposit_in_block(state): assert state.validator_registry[validator_index].pubkey == pubkeys[validator_index] +@with_all_phases @spec_state_test -def test_deposit_top_up(state): +def test_deposit_top_up(spec, state): validator_index = 0 amount = spec.MAX_EFFECTIVE_BALANCE // 4 - deposit = prepare_state_and_deposit(state, validator_index, amount) + deposit = prepare_state_and_deposit(spec, state, validator_index, amount) initial_registry_len = len(state.validator_registry) initial_balances_len = len(state.balances) @@ -213,13 +209,13 @@ def test_deposit_top_up(state): yield 'pre', state - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.body.deposits.append(deposit) - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state assert len(state.validator_registry) == initial_registry_len @@ -227,31 +223,32 @@ def test_deposit_top_up(state): assert get_balance(state, validator_index) == validator_pre_balance + amount +@with_all_phases @spec_state_test -def test_attestation(state): +def test_attestation(spec, state): state.slot = spec.SLOTS_PER_EPOCH yield 'pre', state - attestation = get_valid_attestation(state, signed=True) + attestation = get_valid_attestation(spec, state, signed=True) # Add to state via block transition pre_current_attestations_len = len(state.current_epoch_attestations) - attestation_block = build_empty_block_for_next_slot(state) + attestation_block = build_empty_block_for_next_slot(spec, state) attestation_block.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY attestation_block.body.attestations.append(attestation) - sign_block(state, attestation_block) - state_transition(state, attestation_block) + sign_block(spec, state, attestation_block) + spec.state_transition(state, attestation_block) assert len(state.current_epoch_attestations) == pre_current_attestations_len + 1 # Epoch transition should move to previous_epoch_attestations pre_current_attestations_root = spec.hash_tree_root(state.current_epoch_attestations) - epoch_block = build_empty_block_for_next_slot(state) + epoch_block = build_empty_block_for_next_slot(spec, state) epoch_block.slot += spec.SLOTS_PER_EPOCH - sign_block(state, epoch_block) - state_transition(state, epoch_block) + sign_block(spec, state, epoch_block) + spec.state_transition(state, epoch_block) yield 'blocks', [attestation_block, epoch_block], List[spec.BeaconBlock] yield 'post', state @@ -260,11 +257,12 @@ def test_attestation(state): assert spec.hash_tree_root(state.previous_epoch_attestations) == pre_current_attestations_root +@with_all_phases @spec_state_test -def test_voluntary_exit(state): - validator_index = get_active_validator_indices( +def test_voluntary_exit(spec, state): + validator_index = spec.get_active_validator_indices( state, - get_current_epoch(state) + spec.get_current_epoch(state) )[-1] # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit @@ -272,32 +270,32 @@ def test_voluntary_exit(state): yield 'pre', state - voluntary_exit = VoluntaryExit( - epoch=get_current_epoch(state), + voluntary_exit = spec.VoluntaryExit( + epoch=spec.get_current_epoch(state), validator_index=validator_index, ) voluntary_exit.signature = bls_sign( message_hash=signing_root(voluntary_exit), privkey=privkeys[validator_index], - domain=get_domain( + domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_VOLUNTARY_EXIT, ) ) # Add to state via block transition - initiate_exit_block = build_empty_block_for_next_slot(state) + initiate_exit_block = build_empty_block_for_next_slot(spec, state) initiate_exit_block.body.voluntary_exits.append(voluntary_exit) - sign_block(state, initiate_exit_block) - state_transition(state, initiate_exit_block) + sign_block(spec, state, initiate_exit_block) + spec.state_transition(state, initiate_exit_block) assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH # Process within epoch transition - exit_block = build_empty_block_for_next_slot(state) + exit_block = build_empty_block_for_next_slot(spec, state) exit_block.slot += spec.SLOTS_PER_EPOCH - sign_block(state, exit_block) - state_transition(state, exit_block) + sign_block(spec, state, exit_block) + spec.state_transition(state, exit_block) yield 'blocks', [initiate_exit_block, exit_block], List[spec.BeaconBlock] yield 'post', state @@ -305,15 +303,16 @@ def test_voluntary_exit(state): assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH +@with_all_phases @spec_state_test -def test_transfer(state): +def test_transfer(spec, state): # overwrite default 0 to test spec.MAX_TRANSFERS = 1 - sender_index = get_active_validator_indices(state, get_current_epoch(state))[-1] + sender_index = spec.get_active_validator_indices(state, spec.get_current_epoch(state))[-1] amount = get_balance(state, sender_index) - transfer = get_valid_transfer(state, state.slot + 1, sender_index, amount, signed=True) + transfer = get_valid_transfer(spec, state, state.slot + 1, sender_index, amount, signed=True) recipient_index = transfer.recipient pre_transfer_recipient_balance = get_balance(state, recipient_index) @@ -323,13 +322,13 @@ def test_transfer(state): yield 'pre', state # Add to state via block transition - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.body.transfers.append(transfer) - sign_block(state, block) + sign_block(spec, state, block) yield 'blocks', [block], List[spec.BeaconBlock] - state_transition(state, block) + spec.state_transition(state, block) yield 'post', state sender_balance = get_balance(state, sender_index) @@ -338,10 +337,11 @@ def test_transfer(state): assert recipient_balance == pre_transfer_recipient_balance + amount +@with_all_phases @spec_state_test -def test_balance_driven_status_transitions(state): - current_epoch = get_current_epoch(state) - validator_index = get_active_validator_indices(state, current_epoch)[-1] +def test_balance_driven_status_transitions(spec, state): + current_epoch = spec.get_current_epoch(state) + validator_index = spec.get_active_validator_indices(state, current_epoch)[-1] assert state.validator_registry[validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH @@ -351,10 +351,10 @@ def test_balance_driven_status_transitions(state): yield 'pre', state # trigger epoch transition - block = build_empty_block_for_next_slot(state) + block = build_empty_block_for_next_slot(spec, state) block.slot += spec.SLOTS_PER_EPOCH - sign_block(state, block) - state_transition(state, block) + sign_block(spec, state, block) + spec.state_transition(state, block) yield 'blocks', [block], List[spec.BeaconBlock] yield 'post', state @@ -362,46 +362,48 @@ def test_balance_driven_status_transitions(state): assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH +@with_all_phases @spec_state_test -def test_historical_batch(state): +def test_historical_batch(spec, state): state.slot += spec.SLOTS_PER_HISTORICAL_ROOT - (state.slot % spec.SLOTS_PER_HISTORICAL_ROOT) - 1 pre_historical_roots_len = len(state.historical_roots) yield 'pre', state - block = build_empty_block_for_next_slot(state, signed=True) - state_transition(state, block) + block = build_empty_block_for_next_slot(spec, state, signed=True) + spec.state_transition(state, block) yield 'blocks', [block], List[spec.BeaconBlock] yield 'post', state assert state.slot == block.slot - assert get_current_epoch(state) % (spec.SLOTS_PER_HISTORICAL_ROOT // spec.SLOTS_PER_EPOCH) == 0 + assert spec.get_current_epoch(state) % (spec.SLOTS_PER_HISTORICAL_ROOT // spec.SLOTS_PER_EPOCH) == 0 assert len(state.historical_roots) == pre_historical_roots_len + 1 +# @with_all_phases # @spec_state_test -# def test_eth1_data_votes(state): +# def test_eth1_data_votes(spec, state): # yield 'pre', state -# + # expected_votes = 0 # assert len(state.eth1_data_votes) == expected_votes -# + # blocks = [] # for _ in range(spec.SLOTS_PER_ETH1_VOTING_PERIOD - 1): -# block = build_empty_block_for_next_slot(state) -# state_transition(state, block) +# block = build_empty_block_for_next_slot(spec, state) +# spec.state_transition(state, block) # expected_votes += 1 # assert len(state.eth1_data_votes) == expected_votes # blocks.append(block) -# -# block = build_empty_block_for_next_slot(state) + +# block = build_empty_block_for_next_slot(spec, state) # blocks.append(block) -# -# state_transition(state, block) -# + +# spec.state_transition(state, block) + # yield 'blocks', [block], List[spec.BeaconBlock] # yield 'post', state -# + # assert state.slot % spec.SLOTS_PER_ETH1_VOTING_PERIOD == 0 # assert len(state.eth1_data_votes) == 1 diff --git a/test_libs/pyspec/eth2spec/test/sanity/test_slots.py b/test_libs/pyspec/eth2spec/test/sanity/test_slots.py index 4c3897a6c..6ef6be4d3 100644 --- a/test_libs/pyspec/eth2spec/test/sanity/test_slots.py +++ b/test_libs/pyspec/eth2spec/test/sanity/test_slots.py @@ -1,57 +1,59 @@ -import eth2spec.phase0.spec as spec - -from eth2spec.phase0.spec import process_slots from eth2spec.test.helpers.state import get_state_root -from eth2spec.test.context import spec_state_test +from eth2spec.test.context import spec_state_test, with_all_phases +@with_all_phases @spec_state_test -def test_slots_1(state): +def test_slots_1(spec, state): pre_slot = state.slot pre_root = state.hash_tree_root() yield 'pre', state slots = 1 yield 'slots', slots - process_slots(state, state.slot + slots) + spec.process_slots(state, state.slot + slots) yield 'post', state assert state.slot == pre_slot + 1 - assert get_state_root(state, pre_slot) == pre_root + assert get_state_root(spec, state, pre_slot) == pre_root +@with_all_phases @spec_state_test -def test_slots_2(state): +def test_slots_2(spec, state): yield 'pre', state slots = 2 yield 'slots', slots - process_slots(state, state.slot + slots) + spec.process_slots(state, state.slot + slots) yield 'post', state +@with_all_phases @spec_state_test -def test_empty_epoch(state): +def test_empty_epoch(spec, state): yield 'pre', state slots = spec.SLOTS_PER_EPOCH yield 'slots', slots - process_slots(state, state.slot + slots) + spec.process_slots(state, state.slot + slots) yield 'post', state +@with_all_phases @spec_state_test -def test_double_empty_epoch(state): +def test_double_empty_epoch(spec, state): yield 'pre', state slots = spec.SLOTS_PER_EPOCH * 2 yield 'slots', slots - process_slots(state, state.slot + slots) + spec.process_slots(state, state.slot + slots) yield 'post', state +@with_all_phases @spec_state_test -def test_over_epoch_boundary(state): - process_slots(state, state.slot + (spec.SLOTS_PER_EPOCH // 2)) +def test_over_epoch_boundary(spec, state): + spec.process_slots(state, state.slot + (spec.SLOTS_PER_EPOCH // 2)) yield 'pre', state slots = spec.SLOTS_PER_EPOCH yield 'slots', slots - process_slots(state, state.slot + slots) + spec.process_slots(state, state.slot + slots) yield 'post', state diff --git a/test_libs/pyspec/eth2spec/test/test_finality.py b/test_libs/pyspec/eth2spec/test/test_finality.py index b1948ad8d..801e8b4fd 100644 --- a/test_libs/pyspec/eth2spec/test/test_finality.py +++ b/test_libs/pyspec/eth2spec/test/test_finality.py @@ -1,18 +1,14 @@ from copy import deepcopy from typing import List -import eth2spec.phase0.spec as spec -from eth2spec.phase0.spec import ( - get_current_epoch, - get_epoch_start_slot, -) -from .context import spec_state_test, never_bls -from .helpers.state import next_epoch -from .helpers.block import build_empty_block_for_next_slot, apply_empty_block -from .helpers.attestations import get_valid_attestation +from eth2spec.test.context import spec_state_test, never_bls, with_all_phases +from eth2spec.test.helpers.state import next_epoch +from eth2spec.test.helpers.block import build_empty_block_for_next_slot, apply_empty_block +from eth2spec.test.helpers.attestations import get_valid_attestation -def check_finality(state, +def check_finality(spec, + state, prev_state, current_justified_changed, previous_justified_changed, @@ -39,22 +35,23 @@ def check_finality(state, assert state.finalized_root == prev_state.finalized_root -def next_epoch_with_attestations(state, +def next_epoch_with_attestations(spec, + state, fill_cur_epoch, fill_prev_epoch): post_state = deepcopy(state) blocks = [] for _ in range(spec.SLOTS_PER_EPOCH): - block = build_empty_block_for_next_slot(post_state) + block = build_empty_block_for_next_slot(spec, post_state) if fill_cur_epoch: slot_to_attest = post_state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1 - if slot_to_attest >= get_epoch_start_slot(get_current_epoch(post_state)): - cur_attestation = get_valid_attestation(post_state, slot_to_attest) + if slot_to_attest >= spec.get_epoch_start_slot(spec.get_current_epoch(post_state)): + cur_attestation = get_valid_attestation(spec, post_state, slot_to_attest) block.body.attestations.append(cur_attestation) if fill_prev_epoch: slot_to_attest = post_state.slot - spec.SLOTS_PER_EPOCH + 1 - prev_attestation = get_valid_attestation(post_state, slot_to_attest) + prev_attestation = get_valid_attestation(spec, post_state, slot_to_attest) block.body.attestations.append(prev_attestation) spec.state_transition(post_state, block) @@ -63,27 +60,28 @@ def next_epoch_with_attestations(state, return state, blocks, post_state +@with_all_phases @never_bls @spec_state_test -def test_finality_rule_4(state): +def test_finality_rule_4(spec, state): yield 'pre', state blocks = [] for epoch in range(4): - prev_state, new_blocks, state = next_epoch_with_attestations(state, True, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, True, False) blocks += new_blocks # justification/finalization skipped at GENESIS_EPOCH if epoch == 0: - check_finality(state, prev_state, False, False, False) + check_finality(spec, state, prev_state, False, False, False) # justification/finalization skipped at GENESIS_EPOCH + 1 elif epoch == 1: - check_finality(state, prev_state, False, False, False) + check_finality(spec, state, prev_state, False, False, False) elif epoch == 2: - check_finality(state, prev_state, True, False, False) + check_finality(spec, state, prev_state, True, False, False) elif epoch >= 3: # rule 4 of finality - check_finality(state, prev_state, True, True, True) + check_finality(spec, state, prev_state, True, True, True) assert state.finalized_epoch == prev_state.current_justified_epoch assert state.finalized_root == prev_state.current_justified_root @@ -91,29 +89,30 @@ def test_finality_rule_4(state): yield 'post', state +@with_all_phases @never_bls @spec_state_test -def test_finality_rule_1(state): +def test_finality_rule_1(spec, state): # get past first two epochs that finality does not run on - next_epoch(state) - apply_empty_block(state) - next_epoch(state) - apply_empty_block(state) + next_epoch(spec, state) + apply_empty_block(spec, state) + next_epoch(spec, state) + apply_empty_block(spec, state) yield 'pre', state blocks = [] for epoch in range(3): - prev_state, new_blocks, state = next_epoch_with_attestations(state, False, True) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, False, True) blocks += new_blocks if epoch == 0: - check_finality(state, prev_state, True, False, False) + check_finality(spec, state, prev_state, True, False, False) elif epoch == 1: - check_finality(state, prev_state, True, True, False) + check_finality(spec, state, prev_state, True, True, False) elif epoch == 2: # finalized by rule 1 - check_finality(state, prev_state, True, True, True) + check_finality(spec, state, prev_state, True, True, True) assert state.finalized_epoch == prev_state.previous_justified_epoch assert state.finalized_root == prev_state.previous_justified_root @@ -121,29 +120,30 @@ def test_finality_rule_1(state): yield 'post', state +@with_all_phases @never_bls @spec_state_test -def test_finality_rule_2(state): +def test_finality_rule_2(spec, state): # get past first two epochs that finality does not run on - next_epoch(state) - apply_empty_block(state) - next_epoch(state) - apply_empty_block(state) + next_epoch(spec, state) + apply_empty_block(spec, state) + next_epoch(spec, state) + apply_empty_block(spec, state) yield 'pre', state blocks = [] for epoch in range(3): if epoch == 0: - prev_state, new_blocks, state = next_epoch_with_attestations(state, True, False) - check_finality(state, prev_state, True, False, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, True, False) + check_finality(spec, state, prev_state, True, False, False) elif epoch == 1: - prev_state, new_blocks, state = next_epoch_with_attestations(state, False, False) - check_finality(state, prev_state, False, True, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, False, False) + check_finality(spec, state, prev_state, False, True, False) elif epoch == 2: - prev_state, new_blocks, state = next_epoch_with_attestations(state, False, True) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, False, True) # finalized by rule 2 - check_finality(state, prev_state, True, False, True) + check_finality(spec, state, prev_state, True, False, True) assert state.finalized_epoch == prev_state.previous_justified_epoch assert state.finalized_root == prev_state.previous_justified_root @@ -153,48 +153,49 @@ def test_finality_rule_2(state): yield 'post', state +@with_all_phases @never_bls @spec_state_test -def test_finality_rule_3(state): +def test_finality_rule_3(spec, state): """ Test scenario described here https://github.com/ethereum/eth2.0-specs/issues/611#issuecomment-463612892 """ # get past first two epochs that finality does not run on - next_epoch(state) - apply_empty_block(state) - next_epoch(state) - apply_empty_block(state) + next_epoch(spec, state) + apply_empty_block(spec, state) + next_epoch(spec, state) + apply_empty_block(spec, state) yield 'pre', state blocks = [] - prev_state, new_blocks, state = next_epoch_with_attestations(state, True, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, True, False) blocks += new_blocks - check_finality(state, prev_state, True, False, False) + check_finality(spec, state, prev_state, True, False, False) # In epoch N, JE is set to N, prev JE is set to N-1 - prev_state, new_blocks, state = next_epoch_with_attestations(state, True, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, True, False) blocks += new_blocks - check_finality(state, prev_state, True, True, True) + check_finality(spec, state, prev_state, True, True, True) # In epoch N+1, JE is N, prev JE is N-1, and not enough messages get in to do anything - prev_state, new_blocks, state = next_epoch_with_attestations(state, False, False) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, False, False) blocks += new_blocks - check_finality(state, prev_state, False, True, False) + check_finality(spec, state, prev_state, False, True, False) # In epoch N+2, JE is N, prev JE is N, and enough messages from the previous epoch get in to justify N+1. # N+1 now becomes the JE. Not enough messages from epoch N+2 itself get in to justify N+2 - prev_state, new_blocks, state = next_epoch_with_attestations(state, False, True) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, False, True) blocks += new_blocks # rule 2 - check_finality(state, prev_state, True, False, True) + check_finality(spec, state, prev_state, True, False, True) # In epoch N+3, LJE is N+1, prev LJE is N, and enough messages get in to justify epochs N+2 and N+3. - prev_state, new_blocks, state = next_epoch_with_attestations(state, True, True) + prev_state, new_blocks, state = next_epoch_with_attestations(spec, state, True, True) blocks += new_blocks # rule 3 - check_finality(state, prev_state, True, True, True) + check_finality(spec, state, prev_state, True, True, True) assert state.finalized_epoch == prev_state.current_justified_epoch assert state.finalized_root == prev_state.current_justified_root diff --git a/test_libs/pyspec/eth2spec/utils/ssz/ssz_impl.py b/test_libs/pyspec/eth2spec/utils/ssz/ssz_impl.py index ea4313c67..b3c877d48 100644 --- a/test_libs/pyspec/eth2spec/utils/ssz/ssz_impl.py +++ b/test_libs/pyspec/eth2spec/utils/ssz/ssz_impl.py @@ -4,7 +4,8 @@ from eth2spec.utils.ssz.ssz_typing import ( is_list_kind, is_vector_kind, read_vector_elem_type, read_elem_type, uint_byte_size, - infer_input_type + infer_input_type, + get_zero_value, ) # SSZ Serialization @@ -52,6 +53,10 @@ def is_fixed_size(typ): raise Exception("Type not supported: {}".format(typ)) +def is_empty(obj): + return get_zero_value(type(obj)) == obj + + @infer_input_type def serialize(obj, typ=None): if is_basic_type(typ): diff --git a/test_libs/pyspec/eth2spec/utils/ssz/ssz_typing.py b/test_libs/pyspec/eth2spec/utils/ssz/ssz_typing.py index 1e05ccd5d..368041f90 100644 --- a/test_libs/pyspec/eth2spec/utils/ssz/ssz_typing.py +++ b/test_libs/pyspec/eth2spec/utils/ssz/ssz_typing.py @@ -1,4 +1,3 @@ -from inspect import isclass from typing import List, Iterable, TypeVar, Type, NewType from typing import Union from typing_inspect import get_origin @@ -247,10 +246,10 @@ class Vector(metaclass=VectorMeta): self.items = list(args) - # cannot check non-class objects - if isclass(cls.elem_type): + # cannot check non-type objects, or parametrized types + if isinstance(cls.elem_type, type) and not hasattr(cls.elem_type, '__args__'): for i, item in enumerate(self.items): - if not isinstance(item, cls.elem_type): + if not issubclass(type(item), cls.elem_type): raise TypeError("Typed vector cannot hold differently typed value" " at index %d. Got type: %s, expected type: %s" % (i, type(item), cls.elem_type)) diff --git a/test_libs/pyspec/tests/block_processing_phase1/phase1_test_process_randao_key_reveal.py b/test_libs/pyspec/tests/block_processing_phase1/phase1_test_process_randao_key_reveal.py deleted file mode 100644 index 0be8ab4a9..000000000 --- a/test_libs/pyspec/tests/block_processing_phase1/phase1_test_process_randao_key_reveal.py +++ /dev/null @@ -1,109 +0,0 @@ -from copy import deepcopy -import pytest - -import eth2spec.phase1.spec as spec -from eth2spec.phase1.spec import ( - get_current_epoch, - process_randao_key_reveal, - RANDAO_PENALTY_EPOCHS, - CUSTODY_PERIOD_TO_RANDAO_PADDING, - RANDAO_PENALTY_MAX_FUTURE_EPOCHS, -) -from tests.helpers_phase1 import ( - get_valid_randao_key_reveal, -) - -mark entire file as 'randao_key_reveals' -pytestmark = pytest.mark.randao_key_reveals - - -def run_randao_key_reveal_processing(state, randao_key_reveal, valid=True): - """ - Run ``process_randao_key_reveal`` returning the pre and post state. - If ``valid == False``, run expecting ``AssertionError`` - """ - post_state = deepcopy(state) - - if not valid: - with pytest.raises(AssertionError): - process_randao_key_reveal(post_state, randao_key_reveal) - return state, None - - process_randao_key_reveal(post_state, randao_key_reveal) - - slashed_validator = post_state.validator_registry[randao_key_reveal.revealed_index] - - if randao_key_reveal.epoch >= get_current_epoch(state) + CUSTODY_PERIOD_TO_RANDAO_PADDING: - assert slashed_validator.slashed - assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH - assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH - # lost whistleblower reward - # FIXME: Currently broken because get_base_reward in genesis epoch is 0 - assert ( - post_state.balances[randao_key_reveal.revealed_index] < - state.balances[randao_key_reveal.revealed_index] - ) - - return state, post_state - - -def test_success(state): - randao_key_reveal = get_valid_randao_key_reveal(state) - - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal) - - return pre_state, randao_key_reveal, post_state - - -def test_reveal_from_current_epoch(state): - randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state)) - - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, False) - - return pre_state, randao_key_reveal, post_state - -# Not currently possible as we are testing at epoch 0 -# -#def test_reveal_from_past_epoch(state): -# randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state) - 1) -# -# pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, False) -# -# return pre_state, randao_key_reveal, post_state - -def test_reveal_with_custody_padding(state): - randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state) + CUSTODY_PERIOD_TO_RANDAO_PADDING) - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, True) - - return pre_state, randao_key_reveal, post_state - -def test_reveal_with_custody_padding_minus_one(state): - randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state) + CUSTODY_PERIOD_TO_RANDAO_PADDING - 1) - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, True) - - return pre_state, randao_key_reveal, post_state - -def test_double_reveal(state): - - randao_key_reveal1 = get_valid_randao_key_reveal(state, get_current_epoch(state) + RANDAO_PENALTY_EPOCHS + 1) - pre_state, intermediate_state = run_randao_key_reveal_processing(state, randao_key_reveal1) - - randao_key_reveal2 = get_valid_randao_key_reveal(intermediate_state, get_current_epoch(pre_state) + RANDAO_PENALTY_EPOCHS + 1) - intermediate_state_, post_state = run_randao_key_reveal_processing(intermediate_state, randao_key_reveal2, False) - - return pre_state, [randao_key_reveal1, randao_key_reveal2], post_state - -def test_revealer_is_slashed(state): - randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state)) - state.validator_registry[randao_key_reveal.revealed_index].slashed = True - - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, False) - - return pre_state, randao_key_reveal, post_state - -def test_far_future_epoch(state): - randao_key_reveal = get_valid_randao_key_reveal(state, get_current_epoch(state) + RANDAO_PENALTY_MAX_FUTURE_EPOCHS) - - pre_state, post_state = run_randao_key_reveal_processing(state, randao_key_reveal, False) - - return pre_state, randao_key_reveal, post_state diff --git a/test_libs/pyspec/tests/helpers_phase1.py b/test_libs/pyspec/tests/helpers_phase1.py deleted file mode 100644 index aba93e159..000000000 --- a/test_libs/pyspec/tests/helpers_phase1.py +++ /dev/null @@ -1,50 +0,0 @@ -from py_ecc import bls - -import eth2spec.phase1.spec as spec -from eth2spec.phase0.spec import ( - # constants - ZERO_HASH, - CUSTODY_PERIOD_TO_RANDAO_PADDING, - # SSZ - RandaoKeyReveal, - # functions - get_active_validator_indices, - get_current_epoch, - get_domain, - hash_tree_root, -) - -def get_valid_randao_key_reveal(state, epoch=None): - current_epoch = get_current_epoch(state) - revealed_index = get_active_validator_indices(state, current_epoch)[-1] - masker_index = get_active_validator_indices(state, current_epoch)[0] - - if epoch is None: - epoch = current_epoch + CUSTODY_PERIOD_TO_RANDAO_PADDING - - reveal = bls.sign( - message_hash=hash_tree_root(epoch), - privkey=pubkey_to_privkey[state.validator_registry[revealed_index].pubkey], - domain=get_domain( - state=state, - domain_type=spec.DOMAIN_RANDAO, - message_epoch=epoch, - ), - ) - mask = bls.sign( - message_hash=hash_tree_root(epoch), - privkey=pubkey_to_privkey[state.validator_registry[masker_index].pubkey], - domain=get_domain( - state=state, - domain_type=spec.DOMAIN_RANDAO, - message_epoch=epoch, - ), - ) - - return RandaoKeyReveal( - revealed_index=revealed_index, - epoch=epoch, - reveal=reveal, - masker_index=masker_index, - mask=mask, - )