def case07_aggregate_pubkeys():
pubkeys = [bls.privtopub(privkey) for privkey in PRIVKEYS]
pubkeys_serial = [encode_hex(pubkey) for pubkey in pubkeys]
yield f'agg_pub_keys', {
'input': pubkeys_serial,
'output': encode_hex(bls.aggregate_pubkeys(pubkeys)),
}
def case07_aggregate_pubkeys():
pubkeys = [bls.privtopub(privkey) for privkey in PRIVKEYS]
pubkeys_serial = ['0x' + pubkey.hex() for pubkey in pubkeys]
yield {
'input': pubkeys_serial,
'output': '0x' + bls.aggregate_pubkeys(pubkeys).hex(),
}
def generate_keys(cls, num: int, network_dir: Path,
clients: Tuple[Client, ...]) -> Dict[Any, Any]:
logger = cls.get_logger()
logger.info("Creating %s validators' keys", num)
keys_dir = network_dir / KEYS_DIR
keys_dir.mkdir()
privkeys = tuple(
int.from_bytes(hash_eth2(str(i).encode('utf-8'))[:4], 'big')
for i in range(num))
keymap = {bls.privtopub(key): key for key in privkeys}
num_of_clients = len(clients)
for validator_index, key in enumerate(privkeys):
file_name = f"v{validator_index:07d}.privkey"
private_key_path = keys_dir / file_name
with open(private_key_path, "w") as f:
f.write(str(key))
# Distribute keys to clients
client = clients[validator_index % num_of_clients]
with open(client.validator_keys_dir / file_name, "w") as f:
f.write(str(key))
return keymap
def test_signature_aggregation(msg, privkeys):
domain = (0).to_bytes(8, "little")
sigs = [sign(msg, k, domain=domain) for k in privkeys]
pubs = [privtopub(k) for k in privkeys]
aggsig = aggregate_signatures(sigs)
aggpub = aggregate_pubkeys(pubs)
assert verify(msg, aggpub, aggsig, domain=domain)
def keymap(privkeys):
keymap = {}
for i, k in enumerate(privkeys):
keymap[bls.privtopub(k)] = k
if i % 50 == 0:
print("Generated %d keys" % i)
return keymap
def case03_private_to_public_key():
pubkeys = [bls.privtopub(privkey) for privkey in PRIVKEYS]
pubkeys_serial = ['0x' + pubkey.hex() for pubkey in pubkeys]
for privkey, pubkey_serial in zip(PRIVKEYS, pubkeys_serial):
yield {
'input': int_to_hex(privkey),
'output': pubkey_serial,
}
def extract_privkeys_from_dir(dir_path: Path) -> Dict[BLSPubkey, int]:
validator_keymap = {} # pub -> priv
for key_file_name in os.listdir(dir_path):
key_file_path = dir_path / key_file_name
privkey = _read_privkey(key_file_path)
validator_keymap[bls.privtopub(privkey)] = privkey
if len(validator_keymap) == 0:
raise KeyFileNotFound("No validator key file is provided")
return validator_keymap
def test_bls_core(privkey):
domain = (0).to_bytes(8, "little")
p1 = multiply(G1, privkey)
p2 = multiply(G2, privkey)
msg = str(privkey).encode('utf-8')
msghash = hash_to_G2(msg, domain=domain)
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, privkey, domain=domain)
pub = privtopub(privkey)
assert verify(msg, pub, sig, domain=domain)
def test_multi_aggregation(msg_1, msg_2, privkeys_1, privkeys_2):
domain = (0).to_bytes(8, "little")
sigs_1 = [sign(msg_1, k, domain=domain) for k in privkeys_1]
pubs_1 = [privtopub(k) for k in privkeys_1]
aggsig_1 = aggregate_signatures(sigs_1)
aggpub_1 = aggregate_pubkeys(pubs_1)
sigs_2 = [sign(msg_2, k, domain=domain) for k in privkeys_2]
pubs_2 = [privtopub(k) for k in privkeys_2]
aggsig_2 = aggregate_signatures(sigs_2)
aggpub_2 = aggregate_pubkeys(pubs_2)
message_hashes = [msg_1, msg_2]
pubs = [aggpub_1, aggpub_2]
aggsig = aggregate_signatures([aggsig_1, aggsig_2])
assert verify_multiple(
pubkeys=pubs,
message_hashes=message_hashes,
signature=aggsig,
domain=domain,
)
def initialize_chain(self, base_db: BaseAtomicDB) -> 'BeaconChain':
config = SERENITY_CONFIG
# Only used for testing
num_validators = 10
privkeys = tuple(2**i for i in range(num_validators))
keymap = {}
for k in privkeys:
keymap[bls.privtopub(k)] = k
state, block = create_mock_genesis(
num_validators=num_validators,
config=config,
keymap=keymap,
genesis_block_class=SerenityBeaconBlock,
genesis_time=ZERO_TIMESTAMP,
)
return cast(
'BeaconChain',
self.beacon_chain_class.from_genesis(
base_db=base_db,
genesis_state=state,
genesis_block=block,
))
get_domain,
get_empty_block,
get_epoch_start_slot,
get_genesis_beacon_state,
verify_merkle_branch,
hash,
)
from build.phase0.utils.merkle_minimal import (
calc_merkle_tree_from_leaves,
get_merkle_proof,
get_merkle_root,
)
privkeys_list = [i + 1 for i in range(1000)]
pubkeys_list = [bls.privtopub(privkey) for privkey in privkeys_list]
pubkey_to_privkey = {pubkey: privkey for privkey, pubkey in zip(privkeys_list, pubkeys_list)}
def create_mock_genesis_validator_deposits(num_validators, deposit_data_leaves):
deposit_timestamp = 0
proof_of_possession = b'\x33' * 96
deposit_data_list = []
for i in range(num_validators):
pubkey = pubkeys_list[i]
deposit_data = DepositData(
amount=spec.MAX_DEPOSIT_AMOUNT,
timestamp=deposit_timestamp,
deposit_input=DepositInput(
pubkey=pubkey,
get_previous_epoch,
get_shard_delta,
hash_tree_root,
slot_to_epoch,
verify_merkle_branch,
hash,
)
from eth2spec.utils.merkle_minimal import (
calc_merkle_tree_from_leaves,
get_merkle_proof,
get_merkle_root,
)
privkeys = [i + 1 for i in range(1024)]
pubkeys = [bls.privtopub(privkey) for privkey in privkeys]
pubkey_to_privkey = {pubkey: privkey for privkey, pubkey in zip(privkeys, pubkeys)}
def get_balance(state, index):
return state.balances[index]
def set_bitfield_bit(bitfield, i):
"""
Set the bit in ``bitfield`` at position ``i`` to ``1``.
"""
byte_index = i // 8
bit_index = i % 8
return (
bitfield[:byte_index] +
block = BeaconBlock(**sample_beacon_block_params).copy(slot=block_slot, )
if isinstance(expected, Exception):
with pytest.raises(ValidationError):
validate_block_slot(state, block)
else:
validate_block_slot(state, block)
@pytest.mark.parametrize(
'slots_per_epoch, shard_count,'
'proposer_privkey, proposer_pubkey, is_valid_signature', (
(
5,
2,
0,
bls.privtopub(0),
True,
),
(5, 2, 0, bls.privtopub(0)[1:] + b'\x01', False),
(5, 2, 123, bls.privtopub(123), True),
(5, 2, 123, bls.privtopub(123)[1:] + b'\x01', False),
))
def test_validate_proposer_signature(
slots_per_epoch, shard_count, proposer_privkey, proposer_pubkey,
is_valid_signature, sample_beacon_block_params,
sample_beacon_state_params, target_committee_size, max_deposit_amount,
config):
state = BeaconState(**sample_beacon_state_params).copy(
validator_registry=tuple(
mock_validator(proposer_pubkey, config) for _ in range(10)),
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 py_ecc import bls from eth2spec.phase0.spec import hash privkeys = list(range(1, 101)) pubkeys = [bls.privtopub(k) for k in privkeys] # Insecure, but easier to follow withdrawal_creds = [hash(bls.privtopub(k)) for k in privkeys]
_get_proposer_index, )
from trinity.plugins.eth2.beacon.slot_ticker import (
NewSlotEvent, )
from .helpers import (
get_chain_db, )
NUM_VALIDATORS = 8
privkeys = tuple(
int.from_bytes(hash_eth2(str(i).encode('utf-8'))[:4], 'big')
for i in range(NUM_VALIDATORS))
index_to_pubkey = {}
keymap = {} # pub -> priv
for i, k in enumerate(privkeys):
pubkey = bls.privtopub(k)
index_to_pubkey[i] = pubkey
keymap[pubkey] = k
genesis_time = int(time.time())
genesis_state, genesis_block = create_mock_genesis(
num_validators=NUM_VALIDATORS,
config=XIAO_LONG_BAO_CONFIG,
keymap=keymap,
genesis_block_class=SerenityBeaconBlock,
genesis_time=genesis_time,
)
genesis_data = BeaconGenesisData(
genesis_time=genesis_time,
genesis_slot=XIAO_LONG_BAO_CONFIG.GENESIS_SLOT,
import pexpect
from py_ecc import bls
from hashlib import sha256
import os
import time
from pyevt import abi, ecc, evt_link, libevt
from pyevtsdk import action, api, base, transaction, unit_test
keys = [1111,2222,3333]
pubs = [bls.privtopub(key) for key in keys]
root_key = ecc.PrivateKey.from_string(
'5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3')
root_pub = ecc.PublicKey.from_string(
'EVT6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV')
# root_key = '5JFZQ7bRRuBJyh42uV5ELwswr2Bt3rfwmyEsyXAoUue18NUreAF'
# root_pub = 'EVT8CAme1QR2664bLQsVfrERBkXL3xEKsALMSfogGavaXFkaVVqR1'
url = 'https://testnet1.everitoken.io'
ecc_domain = 43
domain_name = 'virtual-machine'
api = api.Api(url)
# print(api.get_info())
TG = transaction.TrxGenerator(url=url, payer=root_pub)
# user = base.User.from_string(root_key, root_pub)
EvtAsset = base.EvtAsset
AG = action.ActionGenerator()
# newdomain = AG.new_action(
def privtopub(k: int) -> BLSPubkey:
return privtopub(k)
