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