def consensus(reports, reputation, max_iterations=10):
s = t.state()
filename = "consensus.se"
c = s.contract(filename)
num_voters = len(reputation)
num_events = len(reports[0])
v_size = len(reports.flatten())
reputation_fixed = map(fix, reputation)
reports_fixed = map(fix, reports.flatten())
# tx 1: consensus()
result = s.send(t.k0, c, 0,
funid=0,
abi=[reports_fixed, reputation_fixed, max_iterations])
result = np.array(result)
weighted_centered_data = result[0:v_size]
votes_filled = result[v_size:(2*v_size)]
votes_mask = result[(2*v_size):(3*v_size)]
# pca()
s = t.state()
c = s.contract(filename)
scores = s.send(t.k0, c, 0,
funid=1,
abi=[weighted_centered_data.tolist(),
reputation_fixed,
num_voters,
num_events,
max_iterations])
# consensus2()
s = t.state()
c = s.contract(filename)
retval = s.send(t.k0, c, 0,
funid=2,
abi=[reputation_fixed,
scores,
votes_filled.tolist(),
votes_mask.tolist(),
num_voters,
num_events])
outcome_final = retval[0:num_events]
author_bonus = retval[num_events:(2*num_events)]
voter_bonus = retval[(2*num_events):-2]
return outcome_final, author_bonus, voter_bonus, retval[-2] - retval[-1]
def test_callcode():
s = tester.state()
open(filename2, 'w').write(add1_code)
c = s.contract(callcode_test_code)
o1 = s.send(tester.k0, c, 0)
os.remove(filename2)
assert o1 == [64]
def compile(filename):
s = t.state()
start = time.time()
printf('Compiling...\t')
c = suppress_output(lambda: s.abi_contract(filename))
printf('Done in %.1f seconds.\n', time.time() - start)
return c
def test_stateless():
s = tester.state()
open(filename2, "w").write(add1_code)
c = s.contract(stateless_test_code)
o1 = s.send(tester.k0, c, 0, [])
os.remove(filename2)
assert o1 == [64]
def test_stateless():
s = tester.state()
open(filename2, 'w').write(add1_code)
c = s.contract(stateless_test_code)
o1 = s.send(tester.k0, c, 0, [])
os.remove(filename2)
assert o1 == [64]
def test_sort():
s = tester.state()
c = s.abi_contract(sort_code)
assert c.sort([9]) == [9]
assert c.sort([9, 5]) == [5, 9]
assert c.sort([9, 3, 5]) == [3, 5, 9]
assert c.sort([80, 234, 112, 112, 29]) == [29, 80, 112, 112, 234]
def test_returnten():
s = tester.state()
open(filename, 'w').write(mul2_code)
c = s.contract(returnten_code)
s.send(tester.k0, c, 0, [])
b2 = blocks.Block.deserialize(s.db, s.block.serialize())
assert b2.serialize() == s.block.serialize()
def test_returnten():
s = tester.state()
open(filename, 'w').write(mul2_code)
c = s.contract(returnten_code)
o1 = s.send(tester.k0, c, 0)
os.remove(filename)
assert o1 == [10]
def compile(filename):
s = t.state()
start = time.time()
printf('Compiling...\t')
c = suppress_output(lambda: s.abi_contract(filename))
printf('Done in %.1f seconds.\n', time.time() - start)
return c
def test_crowdfund():
s = tester.state()
c = s.abi_contract(crowdfund_code)
# Create a campaign with id 100
c.create_campaign(100, 45, 100000, 2)
# Create a campaign with id 200
c.create_campaign(200, 48, 100000, 2)
# Make some contributions
c.contribute(100, value=1, sender=tester.k1)
assert [1] == c.progress_report(100)
c.contribute(200, value=30000, sender=tester.k2)
c.contribute(100, value=59049, sender=tester.k3)
assert [59050] == c.progress_report(100)
c.contribute(200, value=70001, sender=tester.k4)
# Expect the 100001 units to be delivered to the destination
# account for campaign 2
assert 100001 == s.block.get_balance(utils.int_to_addr(48))
mida1 = s.block.get_balance(tester.a1)
mida3 = s.block.get_balance(tester.a3)
# Mine 5 blocks to expire the campaign
s.mine(5)
# Ping the campaign after expiry
c.contribute(100, value=1)
# Expect refunds
assert mida1 + 1 == s.block.get_balance(tester.a1)
assert mida3 + 59049 == s.block.get_balance(tester.a3)
def test_reverter():
s = tester.state()
c = s.contract(reverter_code, endowment=10 ** 15)
s.send(tester.k0, c, 0, [0])
assert s.block.get_storage_data(c, 8080) == 4040
assert s.block.get_balance("0" * 39 + "1") == 9
assert s.block.get_storage_data(c, 8081) == 0
assert s.block.get_balance("0" * 39 + "2") == 0
def setup_method(self, method):
self.state = tester.state()
self.namereg_contract = self.state.contract(self.namereg)
self.contract = self.state.contract(self.etherex)
self.etx_contract = self.state.contract(self.etx)
self.bob_contract = self.state.contract(self.bob)
def setup_method(self, method):
self.state = tester.state()
self.namereg_contract = self.state.contract(self.namereg)
self.contract = self.state.contract(self.etherex)
self.etx_contract = self.state.contract(self.etx)
self.bob_contract = self.state.contract(self.bob)
def test_reverter():
s = tester.state()
c = s.abi_contract(reverter_code, endowment=10**15)
c.entry()
assert s.block.get_storage_data(c.address, 8080) == 4040
assert s.block.get_balance('0'*39+'7') == 9
assert s.block.get_storage_data(c.address, 8081) == 0
assert s.block.get_balance('0'*39+'8') == 0
def test_blockhashes_300():
s = tester.state()
s.mine(300)
o = s.block.get_ancestor_list(256)
assert o[0] == s.block == s.blocks[300]
for i in range(1, 257):
assert o[i] == s.blocks[300-i]
assert len(o) == 257
def test_reverter():
s = tester.state()
c = s.contract(reverter_code, endowment=10**15)
s.send(tester.k0, c, 0, [0])
assert s.block.get_storage_data(c, 8080) == 4040
assert s.block.get_balance('0' * 39 + '1') == 9
assert s.block.get_storage_data(c, 8081) == 0
assert s.block.get_balance('0' * 39 + '2') == 0
def test_storagevar_fails():
s = tester.state()
success1, success2, success3, success4, success5, success6 = \
0, 0, 0, 0, 0, 0
try:
s.contract(fail1)
except Exception, e:
success1 = "Storage variable access not deep enough" in str(e)
def test_blockhashes_300():
s = tester.state()
s.mine(300)
o = s.block.get_ancestor_list(256)
assert o[0] == s.block == s.blocks[300]
for i in range(1, 257):
assert o[i] == s.blocks[300 - i]
assert len(o) == 257
def run_serpent(contract, parms, convert_to_int=False):
"""Call a serpent (.se) contract on a test blockchain"""
if convert_to_int:
args = convert_args(parms)
else:
args = parms
s = t.state() #Initialize a genesis block
c = s.contract(contract)
return s.send(t.k0, c, 0, [args])
def test_multiarg_code():
s = tester.state()
c = s.contract(multiarg_code)
o = s.send(tester.k0,
c,
0,
funid=0,
abi=[[1, 2, 3], 4, [5, 6, 7], "\"doge\"", 8])
assert o == [862541, ord('d') + ord('o') + ord('g'), 4]
def test_post():
s = tester.state()
c = s.contract(arither_code)
s.send(tester.k0, c, 0, [1])
o2 = s.send(tester.k0, c, 0, [3])
assert o2 == [1010]
c = s.contract(arither_code)
s.send(tester.k0, c, 0, [2])
o2 = s.send(tester.k0, c, 0, [3])
assert o2 == [1001]
def test_post():
s = tester.state()
c = s.contract(arither_code)
s.send(tester.k0, c, 0, [1])
o2 = s.send(tester.k0, c, 0, [3])
assert o2 == [1010]
c = s.contract(arither_code)
s.send(tester.k0, c, 0, [2])
o2 = s.send(tester.k0, c, 0, [3])
assert o2 == [1001]
def setup_class(self):
self.state = tester.state()
self.namereg = self.state.abi_contract(self.namereg)
self.contract = self.state.abi_contract(self.etherex)
self.etx_contract = self.state.abi_contract(self.etx)
self.bob_contract = self.state.abi_contract(self.bob)
self.snapshot = self.state.snapshot()
def test_saveload():
s = tester.state()
c = s.abi_contract(saveload_code)
o = c.kall()
assert o[0] == 0x73697220626f62616c6f7420746f207468652072657363756520212131213121, bitcoin.encode(o[0], 16)
assert o[1] == 0x2131213100000000000000000000000000000000000000000000000000000000, bitcoin.encode(o[1], 16)
assert o[2] == 0x73697220626f62616c6f7420746f207468652072657363756520212131213121, bitcoin.encode(o[2], 16)
assert o[3] == 0x2131213100000000000000000000000000000000000000000000000000000000, bitcoin.encode(o[3], 16)
assert o[4] == 0x73697220626f62616c6f7420746f207468652072657363756520212131213121, bitcoin.encode(o[4], 16)
assert o[5] == 0x2100000000000000000000000000000000000000000000000000000000000000, bitcoin.encode(o[5], 16)
def test_namecoin():
s = tester.state()
c = s.contract(namecoin_code)
o1 = s.send(tester.k0, c, 0, ['"george"', 45])
assert o1 == [1]
o2 = s.send(tester.k0, c, 0, ['"george"', 20])
assert o2 == [0]
o3 = s.send(tester.k0, c, 0, ['"harry"', 60])
assert o3 == [1]
assert s.block.to_dict()
def test_currency():
s = tester.state()
c = s.contract(currency_code, sender=tester.k0)
o1 = s.send(tester.k0, c, 0, [tester.a2, 200])
assert o1 == [1]
o2 = s.send(tester.k0, c, 0, [tester.a2, 900])
assert o2 == [0]
o3 = s.send(tester.k0, c, 0, [tester.a0])
assert o3 == [800]
o4 = s.send(tester.k0, c, 0, [tester.a2])
assert o4 == [200]
def setup_method(self, method):
self.state = tester.state()
self.ncontract = self.state.contract(self.ncode)
self.contract = self.state.contract(self.code)
self.bcontract = self.state.contract(self.bcode)
self.icontract = self.state.contract(self.icode)
self.tcontract = self.state.contract(self.tcode)
self.ccontract = self.state.contract(self.ccode)
self.xcontract = self.state.contract(self.xcode)
def test_calls():
s = tester.state()
c = s.contract(calltest_code)
s.send(tester.k0, c, 0, funid=0, abi=[])
assert [12345] == s.send(tester.k0, c, 0, funid=4, abi=[1])
assert [23456] == s.send(tester.k0, c, 0, funid=4, abi=[2])
assert [34567] == s.send(tester.k0, c, 0, funid=4, abi=[3])
s.send(tester.k0, c, 0, funid=1, abi=[4, 5, 6, 7, 8])
assert [45678] == s.send(tester.k0, c, 0, funid=4, abi=[1])
s.send(tester.k0, c, 0, funid=2, abi=[5, 6, 7, 8, 9])
assert [56789] == s.send(tester.k0, c, 0, funid=4, abi=[2])
def test_blockhashes_10():
s = tester.state()
s.mine(10)
o = s.block.get_ancestor_list(256)
print o
assert o[0] == s.block == s.blocks[10]
for i in range(1, 10):
assert o[i] == s.blocks[10-i]
for i in range(11, 257):
assert o[i] is None
assert len(o) == 257
def test_blockhashes_10():
s = tester.state()
s.mine(10)
o = s.block.get_ancestor_list(256)
print o
assert o[0] == s.block == s.blocks[10]
for i in range(1, 10):
assert o[i] == s.blocks[10 - i]
for i in range(11, 257):
assert o[i] is None
assert len(o) == 257
def test_sha256():
s = tester.state()
c = s.contract(sha256_code)
assert s.send(tester.k0, c, 0) == [
0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 - 2**256,
0xd9147961436944f43cd99d28b2bbddbf452ef872b30c8279e255e7daafc7f946 - 2**256,
0xcd6357efdd966de8c0cb2f876cc89ec74ce35f0968e11743987084bd42fb8944 - 2**256,
0xcd6357efdd966de8c0cb2f876cc89ec74ce35f0968e11743987084bd42fb8944 - 2**256,
0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2e4 - 2**256,
0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2e4 - 2**256
]
def test_sha3():
s = tester.state()
c = s.contract(sha3_code)
assert s.send(tester.k0, c, 0) == [
0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 - 2**256,
0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b - 2**256,
0x41791102999c339c844880b23950704cc43aa840f3739e365323cda4dfa89e7a,
0x41791102999c339c844880b23950704cc43aa840f3739e365323cda4dfa89e7a,
0xdfded4ed5ac76ba7379cfe7b3b0f53e768dca8d45a34854e649cfc3c18cbd9cd - 2**256,
0xdfded4ed5ac76ba7379cfe7b3b0f53e768dca8d45a34854e649cfc3c18cbd9cd - 2**256
]
def test_sort():
s = tester.state()
c = s.contract(sort_code)
a1 = s.send(tester.k0, c, 0, funid=0, abi=[[9]])
assert a1 == [9]
a2 = s.send(tester.k0, c, 0, funid=0, abi=[[9, 5]])
assert a2 == [5, 9]
a3 = s.send(tester.k0, c, 0, funid=0, abi=[[9, 3, 5]])
assert a3 == [3, 5, 9]
a4 = s.send(tester.k0, c, 0, funid=0, abi=[[80, 24, 234, 112, 112, 29]])
assert a4 == [24, 29, 80, 112, 112, 234]
def test_currency():
s = tester.state()
c = s.abi_contract(currency_code, sender=tester.k0)
o1 = c.send(tester.a2, 200)
assert o1 == [1]
o2 = c.send(tester.a2, 900)
assert o2 == [0]
o3 = c.query(tester.a0)
assert o3 == [800]
o4 = c.query(tester.a2)
assert o4 == [200]
def test_returnten():
s = tester.state()
open(filename, 'w').write(mul2_code)
c = s.contract(returnten_code)
snapshot = s.snapshot()
proof = s.mkspv(tester.k0, c, 0, [])
print "Proof length %d" % len(rlp.encode(proof))
s.revert(snapshot)
verify = s.verifyspv(tester.k0, c, 0, [], proof=proof)
assert verify
os.remove(filename)
def test_namecoin():
s = tester.state()
c = s.contract(namecoin_code)
o1 = s.send(tester.k0, c, 0, ['"george"', 45])
assert o1 == ["1"]
o2 = s.send(tester.k0, c, 0, ['"george"', 20])
assert o2 == ["0"]
o3 = s.send(tester.k0, c, 0, ['"harry"', 60])
assert o3 == ["1"]
assert s.block.to_dict()
def test_currency():
s = tester.state()
c = s.contract(currency_code, sender=tester.k0)
o1 = s.send(tester.k0, c, 0, [tester.a2, 200])
assert o1 == ["1"]
o2 = s.send(tester.k0, c, 0, [tester.a2, 900])
assert o2 == ["0"]
o3 = s.send(tester.k0, c, 0, [tester.a0])
assert o3 == ["800"]
o4 = s.send(tester.k0, c, 0, [tester.a2])
assert o4 == ["200"]
def test_namecoin():
s = tester.state()
c = s.abi_contract(namecoin_code)
o1 = c.main("george", 45)
assert o1 == [1]
o2 = c.main("george", 20)
assert o2 == [0]
o3 = c.main("harry", 60)
assert o3 == [1]
assert s.block.to_dict()
def test_calls():
s = tester.state()
c = s.abi_contract(calltest_code)
c.main()
assert [12345] == c.get(1)
assert [23456] == c.get(2)
assert [34567] == c.get(3)
c.first(4, 5, 6, 7, 8)
assert [45678] == c.get(1)
c.second(5, 6, 7, 8, 9)
assert [56789] == c.get(2)
def test_infinite_storage_objects():
s = tester.state()
c = s.contract(infinite_storage_object_test_code)
s.send(tester.k0, c, 0, funid=0, abi=[])
assert [1] == s.send(tester.k0, c, 0, funid=1, abi=[0, 0])
assert [2] == s.send(tester.k0, c, 0, funid=1, abi=[0, 1])
assert [3] == s.send(tester.k0, c, 0, funid=1, abi=[3, 0])
assert [100, 0, 0] == s.send(tester.k0, c, 0, funid=2, abi=[0])
assert [0, 15, 12] == s.send(tester.k0, c, 0, funid=2, abi=[1])
assert [0] == s.send(tester.k0, c, 0, funid=3, abi=[1, 3])
assert [0] == s.send(tester.k0, c, 0, funid=3, abi=[0, 2])
assert [9] == s.send(tester.k0, c, 0, funid=3, abi=[1, 2])
assert [555, 556, 656, 559, 659, 557, 0, 0, 0, 558, 657, 0, 0, 0,
658] == s.send(tester.k0, c, 0, funid=4, abi=[])
def test_data_feeds():
s = tester.state()
c = s.contract(data_feed_code, sender=tester.k0)
o2 = s.send(tester.k0, c, 0, funid=1, abi=[500])
assert o2 == [0]
o3 = s.send(tester.k0, c, 0, funid=0, abi=[500, 19])
assert o3 == [1]
o4 = s.send(tester.k0, c, 0, funid=1, abi=[500])
assert o4 == [19]
o5 = s.send(tester.k1, c, 0, funid=0, abi=[500, 726])
assert o5 == [0]
o6 = s.send(tester.k0, c, 0, funid=0, abi=[500, 726])
assert o6 == [1]
return s, c
def test_data_feeds():
s = tester.state()
c = s.abi_contract(data_feed_code, sender=tester.k0)
o2 = c.get(500)
assert o2 == [0]
o3 = c.set(500, 19)
assert o3 == [1]
o4 = c.get(500)
assert o4 == [19]
o5 = c.set(500, 726, sender=tester.k1)
assert o5 == [0]
o6 = c.set(500, 726)
assert o6 == [1]
return s, c
def test_infinite_storage_objects():
s = tester.state()
c = s.abi_contract(infinite_storage_object_test_code)
c.ping()
assert [1] == c.query_chessboard(0, 0)
assert [2] == c.query_chessboard(0, 1)
assert [3] == c.query_chessboard(3, 0)
assert [100, 0, 0] == c.query_stats(0)
assert [0, 15, 12] == c.query_stats(1)
assert [0] == c.query_items(1, 3)
assert [0] == c.query_items(0, 2)
assert [9] == c.query_items(1, 2)
assert [555, 556, 656, 559, 1659,
557, 0, 0, 0, 558,
657, 0, 0, 0, 658] == c.query_person()
def test_data_feeds():
s = tester.state()
c = s.contract(data_feed_code, sender=tester.k0)
o1 = s.send(tester.k0, c, 0)
assert o1 == ["20"]
o2 = s.send(tester.k0, c, 0, [500])
assert o2 == ["0"]
o3 = s.send(tester.k0, c, 0, [500, 19])
assert o3 == ["1"]
o4 = s.send(tester.k0, c, 0, [500])
assert o4 == ["19"]
o5 = s.send(tester.k1, c, 0, [500, 726])
assert o5 == ["0"]
o6 = s.send(tester.k0, c, 0, [500, 726])
assert o6 == ["1"]
return s, c
def test_prevhashes():
s = tester.state()
c = s.abi_contract(prevhashes_code)
s.mine(7)
# Hashes of last 14 blocks including existing one
o1 = [x % 2**256 for x in c.get_prevhashes(14)]
# hash of self = 0, hash of blocks back to genesis block as is, hash of
# blocks before genesis block = 0
t1 = [0] + [utils.big_endian_to_int(b.hash) for b in s.blocks[-2::-1]] \
+ [0] * 6
assert o1 == t1
s.mine(256)
# Test 256 limit: only 1 <= g <= 256 generation ancestors get hashes shown
o2 = [x % 2**256 for x in c.get_prevhashes(270)]
t2 = [0] + [utils.big_endian_to_int(b.hash) for b in s.blocks[-2:-258:-1]] \
+ [0] * 13
assert o2 == t2
def test_suicider():
s = tester.state()
c = s.contract(suicider_code)
prev_gas_limit = tester.gas_limit
tester.gas_limit = 4000
# Run normally: suicide processes, so the attempt to ping the
# contract fails
s.send(tester.k0, c, 0, [1, 10])
o2 = s.send(tester.k0, c, 0, [2])
assert o2 == []
c = s.contract(suicider_code)
# Run the suicider in such a way that it suicides in a sub-call,
# then runs out of gas, leading to a revert of the suicide and the
# storage mutation
s.send(tester.k0, c, 0, [1, 4000])
# Check that the suicide got reverted
o2 = s.send(tester.k0, c, 0, [2])
assert o2 == [10]
# Check that the storage op got reverted
o3 = s.send(tester.k0, c, 0, [4])
assert o3 == [20]
tester.gas_limit = prev_gas_limit
def test_suicider():
s = tester.state()
c = s.abi_contract(suicider_code)
prev_gas_limit = tester.gas_limit
tester.gas_limit = 8000
# Run normally: suicide processes, so the attempt to ping the
# contract fails
c.entry(10)
o2 = c.ping_ten()
assert o2 == []
c = s.abi_contract(suicider_code)
# Run the suicider in such a way that it suicides in a sub-call,
# then runs out of gas, leading to a revert of the suicide and the
# storage mutation
c.entry(8000)
# Check that the suicide got reverted
o2 = c.ping_ten()
assert o2 == [10]
# Check that the storage op got reverted
o3 = c.ping_storage15()
assert o3 == [20]
tester.gas_limit = prev_gas_limit
