def run_block_test(params, config_overrides=None):
if config_overrides is None:
config_overrides = {}
env = Env(db.EphemDB())
genesis_decl = {}
for param in ("bloom", "timestamp", "nonce", "extraData", "gasLimit",
"coinbase", "difficulty", "parentHash", "mixHash",
"gasUsed"):
genesis_decl[param] = params["genesisBlockHeader"][param]
genesis_decl["alloc"] = params["pre"]
old_config = copy.deepcopy(env.config)
for k, v in config_overrides.items():
env.config[k] = v
# print('overrides', config_overrides)
s = state_from_genesis_declaration(genesis_decl, env, allow_empties=True)
initialize_genesis_keys(s, Block(s.prev_headers[0], [], []))
c = chain.Chain(genesis=s, localtime=2**99)
# print('h', encode_hex(c.state.prev_headers[0].state_root))
# print(c.state.to_dict())
# print(params["pre"])
assert c.state.env == env
assert c.state.prev_headers[0].state_root == safe_decode(
params["genesisBlockHeader"]["stateRoot"]), (
encode_hex(c.state.prev_headers[0].state_root),
params["genesisBlockHeader"]["stateRoot"])
assert c.state.trie.root_hash == safe_decode(
params["genesisBlockHeader"]["stateRoot"])
assert c.state.prev_headers[0].hash == safe_decode(
params["genesisBlockHeader"]["hash"])
#print('std', c.state.to_dict())
for blk in params["blocks"]:
if 'blockHeader' not in blk:
success = True
try:
rlpdata = safe_decode(blk["rlp"][2:])
success = c.add_block(rlp.decode(rlpdata, Block))
except (ValueError, TypeError, AttributeError, VerificationFailed,
DecodingError, DeserializationError, InvalidTransaction,
InvalidNonce, KeyError) as e:
success = False
assert not success
else:
rlpdata = safe_decode(blk["rlp"][2:])
assert c.add_block(rlp.decode(rlpdata, Block))
env.config = old_config
def __init__(self, app):
self.config = app.config
sce = self.config['eth']
if int(sce['pruning']) >= 0:
self.db = RefcountDB(app.services.db)
if "I am not pruning" in self.db.db:
raise RuntimeError(
"The database in '{}' was initialized as non-pruning. "
"Can not enable pruning now.".format(
self.config['data_dir']))
self.db.ttl = int(sce['pruning'])
self.db.db.put("I am pruning", "1")
else:
self.db = app.services.db
if "I am pruning" in self.db:
raise RuntimeError(
"The database in '{}' was initialized as pruning. "
"Can not disable pruning now".format(
self.config['data_dir']))
self.db.put("I am not pruning", "1")
if 'network_id' in self.db:
db_network_id = self.db.get('network_id')
if db_network_id != str(sce['network_id']):
raise RuntimeError(
"The database in '{}' was initialized with network id {} and can not be used "
"when connecting to network id {}. Please choose a different data directory."
.format(self.config['data_dir'], db_network_id,
sce['network_id']))
else:
self.db.put('network_id', str(sce['network_id']))
self.db.commit()
assert self.db is not None
super(ChainService, self).__init__(app)
log.info('initializing chain')
coinbase = app.services.accounts.coinbase
env = Env(self.db, sce['block'])
self.chain = Chain(env,
new_head_cb=self._on_new_head,
coinbase=coinbase)
log.info('chain at', number=self.chain.head.number)
if 'genesis_hash' in sce:
assert sce['genesis_hash'] == self.chain.genesis.hex_hash(), \
"Genesis hash mismatch.\n Expected: %s\n Got: %s" % (
sce['genesis_hash'], self.chain.genesis.hex_hash())
self.synchronizer = Synchronizer(self, force_sync=None)
self.block_queue = Queue(maxsize=self.block_queue_size)
self.transaction_queue = Queue(maxsize=self.transaction_queue_size)
self.add_blocks_lock = False
self.add_transaction_lock = gevent.lock.Semaphore()
self.broadcast_filter = DuplicatesFilter()
self.on_new_head_cbs = []
self.on_new_head_candidate_cbs = []
self.newblock_processing_times = deque(maxlen=1000)
def init_state(env, pre):
# Setup env
state = State(
env=Env(config=konfig),
block_prevhash=decode_hex(remove_0x_head(env['previousHash'])),
prev_headers=[mk_fake_header(i) for i in range(parse_int_or_hex(env['currentNumber']) - 1,
max(-1, parse_int_or_hex(env['currentNumber']) - 257), -1)],
block_number=parse_int_or_hex(env['currentNumber']),
block_coinbase=decode_hex(remove_0x_head(env['currentCoinbase'])),
block_difficulty=parse_int_or_hex(env['currentDifficulty']),
gas_limit=parse_int_or_hex(env['currentGasLimit']),
timestamp=parse_int_or_hex(env['currentTimestamp']))
# Fill up pre
for address, h in list(pre.items()):
assert len(address) in (40, 42)
address = decode_hex(remove_0x_head(address))
assert set(h.keys()) == set(['code', 'nonce', 'balance', 'storage'])
state.set_nonce(address, parse_int_or_hex(h['nonce']))
state.set_balance(address, parse_int_or_hex(h['balance']))
state.set_code(address, decode_hex(remove_0x_head(h['code'])))
for k, v in h['storage'].items():
state.set_storage_data(address,
big_endian_to_int(decode_hex(k[2:])),
big_endian_to_int(decode_hex(v[2:])))
state.commit(allow_empties=True)
# state.commit()
return state
def __init__(self):
tester.GASPRICE = 0
tester.STARTGAS = long(6.7 * 10**7)
config_metropolis['GASLIMIT_ADJMAX_FACTOR'] = .000000000001
config_metropolis['GENESIS_GAS_LIMIT'] = 2**60
config_metropolis['MIN_GAS_LIMIT'] = 2**60
config_metropolis['BLOCK_GAS_LIMIT'] = 2**60
for a in range(10):
tester.base_alloc[getattr(tester, 'a%i' % a)] = {'balance': 10**24}
self.chain = Chain(env=Env(config=config_metropolis))
self.contracts = {}
self.testerAddress = self.generateTesterMap('a')
self.testerKey = self.generateTesterMap('k')
self.testerAddressToKey = dict(zip(self.testerAddress.values(), self.testerKey.values()))
if path.isfile('./allFiredEvents'):
remove_file('./allFiredEvents')
self.relativeContractsPath = '../source/contracts'
self.relativeTestContractsPath = 'solidity_test_helpers'
self.externalContractsPath = '../source/contracts/external'
self.coverageMode = pytest.config.option.cover
self.subFork = pytest.config.option.subFork
if self.coverageMode:
self.chain.head_state.log_listeners.append(self.writeLogToFile)
self.relativeContractsPath = '../coverageEnv/contracts'
self.relativeTestContractsPath = '../coverageEnv/solidity_test_helpers'
self.externalContractsPath = '../coverageEnv/contracts/external'
def test_genesis():
for profile in ['frontier']: # fixme olympics
config = dict(eth=dict())
# Set config values based on profile selection
merge_dict(config, PROFILES[profile])
# Load genesis config
update_config_from_genesis_json(config, config['eth']['genesis'])
konfig.update_config_with_defaults(
config, {'eth': {
'block': blocks.default_config
}})
print config['eth'].keys()
bc = config['eth']['block']
print bc.keys()
env = Env(DB(), bc)
genesis = blocks.genesis(env)
print 'genesis.hash', genesis.hash.encode('hex')
print 'expected', config['eth']['genesis_hash']
assert genesis.hash == config['eth']['genesis_hash'].decode('hex')
def get_chain(data_dir=default_data_dir):
"""
returns an ethereum.chain.Chain instance
"""
dbfile = os.path.join(data_dir, 'leveldb')
db = LevelDB(dbfile)
return Chain(Env(db))
def make_casper_genesis(validators, alloc, timestamp=0, epoch_length=100):
state = mk_basic_state(alloc, None, env=Env(config=casper_config))
state.gas_limit = 10**8 * (len(validators) + 1)
state.timestamp = timestamp
state.block_difficulty = 1
header = state.prev_headers[0]
header.timestamp = timestamp
header.difficulty = 1
ct = get_casper_ct()
initialize(state)
casper_contract_bootstrap(state,
timestamp=header.timestamp,
gas_limit=header.gas_limit)
# Add validators
for i, (vcode, deposit_size, randao_commitment,
address) in enumerate(validators):
validator_inject(state, vcode, deposit_size, randao_commitment,
address, i, ct)
# Start the first epoch
casper_start_epoch(state)
assert call_casper(state, 'getEpoch', []) == 0
assert call_casper(state, 'getTotalDeposits',
[]) == sum([d for a, d, r, a in validators])
state.set_storage_data(
utils.normalize_address(state.config['METROPOLIS_BLOCKHASH_STORE']),
state.block_number % state.config['METROPOLIS_WRAPAROUND'],
header.hash)
state.commit()
return state
def _update_head_candidate(self, forward_pending_transactions=True):
"after new head is set"
log.debug('updating head candidate')
# collect uncles
blk = self.head # parent of the block we are collecting uncles for
uncles = set(u.header for u in self.get_brothers(blk))
for i in range(self.env.config['MAX_UNCLE_DEPTH'] + 2):
for u in blk.uncles:
assert isinstance(u, blocks.BlockHeader)
uncles.discard(u)
if blk.has_parent():
blk = blk.get_parent()
assert not uncles or max(u.number for u in uncles) <= self.head.number
uncles = list(uncles)[:self.env.config['MAX_UNCLES']]
# create block
ts = max(int(time.time()), self.head.timestamp + 1)
_env = Env(OverlayDB(self.head.db), self.env.config, self.env.global_config)
head_candidate = blocks.Block.init_from_parent(self.head, coinbase=self._coinbase,
timestamp=ts, uncles=uncles, env=_env)
assert head_candidate.validate_uncles()
self.pre_finalize_state_root = head_candidate.state_root
head_candidate.finalize()
# add transactions from previous head candidate
old_head_candidate = self.head_candidate
self.head_candidate = head_candidate
if old_head_candidate is not None and forward_pending_transactions:
log.debug('forwarding pending transactions')
for tx in old_head_candidate.get_transactions():
self.add_transaction(tx)
else:
log.debug('discarding pending transactions')
def test_genesis_config():
"test setting genesis alloc using the config"
alloc = {
'1' * 40: {
'wei': 1
}, # wei
'2' * 40: {
'balance': 2
}, # balance
'3' * 20: {
'balance': 3
}, # 20 bytes
}
config = dict(eth=dict(genesis=dict(alloc=alloc)))
konfig.update_config_with_defaults(
config, {'eth': {
'block': blocks.default_config
}})
# Load genesis config
update_config_from_genesis_json(config, config['eth']['genesis'])
bc = config['eth']['block']
pprint(bc)
env = Env(DB(), bc)
genesis = blocks.genesis(env)
for address, value_dict in alloc.items():
value = value_dict.values()[0]
assert genesis.get_balance(address) == value
def resetToSnapshot(self, snapshot):
if not 'state' in snapshot: raise "snapshot is missing 'state'"
if not 'contracts' in snapshot: raise "snapshot is missing 'contracts'"
self.chain = Chain(genesis=snapshot['state'], env=Env(config=config_metropolis))
self.contracts = {}
for contractName in snapshot['contracts']:
contract = snapshot['contracts'][contractName]
self.contracts[contractName] = ABIContract(self.chain, contract['translator'], contract['address'])
def __init__(self, root=b'', env=Env(), **kwargs):
self.env = env
self.trie = SecureTrie(Trie(self.db, root))
for k, v in STATE_DEFAULTS.items():
setattr(self, k, kwargs.get(k, copy.copy(v)))
self.journal = []
self.cache = {}
self.log_listeners = []
def get_contract_code(init_code):
s = State(env=Env(config=casper_config))
s.gas_limit = 10**9
apply_transaction(s, Transaction(0, 0, 10**8, '', 0, init_code))
addr = utils.mk_metropolis_contract_address(
casper_config['METROPOLIS_ENTRY_POINT'], init_code)
o = s.get_code(addr)
assert o
return o
def get_env(env):
d = {
None: config_metropolis,
'mainnet': default_config,
'homestead': config_homestead,
'tangerine': config_tangerine,
'spurious': config_spurious,
'metropolis': config_metropolis,
}
return env if isinstance(env, Env) else Env(config=d[env])
def resetToSnapshot(self, snapshot):
if not 'state' in snapshot: raise "snapshot is missing 'state'"
if not 'contracts' in snapshot: raise "snapshot is missing 'contracts'"
self.chain = Chain(genesis=snapshot['state'], env=Env(config=config_metropolis))
if self.coverageMode:
self.chain.head_state.log_listeners.append(self.writeLogToFile)
self.contracts = {}
for contractName in snapshot['contracts']:
contract = snapshot['contracts'][contractName]
self.contracts[contractName] = ABIContract(self.chain, contract['translator'], contract['address'])
def __init__(self, root=b'', env=Env(), executing_on_head=False, **kwargs):
self.env = env
self.trie = SecureTrie(Trie(RefcountDB(self.db), root))
for k, v in STATE_DEFAULTS.items():
setattr(self, k, kwargs.get(k, copy.copy(v)))
self.journal = []
self.cache = {}
self.log_listeners = []
self.deletes = []
self.changed = {}
self.executing_on_head = executing_on_head
def check_snapshot_consistency(snapshot, env=None):
if env:
c = chain.Chain(env=env)
else:
c = chain.Chain(snapshot, Env())
snapshot2 = c.state.to_snapshot()
if snapshot != snapshot2: # FIXME
for i, ss in enumerate([snapshot, snapshot2]):
fn = '/tmp/{}_{}'.format(STATE_STORE_FN, i)
open(fn, 'w').write(json.dumps(snapshot))
raise Exception("snapshot difference, see {}*".format(fn[:-1]))
def __init__(self, app):
self.config = app.config
sce = self.config['eth']
if int(sce['pruning']) >= 0:
self.db = RefcountDB(app.services.db)
if "I am not pruning" in self.db.db:
raise Exception("This database was initialized as non-pruning."
" Kinda hard to start pruning now.")
self.db.ttl = int(sce['pruning'])
self.db.db.put("I am pruning", "1")
else:
self.db = app.services.db
if "I am pruning" in self.db:
raise Exception("This database was initialized as pruning."
" Kinda hard to stop pruning now.")
self.db.put("I am not pruning", "1")
if 'network_id' in self.db:
db_network_id = self.db.get('network_id')
if db_network_id != str(sce['network_id']):
raise Exception(
"This database was initialized with network_id {} "
"and can not be used when connecting to network_id {}".
format(db_network_id, sce['network_id']))
else:
self.db.put('network_id', str(sce['network_id']))
self.db.commit()
assert self.db is not None
super(ChainService, self).__init__(app)
log.info('initializing chain')
coinbase = app.services.accounts.coinbase
env = Env(self.db, sce['block'])
self.chain = Chain(env,
new_head_cb=self._on_new_head,
coinbase=coinbase)
log.info('chain at', number=self.chain.head.number)
if 'genesis_hash' in sce:
assert sce['genesis_hash'] == self.chain.genesis.hex_hash()
self.synchronizer = Synchronizer(self, force_sync=None)
self.block_queue = Queue(maxsize=self.block_queue_size)
self.transaction_queue = Queue(maxsize=self.transaction_queue_size)
self.add_blocks_lock = False
self.add_transaction_lock = gevent.lock.Semaphore()
self.broadcast_filter = DuplicatesFilter()
self.on_new_head_cbs = []
self.on_new_head_candidate_cbs = []
self.newblock_processing_times = deque(maxlen=1000)
def ephemeral_clone(self):
snapshot = self.to_snapshot(root_only=True, no_prevblocks=True)
env2 = Env(OverlayDB(self.env.db), self.env.config)
s = State.from_snapshot(snapshot, env2)
for param in STATE_DEFAULTS:
setattr(s, param, getattr(self, param))
s.recent_uncles = self.recent_uncles
s.prev_headers = self.prev_headers
for acct in self.cache.values():
assert not acct.touched or not acct.deleted
s.journal = copy.copy(self.journal)
s.cache = {}
return s
def get_initial_stuff():
config_metropolis['BLOCK_GAS_LIMIT'] = 2**60
chain = tester.Chain(env=Env(config=config_metropolis))
AdContract_code, ManualAdCampaign_code = rearrange_code('AdContract.sol')
AdContract = chain.contract(AdContract_code,
language='solidity',
sender=tester.k0)
ManualAdCampaign = chain.contract(ManualAdCampaign_code,
language='solidity',
sender=tester.k1)
return chain, AdContract, ManualAdCampaign
def __init__(self):
tester.GASPRICE = 0
config_metropolis['GASLIMIT_ADJMAX_FACTOR'] = .000000000001
config_metropolis['GENESIS_GAS_LIMIT'] = 2**60
config_metropolis['MIN_GAS_LIMIT'] = 2**60
config_metropolis['BLOCK_GAS_LIMIT'] = 2**60
for a in range(10):
tester.base_alloc[getattr(tester, 'a%i' % a)] = {'balance': 10**24}
self.chain = Chain(env=Env(config=config_metropolis))
self.contracts = {}
self.testerAddress = self.generateTesterMap('a')
self.testerKey = self.generateTesterMap('k')
def __init__(self, app):
super(ChainService, self).__init__(app)
sce = self.config['eth']
env = Env(self.db, sce['block'])
coinbase = app.services.accounts.coinbase
self.chain = Chain(env, new_head_cb=self._on_new_head, coinbase=coinbase, process_block_cb=self.process_block, revert_block_cb=self.on_revert_blocks)
self.progress_bar = True
# sanitize the configured addrs
for addr in self.start_blocks.keys():
new_addr = addr
if new_addr[0:2] == '0x':
new_addr = new_addr[2:]
if new_addr != addr:
self.start_blocks[new_addr] = self.start_blocks[addr]
del self.start_blocks[addr]
def __init__(self, num_accounts=len(keys)):
global serpent
if not serpent:
serpent = __import__('serpent')
self.temp_data_dir = tempfile.mkdtemp()
self.db = db.EphemDB()
self.env = Env(self.db)
o = {}
for i in range(num_accounts):
o[accounts[i]] = {"wei": 10**24}
for i in range(1, 5):
o[u.int_to_addr(i)] = {"wei": 1}
self.block = b.genesis(self.env, start_alloc=o)
self.blocks = [self.block]
self.block.timestamp = 1410973349
self.block.coinbase = a0
self.block.gas_limit = 10**9
def __init__(self, genesis):
env = Env(EphemDB(), konfig)
if not genesis:
genesis = mk_genesis_data(env)
if 'config' in genesis:
if 'homesteadBlock' in genesis['config']:
env.config['HOMESTEAD_FORK_BLKNUM'] = int(genesis['config']['homesteadBlock'])
env.config['DAO_FORK_BLKNUM'] = int(genesis['config']['homesteadBlock'])
env.config['ANTI_DOS_FORK_BLKNUM'] = int(genesis['config']['homesteadBlock'])
env.config['SPURIOUS_DRAGON_FORK_BLKNUM'] = int(genesis['config']['homesteadBlock'])
self.state = state_from_genesis_declaration(genesis, env)
initialize_genesis_keys(self.state, Block(self.state.prev_headers[0], [], []))
def test_profile(profile):
config = dict(eth=dict())
konfig.update_config_with_defaults(
config, {'eth': {
'block': blocks.default_config
}})
# Set config values based on profile selection
merge_dict(config, PROFILES[profile])
# Load genesis config
update_config_from_genesis_json(config, config['eth']['genesis'])
bc = config['eth']['block']
pprint(bc)
env = Env(DB(), bc)
genesis = blocks.genesis(env)
assert genesis.hash.encode('hex') == config['eth']['genesis_hash']
def mk_basic_state(alloc, header=None, env=None, executing_on_head=False):
env = env or Env()
state = State(env=env, executing_on_head=executing_on_head)
if not header:
header = {
"number": 0,
"gas_limit": env.config['BLOCK_GAS_LIMIT'],
"gas_used": 0,
"timestamp": 1467446877,
"difficulty": 1,
"uncles_hash": '0x' + encode_hex(BLANK_UNCLES_HASH)
}
h = BlockHeader(number=parse_as_int(header['number']),
timestamp=parse_as_int(header['timestamp']),
difficulty=parse_as_int(header['difficulty']),
gas_limit=parse_as_int(header['gas_limit']),
uncles_hash=parse_as_bin(header['uncles_hash']))
state.prev_headers = [h]
for addr, data in alloc.items():
addr = normalize_address(addr)
assert len(addr) == 20
if 'wei' in data:
state.set_balance(addr, parse_as_int(data['wei']))
if 'balance' in data:
state.set_balance(addr, parse_as_int(data['balance']))
if 'code' in data:
state.set_code(addr, parse_as_bin(data['code']))
if 'nonce' in data:
state.set_nonce(addr, parse_as_int(data['nonce']))
if 'storage' in data:
for k, v in data['storage'].items():
state.set_storage_data(addr, parse_as_bin(k), parse_as_bin(v))
state.block_number = header["number"]
state.gas_limit = header["gas_limit"]
state.timestamp = header["timestamp"]
state.block_difficulty = header["difficulty"]
state.commit()
return state
def __init__(self, num_accounts=len(keys)):
self.temp_data_dir = tempfile.mkdtemp()
self.db = db.EphemDB()
self.env = Env(self.db)
self.last_tx = None
initial_balances = {}
for i in range(num_accounts):
account = accounts[i]
initial_balances[account] = {'wei': 10**24}
for i in range(1, 5):
address = int_to_addr(i)
initial_balances[address] = {'wei': 1}
self.block = blocks.genesis(
self.env,
start_alloc=initial_balances,
)
self.blocks = [self.block]
self.block.timestamp = 1410973349
self.block.coinbase = DEFAULT_ACCOUNT
self.block.gas_limit = 10**9
def __init__(self, app):
self.config = app.config
sce = self.config['eth']
if int(sce['pruning']) >= 0:
self.db = RefcountDB(app.services.db)
if "I am not pruning" in self.db.db:
raise Exception("This database was initialized as non-pruning."
" Kinda hard to start pruning now.")
self.db.ttl = int(sce['pruning'])
self.db.db.put("I am pruning", "1")
else:
self.db = app.services.db
if "I am pruning" in self.db:
raise Exception("This database was initialized as pruning."
" Kinda hard to stop pruning now.")
self.db.put("I am not pruning", "1")
if 'network_id' in self.db:
db_network_id = self.db.get('network_id')
if db_network_id != str(sce['network_id']):
raise Exception(
"This database was initialized with network_id {} "
"and can not be used when connecting to network_id {}".
format(db_network_id, sce['network_id']))
else:
self.db.put('network_id', str(sce['network_id']))
self.db.commit()
assert self.db is not None
WiredService.__init__(self, app)
log.info('initializing chain')
coinbase = app.services.accounts.coinbase
env = Env(self.db, sce['block'])
self.chain = Chain(env,
new_head_cb=self._on_new_head,
coinbase=coinbase)
log.info('chain at', number=self.chain.head.number)
if 'genesis_hash' in sce:
assert sce['genesis_hash'] == self.chain.genesis.hex_hash()
self.transaction_queue = Queue(maxsize=self.transaction_queue_size)
self.add_blocks_lock = False
self.add_transaction_lock = gevent.lock.BoundedSemaphore()
self.broadcast_filter = DuplicatesFilter()
self.on_new_head_cbs = []
self.on_new_head_candidate_cbs = []
self.newblock_processing_times = deque(maxlen=1000)
# Consensus
self.consensus_contract = ConsensusContract(
validators=self.config['hdc']['validators'])
self.consensus_manager = ConsensusManager(self,
self.consensus_contract,
self.consensus_privkey)
# lock blocks that where proposed, so they don't get mutated
self.proposal_lock = ProposalLock()
assert not self.proposal_lock.is_locked()
def __init__(self,
genesis=None,
env=None,
coinbase=b'\x00' * 20,
new_head_cb=None,
reset_genesis=False,
localtime=None,
**kwargs):
self.env = env or Env()
# Initialize the state
if b'head_hash' in self.db: # new head tag
self.state = self.mk_poststate_of_blockhash(
self.db.get(b'head_hash'))
print('Initializing chain from saved head, #%d (%s)' %
(self.state.prev_headers[0].number,
encode_hex(self.state.prev_headers[0].hash)))
elif genesis is None:
raise Exception("Need genesis decl!")
elif isinstance(genesis, State):
assert env is None
self.state = genesis
self.env = self.state.env
print('Initializing chain from provided state')
elif "extraData" in genesis:
self.state = state_from_genesis_declaration(genesis, self.env)
reset_genesis = True
print('Initializing chain from provided genesis declaration')
elif "prev_headers" in genesis:
self.state = State.from_snapshot(genesis, self.env)
reset_genesis = True
print('Initializing chain from provided state snapshot, %d (%s)' %
(self.state.block_number,
encode_hex(self.state.prev_headers[0].hash[:8])))
else:
print('Initializing chain from new state based on alloc')
self.state = mk_basic_state(
genesis, {
"number":
kwargs.get('number', 0),
"gas_limit":
kwargs.get('gas_limit', 4712388),
"gas_used":
kwargs.get('gas_used', 0),
"timestamp":
kwargs.get('timestamp', 1467446877),
"difficulty":
kwargs.get('difficulty', 2**25),
"hash":
kwargs.get('prevhash', '00' * 32),
"uncles_hash":
kwargs.get('uncles_hash',
'0x' + encode_hex(BLANK_UNCLES_HASH))
}, self.env)
reset_genesis = True
assert self.env.db == self.state.db
initialize(self.state)
self.new_head_cb = new_head_cb
self.head_hash = self.state.prev_headers[0].hash
self.checkpoint_head_hash = b'\x00' * 32
self.db.put(b'cp_subtree_score' + b'\x00' * 32, 2 / 3.)
self.commit_logs = []
self.casper_address = self.config['CASPER_ADDRESS']
self.db.put(b'GENESIS_NUMBER', to_string(self.state.block_number))
assert self.state.block_number == self.state.prev_headers[0].number
if reset_genesis:
self.genesis = Block(self.state.prev_headers[0], [], [])
initialize_genesis_keys(self.state, self.genesis)
else:
self.genesis = self.get_block_by_number(0)
self.db.put(b'cp_subtree_score' + self.genesis.hash, 2 / 3.)
self.min_gasprice = kwargs.get('min_gasprice', 5 * 10**9)
self.coinbase = coinbase
self.extra_data = 'moo ha ha says the laughing cow.'
self.time_queue = []
self.parent_queue = {}
self.localtime = time.time() if localtime is None else localtime
import rlp
from rlp.utils import decode_hex, encode_hex, ascii_chr, str_to_bytes
from ethereum import processblock as pb
import copy
from ethereum.db import EphemDB
from ethereum.utils import to_string, safe_ord, parse_int_or_hex
from ethereum.utils import remove_0x_head, int_to_hex
from ethereum.config import Env
import json
import os
import time
from ethereum import ethash
from ethereum import ethash_utils
db = EphemDB()
db_env = Env(db)
env = {
"currentCoinbase":
b"2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
"currentDifficulty":
"256",
"currentGasLimit":
"1000000000",
"currentNumber":
"257",
"currentTimestamp":
"1",
"previousHash":
b"5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
}
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'
validators = [
Validator(g, k, n, Env(config=casper_config), time_offset=4) for k in keys
]
n.agents = validators
n.generate_peers()
lowest_shared_height = -1
made_101_check = 0
for i in range(100000):
# print 'ticking'
n.tick()
if i % 100 == 0:
print '%d ticks passed' % i
print 'Validator heads:', [
v.chain.head.header.number if v.chain.head else None
for v in validators
]
