mirror of
https://github.com/status-im/eth2.0-specs.git
synced 2025-01-12 11:44:41 +00:00
245 lines
8.3 KiB
Python
245 lines
8.3 KiB
Python
import sys
|
|
import re
|
|
import function_puller
|
|
from argparse import ArgumentParser
|
|
from typing import Tuple, List
|
|
|
|
|
|
IMPORTS = '''from typing import (
|
|
Any,
|
|
Dict,
|
|
List,
|
|
NewType,
|
|
Tuple,
|
|
)
|
|
|
|
from eth2spec.utils.minimal_ssz import (
|
|
SSZType,
|
|
hash_tree_root,
|
|
signing_root,
|
|
)
|
|
|
|
from eth2spec.utils.bls_stub import (
|
|
bls_aggregate_pubkeys,
|
|
bls_verify,
|
|
bls_verify_multiple,
|
|
)
|
|
|
|
from eth2spec.utils.hash_function import hash
|
|
'''
|
|
NEW_TYPE_DEFINITIONS = '''
|
|
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
|
|
Bytes32 = NewType('Bytes32', bytes) # bytes32
|
|
BLSPubkey = NewType('BLSPubkey', bytes) # bytes48
|
|
BLSSignature = NewType('BLSSignature', bytes) # bytes96
|
|
Store = None
|
|
'''
|
|
SUNDRY_FUNCTIONS = '''
|
|
# 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 split_and_label(regex_pattern: str, text: str) -> List[str]:
|
|
'''
|
|
Splits a string based on regex, but down not remove the matched text.
|
|
It subsequently labels the matches with their match
|
|
'''
|
|
find_pattern = r'''%s.*?(?=%s|$)''' % (regex_pattern, regex_pattern)
|
|
matches = re.findall(find_pattern, text, re.DOTALL)
|
|
return list(map(lambda x: [re.match(regex_pattern, x).group(0), x], matches))
|
|
|
|
|
|
def inserter(oldfile: str, newfile: str) -> Tuple[str, str]:
|
|
'''
|
|
Searches for occurrences of @LabelName in oldfile and replaces them with instances of code wraped as follows:
|
|
# begin insert @LabelName
|
|
def foo(bar):
|
|
return bar
|
|
# end insert @LabelName
|
|
'''
|
|
new_insert_objects = re.split(r"(# begin insert |# end insert @[\w\d_]*\n)", newfile)
|
|
# Retrieve label from insert objects
|
|
def get_labeled_object(labeled_text):
|
|
label = re.match(r"@[\w\d_]*\n", labeled_text)
|
|
if label is not None:
|
|
label = label.group(0)
|
|
labeled_text = re.sub(label, '', labeled_text)
|
|
return {'label': label, 'text': labeled_text}
|
|
new_insert_objects = map(get_labeled_object, new_insert_objects)
|
|
# Find and replace labels
|
|
newfile = ""
|
|
for item in new_insert_objects:
|
|
if item['label'] is not None:
|
|
oldfile, insertions = re.subn('# %s' % item['label'], item['text'], oldfile)
|
|
if insertions == 0:
|
|
newfile.join('# begin insert %s/n%s# end insert %s' % (item['label'], item['text'], item['label']))
|
|
elif re.match(r"(# begin insert |# end insert )", item['text']) is None:
|
|
newfile += item['text']
|
|
return oldfile, newfile
|
|
|
|
|
|
def merger(oldfile:str, newfile:str) -> str:
|
|
'''
|
|
Seeks out functions and objects in new and old files.
|
|
Replaces old objects with new ones if they exist.
|
|
'''
|
|
object_regex = r'''(?:\n[@\w]+[\s\w]*[='" "\.\w]*)|(?:\s{4}global_vars\["\w+"\])'''
|
|
ssz_object_regex = r'''(?:\w+|\s{4}global_vars\["\w+"\]) = SSZType\(\{\n'''
|
|
old_objects = split_and_label(object_regex, oldfile)
|
|
new_objects = split_and_label(object_regex, newfile)
|
|
for new_item in new_objects:
|
|
found_old = False
|
|
for index, old_item in enumerate(old_objects):
|
|
if old_item[0] == new_item[0]:
|
|
ssz_object_match = re.match(ssz_object_regex, new_item[1])
|
|
if ssz_object_match is not None:
|
|
new_item[1] = re.sub(ssz_object_regex, '', new_item[1])
|
|
old_item[1] = re.sub(r'\n\w*\}\)', '', old_item[1])
|
|
old_item[1] += new_item[1]
|
|
else:
|
|
old_item[1] = new_item[1]
|
|
found_old = True
|
|
old_objects[index] = old_item
|
|
break
|
|
if not found_old:
|
|
old_objects.append(new_item)
|
|
return ''.join(elem for elem in map(lambda x: x[1], old_objects))
|
|
|
|
|
|
def objects_to_spec(functions, constants, ssz_objects):
|
|
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'.join(map(lambda x: '%s = SSZType(%s)' % (x, ssz_objects[x][:-1]), ssz_objects))
|
|
ssz_objects_reinitialization_spec = '\n'.join(
|
|
map(lambda x: ' global_vars[%s] = SSZType(%s })' % (x, re.sub('( ){4}', ' '*8, ssz_objects[x][:-2])), ssz_objects))
|
|
ssz_objects_reinitialization_spec = (
|
|
'def init_SSZ_types():\n global_vars = globals()\n'
|
|
+ ssz_objects_reinitialization_spec
|
|
)
|
|
return (
|
|
IMPORTS
|
|
+ '\n' + NEW_TYPE_DEFINITIONS
|
|
+ '\n' + constants_spec
|
|
+ '\n' + ssz_objects_instantiation_spec
|
|
+ '\n\n\n' + functions_spec
|
|
+ '\n' + SUNDRY_FUNCTIONS
|
|
+ '\n\n' + ssz_objects_reinitialization_spec
|
|
+ '\n'
|
|
)
|
|
|
|
def combine_functions(old_funcitons, new_functions):
|
|
for key, value in new_functions.items():
|
|
old_funcitons[key] = value
|
|
# TODO: Add insert functionality
|
|
return old_funcitons
|
|
|
|
|
|
def combine_constants(old_constants, new_constants):
|
|
for key, value in new_constants.items():
|
|
old_constants[key] = value
|
|
return old_constants
|
|
|
|
def combine_ssz_objects(old_objects, new_objects):
|
|
remove_encasing = lambda x: x[1:-1]
|
|
old_objects = map(remove_encasing, old_objects)
|
|
new_objects = map(remove_encasing, new_objects)
|
|
for key, value in new_objects.items():
|
|
old_objects[key] += value
|
|
reapply_encasing = lambda x: '{%s}' %x
|
|
return map(reapply_encasing, old_objects)
|
|
|
|
|
|
def build_phase0_spec(sourcefile, outfile=None):
|
|
functions, constants, ssz_objects = function_puller.get_spec(sourcefile)
|
|
spec = objects_to_spec(functions, constants, ssz_objects)
|
|
if outfile is not None:
|
|
with open(outfile, 'w') as out:
|
|
out.write(spec)
|
|
else:
|
|
return spec
|
|
|
|
|
|
def build_phase1_spec(phase0_sourcefile, phase1_sourcefile, outfile=None):
|
|
phase0_functions, phase0_constants, phase0_ssz_objects = function_puller.get_spec(phase0_sourcefile)
|
|
phase1_functions, phase1_constants, phase1_ssz_objects = function_puller.get_spec(phase1_sourcefile)
|
|
functions = combine_functions(phase0_functions, phase1_functions)
|
|
constants = combine_constants(phase0_constants, phase1_constants)
|
|
ssz_objects = combine_functions(phase0_ssz_objects, phase1_ssz_objects)
|
|
spec = objects_to_spec(functions, constants, ssz_objects)
|
|
if outfile is not None:
|
|
with open(outfile, 'w') as out:
|
|
out.write(spec)
|
|
else:
|
|
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.md
|
|
3rd 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:
|
|
build_phase0_spec(*args.files)
|
|
elif args.phase == 1:
|
|
if len(args.files) == 3:
|
|
build_phase1_spec(*args.files)
|
|
else:
|
|
print(" Phase 1 requires an output as well as 2 input files (phase0.md and phase1.md)")
|
|
else:
|
|
print("Invalid phase: {0}".format(args.phase))
|