def set_storage_data(self, address, index, val):
t = self.get_storage(address)
if val:
t.update(utils.coerce_to_bytes(index), encode_int(val))
else:
t.delete(utils.coerce_to_bytes(index))
self.set_index(address, STORAGE_INDEX, t.root)
def set_storage_data(self, address, index, val):
t = self.get_storage(address)
if val:
t.update(utils.coerce_to_bytes(index), utils.encode_int(val))
else:
t.delete(utils.coerce_to_bytes(index))
self._set_acct_item(address, 'storage', t.root_hash)
def set_storage_data(self,address,index,val):
t = self.get_storage(address)
if val:
t.update(utils.coerce_to_bytes(index),encode_int(val))
else:
t.delete(utils.coerce_to_bytes(index))
self.set_index(address,STORAGE_INDEX,t.root)
def set_storage_data(self, address, index, val):
t = self.get_storage(address)
if val:
t.update(utils.coerce_to_bytes(index), utils.encode_int(val))
else:
t.delete(utils.coerce_to_bytes(index))
self._set_acct_item(address, 'storage', t.root_hash)
def commit_state(self):
if not len(self.journal):
return
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(utils.get_db_path(), acct[i])
t.proof_mode = self.proof_mode
t.proof_nodes = self.proof_nodes
for k, v in self.caches.get('storage:' + address,
{}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
if self.proof_mode == RECORDING:
self.proof_nodes.extend(t.proof_nodes)
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
acct[i] = utils.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
if self.proof_mode == RECORDING:
self.proof_nodes.extend(self.state.proof_nodes)
self.state.proof_nodes = []
self.reset_cache()
def account_to_dict(self, address, with_storage_root=False, with_storage=True):
if with_storage_root:
assert len(self.journal) == 0
med_dict = {}
for i, val in enumerate(self.get_acct(address)):
name, typ, default = acct_structure[i]
key = acct_structure[i][0]
if name == 'storage':
strie = trie.Trie(utils.get_db_path(), val)
if with_storage_root:
med_dict['storage_root'] = strie.get_root_hash().encode('hex')
else:
med_dict[key] = self.caches[key].get(address, utils.printers[typ](val))
if with_storage:
med_dict['storage'] = {}
d = strie.to_dict()
subcache = self.caches.get('storage:'+address, {})
subkeys = [utils.zpad(utils.coerce_to_bytes(kk), 32) for kk in subcache.keys()]
for k in d.keys() + subkeys:
v = d.get(k, None)
v2 = subcache.get(utils.big_endian_to_int(k), None)
hexkey = '0x'+k.encode('hex')
if v2 is not None:
if v2 != 0:
med_dict['storage'][hexkey] = '0x'+utils.int_to_big_endian(v2).encode('hex')
elif v is not None:
med_dict['storage'][hexkey] = '0x'+rlp.decode(v).encode('hex')
return med_dict
def account_to_dict(self, address, with_storage_root=False,
with_storage=True, for_vmtest=False):
if with_storage_root:
assert len(self.journal) == 0
med_dict = {}
for i, val in enumerate(self.get_acct(address)):
name, typ, default = acct_structure[i]
key = acct_structure[i][0]
if name == 'storage':
strie = trie.Trie(self.db, val)
if with_storage_root:
med_dict['storage_root'] = strie.get_root_hash().encode('hex')
else:
med_dict[key] = utils.printers[typ](self.caches[key].get(address, val))
if with_storage:
med_dict['storage'] = {}
d = strie.to_dict()
subcache = self.caches.get('storage:' + address, {})
subkeys = [utils.zpad(utils.coerce_to_bytes(kk), 32) for kk in subcache.keys()]
for k in d.keys() + subkeys:
v = d.get(k, None)
v2 = subcache.get(utils.big_endian_to_int(k), None)
hexkey = '0x' + utils.zunpad(k).encode('hex')
if v2 is not None:
if v2 != 0:
med_dict['storage'][hexkey] = \
'0x' + utils.int_to_big_endian(v2).encode('hex')
elif v is not None:
med_dict['storage'][hexkey] = '0x' + rlp.decode(v).encode('hex')
return med_dict
def commit_state(self):
changes = []
if not len(self.journal):
# log_state.trace('delta', changes=[])
return
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(self.db, acct[i])
for k, v in self.caches.get('storage:' + address, {}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
changes.append(['storage', address, k, v])
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
changes.append([key, address, v])
acct[i] = self.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
log_state.trace('delta', changes=changes)
self.reset_cache()
def commit_state(self):
changes = []
if not len(self.journal):
# log_state.trace('delta', changes=[])
return
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(self.db, acct[i])
for k, v in self.caches.get('storage:' + address, {}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
changes.append(['storage', address, k, v])
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
changes.append([key, address, v])
acct[i] = self.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
log_state.trace('delta', changes=changes)
self.reset_cache()
def commit_state(self):
if not len(self.journal):
return
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(utils.get_db_path(), acct[i])
t.proof_mode = self.proof_mode
t.proof_nodes = self.proof_nodes
for k, v in self.caches.get('storage:'+address, {}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
if self.proof_mode == RECORDING:
self.proof_nodes.extend(t.proof_nodes)
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
acct[i] = utils.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
if self.proof_mode == RECORDING:
self.proof_nodes.extend(self.state.proof_nodes)
self.state.proof_nodes = []
self.reset_cache()
def get_storage_data(self, address, index):
CACHE_KEY = 'storage:'+address
if CACHE_KEY in self.caches:
if index in self.caches[CACHE_KEY]:
return self.caches[CACHE_KEY][index]
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(self.get_storage(address).get(key))
return utils.big_endian_to_int(val) if val else 0
def get_storage_data(self, address, index):
if address in self.caches['storage']:
if index in self.caches['storage'][address]:
return self.caches['storage'][address][index]
t = self.get_storage(address)
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(t.get(key))
return utils.big_endian_to_int(val) if val else 0
def get_storage_data(self, address, index):
if address in self.caches['storage']:
if index in self.caches['storage'][address]:
return self.caches['storage'][address][index]
t = self.get_storage(address)
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(t.get(key))
return utils.big_endian_to_int(val) if val else 0
def get_storage_data(self, address, index):
CACHE_KEY = 'storage:'+address
if CACHE_KEY in self.caches:
if index in self.caches[CACHE_KEY]:
return self.caches[CACHE_KEY][index]
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(self.get_storage(address).get(key))
return utils.big_endian_to_int(val) if val else 0
def get_storage_data(self, address, index):
if 'storage:' + address in self.caches:
if index in self.caches['storage:' + address]:
return self.caches['storage:' + address][index]
t = self.get_storage(address)
t.proof_mode = self.proof_mode
t.proof_nodes = self.proof_nodes
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(t.get(key))
if self.proof_mode == RECORDING:
self.proof_nodes.extend(t.proof_nodes)
return utils.big_endian_to_int(val) if val else 0
def get_storage_data(self, address, index):
if 'storage:'+address in self.caches:
if index in self.caches['storage:'+address]:
return self.caches['storage:'+address][index]
t = self.get_storage(address)
t.proof_mode = self.proof_mode
t.proof_nodes = self.proof_nodes
key = utils.zpad(utils.coerce_to_bytes(index), 32)
val = rlp.decode(t.get(key))
if self.proof_mode == RECORDING:
self.proof_nodes.extend(t.proof_nodes)
return utils.big_endian_to_int(val) if val else 0
def commit_state(self):
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(utils.get_db_path(), acct[i])
for k, v in self.caches[key].get(address, {}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
acct[i] = utils.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
self.reset_cache()
def commit_state(self):
for address in self.caches['all']:
acct = rlp.decode(self.state.get(address.decode('hex'))) \
or self.mk_blank_acct()
for i, (key, typ, default) in enumerate(acct_structure):
if key == 'storage':
t = trie.Trie(utils.get_db_path(), acct[i])
for k, v in self.caches[key].get(address, {}).iteritems():
enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
val = rlp.encode(utils.int_to_big_endian(v))
if v:
t.update(enckey, val)
else:
t.delete(enckey)
acct[i] = t.root_hash
else:
if address in self.caches[key]:
v = self.caches[key].get(address, default)
acct[i] = utils.encoders[acct_structure[i][1]](v)
self.state.update(address.decode('hex'), rlp.encode(acct))
self.reset_cache()
def get_storage_data(self, address, index):
t = self.get_storage(address)
val = t.get(utils.coerce_to_bytes(index))
return utils.decode_int(val) if val else 0
def get_storage_data(self, address, index):
t = self.get_storage(address)
return decode_int(t.get(utils.coerce_to_bytes(index)))
def get_storage_data(self, address, index):
t = self.get_storage(address)
val = t.get(utils.coerce_to_bytes(index))
return utils.decode_int(val) if val else 0
def get_storage_data(self, address, index):
t = self.get_storage(address)
return decode_int(t.get(utils.coerce_to_bytes(index)))
