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)