def test_data_feeds():
k, v, k2, v2 = accounts()
scode3 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[1001] = msg.sender
return(0)
elif msg.sender == contract.storage[1001] and msg.datasize == 2:
contract.storage[msg.data[0]] = msg.data[1]
return(1)
else:
return(contract.storage[msg.data[0]])
'''
code3 = serpent.compile(scode3)
logger.debug("AST", serpent.rewrite(serpent.parse(scode3)))
blk = b.genesis({v: 10 ** 18, v2: 10 ** 18})
tx10 = t.contract(0, gasprice, startgas, 0, code3).sign(k)
s, addr = pb.apply_transaction(blk, tx10)
tx11 = t.Transaction(1, gasprice, startgas, addr, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx11)
tx12 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx12)
assert serpent.decode_datalist(o) == [0]
tx13 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 726])).sign(k)
s, o = pb.apply_transaction(blk, tx13)
assert serpent.decode_datalist(o) == [1]
tx14 = t.Transaction(4, gasprice, startgas, addr, 0,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx14)
assert serpent.decode_datalist(o) == [726]
return blk, addr
def test_namecoin():
k, v, k2, v2 = accounts()
blk = b.genesis({v: u.denoms.ether * 1})
code1 = serpent.compile(namecoin_code)
tx1 = t.contract(0, gasprice, startgas, 0, code1).sign(k)
s, addr = pb.apply_transaction(blk, tx1)
snapshot = blk.snapshot()
# tx2
tx2 = t.Transaction(1, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 45]))
tx2.sign(k)
s, o = pb.apply_transaction(blk, tx2)
assert serpent.decode_datalist(o) == [1]
# tx3
tx3 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 20])).sign(k)
s, o = pb.apply_transaction(blk, tx3)
assert serpent.decode_datalist(o) == [0]
# tx4
tx4 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist(['harry', 60])).sign(k)
s, o = pb.apply_transaction(blk, tx4)
assert serpent.decode_datalist(o) == [1]
blk.revert(snapshot)
assert blk.to_dict()
assert blk.to_dict()['state'][addr]['code']
def test_data_feeds():
k, v, k2, v2 = accounts()
scode3 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[1001] = msg.sender
return(0)
elif msg.sender == contract.storage[1001] and msg.datasize == 2:
contract.storage[msg.data[0]] = msg.data[1]
return(1)
else:
return(contract.storage[msg.data[0]])
'''
code3 = serpent_compile(scode3)
logger.debug("AST", serpent.rewrite(serpent.parse(scode3)))
blk = b.genesis({v: 10**18, v2: 10**18})
tx10 = t.contract(0, gasprice, startgas, 0, code3).sign(k)
s, addr = pb.apply_transaction(blk, tx10)
tx11 = t.Transaction(1, gasprice, startgas, addr, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx11)
tx12 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx12)
assert serpent.decode_datalist(o) == [0]
tx13 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 726])).sign(k)
s, o = pb.apply_transaction(blk, tx13)
assert serpent.decode_datalist(o) == [1]
tx14 = t.Transaction(4, gasprice, startgas, addr, 0,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx14)
assert serpent.decode_datalist(o) == [726]
return blk, addr
def test_namecoin():
k, v, k2, v2 = accounts()
blk = b.genesis({v: u.denoms.ether * 1})
code1 = serpent_compile(namecoin_code)
tx1 = t.contract(0, gasprice, startgas, 0, code1).sign(k)
s, addr = pb.apply_transaction(blk, tx1)
snapshot = blk.snapshot()
# tx2
tx2 = t.Transaction(1, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 45]))
tx2.sign(k)
s, o = pb.apply_transaction(blk, tx2)
assert serpent.decode_datalist(o) == [1]
# tx3
tx3 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 20])).sign(k)
s, o = pb.apply_transaction(blk, tx3)
assert serpent.decode_datalist(o) == [0]
# tx4
tx4 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist(['harry', 60])).sign(k)
s, o = pb.apply_transaction(blk, tx4)
assert serpent.decode_datalist(o) == [1]
blk.revert(snapshot)
assert blk.to_dict()
assert blk.to_dict()['state'][addr]['code']
def format_debug(self, data):
try:
d = ''.join(chr(x) for x in data['result'])
except TypeError as e:
return
o = serpent.decode_datalist(d)
words = map(lambda x: x-2**256 if x > 2**255 else x, o)
if words and words[0] == 0xdeba6:
if len(words) >= 4 + 4 * 16 + 1: # have at least 16 cells
words = words[1:]
#msg.data = [cols, rows, a_ai, b_ai] + [a_grid] + [b_grid] + [sorted_redistribution_grid]
ncells = words[0] * words[1]
# restore redist
redist = [0] * ncells
for i in range(ncells):
v = words[4 + ncells * 2 + i*2]
c = words[4 + ncells * 2 + i*2 + 1]
redist[c] = v
self.sim_steps += 1
zeros = [0] * ncells
# blink grid values
ui.draw(sim_steps=self.sim_steps, cols=words[0], rows=words[1], a_grid=zeros,
b_grid=zeros, redistribution_grid=redist)
time.sleep(.2)
ui.draw(sim_steps=self.sim_steps, cols=words[0], rows=words[1], a_grid=words[4:4+ncells],
b_grid=words[4+ncells:4+ncells*2], redistribution_grid=redist)
def format_debug(self, data):
def is_printable(str):
return set(str).issubset(string.printable)
try:
d = ''.join(chr(x) for x in data['result'])
except TypeError as e:
print e
print data
return
o = serpent.decode_datalist(d)
words = map(lambda x: x - 2**256 if x > 2**255 else x, o)
if words and words[0] == 0xdeba6:
self.debug_contract = data['to']
self.register_address('debug', data['to'])
if len(words) < 2:
print "DEBUG:\t%r > %r" % (self.name(data['sender']), [])
return
h = hex(words[1])[2:].replace('L', '')
try:
label = ('0' + h if len(h) % 2 else h).decode('hex')
except TypeError:
label = '0x%s' % h
if is_printable(label):
print "DEBUG:\t%r > %r: %r" % (self.name(
data['sender']).ljust(4), label, words[2:])
else:
print "DEBUG:\t%r > %r" % (self.name(
data['sender']), words[1:])
return True
def format_debug(self, data):
def is_printable(str):
return set(str).issubset(string.printable)
try:
d = ''.join(chr(x) for x in data['result'])
except TypeError as e:
print e
print data
return
o = serpent.decode_datalist(d)
words = map(lambda x: x-2**256 if x > 2**255 else x, o)
if words and words[0] == 0xdeba6:
self.debug_contract = data['to']
self.register_address('debug', data['to'])
if len(words) < 2:
print "DEBUG:\t%r > %r" % (self.name(data['sender']), [])
return
h = hex(words[1])[2:].replace('L','')
try:
label = ('0' + h if len(h) % 2 else h).decode('hex')
except TypeError:
label = '0x%s' % h
if is_printable(label):
print "DEBUG:\t%r > %r: %r" % (self.name(data['sender']).ljust(4), label, words[2:])
else:
print "DEBUG:\t%r > %r" % (self.name(data['sender']), words[1:])
return True
def tx(self, frm, to, value, data, gas=STARTGAS):
_tx = transactions.Transaction(nonce=self.nonce[frm], gasprice=self.GASPRICE, startgas=gas,
to=to, value=value, data=serpent.encode_datalist(data)).sign(frm.key)
result, ans = processblock.apply_transaction(self.genesis, _tx)
assert result
self.nonce[frm] += 1
return serpent.decode_datalist(ans)
def test_currency():
k, v, k2, v2 = accounts()
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[0x%s] = 1000
return(1)
elif msg.datasize == 1:
addr = msg.data[0]
return(contract.storage[addr])
else:
from = msg.sender
fromvalue = contract.storage[from]
to = msg.data[0]
value = msg.data[1]
if fromvalue >= value:
contract.storage[from] = fromvalue - value
contract.storage[to] = contract.storage[to] + value
return(1)
else:
return(0)
''' % v
code2 = serpent_compile(scode2)
blk = b.genesis({v: 10**18})
tx4 = t.contract(0, gasprice, startgas, 0, code2).sign(k)
s, addr = pb.apply_transaction(blk, tx4)
tx5 = t.Transaction(1, gasprice, startgas, addr, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx5)
assert serpent.decode_datalist(o) == [1]
tx6 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2, 200])).sign(k)
s, o = pb.apply_transaction(blk, tx6)
assert serpent.decode_datalist(o) == [1]
tx7 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2, 900])).sign(k)
s, o = pb.apply_transaction(blk, tx7)
assert serpent.decode_datalist(o) == [0]
tx8 = t.Transaction(4, gasprice, startgas, addr, 0,
serpent.encode_datalist([v])).sign(k)
s, o = pb.apply_transaction(blk, tx8)
assert serpent.decode_datalist(o) == [800]
tx9 = t.Transaction(5, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2])).sign(k)
s, o = pb.apply_transaction(blk, tx9)
assert serpent.decode_datalist(o) == [200]
def test_currency():
k, v, k2, v2 = accounts()
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[0x%s] = 1000
return(1)
elif msg.datasize == 1:
addr = msg.data[0]
return(contract.storage[addr])
else:
from = msg.sender
fromvalue = contract.storage[from]
to = msg.data[0]
value = msg.data[1]
if fromvalue >= value:
contract.storage[from] = fromvalue - value
contract.storage[to] = contract.storage[to] + value
return(1)
else:
return(0)
''' % v
code2 = serpent.compile(scode2)
blk = b.genesis({v: 10 ** 18})
tx4 = t.contract(0, gasprice, startgas, 0, code2).sign(k)
s, addr = pb.apply_transaction(blk, tx4)
tx5 = t.Transaction(1, gasprice, startgas, addr, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx5)
assert serpent.decode_datalist(o) == [1]
tx6 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2, 200])).sign(k)
s, o = pb.apply_transaction(blk, tx6)
assert serpent.decode_datalist(o) == [1]
tx7 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2, 900])).sign(k)
s, o = pb.apply_transaction(blk, tx7)
assert serpent.decode_datalist(o) == [0]
tx8 = t.Transaction(4, gasprice, startgas, addr, 0,
serpent.encode_datalist([v])).sign(k)
s, o = pb.apply_transaction(blk, tx8)
assert serpent.decode_datalist(o) == [800]
tx9 = t.Transaction(5, gasprice, startgas, addr, 0,
serpent.encode_datalist([v2])).sign(k)
s, o = pb.apply_transaction(blk, tx9)
assert serpent.decode_datalist(o) == [200]
def _add_dc_to_dcp(self, to_addr, from_addr, sig, msghash, msgsize, data):
assert(self.verify_dc_sig(sig, msghash, msgsize, from_addr, data))
tx = self.dcp_list[to_addr]
txdata = serpent.decode_datalist(tx.data)
txdata[0] += 1 #increment dc count
#append dc data to dcp tx
strings = byte_arrays_to_string(data) # data contains from_addr, msg_size, [args]
map(txdata.append, strings)
self.dcp_list[to_addr].data = serpent.encode_datalist(txdata)
self.dcp_list[to_addr].sign(privkey)
def call(self, dest, from_=DEFAULT_ADDRESS, funid=None, data=None, gas=DEFAULT_GAS, gas_price=GAS_PRICE, value=0):
if not dest.startswith("0x"):
dest = "0x" + dest
if funid is not None:
data = "0x" + serpent.encode_abi(funid, *data).encode("hex")
params = [{"to": dest, "data": data, "gas": hex(gas), "gasPrice": hex(gas_price), "value": hex(value)}]
r = self._rpc_post("eth_call", params)
return serpent.decode_datalist(r[2:].decode("hex"))
def _add_dc_to_dcp(self, to_addr, from_addr, sig, msghash, msgsize, data):
assert (self.verify_dc_sig(sig, msghash, msgsize, from_addr, data))
tx = self.dcp_list[to_addr]
txdata = serpent.decode_datalist(tx.data)
txdata[0] += 1 #increment dc count
#append dc data to dcp tx
strings = byte_arrays_to_string(
data) # data contains from_addr, msg_size, [args]
map(txdata.append, strings)
self.dcp_list[to_addr].data = serpent.encode_datalist(txdata)
self.dcp_list[to_addr].sign(privkey)
def get_all_content(genesis, root_contract, usr):
key, addr = usr
nonce = get_nonce(genesis, addr)
tx_v = transactions.Transaction(nonce, 0, 10**12, 10000, root_contract, serpent.encode_datalist([7, 'kjsdhg'])).sign(key)
ans = processblock.apply_tx(genesis, tx_v)
decoded = serpent.decode_datalist(ans)
hexd = map(hex, decoded)
f = lambda x : x[2:-1]
hexd = map(f, hexd)
f = lambda x: x.decode('hex')
hexd = map(f, hexd)
return hexd
def tx(self, frm, to, value, data, gas=STARTGAS):
_tx = transactions.Transaction(nonce=self.nonce[frm],
gasprice=self.GASPRICE,
startgas=gas,
to=to,
value=value,
data=encode_datalist(data)).sign(
frm.key)
result, ans = processblock.apply_transaction(self.genesis, _tx)
assert result
self.nonce[frm] += 1
return decode_datalist(ans)
def get_all_content(genesis, root_contract, usr):
key, addr = usr
nonce = get_nonce(genesis, addr)
tx_v = transactions.Transaction(nonce, 0, 10**12, 10000, root_contract,
serpent.encode_datalist([7, 'kjsdhg'
])).sign(key)
ans = processblock.apply_tx(genesis, tx_v)
decoded = serpent.decode_datalist(ans)
hexd = map(hex, decoded)
f = lambda x: x[2:-1]
hexd = map(f, hexd)
f = lambda x: x.decode('hex')
hexd = map(f, hexd)
return hexd
def call(self,
dest,
sig=None,
data=None,
gas=None,
gas_price=None,
value=0,
from_=None,
defaultBlock='latest',
fun_name=None):
if not dest.startswith('0x'):
dest = '0x' + dest
if fun_name is not None:
raise DeprecationWarning(
"The `fun_name` definition is deprecated, use `serpent mk_signature <file>`"
" output for your method in `sig` instead.")
if sig is not None:
data = abi_data(sig, data)
if from_ is None:
from_ = self.address
if gas is None:
gas = self.gas
if gas_price is None:
gas_price = self.gas_price
if not self.fixed_price:
net_price = self.gasprice()
if net_price is None:
gas_price = self.gas_price
else:
logger.info(" Gas price: {:.4f} szabo * {:.4f}".format(
float(net_price) / 1000000000000, self.gas_price_modifier))
gas_price = int(net_price * self.gas_price_modifier)
logger.info(" Our price: %s" % "{:,}".format(gas_price))
params = [{
'from': from_,
'to': dest,
'data': data,
'gas': hex(gas).rstrip('L'),
'gasPrice': hex(gas_price).rstrip('L'),
'value': hex(value).rstrip('L')
}, defaultBlock]
r = self._rpc_post('eth_call', params)
if r is not None:
return decode_datalist(r[2:].decode('hex'))
return []
def call(self, dest, fun_name, sig='', data=None, from_=None, defaultBlock='latest'):
if not dest.startswith('0x'):
dest = '0x' + dest
if fun_name is not None:
data = abi_data(fun_name, sig, data)
if from_ is None:
from_ = self.address
params = [{
'from': from_,
'to': dest,
'data': data}, defaultBlock]
r = self._rpc_post('eth_call', params)
if r is not None:
return decode_datalist(r[2:].decode('hex'))
return []
def call(self,
dest,
fun_name,
sig='',
data=None,
from_=None,
defaultBlock='latest'):
if not dest.startswith('0x'):
dest = '0x' + dest
if fun_name is not None:
data = abi_data(fun_name, sig, data)
if from_ is None:
from_ = self.address
params = [{'from': from_, 'to': dest, 'data': data}, defaultBlock]
r = self._rpc_post('eth_call', params)
if r is not None:
return decode_datalist(r[2:].decode('hex'))
return []
def call(self,
dest,
from_=DEFAULT_ADDRESS,
funid=None,
data=None,
gas=DEFAULT_GAS,
gas_price=GAS_PRICE,
value=0):
if not dest.startswith('0x'):
dest = '0x' + dest
if funid is not None:
data = "0x" + serpent.encode_abi(funid, *data).encode('hex')
params = [{
'to': dest,
'data': data,
'gas': hex(gas),
'gasPrice': hex(gas_price),
'value': hex(value)
}]
r = self._rpc_post('eth_call', params)
return serpent.decode_datalist(r[2:].decode('hex'))
def call(self, dest, sig=None, data=None, gas=None, gas_price=None, value=0, from_=None, defaultBlock='latest', fun_name=None):
if not dest.startswith('0x'):
dest = '0x' + dest
if fun_name is not None:
raise DeprecationWarning("The `fun_name` definition is deprecated, use `serpent mk_signature <file>`"
" output for your method in `sig` instead.")
if sig is not None:
data = abi_data(sig, data)
if from_ is None:
from_ = self.address
if gas is None:
gas = self.gas
if gas_price is None:
gas_price = self.gas_price
if not self.fixed_price:
net_price = self.gasprice()
if net_price is None:
gas_price = self.gas_price
else:
logger.info(" Gas price: {:.4f} szabo * {:.4f}".format(float(net_price) / 1000000000000, self.gas_price_modifier))
gas_price = int(net_price * self.gas_price_modifier)
logger.info(" Our price: %s" % "{:,}".format(gas_price))
params = [{
'from': from_,
'to': dest,
'data': data,
'gas': hex(gas).rstrip('L'),
'gasPrice': hex(gas_price).rstrip('L'),
'value': hex(value).rstrip('L')}, defaultBlock]
r = self._rpc_post('eth_call', params)
if r is not None:
return decode_datalist(r[2:].decode('hex'))
return []
def format_debug(self, data):
try:
d = ''.join(chr(x) for x in data['result'])
except TypeError as e:
return
o = serpent.decode_datalist(d)
words = map(lambda x: x - 2**256 if x > 2**255 else x, o)
if words and words[0] == 0xdeba6:
if len(words) >= 4 + 4 * 16 + 1: # have at least 16 cells
words = words[1:]
#msg.data = [cols, rows, a_ai, b_ai] + [a_grid] + [b_grid] + [sorted_redistribution_grid]
ncells = words[0] * words[1]
# restore redist
redist = [0] * ncells
for i in range(ncells):
v = words[4 + ncells * 2 + i * 2]
c = words[4 + ncells * 2 + i * 2 + 1]
redist[c] = v
self.sim_steps += 1
zeros = [0] * ncells
# blink grid values
ui.draw(sim_steps=self.sim_steps,
cols=words[0],
rows=words[1],
a_grid=zeros,
b_grid=zeros,
redistribution_grid=redist)
time.sleep(.2)
ui.draw(sim_steps=self.sim_steps,
cols=words[0],
rows=words[1],
a_grid=words[4:4 + ncells],
b_grid=words[4 + ncells:4 + ncells * 2],
redistribution_grid=redist)
contract.storage[msg.data[0]] = msg.data[1]
return(1)
else:
return(0)
'''
code1 = serpent.compile(scode1)
print "AST", serpent.rewrite(serpent.parse(scode1))
print "Assembly", serpent.compile_to_assembly(scode1)
tx1 = t.Transaction.contract(0,0,10**12,1000,code1).sign(k)
addr = pb.apply_tx(blk,tx1)
snapshot = blk.snapshot()
print "Contract address", addr.encode('hex')
tx2 = t.Transaction(1,0,10**12,1000,addr,serpent.encode_datalist(['george',45]))
tx2.sign(k)
o = pb.apply_tx(blk,tx2)
print "Result of registering george:45: ", serpent.decode_datalist(o)
tx3 = t.Transaction(2,0,10**12,1000,addr,serpent.encode_datalist(['george',20])).sign(k)
o = pb.apply_tx(blk,tx3)
print "Result of registering george:20: ", serpent.decode_datalist(o)
tx4 = t.Transaction(3,0,10**12,1000,addr,serpent.encode_datalist(['harry',60])).sign(k)
o = pb.apply_tx(blk,tx4)
print "Result of registering harry:60: ", serpent.decode_datalist(o)
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[0x%s] = 1000
elif msg.datasize == 1:
addr = msg.data[0]
return(contract.storage[addr])
else:
return(1)
else:
return(0)
'''
code1 = serpent.compile(scode1)
print "AST", serpent.rewrite(serpent.parse(scode1))
print "Assembly", serpent.compile_to_assembly(scode1)
tx1 = t.Transaction.contract(0, 0, 10**12, 1000, code1).sign(k)
addr = pb.apply_tx(blk, tx1)
snapshot = blk.snapshot()
print "Contract address", addr.encode('hex')
tx2 = t.Transaction(1, 0, 10**12, 1000, addr,
serpent.encode_datalist(['george', 45]))
tx2.sign(k)
o = pb.apply_tx(blk, tx2)
print "Result of registering george:45: ", serpent.decode_datalist(o)
tx3 = t.Transaction(2, 0, 10**12, 1000, addr,
serpent.encode_datalist(['george', 20])).sign(k)
o = pb.apply_tx(blk, tx3)
print "Result of registering george:20: ", serpent.decode_datalist(o)
tx4 = t.Transaction(3, 0, 10**12, 1000, addr,
serpent.encode_datalist(['harry', 60])).sign(k)
o = pb.apply_tx(blk, tx4)
print "Result of registering harry:60: ", serpent.decode_datalist(o)
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[0x%s] = 1000
elif msg.datasize == 1:
addr = msg.data[0]
def test_hedge():
k, v, k2, v2 = accounts()
blk, addr = test_data_feeds()
scode4 = '''
if !contract.storage[1000]:
contract.storage[1000] = msg.sender
contract.storage[1002] = msg.value
contract.storage[1003] = msg.data[0]
return(1)
elif !contract.storage[1001]:
ethvalue = contract.storage[1002]
if msg.value >= ethvalue:
contract.storage[1001] = msg.sender
othervalue = ethvalue * call(0x%s,[contract.storage[1003]],1)
contract.storage[1004] = othervalue
contract.storage[1005] = block.timestamp + 86400
return([2,othervalue],2)
else:
othervalue = contract.storage[1004]
ethvalue = othervalue / call(0x%s,contract.storage[1003])
if ethvalue >= contract.balance:
send(contract.storage[1000],contract.balance)
return(3)
elif block.timestamp > contract.storage[1005]:
send(contract.storage[1001],contract.balance - ethvalue)
send(contract.storage[1000],ethvalue)
return(4)
else:
return(5)
''' % (addr, addr)
code4 = serpent.compile(scode4)
logger.debug("AST", serpent.rewrite(serpent.parse(scode4)))
# important: no new genesis block
tx15 = t.contract(5, gasprice, startgas, 0, code4).sign(k)
s, addr2 = pb.apply_transaction(blk, tx15)
tx16 = t.Transaction(6, gasprice, startgas, addr2, 10 ** 17,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx16)
assert serpent.decode_datalist(o) == [1]
tx17 = t.Transaction(0, gasprice, startgas, addr2, 10 ** 17,
serpent.encode_datalist([500])).sign(k2)
s, o = pb.apply_transaction(blk, tx17)
assert serpent.decode_datalist(o) == [2, 72600000000000000000L]
snapshot = blk.snapshot()
tx18 = t.Transaction(7, gasprice, startgas, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx18)
assert serpent.decode_datalist(o) == [5]
tx19 = t.Transaction(8, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 300])).sign(k)
s, o = pb.apply_transaction(blk, tx19)
assert serpent.decode_datalist(o) == [1]
tx20 = t.Transaction(9, gasprice, startgas, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx20)
assert serpent.decode_datalist(o) == [3]
blk.revert(snapshot)
blk.timestamp += 200000
tx21 = t.Transaction(7, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 1452])).sign(k)
s, o = pb.apply_transaction(blk, tx21)
assert serpent.decode_datalist(o) == [1]
tx22 = t.Transaction(8, gasprice, 2000, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx22)
assert serpent.decode_datalist(o) == [4]
v, r, s = bitcoin.ecdsa_raw_sign(msg_hash, key)
pub = bitcoin.privkey_to_pubkey(key)
verified = bitcoin.ecdsa_raw_verify(msg_hash, (v, r, s), pub)
print verified
tx_make_root = transactions.contract(0,10,10**30, 10**30, code).sign(key)
success, root_contract = processblock.apply_tx(gen, tx_make_root)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist([msg_hash, v, r, s])).sign(key)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist(['hi', 'bye'])).sign(key)
tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist([2, '139dcd5cc79e260272e05147c349ab5f2db3f102', 1])).sign(key)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist([2, 1])).sign(key)
print assembly
success, ans = processblock.apply_tx(gen, tx_init_root)
print ans
data = serpent.decode_datalist(ans)
print data
print hex(data[0])
quit()
print ans.encode('hex')
data = serpent.decode_datalist(ans)
print 'raw decoded data:', data
print 'data as hex:'
print map(hex, data)
#print ('%02x'%data).decode('hex')
print assembly
print data
print 'correct: ' , utils.sha3('\x00'*30+'hi').encode('hex')
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 test_hedge():
k, v, k2, v2 = accounts()
blk, addr = test_data_feeds()
scode4 = '''
if !contract.storage[1000]:
contract.storage[1000] = msg.sender
contract.storage[1002] = msg.value
contract.storage[1003] = msg.data[0]
return(1)
elif !contract.storage[1001]:
ethvalue = contract.storage[1002]
if msg.value >= ethvalue:
contract.storage[1001] = msg.sender
othervalue = ethvalue * call(0x%s,[contract.storage[1003]],1)
contract.storage[1004] = othervalue
contract.storage[1005] = block.timestamp + 86400
return([2,othervalue],2)
else:
othervalue = contract.storage[1004]
ethvalue = othervalue / call(0x%s,contract.storage[1003])
if ethvalue >= contract.balance:
send(contract.storage[1000],contract.balance)
return(3)
elif block.timestamp > contract.storage[1005]:
send(contract.storage[1001],contract.balance - ethvalue)
send(contract.storage[1000],ethvalue)
return(4)
else:
return(5)
''' % (addr, addr)
code4 = serpent_compile(scode4)
logger.debug("AST", serpent.rewrite(serpent.parse(scode4)))
# important: no new genesis block
tx15 = t.contract(5, gasprice, startgas, 0, code4).sign(k)
s, addr2 = pb.apply_transaction(blk, tx15)
tx16 = t.Transaction(6, gasprice, startgas, addr2, 10**17,
serpent.encode_datalist([500])).sign(k)
s, o = pb.apply_transaction(blk, tx16)
assert serpent.decode_datalist(o) == [1]
tx17 = t.Transaction(0, gasprice, startgas, addr2, 10**17,
serpent.encode_datalist([500])).sign(k2)
s, o = pb.apply_transaction(blk, tx17)
assert serpent.decode_datalist(o) == [2, 72600000000000000000L]
snapshot = blk.snapshot()
tx18 = t.Transaction(7, gasprice, startgas, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx18)
assert serpent.decode_datalist(o) == [5]
tx19 = t.Transaction(8, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 300])).sign(k)
s, o = pb.apply_transaction(blk, tx19)
assert serpent.decode_datalist(o) == [1]
tx20 = t.Transaction(9, gasprice, startgas, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx20)
assert serpent.decode_datalist(o) == [3]
blk.revert(snapshot)
blk.timestamp += 200000
tx21 = t.Transaction(7, gasprice, startgas, addr, 0,
serpent.encode_datalist([500, 1452])).sign(k)
s, o = pb.apply_transaction(blk, tx21)
assert serpent.decode_datalist(o) == [1]
tx22 = t.Transaction(8, gasprice, 2000, addr2, 0, '').sign(k)
s, o = pb.apply_transaction(blk, tx22)
assert serpent.decode_datalist(o) == [4]
h = "%02x"%n
l = len(h)
return "0"*(32-l)+h
nargs = pad32(1)
d0 = pad32('hi')
print nargs, d0
msg_hash = utils.sha3(nargs+d0)
v, r, s = bitcoin.ecdsa_raw_sign(msg_hash, key)
pubkey = bitcoin.privkey_to_pubkey(key)
verified = bitcoin.ecdsa_raw_verify(msg_hash, (v,r,s), pubkey)
gen = blocks.genesis({addr: 10**18})
print serpent.compile_to_assembly(open("DAOist frame.se").read())
DAOcode = serpent.compile(open("DAOist frame.se").read())
DAOcontract = transactions.contract(0, 1, 10**12, 100, DAOcode)
DAOcontract.sign(key)
success, contract_address = processblock.apply_tx(gen, DAOcontract)
DCP = transactions.Transaction(1,10**12, 10000, contract_address, 0, serpent.encode_datalist([1,1,v,r,s,1,'hi']))
DCP.sign(key)
success, result = processblock.apply_tx(gen, DCP)
print "success: ", success
print serpent.decode_datalist(result)
nargs = pad32(1)
d0 = pad32('hi')
print nargs, d0
msg_hash = utils.sha3(nargs + d0)
v, r, s = bitcoin.ecdsa_raw_sign(msg_hash, key)
pubkey = bitcoin.privkey_to_pubkey(key)
verified = bitcoin.ecdsa_raw_verify(msg_hash, (v, r, s), pubkey)
gen = blocks.genesis({addr: 10**18})
print serpent.compile_to_assembly(open("DAOist frame.se").read())
DAOcode = serpent.compile(open("DAOist frame.se").read())
DAOcontract = transactions.contract(0, 1, 10**12, 100, DAOcode)
DAOcontract.sign(key)
success, contract_address = processblock.apply_tx(gen, DAOcontract)
DCP = transactions.Transaction(
1, 10**12, 10000, contract_address, 0,
serpent.encode_datalist([1, 1, v, r, s, 1, 'hi']))
DCP.sign(key)
success, result = processblock.apply_tx(gen, DCP)
print "success: ", success
print serpent.decode_datalist(result)
### From here is pasted together from earlier version of pyetherem
import serpent
from pyethereum import transactions, blocks, processblock, utils
#processblock.print_debug = 1
from pyethereum import slogging
slogging.set_level('eth.tx', "DEBUG")
code = serpent.compile(namecoin_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis(new_db(), {addr: 10**18})
tx1 = transactions.contract(nonce=0,
gasprice=10**12,
startgas=10000,
endowment=0,
code=code).sign(key)
result, contract = processblock.apply_transaction(genesis, tx1)
print genesis.to_dict()
tx2 = transactions.Transaction(nonce=1,
gasprice=10**12,
startgas=10000,
to=contract,
value=0,
data=serpent.encode_abi(0, 1, 45)).sign(key)
result, ans = processblock.apply_transaction(genesis, tx2)
serpent.decode_datalist(ans)
#print genesis.to_dict()
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:
logger.debug("Out of gas %s need %s", compustate.gas, fee)
logger.debug('%s %s', op, list(reversed(compustate.stack)))
return OUT_OF_GAS
stackargs = []
for i in range(in_args):
stackargs.append(compustate.stack.pop())
if expensive_debug:
import serpent
if op[:4] == 'PUSH':
start, n = compustate.pc + 1, int(op[4:])
logger.debug('%s %s ', op,
utils.big_endian_to_int(code[start:start + n]))
else:
logger.debug('%s %s %s', 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]]))
stk.append(utils.big_endian_to_int(utils.sha3(data)))
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]
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]]))
logger.debug("Sub-contract: %s %s %s %s ", msg.to, value, gas, data)
addr, gas, code = create_contract(
block, tx, Message(msg.to, '', value, gas, data))
logger.debug("Output of contract creation: %s %s ", 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]]))
logger.debug(
"Sub-call: %s %s %s %s %s ", 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))
logger.debug(
"Output of sub-call: %s %s length %s expected %s", result, data, len(data),
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.delete(msg.to)
return []
pub = bitcoin.privkey_to_pubkey(key)
verified = bitcoin.ecdsa_raw_verify(msg_hash, (v, r, s), pub)
print verified
tx_make_root = transactions.contract(0, 10, 10**30, 10**30, code).sign(key)
success, root_contract = processblock.apply_tx(gen, tx_make_root)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist([msg_hash, v, r, s])).sign(key)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist(['hi', 'bye'])).sign(key)
tx_init_root = transactions.Transaction(
1, 100, 10**40, root_contract, 0,
serpent.encode_datalist([2, '139dcd5cc79e260272e05147c349ab5f2db3f102',
1])).sign(key)
#tx_init_root = transactions.Transaction(1, 100, 10**40, root_contract, 0, serpent.encode_datalist([2, 1])).sign(key)
print assembly
success, ans = processblock.apply_tx(gen, tx_init_root)
print ans
data = serpent.decode_datalist(ans)
print data
print hex(data[0])
quit()
print ans.encode('hex')
data = serpent.decode_datalist(ans)
print 'raw decoded data:', data
print 'data as hex:'
print map(hex, data)
#print ('%02x'%data).decode('hex')
print assembly
print data
print 'correct: ', utils.sha3('\x00' * 30 + 'hi').encode('hex')
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:
logger.debug("Out of gas %s need %s", compustate.gas, fee)
logger.debug('%s %s', op, list(reversed(compustate.stack)))
return OUT_OF_GAS
stackargs = []
for i in range(in_args):
stackargs.append(compustate.stack.pop())
if expensive_debug:
import serpent
if op[:4] == 'PUSH':
start, n = compustate.pc + 1, int(op[4:])
logger.debug('%s %s ', op,
utils.big_endian_to_int(code[start:start + n]))
else:
logger.debug('%s %s %s', 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]]))
stk.append(utils.big_endian_to_int(utils.sha3(data)))
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]
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]]))
logger.debug("Sub-contract: %s %s %s %s ", msg.to, value, gas, data)
addr, gas, code = create_contract(
block, tx, Message(msg.to, '', value, gas, data))
logger.debug("Output of contract creation: %s %s ", 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]]))
logger.debug(
"Sub-call: %s %s %s %s %s ", 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))
logger.debug(
"Output of sub-call: %s %s length %s expected %s", result, data, len(data),
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.delete(msg.to)
return []
def sha3(data):
return serpent.decode_datalist(utils.sha3(serpent.encode_datalist(*data)))[0]
return(1)
else:
return(0)
'''
code1 = serpent.compile(scode1)
# print("AST", serpent.rewrite(serpent.parse(scode1)))
# print("Assembly", serpent.compile_to_assembly(scode1))
tx1 = t.contract(0, gasprice, startgas, 0, code1).sign(k)
s, addr = pb.apply_tx(blk, tx1)
snapshot = blk.snapshot()
print("Contract address", addr)
tx2 = t.Transaction(1, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 45]))
tx2.sign(k)
s, o = pb.apply_tx(blk, tx2)
print("Result of registering george:45: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [1]
tx3 = t.Transaction(2, gasprice, startgas, addr, 0,
serpent.encode_datalist(['george', 20])).sign(k)
s, o = pb.apply_tx(blk, tx3)
print("Result of registering george:20: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [0]
tx4 = t.Transaction(3, gasprice, startgas, addr, 0,
serpent.encode_datalist(['harry', 60])).sign(k)
s, o = pb.apply_tx(blk, tx4)
print("Result of registering harry:60: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [1]
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[msg.data[0]] = msg.data[1]
return(1)
else:
return(0)
'''
code1 = serpent.compile(scode1)
# print("AST", serpent.rewrite(serpent.parse(scode1)))
# print("Assembly", serpent.compile_to_assembly(scode1))
tx1 = t.contract(0, gasprice, startgas, 0, code1).sign(k)
s, addr = pb.apply_tx(blk, tx1)
snapshot = blk.snapshot()
print("Contract address", addr)
tx2 = t.Transaction(1, gasprice, startgas, addr, 0, serpent.encode_datalist(['george', 45]))
tx2.sign(k)
s, o = pb.apply_tx(blk, tx2)
print("Result of registering george:45: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [1]
tx3 = t.Transaction(2, gasprice, startgas, addr, 0, serpent.encode_datalist(['george', 20])).sign(k)
s, o = pb.apply_tx(blk, tx3)
print("Result of registering george:20: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [0]
tx4 = t.Transaction(3, gasprice, startgas, addr, 0, serpent.encode_datalist(['harry', 60])).sign(k)
s, o = pb.apply_tx(blk, tx4)
print("Result of registering harry:60: ", serpent.decode_datalist(o))
assert serpent.decode_datalist(o) == [1]
scode2 = '''
if !contract.storage[1000]:
contract.storage[1000] = 1
contract.storage[0x%s] = 1000
return(1)
def new_config(data_dir=None):
cfg = _get_default_config()
if not data_dir:
tempfile.mktemp()
cfg.set('misc', 'data_dir', data_dir)
return cfg
### From here is pasted together from earlier version of pyetherem
import serpent
from pyethereum import transactions, blocks, processblock, utils
#processblock.print_debug = 1
from pyethereum import slogging
slogging.set_level('eth.tx',"DEBUG")
code = serpent.compile(namecoin_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis(new_db(), { addr: 10**18 })
tx1 = transactions.contract(nonce=0,gasprice=10**12,startgas=10000,endowment=0,code=code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)
print genesis.to_dict()
tx2 = transactions.Transaction(nonce=1,gasprice=10**12,startgas=10000,to=contract,value=0,
data=serpent.encode_abi(0,1,45)).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)
serpent.decode_datalist(ans)
#print genesis.to_dict()
