def get_receipts(self, block):
# Receipts are no longer stored in the database, so need to generate
# them on the fly here.
temp_state = self.chain.mk_poststate_of_blockhash(
block.header.prevhash)
initialize(temp_state, block)
for tx in block.transactions:
apply_transaction(temp_state, tx)
return temp_state.receipts
def call(this,
to,
value=0,
data='',
sender=None,
startgas=25000,
gasprice=60 * denoms.shannon):
sender = normalize_address(sender or this.coinbase)
to = normalize_address(to, allow_blank=True)
block = this.head_candidate
state_root_before = block.state_root
assert block.prevhash == this.chain.head_hash
# rebuild block state before finalization
test_state = this.chain.mk_poststate_of_blockhash(
block.prevhash)
initialize(test_state, block)
for tx in block.transactions:
success, _ = apply_transaction(test_state, tx)
assert success
# Need this because otherwise the Transaction.network_id
# @property returns 0, which causes the tx to fail validation.
class MockedTx(Transaction):
network_id = None
# apply transaction
nonce = test_state.get_nonce(sender)
tx = MockedTx(nonce, gasprice, startgas, to, value, data)
tx.sender = sender
try:
success, output = apply_transaction(test_state, tx)
except InvalidTransaction as e:
log.debug("error applying tx in Eth.call", exc=e)
success = False
assert block.state_root == state_root_before
if success:
return output
else:
return False
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
def __init__(self,
shard_id,
env=None,
new_head_cb=None,
reset_genesis=False,
localtime=None,
max_history=1000,
initial_state=None,
main_chain=None,
**kwargs):
self.env = env or Env()
self.shard_id = shard_id
self.collation_blockhash_lists = defaultdict(
list) # M1: collation_header_hash -> list[blockhash]
self.head_collation_of_block = {} # M2: blockhash -> head_collation
self.main_chain = main_chain
# Initialize the state
head_hash_key = 'shard_' + str(shard_id) + '_head_hash'
if head_hash_key in self.db: # new head tag
self.state = self.mk_poststate_of_collation_hash(
self.db.get(head_hash_key))
log.info('Initializing shard chain from saved head, #%d (%s)' %
(self.state.prev_headers[0].number,
encode_hex(self.state.prev_headers[0].hash)))
self.head_hash = self.state.prev_headers[0].hash
else:
# no head_hash in db -> empty shard chain
if initial_state is not None and isinstance(initial_state, State):
# Normally, initial_state is for testing
assert env is None
self.state = initial_state
self.env = self.state.env
log.info('Initializing chain from provided state')
else:
self.state = State(env=self.env)
self.last_state = self.state.to_snapshot()
self.head_hash = self.env.config['GENESIS_PREVHASH']
self.db.put(self.head_hash, 'GENESIS')
self.db.put(head_hash_key, self.head_hash)
# initial score
key = b'score:' + self.head_hash
self.db.put(key, str(0))
self.db.commit()
reset_genesis = True
assert self.env.db == self.state.db
initialize(self.state)
self.new_head_cb = new_head_cb
if reset_genesis:
initialize_genesis_keys(self.state, Collation(CollationHeader()))
self.time_queue = []
self.parent_queue = {}
self.localtime = time.time() if localtime is None else localtime
self.max_history = max_history
def __init__(self,
genesis=None,
env=None,
new_head_cb=None,
reset_genesis=False,
localtime=None,
max_history=1000,
**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('head_hash'))
self.state.executing_on_head = True
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')
reset_genesis = True
elif "extraData" in genesis:
self.state = state_from_genesis_declaration(genesis,
self.env,
executing_on_head=True)
reset_genesis = True
print('Initializing chain from provided genesis declaration')
elif "prev_headers" in genesis:
self.state = State.from_snapshot(genesis,
self.env,
executing_on_head=True)
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])))
elif isinstance(genesis, dict):
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',
self.env.config['BLOCK_GAS_LIMIT']),
"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
if self.state.block_number == 0:
assert self.state.block_number == self.state.prev_headers[0].number
else:
assert self.state.block_number - 1 == self.state.prev_headers[
0].number
if reset_genesis:
if isinstance(self.state.prev_headers[0], FakeHeader):
header = self.state.prev_headers[0].to_block_header()
else:
header = self.state.prev_headers[0]
self.genesis = Block(header)
self.state.prev_headers[0] = header
initialize_genesis_keys(self.state, self.genesis)
else:
self.genesis = self.get_block_by_number(0)
self.head_hash = self.state.prev_headers[0].hash
self.time_queue = []
self.parent_queue = {}
self.localtime = time.time() if localtime is None else localtime
self.max_history = max_history