Example #1
0
def create_valid_beacon_state(spec):
    deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
    deposits, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)

    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME
    return spec.initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp, deposits)
def write_beacon_state(path):
    """
    This method outlines how we build beacon state for unit tests.
    """
    from eth2spec.config.config_util import prepare_config
    prepare_config('tests/config', 'minimal')

    from eth2spec.phase0.spec import initialize_beacon_state_from_eth1
    from eth2spec.test.helpers.deposits import prepare_genesis_deposits

    import eth2fastspec as spec

    print('preparing genesis deposits')
    deposits, deposit_root, _ = prepare_genesis_deposits(
        spec,
        spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT,
        spec.MAX_EFFECTIVE_BALANCE,
        signed=True)

    print('initializing beacon state')
    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME
    state = initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp,
                                              deposits)

    print('writing beacon state')
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, 'wb') as w:
        state.serialize(w)

    return state
def test_initialize_beacon_state_from_eth1(spec):
    deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
    deposits, deposit_root, _ = prepare_genesis_deposits(
        spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)

    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME

    yield 'eth1_block_hash', eth1_block_hash
    yield 'eth1_timestamp', eth1_timestamp
    yield 'deposits', deposits

    # initialize beacon_state
    state = spec.initialize_beacon_state_from_eth1(eth1_block_hash,
                                                   eth1_timestamp, deposits)

    assert state.genesis_time == eth1_timestamp - eth1_timestamp % spec.MIN_GENESIS_DELAY + 2 * spec.MIN_GENESIS_DELAY
    assert len(state.validators) == deposit_count
    assert state.eth1_data.deposit_root == deposit_root
    assert state.eth1_data.deposit_count == deposit_count
    assert state.eth1_data.block_hash == eth1_block_hash
    assert spec.get_total_active_balance(
        state) == deposit_count * spec.MAX_EFFECTIVE_BALANCE

    # yield state
    yield 'state', state
Example #4
0
def test_is_valid_genesis_state_false_not_enough_validator(spec):
    deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT - 1
    deposits, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)

    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME
    state = spec.initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp, deposits)

    yield from run_is_valid_genesis_state(spec, state, valid=False)
def test_initialize_beacon_state_some_small_balances(spec):
    main_deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
    main_deposits, _, deposit_data_list = prepare_genesis_deposits(
        spec, main_deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
    # For deposits above, and for another deposit_count, add a balance of EFFECTIVE_BALANCE_INCREMENT
    small_deposit_count = main_deposit_count * 2
    small_deposits, deposit_root, _ = prepare_genesis_deposits(
        spec,
        small_deposit_count,
        spec.MIN_DEPOSIT_AMOUNT,
        signed=True,
        deposit_data_list=deposit_data_list)
    deposits = main_deposits + small_deposits

    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME

    yield 'eth1_block_hash', eth1_block_hash
    yield 'eth1_timestamp', eth1_timestamp
    yield 'deposits', deposits

    # initialize beacon_state
    state = spec.initialize_beacon_state_from_eth1(eth1_block_hash,
                                                   eth1_timestamp, deposits)

    assert state.genesis_time == eth1_timestamp - eth1_timestamp % spec.MIN_GENESIS_DELAY + 2 * spec.MIN_GENESIS_DELAY
    assert len(state.validators) == small_deposit_count
    assert state.eth1_data.deposit_root == deposit_root
    assert state.eth1_data.deposit_count == len(deposits)
    assert state.eth1_data.block_hash == eth1_block_hash
    # only main deposits participate to the active balance
    assert spec.get_total_active_balance(
        state) == main_deposit_count * spec.MAX_EFFECTIVE_BALANCE

    # yield state
    yield 'state', state
Example #6
0
def default_builder():
    from eth2spec.config.config_util import prepare_config
    prepare_config('config', 'minimal')

    from eth2spec.phase0.spec import initialize_beacon_state_from_eth1
    from eth2spec.test.helpers.deposits import prepare_genesis_deposits

    import eth2fastspec as spec

    deposits, deposit_root, _ = prepare_genesis_deposits(
        spec,
        spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT,
        spec.MAX_EFFECTIVE_BALANCE,
        signed=True)

    eth1_block_hash = b'\x12' * 32
    eth1_timestamp = spec.MIN_GENESIS_TIME
    state = initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp,
                                              deposits)

    return state
# Before importing spec, load config:
# from eth2spec.config.config_util import prepare_config
# prepare_config("./some-dir", "config-name")

from eth2spec.phase0.spec import *
from eth2spec.phase0 import spec

from eth2spec.test.helpers.deposits import prepare_genesis_deposits

# Hack to disable BLS, no need for verification of deposits here.
spec.bls.bls_active = False

eth1_block_hash = b'\x12' * 32
eth1_timestamp = uint64(int(time.time()) + 60)  # a minute from now

print(f"creating state! genesis time: {eth1_timestamp}")

deposits, deposit_root, _ = prepare_genesis_deposits(spec,
                                                     200,  # Just 200 validators, lazy
                                                     MAX_EFFECTIVE_BALANCE,
                                                     signed=True)

state = initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp, deposits)

print("writing state!")

with io.open('genesis.ssz', 'wb') as w:
    state.serialize(w)

print("done!")