def state_from_genesis_declaration(genesis_data, env, block=None, allow_empties=False):
if block:
assert isinstance(block, Block)
else:
block = block_from_genesis_declaration(genesis_data, env)
state = State(env=env)
for addr, data in genesis_data["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, big_endian_to_int(parse_as_bin(k)), big_endian_to_int(parse_as_bin(v)))
get_consensus_strategy(state.config).initialize(state, block)
state.commit(allow_empties=allow_empties)
print('deleting %d' % len(state.deletes))
rdb = RefcountDB(state.db)
for delete in state.deletes:
rdb.delete(delete)
block.header.state_root = state.trie.root_hash
state.prev_headers=[block.header]
return state
def mk_poststate_of_blockhash(self, blockhash, convert=False):
if blockhash not in self.db:
raise Exception("Block hash %s not found" % encode_hex(blockhash))
block_rlp = self.db.get(blockhash)
if block_rlp == b'GENESIS':
return State.from_snapshot(
json.loads(self.db.get(b'GENESIS_STATE')), self.env)
block = rlp.decode(block_rlp, Block)
state = State(env=self.env)
state.trie.root_hash = block.header.state_root if convert else self.db.get(
b'state:' + blockhash)
update_block_env_variables(state, block)
state.gas_used = block.header.gas_used
state.txindex = len(block.transactions)
state.recent_uncles = {}
state.prev_headers = []
b = block
header_depth = state.config['PREV_HEADER_DEPTH']
for i in range(header_depth + 1):
state.prev_headers.append(b.header)
if i < 6:
state.recent_uncles[state.block_number - i] = []
for u in b.uncles:
state.recent_uncles[state.block_number - i].append(u.hash)
try:
b = rlp.decode(state.db.get(b.header.prevhash), Block)
except:
break
if i < header_depth:
if state.db.get(b.header.prevhash) == b'GENESIS':
jsondata = json.loads(state.db.get(b'GENESIS_STATE'))
for h in jsondata["prev_headers"][:header_depth - i]:
state.prev_headers.append(dict_to_prev_header(h))
for blknum, uncles in jsondata["recent_uncles"].items():
if int(blknum) >= state.block_number - int(
state.config['MAX_UNCLE_DEPTH']):
state.recent_uncles[blknum] = [
parse_as_bin(u) for u in uncles
]
else:
raise Exception("Dangling prevhash")
assert len(state.journal) == 0, state.journal
return state
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 mk_poststate_of_collation_hash(self, collation_hash):
"""Return the post-state of the collation
"""
if collation_hash not in self.db:
raise Exception("Collation hash %s not found" %
encode_hex(collation_hash))
collation_rlp = self.db.get(collation_hash)
if collation_rlp == 'GENESIS':
return State.from_snapshot(
json.loads(self.db.get('GENESIS_STATE')), self.env)
collation = rlp.decode(collation_rlp, Collation)
state = State(env=self.env)
state.trie.root_hash = collation.header.post_state_root
update_collation_env_variables(state, collation)
state.gas_used = 0
state.txindex = len(collation.transactions)
state.recent_uncles = {}
state.prev_headers = []
assert len(state.journal) == 0, state.journal
return state
