def verify_dc_sig(self, sig, msghash, msgsize, from_addr, data):
# data comes in as array of byte array (bytes as ints, from js)
tohash = byte_arrays_to_string(data)
assert (msghash == utils.sha3(tohash))
X, Y = ecdsa_raw_recover(msghash, sig)
pX = utils.int_to_big_endian(X).encode('hex')
pY = utils.int_to_big_endian(Y).encode('hex')
pub = '04'+pX+pY
return ecdsa_raw_verify(msghash, sig, pub.decode('hex'))
def verify_dc_sig(self, sig, msghash, msgsize, from_addr, data):
# data comes in as array of byte array (bytes as ints, from js)
tohash = byte_arrays_to_string(data)
assert (msghash == utils.sha3(tohash))
X, Y = ecdsa_raw_recover(msghash, sig)
pX = utils.int_to_big_endian(X).encode('hex')
pY = utils.int_to_big_endian(Y).encode('hex')
pub = '04' + pX + pY
return ecdsa_raw_verify(msghash, sig, pub.decode('hex'))
def account_to_dict(self, address, with_storage_root=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(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))
med_dict['storage'] = {}
d = strie.to_dict()
for k in d.keys() + self.caches['all'].keys():
v = d.get(k, None)
subcache = self.caches.get('storage:' + address, {})
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 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 to_dict(self):
return dict(address=self.address,
topics=[
utils.zpad(utils.int_to_big_endian(x),
32).encode('hex') for x in self.topics
],
data='0x' + self.data.encode('hex'))
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 account_to_dict(self, address, with_storage_root=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(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))
med_dict['storage'] = {}
d = strie.to_dict()
for k in d.keys() + self.caches['all'].keys():
v = d.get(k, None)
subcache = self.caches.get('storage:'+address, {})
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 add_block(self, block):
blockhash = block.hash()
if blockhash == GENESIS_H:
parent_score = 0
else:
try:
parent = rlp.decode(self.blockchain.get(block.prevhash))
except:
raise Exception("Parent of block not found")
parent_score = utils.big_endian_to_int(parent[1])
total_score = utils.int_to_big_endian(block.difficulty + parent_score)
self.blockchain.put(
blockhash, rlp.encode([block.serialize(), total_score]))
try:
head = self.blockchain.get('head')
head_data = rlp.decode(self.blockchain.get(head))
head_score = utils.big_endian_to_int(head_data[1])
except:
head_score = 0
if total_score > head_score:
self.head = blockhash
self.blockchain.put('head', blockhash)
return True
return False
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 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, 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 encode_length(L, offset):
if L < 56:
return chr(L + offset)
elif L < 256**8:
BL = int_to_big_endian(L)
return chr(len(BL) + offset + 55) + BL
else:
raise Exception("input too long")
def encode_length(L, offset):
if L < 56:
return chr(L + offset)
elif L < 256 ** 8:
BL = int_to_big_endian(L)
return chr(len(BL) + offset + 55) + BL
else:
raise Exception("input too long")
def quickcontract(self, gasprice, startgas, value, code, pkey_hex):
sender = privtoaddr(pkey_hex)
nonce = self.getnonce(sender)
tx = contract(nonce, gasprice, startgas, value, code)
formatted_rlp = [sender.decode('hex'), utils.int_to_big_endian(nonce)]
addr = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex')
o = self.applytx(sign(tx, pkey_hex))
o['addr'] = addr
return o
def quickcontract(self, gasprice, startgas, value, code, pkey_hex):
sender = privtoaddr(pkey_hex)
nonce = self.getnonce(sender)
tx = contract(nonce, gasprice, startgas, value, code)
formatted_rlp = [sender.decode('hex'), utils.int_to_big_endian(nonce)]
addr = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex')
o = self.applytx(sign(tx, pkey_hex))
o['addr'] = addr
return o
def length_prefix(length, offset):
"""Construct the prefix to lists or strings denoting their length.
:param length: the length of the item in bytes
:param offset: ``0x80`` when encoding raw bytes, ``0xc0`` when encoding a
list
"""
if length < 56:
return chr(offset + length)
else:
length_string = int_to_big_endian(length)
return chr(offset + 56 - 1 + len(length_string)) + length_string
def contract_address(self):
"""For contract creation transactions, return the address of the new
account.
:raises `ValueError`: if the transaction is not signed
:raises `ValueError`: if the transaction is not a contract creation
"""
if self.sender == 0:
raise ValueError('Transaction is not signed')
if bool(self.to):
raise ValueError('Transaction is not a contract creation')
formatted_rlp = [self.sender.decode('hex'),
utils.int_to_big_endian(self.nonce)]
address = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex')
return address
def contract_address(self):
"""For contract creation transactions, return the address of the new
account.
:raises `ValueError`: if the transaction is not signed
:raises `ValueError`: if the transaction is not a contract creation
"""
if self.sender == 0:
raise ValueError('Transaction is not signed')
if bool(self.to):
raise ValueError('Transaction is not a contract creation')
formatted_rlp = [
self.sender.decode('hex'),
utils.int_to_big_endian(self.nonce)
]
address = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex')
return address
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 account_to_dict(self, address, with_storage_root=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(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))
med_dict["storage"] = {}
for k, v in strie.to_dict().iteritems():
subcache = self.caches.get("storage:" + address, {})
v2 = subcache.get(utils.big_endian_to_int(k), None)
hexkey = "0x" + k.encode("hex")
if v2 is not None:
med_dict["storage"][hexkey] = "0x" + utils.int_to_big_endian(v2).encode("hex")
else:
med_dict["storage"][hexkey] = "0x" + v.encode("hex")
return med_dict
def to_dict(self):
return dict(address=self.address,
topics=[utils.zpad(utils.int_to_big_endian(x), 32).encode('hex')
for x in self.topics],
data='0x' + self.data.encode('hex'))
def b64(int_bloom):
"returns b64"
return utils.zpad(utils.int_to_big_endian(int_bloom), 64)
def b64(int_bloom):
"returns b64"
return utils.zpad(utils.int_to_big_endian(int_bloom), 64)
def length_prefix(length, offset):
if length < 56:
return chr(offset + length)
else:
length_string = utils.int_to_big_endian(length)
return chr(offset + 56 - 1 + len(length_string)) + length_string
def apply_op(block, tx, msg, code, compustate):
op, in_args, out_args = get_op_data(code, compustate.pc)
# empty stack error
if in_args > len(compustate.stack):
return []
# out of gas error
fee = calcfee(block, tx, msg, compustate, op)
if fee > compustate.gas:
if debug:
print("Out of gas", compustate.gas, "need", fee)
print(op, list(reversed(compustate.stack)))
return OUT_OF_GAS
stackargs = []
for i in range(in_args):
stackargs.append(compustate.stack.pop())
if debug:
import serpent
if op[:4] == 'PUSH':
start, n = compustate.pc + 1, int(op[4:])
print(op, utils.big_endian_to_int(code[start:start + n]))
else:
print(op, ' '.join(map(str, stackargs)),
serpent.decode_datalist(compustate.memory))
# Apply operation
oldgas = compustate.gas
oldpc = compustate.pc
compustate.gas -= fee
compustate.pc += 1
stk = compustate.stack
mem = compustate.memory
if op == 'STOP':
return []
elif op == 'ADD':
stk.append((stackargs[0] + stackargs[1]) % 2 ** 256)
elif op == 'SUB':
stk.append((stackargs[0] - stackargs[1]) % 2 ** 256)
elif op == 'MUL':
stk.append((stackargs[0] * stackargs[1]) % 2 ** 256)
elif op == 'DIV':
if stackargs[1] == 0:
return []
stk.append(stackargs[0] / stackargs[1])
elif op == 'MOD':
if stackargs[1] == 0:
return []
stk.append(stackargs[0] % stackargs[1])
elif op == 'SDIV':
if stackargs[1] == 0:
return []
if stackargs[0] >= 2 ** 255:
stackargs[0] -= 2 ** 256
if stackargs[1] >= 2 ** 255:
stackargs[1] -= 2 ** 256
stk.append((stackargs[0] / stackargs[1]) % 2 ** 256)
elif op == 'SMOD':
if stackargs[1] == 0:
return []
if stackargs[0] >= 2 ** 255:
stackargs[0] -= 2 ** 256
if stackargs[1] >= 2 ** 255:
stackargs[1] -= 2 ** 256
stk.append((stackargs[0] % stackargs[1]) % 2 ** 256)
elif op == 'EXP':
stk.append(pow(stackargs[0], stackargs[1], 2 ** 256))
elif op == 'NEG':
stk.append(2 ** 256 - stackargs[0])
elif op == 'LT':
stk.append(1 if stackargs[0] < stackargs[1] else 0)
elif op == 'GT':
stk.append(1 if stackargs[0] > stackargs[1] else 0)
elif op == 'SLT':
if stackargs[0] >= 2 ** 255:
stackargs[0] -= 2 ** 256
if stackargs[1] >= 2 ** 255:
stackargs[1] -= 2 ** 256
stk.append(1 if stackargs[0] < stackargs[1] else 0)
elif op == 'SGT':
if stackargs[0] >= 2 ** 255:
stackargs[0] -= 2 ** 256
if stackargs[1] >= 2 ** 255:
stackargs[1] -= 2 ** 256
stk.append(1 if stackargs[0] > stackargs[1] else 0)
elif op == 'EQ':
stk.append(1 if stackargs[0] == stackargs[1] else 0)
elif op == 'NOT':
stk.append(0 if stackargs[0] else 1)
elif op == 'AND':
stk.append(stackargs[0] & stackargs[1])
elif op == 'OR':
stk.append(stackargs[0] | stackargs[1])
elif op == 'XOR':
stk.append(stackargs[0] ^ stackargs[1])
elif op == 'BYTE':
if stackargs[0] >= 32:
stk.append(0)
else:
stk.append((stackargs[1] / 256 ** stackargs[0]) % 256)
elif op == 'SHA3':
if len(mem) < ceil32(stackargs[0] + stackargs[1]):
mem.extend([0] * (ceil32(stackargs[0] + stackargs[1]) - len(mem)))
data = ''.join(map(chr, mem[stackargs[0]:stackargs[0] + stackargs[1]]))
print 'data time!'
print data
print data.encode('hex')
stk.append(int(utils.sha3(data).encode('hex'), 16))
elif op == 'ECVERIFY':
# parameters: msg_hash (32), v (32), r (32), s (32), pubX (32), pubY (32)
# stack should have all args
msg_hash, v, r, s, pubX, pubY = stackargs
pubX = utils.int_to_big_endian(pubX).encode('hex')
pubY = utils.int_to_big_endian(pubY).encode('hex')
msg_hash = utils.int_to_big_endian(msg_hash)
pub = ('04' + pubX + pubY).decode('hex')
verified = ecdsa_raw_verify(msg_hash, (v, r, s), pub)
print 'verified: ', verified
stk.append(verified)
elif op == 'ECRECOVER':
# parameters: msg_hash (32), v (32), r (32), s (32), p (64 - empty array to hold pubkey)
# stack should have all args
msg_hash, v, r, s = stackargs
msg_hash = utils.int_to_big_endian(msg_hash)
pubX, pubY = ecdsa_raw_recover(msg_hash, (v, r, s))
stk.append(pubX)
stk.append(pubY)
elif op == 'PUB2ADDR':
pubX, pubY = stackargs
pubX = utils.int_to_big_endian(pubX).encode('hex')
pubY = utils.int_to_big_endian(pubY).encode('hex')
pub = pubX + pubY
pub = pub.decode('hex')
addr = utils.sha3(pub)[12:]
stk.append(addr)
elif op == 'ADDRESS':
stk.append(msg.to)
elif op == 'BALANCE':
stk.append(block.get_balance(msg.to))
elif op == 'ORIGIN':
stk.append(tx.sender)
elif op == 'CALLER':
stk.append(utils.coerce_to_int(msg.sender))
elif op == 'CALLVALUE':
stk.append(msg.value)
elif op == 'CALLDATALOAD':
if stackargs[0] >= len(msg.data):
stk.append(0)
else:
dat = msg.data[stackargs[0]:stackargs[0] + 32]
stk.append(utils.big_endian_to_int(dat + '\x00' * (32 - len(dat))))
elif op == 'CALLDATASIZE':
stk.append(len(msg.data))
elif op == 'CALLDATACOPY':
if len(mem) < ceil32(stackargs[1] + stackargs[2]):
mem.extend([0] * (ceil32(stackargs[1] + stackargs[2]) - len(mem)))
for i in range(stackargs[2]):
if stackargs[0] + i < len(msg.data):
mem[stackargs[1] + i] = ord(msg.data[stackargs[0] + i])
else:
mem[stackargs[1] + i] = 0
elif op == 'GASPRICE':
stk.append(tx.gasprice)
elif op == 'CODECOPY':
if len(mem) < ceil32(stackargs[1] + stackargs[2]):
mem.extend([0] * (ceil32(stackargs[1] + stackargs[2]) - len(mem)))
for i in range(stackargs[2]):
if stackargs[0] + i < len(code):
mem[stackargs[1] + i] = ord(code[stackargs[0] + i])
else:
mem[stackargs[1] + i] = 0
elif op == 'PREVHASH':
stk.append(utils.big_endian_to_int(block.prevhash))
elif op == 'COINBASE':
stk.append(utils.big_endian_to_int(block.coinbase.decode('hex')))
elif op == 'TIMESTAMP':
stk.append(block.timestamp)
elif op == 'NUMBER':
stk.append(block.number)
elif op == 'DIFFICULTY':
stk.append(block.difficulty)
elif op == 'GASLIMIT':
stk.append(block.gaslimit)
elif op == 'POP':
pass
elif op == 'DUP':
stk.append(stackargs[0])
stk.append(stackargs[0])
elif op == 'SWAP':
stk.append(stackargs[0])
stk.append(stackargs[1])
elif op == 'MLOAD':
if len(mem) < ceil32(stackargs[0] + 32):
mem.extend([0] * (ceil32(stackargs[0] + 32) - len(mem)))
data = ''.join(map(chr, mem[stackargs[0]:stackargs[0] + 32]))
stk.append(utils.big_endian_to_int(data))
elif op == 'MSTORE':
if len(mem) < ceil32(stackargs[0] + 32):
mem.extend([0] * (ceil32(stackargs[0] + 32) - len(mem)))
v = stackargs[1]
#if isinstance(v, str):
# v = int(v.encode('hex'), 16)
for i in range(31, -1, -1):
mem[stackargs[0] + i] = v % 256
v /= 256
elif op == 'MSTORE8':
if len(mem) < ceil32(stackargs[0] + 1):
mem.extend([0] * (ceil32(stackargs[0] + 1) - len(mem)))
mem[stackargs[0]] = stackargs[1] % 256
elif op == 'SLOAD':
stk.append(block.get_storage_data(msg.to, stackargs[0]))
elif op == 'SSTORE':
block.set_storage_data(msg.to, stackargs[0], stackargs[1])
elif op == 'JUMP':
compustate.pc = stackargs[0]
elif op == 'JUMPI':
if stackargs[1]:
compustate.pc = stackargs[0]
elif op == 'PC':
stk.append(compustate.pc)
elif op == 'MSIZE':
stk.append(len(mem))
elif op == 'GAS':
stk.append(oldgas)
elif op[:4] == 'PUSH':
pushnum = int(op[4:])
compustate.pc = oldpc + 1 + pushnum
dat = code[oldpc + 1: oldpc + 1 + pushnum]
stk.append(utils.big_endian_to_int(dat))
elif op == 'CREATE':
if len(mem) < ceil32(stackargs[2] + stackargs[3]):
mem.extend([0] * (ceil32(stackargs[2] + stackargs[3]) - len(mem)))
gas = stackargs[0]
value = stackargs[1]
data = ''.join(map(chr, mem[stackargs[2]:stackargs[2] + stackargs[3]]))
if debug:
print("Sub-contract:", msg.to, value, gas, data)
addr, gas, code = create_contract(
block, tx, Message(msg.to, '', value, gas, data))
if debug:
print("Output of contract creation:", addr, code)
if addr:
stk.append(utils.coerce_to_int(addr))
else:
stk.append(0)
elif op == 'CALL':
if len(mem) < ceil32(stackargs[3] + stackargs[4]):
mem.extend([0] * (ceil32(stackargs[3] + stackargs[4]) - len(mem)))
if len(mem) < ceil32(stackargs[5] + stackargs[6]):
mem.extend([0] * (ceil32(stackargs[5] + stackargs[6]) - len(mem)))
gas = stackargs[0]
to = utils.encode_int(stackargs[1])
to = (('\x00' * (32 - len(to))) + to)[12:]
value = stackargs[2]
data = ''.join(map(chr, mem[stackargs[3]:stackargs[3] + stackargs[4]]))
if debug:
print("Sub-call:", utils.coerce_addr_to_hex(msg.to),
utils.coerce_addr_to_hex(to), value, gas, data)
result, gas, data = apply_msg(
block, tx, Message(msg.to, to, value, gas, data))
if debug:
print("Output of sub-call:", result, data, "length", len(data),
"expected", stackargs[6])
for i in range(stackargs[6]):
mem[stackargs[5] + i] = 0
if result == 0:
stk.append(0)
else:
stk.append(1)
compustate.gas += gas
for i in range(len(data)):
mem[stackargs[5] + i] = data[i]
elif op == 'RETURN':
if len(mem) < ceil32(stackargs[0] + stackargs[1]):
mem.extend([0] * (ceil32(stackargs[0] + stackargs[1]) - len(mem)))
return mem[stackargs[0]:stackargs[0] + stackargs[1]]
elif op == 'SUICIDE':
to = utils.encode_int(stackargs[0])
to = (('\x00' * (32 - len(to))) + to)[12:]
block.delta_balance(to, block.get_balance(msg.to))
block.state.update(msg.to, '')
return []
def serialize(cls, i):
return int_to_big_endian(i)
def _parse_payload(self):
return ''.join(int_to_big_endian(i) for i in self._payload)
def __str__(self):
body = '{0}{1}'.format(self._encoded_id(), self.string)
strlen = int_to_big_endian(len(body))
msg = '{0}{1}'.format(strlen, body)
print 'This {0} is {1} characters long.'.format(type(self), len(msg))
return msg
