from hashlib import blake2s blake = lambda x: blake2s(x).digest() from rlp.sedes import big_endian_int, Binary, binary, CountableList, BigEndianInt, Binary int256 = BigEndianInt(256) hash32 = Binary.fixed_length(32) import rlp import bls import random privkeys = [ int.from_bytes(blake(str(i).encode('utf-8')), 'big') for i in range(30) ] keymap = {bls.privtopub(k): k for k in privkeys} class AggregateVote(rlp.Serializable): fields = [('shard_id', int256), ('checkpoint', hash32), ('signer_bitmask', binary), ('aggregate_sig', int256)] def __init__(self, shard_id, checkpoint, signer_bitmask, aggregate_sig): # at the beginning of a method, locals() is a dict of all arguments fields = {k: v for k, v in locals().items() if k != 'self'} super(BlockHeader, self).__init__(**fields) class BeaconBlock(rlp.Serializable): fields = [ # Hash of the parent block ('parent_hash', hash32), # Number of skips (for the full PoS mechanism)
from simpleserialize import serialize, deserialize, eq from full_pos import ActiveState, CheckpointRecord for x in (1, 5, 124, 735, 127409812145, 90768492698215092512159, 0): print('Testing with privkey %d' % x) p1 = multiply(G1, x) p2 = multiply(G2, x) msg = str(x).encode('utf-8') msghash = hash_to_G2(msg) assert normalize(decompress_G1(compress_G1(p1))) == normalize(p1) assert normalize(decompress_G2(compress_G2(p2))) == normalize(p2) assert normalize(decompress_G2(compress_G2(msghash))) == normalize(msghash) sig = sign(msg, x) pub = privtopub(x) assert verify(msg, pub, sig) print('Testing signature aggregation') msg = b'cow' keys = [1, 5, 124, 735, 127409812145, 90768492698215092512159, 0] sigs = [sign(msg, k) for k in keys] pubs = [privtopub(k) for k in keys] aggsig = aggregate_sigs(sigs) aggpub = aggregate_pubs(pubs) assert verify(msg, aggpub, aggsig) print('Testing basic serialization') assert serialize(5, 'int8') == b'\x05' assert deserialize(b'\x05', 'int8') == 5
case02_message_hash_G2_compressed = [] for msg in MESSAGES: for domain in DOMAINS: case02_message_hash_G2_compressed.append({ 'input': { 'message': '0x' + msg.hex(), 'domain': int_to_hex(domain) }, 'output': hash_message_compressed(msg, domain) }) case03_private_to_public_key = [] # Used in later cases pubkeys = [bls.privtopub(privkey) for privkey in PRIVKEYS] # Used in public key aggregation pubkeys_serial = ['0x' + pubkey.hex() for pubkey in pubkeys] case03_private_to_public_key = [{ 'input': int_to_hex(privkey), 'output': pubkey_serial, } for privkey, pubkey_serial in zip(PRIVKEYS, pubkeys_serial)] case04_sign_messages = [] sigs = [] # used in verify for privkey in PRIVKEYS: for message in MESSAGES: for domain in DOMAINS: sig = bls.sign(message, privkey, domain) case04_sign_messages.append({ 'input': {
from full_pos import blake, mk_genesis_state_and_block, compute_state_transition, \ get_attesters_and_signer, Block, get_crosslink_aggvote_msg, AggregateVote, \ SHARD_COUNT, ATTESTER_COUNT, get_shard_attesters import random import bls from simpleserialize import serialize, deserialize, eq, deepcopy import time privkeys = [ int.from_bytes(blake(str(i).encode('utf-8'))[:4], 'big') for i in range(100000) ] print('Generated privkeys') keymap = {} for i, k in enumerate(privkeys): keymap[bls.privtopub(k)] = k if i % 50 == 0: print("Generated %d keys" % i) def mock_make_child(parent_state, parent, skips, attester_share=0.8, crosslink_shards=[]): crystallized_state, active_state = parent_state parent_attestation = serialize(parent) validator_count = len(crystallized_state.active_validators) indices, main_signer = get_attesters_and_signer(crystallized_state, active_state, skips) print('Selected indices: %r' % indices)