def merge(h, i): j = 0 while True: if i & (1 << j) == 0: if i == count and j < depth: h = hash(h + zerohashes[j]) # keep going if we are complementing the void to the next power of 2 else: break else: h = hash(tmp[j] + h) j += 1 tmp[j] = h
def compute_merkle_root(leaf_nodes): assert len(leaf_nodes) >= 1 empty_node = b'\x00' * 32 child_nodes = leaf_nodes[:] for _ in range(DEPOSIT_CONTRACT_TREE_DEPTH): parent_nodes = [] if len(child_nodes) % 2 == 1: child_nodes.append(empty_node) for j in range(0, len(child_nodes), 2): parent_nodes.append(hash(child_nodes[j] + child_nodes[j + 1])) child_nodes = parent_nodes empty_node = hash(empty_node + empty_node) return child_nodes[0]
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 # Generate the secret that is being revealed domain = spec.get_domain(state, spec.DOMAIN_RANDAO, epoch) signing_root = spec.compute_signing_root(spec.Epoch(epoch), domain) reveal = bls.Sign(privkeys[revealed_index], signing_root) # Generate the mask (any random 32 bytes that don't reveal the masker's secret will do) mask = hash(reveal) # Generate masker's signature on the mask signing_root = spec.compute_signing_root(mask, domain) masker_signature = bls.Sign(privkeys[masker_index], signing_root) masked_reveal = bls.Aggregate([reveal, masker_signature]) return spec.EarlyDerivedSecretReveal( revealed_index=revealed_index, epoch=epoch, reveal=masked_reveal, masker_index=masker_index, mask=mask, )
def calc_merkle_tree_from_leaves(values, layer_count=32): values = list(values) tree = [values[::]] for h in range(layer_count): if len(values) % 2 == 1: values.append(zerohashes[h]) values = [hash(values[i] + values[i + 1]) for i in range(0, len(values), 2)] tree.append(values[::]) return tree
def merkleize_chunks(chunks, limit=None): # If no limit is defined, we are just merkleizing chunks (e.g. SSZ container). if limit is None: limit = len(chunks) count = len(chunks) # See if the input is within expected size. # If not, a list-limit is set incorrectly, or a value is unexpectedly large. assert count <= limit if limit == 0: return zerohashes[0] depth = max(count - 1, 0).bit_length() max_depth = (limit - 1).bit_length() tmp = [None for _ in range(max_depth + 1)] def merge(h, i): j = 0 while True: if i & (1 << j) == 0: if i == count and j < depth: h = hash( h + zerohashes[j] ) # keep going if we are complementing the void to the next power of 2 else: break else: h = hash(tmp[j] + h) j += 1 tmp[j] = h # merge in leaf by leaf. for i in range(count): merge(chunks[i], i) # complement with 0 if empty, or if not the right power of 2 if 1 << depth != count: merge(zerohashes[0], count) # the next power of two may be smaller than the ultimate virtual size, complement with zero-hashes at each depth. for j in range(depth, max_depth): tmp[j + 1] = hash(tmp[j] + zerohashes[j]) return tmp[max_depth]
def get_committee_indices(spec, state, duplicates=False): """ This utility function allows the caller to ensure there are or are not duplicate validator indices in the returned committee based on the boolean ``duplicates``. """ state = state.copy() current_epoch = spec.get_current_epoch(state) randao_index = (current_epoch + 1) % spec.EPOCHS_PER_HISTORICAL_VECTOR while True: committee = spec.get_next_sync_committee_indices(state) if duplicates: if len(committee) != len(set(committee)): return committee else: if len(committee) == len(set(committee)): return committee state.randao_mixes[randao_index] = hash(state.randao_mixes[randao_index])
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 # Generate the secret that is being revealed reveal = bls_sign( message_hash=spec.hash_tree_root(spec.Epoch(epoch)), privkey=privkeys[revealed_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) # Generate the mask (any random 32 bytes that don't reveal the masker's secret will do) mask = hash(reveal) # Generate masker's signature on the mask masker_signature = bls_sign( message_hash=mask, privkey=privkeys[masker_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) masked_reveal = bls_aggregate_signatures([reveal, masker_signature]) return spec.EarlyDerivedSecretReveal( revealed_index=revealed_index, epoch=epoch, reveal=masked_reveal, masker_index=masker_index, mask=mask, )
from eth2spec.utils.hash_function import hash from math import log2 ZERO_BYTES32 = b'\x00' * 32 zerohashes = [ZERO_BYTES32] for layer in range(1, 100): zerohashes.append(hash(zerohashes[layer - 1] + zerohashes[layer - 1])) def calc_merkle_tree_from_leaves(values, layer_count=32): values = list(values) tree = [values[::]] for h in range(layer_count): if len(values) % 2 == 1: values.append(zerohashes[h]) values = [hash(values[i] + values[i + 1]) for i in range(0, len(values), 2)] tree.append(values[::]) return tree def get_merkle_tree(values, pad_to=None): layer_count = (len(values) - 1).bit_length() if pad_to is None else (pad_to - 1).bit_length() if len(values) == 0: return zerohashes[layer_count] return calc_merkle_tree_from_leaves(values, layer_count) def get_merkle_root(values, pad_to=1): if pad_to == 0:
def get_genesis_state(n, seed="hello"): block_hash = hash(seed.encode("utf-8")) eth1_timestamp = 1578009600 return specs.initialize_beacon_state_from_eth1(block_hash, eth1_timestamp, get_initial_deposits(n))