def test_decoder():
rng = Random(123)
# check these types only, Block covers a lot of operation types already.
for typ in [spec.AttestationDataAndCustodyBit, spec.BeaconState, spec.BeaconBlock]:
# create a random pyspec value
original = random_value.get_random_ssz_object(rng, typ, 100, 10,
mode=random_value.RandomizationMode.mode_random,
chaos=True)
# serialize it, using pyspec
pyspec_data = spec_ssz_impl.serialize(original)
# get the py-ssz type for it
block_sedes = translate_typ(typ)
# try decoding using the py-ssz type
raw_value = block_sedes.deserialize(pyspec_data)
# serialize it using py-ssz
pyssz_data = block_sedes.serialize(raw_value)
# now check if the serialized form is equal. If so, we confirmed decoding and encoding to work.
assert pyspec_data == pyssz_data
# now translate the py-ssz value in a pyspec-value
block = translate_value(raw_value, typ)
# and see if the hash-tree-root of the original matches the hash-tree-root of the decoded & translated value.
original_hash_tree_root = spec_ssz_impl.hash_tree_root(original)
assert original_hash_tree_root == spec_ssz_impl.hash_tree_root(block)
assert original_hash_tree_root == block_sedes.get_hash_tree_root(raw_value)
def pyspec_transition(pre_state, pre_block):
yaml = YAML(typ='base')
loaded = yaml.load(Path('min.config.bak'))
config_data = dict()
for k, v in loaded.items():
if v.startswith("0x"):
config_data[k] = bytes.fromhex(v[2:])
else:
config_data[k] = int(v)
spec.apply_constants_preset(config_data)
spec_pre_state = decoder.translate_value(pre_state, spec.BeaconState)
spec_pre_block = decoder.translate_value(pre_block, spec.BeaconBlock)
spec_post_block = spec.state_transition(spec_pre_state, spec_pre_block,
False)
return spec_post_block
def convert_raw_to_ssz(raw, ssz_typ):
# get the pyssz type
# read raw with the pyszz from from pyssz
# convert pyssz ob to ssz_type
sedes = translate_typ(ssz_typ)
pyssz_value = sedes.deserialize(raw)
ssz_value = translate_value(pyssz_value, ssz_typ)
return ssz_value
def FuzzerRunOne(input_data: bytes) -> typing.Optional[bytes]:
test_case = translate_value(deposit_sedes.deserialize(input_data),
DepositTestCase)
try:
# modifies state in place
spec.process_deposit(state=test_case.pre, deposit=test_case.deposit)
return serialize(test_case.pre)
except (AssertionError, IndexError):
return None
def FuzzerRunOne(input_data: bytes) -> typing.Optional[bytes]:
test_case = translate_value(block_header_sedes.deserialize(input_data),
BlockHeaderTestCase)
try:
# modifies state in place
spec.process_block_header(state=test_case.pre, block=test_case.block)
# NOTE - signature verification should do nothing with bls disabled
return serialize(test_case.pre)
except (AssertionError, IndexError):
return None
def FuzzerRunOne(FuzzerInput):
state_block = translate_value(state_block_sedes.deserialize(FuzzerInput),
StateBlock)
prestate = copy.deepcopy(prestates[state_block.stateID])
try:
poststate = spec.state_transition(prestate, state_block.block, False)
return serialize(poststate)
except AssertionError as e:
pass
except IndexError:
pass
def FuzzerRunOne(input_data: bytes) -> typing.Optional[bytes]:
test_case = translate_value(
proposer_slashing_sedes.deserialize(input_data),
ProposerSlashingTestCase)
try:
# modifies state in place
spec.process_proposer_slashing(test_case.pre,
test_case.proposer_slashing)
# NOTE - signature verification should do nothing with bls disabled
return serialize(test_case.pre)
except (AssertionError, IndexError):
return None
def FuzzerRunOne(fuzzer_input):
state_block = translate_value(block_sedes.deserialize(fuzzer_input),
BlockTestCase)
try:
# NOTE we don't validate state root here
poststate = spec.state_transition(
state=state_block.pre,
block=state_block.block,
validate_state_root=VALIDATE_STATE_ROOT,
)
return serialize(poststate)
except (AssertionError, IndexError):
return None
def get_operations(
search_dir: pathlib.Path, op_details: OperationRegistryEntry
) -> typing.Iterable[SSZType]:
"""Returns unique operations in the search directory."""
# TODO deduplication? Only an efficiency not correctness problem. SHA1 does dedup after this
seen_ops: typing.Set[bytes] = set()
for f in recursive_iterfiles(search_dir):
if f.name.lower() in op_details.ssz_file_names:
raw = f.read_bytes()
raw_hash = hashlib.sha1(raw).digest()
if raw_hash not in seen_ops:
# TODO handle deserialization errors
seen_ops.add(raw_hash)
yield translate_value(
op_details.operation_sedes.deserialize(raw),
op_details.operation_type,
)
def load_prestates():
prestates = []
assert 'ETH2_FUZZER_STATE_CORPUS_PATH' in os.environ, "ETH2_FUZZER_STATE_CORPUS_PATH not set"
ETH2_FUZZER_STATE_CORPUS_PATH = os.environ['ETH2_FUZZER_STATE_CORPUS_PATH']
i = 0
while True:
try:
with open(os.path.join(ETH2_FUZZER_STATE_CORPUS_PATH, str(i)),
'rb') as fp:
raw_value = translate_typ(spec.BeaconState).deserialize(
fp.read())
prestates += [translate_value(raw_value, spec.BeaconState)]
except FileNotFoundError:
break
i += 1
assert len(prestates) > 0, "Could not load any prestates"
return prestates