def __init__(self, genesis, key, network, env, time_offset=5):
# Create a chain object
self.chain = Chain(genesis, env=env)
# Use the validator's time as the chain's time
self.chain.time = lambda: self.get_timestamp()
# My private key
self.key = key
# My address
self.address = privtoaddr(key)
# My randao
self.randao = RandaoManager(sha3(self.key))
# Pointer to the test p2p network
self.network = network
# Record of objects already received and processed
self.received_objects = {}
# The minimum eligible timestamp given a particular number of skips
self.next_skip_count = 0
self.next_skip_timestamp = 0
# This validator's indices in the state
self.indices = None
# Is this validator active?
self.active = False
# Code that verifies signatures from this validator
self.validation_code = generate_validation_code(privtoaddr(key))
# Parents that this validator has already built a block on
self.used_parents = {}
# This validator's clock offset (for testing purposes)
self.time_offset = random.randrange(time_offset) - (time_offset // 2)
# Determine the epoch length
self.epoch_length = self.call_casper('getEpochLength')
# Give this validator a unique ID
self.id = len(ids)
ids.append(self.id)
self.find_my_indices()
self.cached_head = self.chain.head_hash
def generate_genesis(path=None, num_participants=1):
privkeys = [
utils.sha3(utils.to_string(i)) for i in range(num_participants)
]
addrs = [utils.privtoaddr(k) for k in privkeys]
deposit_sizes = [i * 500 + 500 for i in range(num_participants)]
randaos = [RandaoManager(utils.sha3(k)) for k in privkeys]
validators = [(generate_validation_code(a), ds * 10**18, r.get(9999), a)
for a, ds, r in zip(addrs, deposit_sizes, randaos)]
s = make_casper_genesis(validators=validators,
alloc={a: {
'balance': 10**18
}
for a in addrs},
timestamp=int(time.time()),
epoch_length=100)
genesis_hash = apply_const_message(
s,
sender=casper_config['METROPOLIS_ENTRY_POINT'],
to=casper_config['METROPOLIS_BLOCKHASH_STORE'],
data=utils.encode_int32(0))
genesis_number = call_casper(s, 'getBlockNumber')
print('genesis block hash: %s' % utils.encode_hex(genesis_hash))
print('genesis block number: %d' % genesis_number)
print('%d validators: %r' %
(num_participants, [utils.encode_hex(a) for a in addrs]))
snapshot = s.to_snapshot()
header = s.prev_headers[0]
genesis = {
"nonce": "0x" + utils.encode_hex(header.nonce),
"difficulty": utils.int_to_hex(header.difficulty),
"mixhash": "0x" + utils.encode_hex(header.mixhash),
"coinbase": "0x" + utils.encode_hex(header.coinbase),
"timestamp": utils.int_to_hex(header.timestamp),
"parentHash": "0x" + utils.encode_hex(header.prevhash),
"extraData": "0x" + utils.encode_hex(header.extra_data),
"gasLimit": utils.int_to_hex(header.gas_limit),
"alloc": snapshot["alloc"]
}
if path:
with open(path, 'w') as f:
json.dump(genesis,
f,
sort_keys=False,
indent=4,
separators=(',', ': '))
print('casper genesis generated')
else:
return genesis
from ethereum.config import default_config, Env
import copy
import time
import rlp
# config_string = ':info,eth.vm.log:trace,eth.vm.op:trace,eth.vm.stack:trace,eth.vm.exit:trace,eth.pb.msg:trace,eth.pb.tx:debug'
config_string = ':info,eth.vm.log:trace'
configure_logging(config_string=config_string)
NUM_PARTICIPANTS = 10
BLOCK_MAKING_PPB = 10
print('Initializing privkeys, addresses and randaos for validators')
privkeys = [utils.sha3(str(i)) for i in range(NUM_PARTICIPANTS)]
addrs = [utils.privtoaddr(k) for k in privkeys]
randaos = [RandaoManager(utils.sha3(str(i))) for i in range(NUM_PARTICIPANTS)]
deposit_sizes = [i * 500 + 500 for i in range(NUM_PARTICIPANTS)]
vcodes = [generate_validation_code(a) for a in addrs]
vchashes = [utils.sha3(c) for c in vcodes]
assert len(privkeys) == len(addrs) == len(randaos) == len(deposit_sizes) == len(vcodes) == len(vchashes) == NUM_PARTICIPANTS
# Creating casper contract translator
ct = get_casper_ct()
assert ct
print('Constructing genesis')
s = make_casper_genesis(validators=[(generate_validation_code(a), ds * 10**18, r.get(9999), a)
for a, ds, r in zip(addrs, deposit_sizes, randaos)][:-1],
alloc={a: {'balance': 10**18} for a in addrs},
timestamp=int(time.time() - 99999),
epoch_length=100)
print('Genesis constructed successfully')
get_hash_without_ed_code, make_casper_genesis
from ethereum.utils import sha3, privtoaddr
from ethereum.transactions import Transaction
from ethereum.state_transition import apply_transaction
from ethereum.slogging import LogRecorder, configure_logging, set_level
# config_string = ':info,eth.vm.log:trace,eth.vm.op:trace,eth.vm.stack:trace,eth.vm.exit:trace,eth.pb.msg:trace,eth.pb.tx:debug'
config_string = ':info,eth.vm.log:trace'
configure_logging(config_string=config_string)
n = networksim.NetworkSimulator(latency=150)
n.time = 2
print 'Generating keys'
keys = [sha3(str(i)) for i in range(20)]
print 'Initializing randaos'
randaos = [RandaoManager(sha3(k)) for k in keys]
deposit_sizes = [128] * 15 + [256] * 5
print 'Creating genesis state'
s = make_casper_genesis(
validators=[(generate_validation_code(privtoaddr(k)), ds * 10**18,
r.get(9999))
for k, ds, r in zip(keys, deposit_sizes, randaos)],
alloc={privtoaddr(k): {
'balance': 10**18
}
for k in keys},
timestamp=2,
epoch_length=50)
g = s.to_snapshot()
print 'Genesis state created'