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)