def test_many_auth_transfer(self): ## ## run service ## checker_service_process = Process( target=bank_authenticated_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # create alice's and bob public key num_transfers = 7 transfer_amount = 1 params = setup() (alice_priv, alice_pub) = key_gen(params) (bob_priv, bob_pub) = key_gen(params) # init init_transaction = bank_authenticated.init()['transaction'] token = init_transaction['outputs'][0] # create alice's account create_alice_account_transaction = bank_authenticated.create_account( (token, ), None, None, pack(alice_pub))['transaction'] token = create_alice_account_transaction['outputs'][0] alice_account = create_alice_account_transaction['outputs'][1] # create bob's account create_bob_account_transaction = bank_authenticated.create_account( (token, ), None, None, pack(bob_pub))['transaction'] bob_account = create_bob_account_transaction['outputs'][1] # pack transaction transaction = {} input_obj = [alice_account, bob_account] for i in range(0, num_transfers): transaction_dict = bank_authenticated.auth_transfer( input_obj, None, [dumps(transfer_amount)], pack(alice_priv)) input_obj = transaction_dict['transaction']['outputs'] ## ## submit transaction ## response = requests.post( 'http://127.0.0.1:5000/' + bank_authenticated_contract.contract_name + '/auth_transfer', json=transaction_to_solution(transaction_dict)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_create_vote(self): ## ## run service ## checker_service_process = Process(target=vote_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # create keys params = setup() (tally_priv, tally_pub) = key_gen(params) (_, voter1_pub) = key_gen(params) (_, voter2_pub) = key_gen(params) (_, voter3_pub) = key_gen(params) # set up options, particpants, and tally's key options = ['alice', 'bob'] participants = [pack(voter1_pub), pack(voter2_pub), pack(voter3_pub)] # init init_transaction = vote.init() token = init_transaction['transaction']['outputs'][0] # initialise vote (all votes are zero) transaction = vote.create_vote( (token, ), None, None, dumps(options), dumps(participants), pack(tally_priv), pack(tally_pub) ) print transaction ## ## submit transaction ## response = requests.post( 'http://127.0.0.1:5000/' + vote_contract.contract_name + '/create_vote', json=transaction_to_solution(transaction) ) print response.json() self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_submit_bid(self): ## ## run service ## checker_service_process = Process( target=energy_bidding_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # generate crypto params G = setup()[0] (provider_priv, provider_pub) = key_gen(setup()) # init init_transaction = energy_bidding.init() token = init_transaction['transaction']['outputs'][0] # create meter create_meter_transaction = energy_bidding.create_meter( (token, ), None, None, pack(provider_pub), 'Some info about the meter.', dumps([5, 3, 5, 3, 5]), # the tariffs dumps(764) # billing period ) token = create_meter_transaction['transaction']['outputs'][0] meter = create_meter_transaction['transaction']['outputs'][1] # Submit bid transaction = energy_bidding.submit_bid((token, ), (meter, ), (dumps({ 'type': 'EBBuy', 'energy': 10, 'price': 50 }), ), pack(provider_priv)) token = bid_transaction['transaction']['outputs'][0] bid = bid_transaction['transaction']['outputs'][1] print transaction ## ## submit transaction ## response = requests.post('http://127.0.0.1:5000/' + energy_bidding_contract.contract_name + '/submit_bid', json=transaction_to_solution(transaction)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_add_many_reading(self): ## ## run service ## checker_service_process = Process( target=smart_meter_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # generate crypto params G = setup()[0] (provider_priv, provider_pub) = key_gen(setup()) # set init values tariffs = [5, 3, 5, 3, 5] readings = [10, 20, 30, 10, 50] openings = [G.order().random() for _ in tariffs] billing_period = 764 # init init_transaction = smart_meter.init() token = init_transaction['transaction']['outputs'][0] # create meter create_meter_transaction = smart_meter.create_meter( (token, ), None, None, pack(provider_pub), 'Some info about the meter.', dumps(tariffs), dumps(billing_period)) meter = create_meter_transaction['transaction']['outputs'][1] # add a readings transaction = {} input_obj = meter for i in range(0, len(tariffs)): transaction = smart_meter.add_reading((input_obj, ), None, None, pack(provider_priv), dumps(readings[i]), pack(openings[i])) input_obj = transaction['transaction']['outputs'][0] ## ## submit transaction ## response = requests.post('http://127.0.0.1:5000/' + smart_meter_contract.contract_name + '/add_reading', json=transaction_to_solution(transaction)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_add_reading(self): ## ## run service ## checker_service_process = Process( target=smart_meter_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # generate crypto params G = setup()[0] (provider_priv, provider_pub) = key_gen(setup()) # init init_transaction = smart_meter.init() token = init_transaction['transaction']['outputs'][0] # create meter create_meter_transaction = smart_meter.create_meter( (token, ), None, None, pack(provider_pub), 'Some info about the meter.', dumps([5, 3, 5, 3, 5]), # the tariffs dumps(764) # billing period ) meter = create_meter_transaction['transaction']['outputs'][1] # add a reading transaction = smart_meter.add_reading( (meter, ), None, None, pack(provider_priv), dumps(10), # the new reading pack(G.order().random()) # the opening value ) print transaction ## ## submit transaction ## response = requests.post('http://127.0.0.1:5000/' + smart_meter_contract.contract_name + '/add_reading', json=transaction_to_solution(transaction)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_create_vote(self): ## ## init ## transaction = vote.init() response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) self.assertTrue(response.json()['success']) ## ## create transaction ## # create keys params = setup() (tally_priv, tally_pub) = key_gen(params) (_, voter1_pub) = key_gen(params) (_, voter2_pub) = key_gen(params) (_, voter3_pub) = key_gen(params) # set up options, particpants, and tally's key options = ['alice', 'bob'] participants = [pack(voter1_pub), pack(voter2_pub), pack(voter3_pub)] # init init_transaction = vote.init() token = init_transaction['transaction']['outputs'][0] # initialise vote (all votes are zero) transaction = vote.create_vote((token, ), None, None, dumps(options), dumps(participants), pack(tally_priv), pack(tally_pub)) ## ## submit transaction ## response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) self.assertTrue(response.json()['success'])
def test_create_account(self): ## create transaction transaction = bank_authenticated.init() ## submit transaction response = requests.post('http://127.0.0.1:' +port+ '/api/' +version+ '/transaction/process', json=transaction) #print response.json() self.assertTrue(response.json()['success']) ## create transaction transaction = bank_authenticated.init() ## submit transaction response = requests.post( 'http://127.0.0.1:' +port+ '/api/' +version+ '/transaction/process', json=transaction ) #print response.json() self.assertTrue(response.json()['success']) ## ## create transaction ## # create alice's public key (_, alice_pub) = key_gen(setup()) # init init_transaction = bank_authenticated.init()['transaction'] token = init_transaction['outputs'][0] # create bank account transaction = bank_authenticated.create_account( (token,), None, None, pack(alice_pub) ) ## ## submit transaction ## response = requests.post( 'http://127.0.0.1:' +port+ '/api/' +version+ '/transaction/process', json=transaction ) #print response.json() self.assertTrue(response.json()['success'])
def test_create_meter(self): ## ## run service ## checker_service_process = Process( target=energy_bidding_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # create provider's public key (_, provider_pub) = key_gen(setup()) # init init_transaction = energy_bidding.init() token = init_transaction['transaction']['outputs'][0] # create meter transaction = energy_bidding.create_meter( (token, ), None, None, pack(provider_pub), 'Some info about the meter.', # some info about the meter dumps([5, 3, 5, 3, 5]), # the tariffs dumps(764) # the billing period ) print transaction ## ## submit transaction ## response = requests.post('http://127.0.0.1:5000/' + energy_bidding_contract.contract_name + '/create_meter', json=transaction_to_solution(transaction)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def test_create_meter(self): ## ## init ## transaction = smart_meter.init() response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) self.assertTrue(response.json()['success']) ## ## create transaction ## # create provider's public key (_, provider_pub) = key_gen(setup()) # init init_transaction = smart_meter.init() token = init_transaction['transaction']['outputs'][0] # create meter transaction = smart_meter.create_meter( (token, ), None, None, pack(provider_pub), 'Some info about the meter.', # some info about the meter dumps([5, 3, 5, 3, 5]), # the tariffs dumps(764) # the billing period ) ## ## submit transaction ## response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) self.assertTrue(response.json()['success'])
def test_create_account(self): ## ## run service ## checker_service_process = Process( target=bank_authenticated_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # create alice's public key (_, alice_pub) = key_gen(setup()) # init init_transaction = bank_authenticated.init()['transaction'] token = init_transaction['outputs'][0] # create bank account transaction_dict = bank_authenticated.create_account((token, ), None, None, pack(alice_pub)) ## ## submit transaction ## response = requests.post( 'http://127.0.0.1:5000/' + bank_authenticated_contract.contract_name + '/create_account', json=transaction_to_solution(transaction_dict)) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()
def main(): ## get contract and init pint vote.contract._populate_empty_checkers() print "operation\t\tmean (s)\t\tsd (s)\t\truns" # --------------------------------------------------------- # get functions # --------------------------------------------------------- # params params = setup() (tally_priv, tally_pub) = key_gen(params) (voter1_priv, voter1_pub) = key_gen(params) options = ['alice', 'bob'] participants = [pack(voter1_pub)] # init init_tx = vote.init() token = init_tx['transaction']['outputs'][0] # create vote create_vote_tx = vote.create_vote((token, ), None, None, dumps(options), dumps(participants), pack(tally_priv), pack(tally_pub)) vote_obj = create_vote_tx['transaction']['outputs'][1] # add vote add_vote_tx = vote.add_vote((vote_obj, ), None, None, dumps([1]), pack(voter1_priv), pack(voter1_pub)) # tally last_vote_obj = add_vote_tx['transaction']['outputs'][0] tally_tx = vote.tally((last_vote_obj, ), None, None, pack(tally_priv), pack(tally_pub)) # --------------------------------------------------------- # test create_vote # --------------------------------------------------------- # [gen] tester(RUNS, "create_vote [g]", vote.create_vote, (token, ), None, None, dumps(options), dumps(participants), pack(tally_priv), pack(tally_pub)) # [check] solution = transaction_to_solution(create_vote_tx) tester( RUNS, "create_vote [c]", vote.contract.checkers['create_vote'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) # --------------------------------------------------------- # test add_vote # --------------------------------------------------------- # [gen] tester(RUNS, "add_vote [g]\t", vote.add_vote, (vote_obj, ), None, None, dumps([1, 0]), pack(voter1_priv), pack(voter1_pub)) # [check] solution = transaction_to_solution(add_vote_tx) tester( RUNS, "add_vote [c]\t", vote.contract.checkers['add_vote'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) # --------------------------------------------------------- # test compute bill # --------------------------------------------------------- # [gen] tester(RUNS, "tally [g]\t", vote.tally, (last_vote_obj, ), None, None, pack(tally_priv), pack(tally_pub)) # [check] solution = transaction_to_solution(tally_tx) tester( RUNS, "tally [c]\t", vote.contract.checkers['tally'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], )
start_tx = datetime.now() response = client.process_transaction(tx) client_latency = (datetime.now() - start_tx) print response.text json_response = json.loads(response.text) results.append( (json_response['success'], response.url, tx['transaction']['methodID'], str(client_latency))) start_time = datetime.now() client = ChainspaceClient() params = setup() (tally_priv, tally_pub) = key_gen(params) # set up options, participants, and tally's key options = ['YES', 'NO'] init_transaction = petition_encrypted.init() # pp_object(init_transaction) post_transaction(init_transaction) # pp_object(init_transaction) petition_token = init_transaction['transaction']['outputs'][0] print "\nCreate the petition\n"
from json import dumps, loads import time import unittest import requests # chainsapce from chainspacecontract import transaction_to_solution # from chainspacecontract.examples.centra import contract as centra_contract from chainspacecontract.examples import centra # crypto from chainspacecontract.examples.utils import setup, key_gen, pack from chainspaceapi import ChainspaceClient G = setup()[0] (provider_priv1, provider_pub1) = key_gen(setup()) (provider_priv2, provider_pub2) = key_gen(setup()) (provider_priv3, provider_pub3) = key_gen(setup()) client1 = ChainspaceClient(port=5000) client2 = ChainspaceClient(port=5001) client3 = ChainspaceClient(port=5000) # Init txn init_transaction = centra.init() init_s0_token1 = init_transaction['transaction']['outputs'][0] client1.process_transaction(init_transaction) init_transaction = centra.init() init_s1_token1 = init_transaction['transaction']['outputs'][0] client2.process_transaction(init_transaction) ########################################################################### ############################ Client 1 ###################################
def main(): ## get contract and init pint smart_meter.contract._populate_empty_checkers() print "operation\t\tmean (s)\t\tsd (s)\t\truns" # --------------------------------------------------------- # get functions # --------------------------------------------------------- # params params = setup() G = params[0] (provider_priv, provider_pub) = key_gen(params) tariffs = [5, 3, 5, 3, 5] readings = [10, 20, 30, 10, 50] openings = [G.order().random() for _ in tariffs] # init init_tx = smart_meter.init() token = init_tx['transaction']['outputs'][0] # create smart_meter create_meter_tx = smart_meter.create_meter( (token,), None, None, pack(provider_pub), 'Some info about the meter.', # some info about the meter dumps([5, 3, 5, 3, 5]), # the tariffs dumps(764) # the billing period ) meter_obj = create_meter_tx['transaction']['outputs'][1] # add reading add_reading_tx = smart_meter.add_reading( (meter_obj,), None, None, pack(provider_priv), dumps(10), # the new reading pack(G.order().random()) # the opening value ) # compute bill last_meter_obj = add_reading_tx['transaction']['outputs'][0] compute_bill_tx = smart_meter.compute_bill( (last_meter_obj,), None, None, dumps(readings), pack(openings), dumps(tariffs) ) # --------------------------------------------------------- # test create_meter # --------------------------------------------------------- # [gen] tester(RUNS, "create_meter [g]", smart_meter.create_meter, (token,), None, None, pack(provider_pub), 'Some info about the meter.', dumps([5, 3, 5, 3, 5]), dumps(764) ) # [check] solution = transaction_to_solution(create_meter_tx) tester(RUNS, "create_meter [c]", smart_meter.contract.checkers['create_meter'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) # --------------------------------------------------------- # test add_reading # --------------------------------------------------------- # [gen] tester(RUNS, "add_reading [g]", smart_meter.add_reading, (meter_obj,), None, None, pack(provider_priv), dumps(10), pack(G.order().random()) ) # [check] solution = transaction_to_solution(add_reading_tx) tester(RUNS, "add_reading [c]", smart_meter.contract.checkers['add_reading'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) # --------------------------------------------------------- # test compute bill # --------------------------------------------------------- # [gen] tester(RUNS, "compute_bill [g]", smart_meter.compute_bill, (last_meter_obj,), None, None, dumps(readings), pack(openings), dumps(tariffs) ) # [check] solution = transaction_to_solution(compute_bill_tx) tester(RUNS, "compute_bill [c]", smart_meter.contract.checkers['compute_bill'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], )
import time import unittest import requests # chainspace from chainspacecontract import transaction_to_solution from chainspacecontract.examples.cscoin import contract as cscoin_contract from chainspacecontract.examples import cscoin # crypto from chainspacecontract.examples.utils import setup, key_gen, pack #################################################################### # CSCoin #################################################################### callback = 'hello.init' # id of the callback contract params = setup() (alice_priv, alice_pub) = key_gen(params) (bob_priv, bob_pub) = key_gen(params) class TestBankAuthenticated(unittest.TestCase): # -------------------------------------------------------------- # test init # -------------------------------------------------------------- def test_init(self): ## run service checker_service_process = Process( target=cscoin_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## create transaction
def main(): ## get contract and init pint bank_authenticated.contract._populate_empty_checkers() print "operation\t\tmean (s)\t\tsd (s)\t\truns" # --------------------------------------------------------- # get functions # --------------------------------------------------------- # params params = setup() (alice_priv, alice_pub) = key_gen(params) (_, bob_pub) = key_gen(params) # init init_tx = bank_authenticated.init() token = init_tx['transaction']['outputs'][0] # create accounts create_alice_account_tx = bank_authenticated.create_account( (token, ), None, None, pack(alice_pub)) create_bob_account_tx = bank_authenticated.create_account((token, ), None, None, pack(bob_pub)) alice_account = create_alice_account_tx['transaction']['outputs'][1] bob_account = create_bob_account_tx['transaction']['outputs'][1] # make transfer auth_transfer_tx = bank_authenticated.auth_transfer( (alice_account, bob_account), None, ('3', ), pack(alice_priv)) # --------------------------------------------------------- # test create_account # --------------------------------------------------------- # [gen] tester(RUNS, "create_account [g]", bank_authenticated.create_account, (token, ), None, None, pack(alice_pub)) # [check] solution = transaction_to_solution(create_alice_account_tx) tester( RUNS, "create_account [c]", bank_authenticated.contract.checkers['create_account'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) # --------------------------------------------------------- # test transfer # --------------------------------------------------------- # [gen] tester(RUNS, "auth_transfer [g]", bank_authenticated.auth_transfer, (alice_account, bob_account), None, ('3', ), pack(alice_priv)) # [gen] solution = transaction_to_solution(auth_transfer_tx) tester( RUNS, "auth_transfer [c]", bank_authenticated.contract.checkers['auth_transfer'], solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], )
def test(self): ## ## params ## params = setup() (alice_priv, alice_pub) = key_gen(params) (bob_priv, bob_pub) = key_gen(params) ## ## init ## transaction = bank_authenticated.init() response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) self.assertTrue(response.json()['success']) time.sleep(1) ## ## create alice's account ## token = transaction['transaction']['outputs'][0] create_alice_account_transaction = bank_authenticated.create_account( (token, ), None, None, pack(alice_pub)) response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=create_alice_account_transaction) self.assertTrue(response.json()['success']) time.sleep(1) ## ## create bob's account ## token = create_alice_account_transaction['transaction']['outputs'][0] create_bob_account_transaction = bank_authenticated.create_account( (token, ), None, None, pack(alice_pub)) response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=create_bob_account_transaction) self.assertTrue(response.json()['success']) time.sleep(1) ## ## make transfer ## alice_account = create_alice_account_transaction['transaction'][ 'outputs'][1] bob_account = create_bob_account_transaction['transaction']['outputs'][ 1] transfer_transaction = bank_authenticated.auth_transfer( [alice_account, bob_account], None, [dumps(3)], pack(alice_priv)) response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transfer_transaction) self.assertTrue(response.json()['success'] == 'True') time.sleep(1) ## ## read alice's balance ## alice_account = transfer_transaction['transaction']['outputs'][0] transaction = bank_authenticated.read(None, (alice_account, ), None) response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) #print response.json() self.assertTrue(response.json()['success']) time.sleep(1) ## ## read bob's balance ## bob_account = transfer_transaction['transaction']['outputs'][1] transaction = bank_authenticated.read(None, (bob_account, ), None) response = requests.post('http://127.0.0.1:' + port + '/api/' + version + '/transaction/process', json=transaction) #print response.json() self.assertTrue(response.json()['success']) time.sleep(1)
pp.pprint(json.loads(json_str)) def pp_object(obj): pp.pprint(obj) def post_transaction(method, tx): requests.post( 'http://127.0.0.1:5000/' + vote_contract.contract_name + '/' + method, json=transaction_to_solution(tx) ) params = setup() (tally_priv, tally_pub) = key_gen(params) (voter1_priv, voter1_pub) = key_gen(params) (voter2_priv, voter2_pub) = key_gen(params) (voter3_priv, voter3_pub) = key_gen(params) # set up options, participants, and tally's key options = ['alice', 'bob'] participants = [pack(voter1_pub), pack(voter2_pub), pack(voter3_pub)] init_transaction = vote.init() # pp_object(init_transaction) post_transaction("init", init_transaction)
from json import dumps, loads import time import unittest import requests # chainsapce from chainspacecontract import transaction_to_solution # from chainspacecontract.examples.energy_bidding import contract as energy_bidding_contract from chainspacecontract.examples import energy_bidding # crypto from chainspacecontract.examples.utils import setup, key_gen, pack from chainspaceapi import ChainspaceClient G = setup()[0] (provider_priv, provider_pub) = key_gen(setup()) client = ChainspaceClient(port=5001) # Init txn init_transaction = energy_bidding.init() token = init_transaction['transaction']['outputs'][0] client.process_transaction(init_transaction) # # Create meter # create_meter_transaction = energy_bidding.create_meter( # (token,), # None, # None, # pack(provider_pub), # 'Some info about the meter.', # dumps([5, 3, 5, 3, 5]), # the tariffs # dumps(764) # billing period # )
def main(): bank_authenticated.contract._populate_empty_checkers() print "operation\t\tmean (s)\t\tsd (s)\t\truns" # gen init tx times = [] for i in range(RUNS): start_time = time.time() bank_authenticated.init() end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "gen init tx\t\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS) # check init tx init_tx = bank_authenticated.init() solution = transaction_to_solution(init_tx) times = [] for i in range(RUNS): start_time = time.time() bank_authenticated.contract.checkers['init']( solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "check init tx\t\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS) # gen create_account tx times = [] for i in range(RUNS): start_time = time.time() (_, alice_pub) = key_gen(setup()) bank_authenticated.create_account( (init_tx['transaction']['outputs'][0],), None, None, pack(alice_pub) ) end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "gen create_account tx\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS) # check create_account tx (a_priv, a_pub) = key_gen(setup()) create_account_tx = bank_authenticated.create_account( (init_tx['transaction']['outputs'][0],), None, None, pack(a_pub) ) solution = transaction_to_solution(create_account_tx) times = [] for i in range(RUNS): start_time = time.time() bank_authenticated.contract.checkers['create_account']( solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "check create_account tx\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS) # gen auth_transfer tx create_account_a_tx = create_account_tx (b_priv, b_pub) = key_gen(setup()) create_account_b_tx = bank_authenticated.create_account( (create_account_a_tx['transaction']['outputs'][0],), None, None, pack(b_pub) ) a_account = create_account_a_tx['transaction']['outputs'][1] b_account = create_account_b_tx['transaction']['outputs'][1] times = [] for i in range(RUNS): start_time = time.time() bank_authenticated.auth_transfer( [a_account, b_account], None, ['3'], pack(a_priv) ) end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "gen auth_transfer tx\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS) # check auth_transfer tx auth_transfer_tx = bank_authenticated.auth_transfer( [a_account, b_account], None, ['3'], pack(a_priv) ) solution = transaction_to_solution(auth_transfer_tx) times = [] for i in range(RUNS): start_time = time.time() bank_authenticated.contract.checkers['auth_transfer']( solution['inputs'], solution['referenceInputs'], solution['parameters'], solution['outputs'], solution['returns'], solution['dependencies'], ) end_time = time.time() times.append(end_time-start_time) mean = numpy.mean(times) sd = numpy.std(times) print "check auth_transfer tx\t{:.10f}\t\t{:.10f}\t{}".format(mean, sd, RUNS)
def __init__(self, host='127.0.0.1', port=5000, init_token=None): (self.priv, self.pub) = key_gen(setup()) self.cs_client = ChainspaceClient(host=host, port=port) if init_token: self.create_centra_client(init_token)
def test_read(self): ## ## run service ## checker_service_process = Process(target=vote_contract.run_checker_service) checker_service_process.start() time.sleep(0.1) ## ## create transaction ## # number of voters and values options = ['alice', 'bob', 'sally'] num_voters = 50 values = [[1, 0, 0] for _ in range(0, num_voters)] # create keys and particpants params = setup() (tally_priv, tally_pub) = key_gen(params) keys = [key_gen(params) for _ in range(0, num_voters)] participants = [pack(pub) for (_, pub) in keys] # get init token init_transaction = vote.init() # get initial scores create_vote_transaction = vote.create_vote( (init_transaction['transaction']['outputs'][0],), None, None, dumps(options), dumps(participants), pack(tally_priv), pack(tally_pub) ) vote_0 = create_vote_transaction['transaction']['outputs'][1] # add votes transaction = {} input_obj = vote_0 for i in range(0, num_voters): transaction = vote.add_vote( (input_obj,), None, None, dumps(values[i]), # votes' valu (0 or 1) pack(keys[i][0]), # voter's priv key pack(keys[i][1]) # voter's pub key ) input_obj = transaction['transaction']['outputs'][0] # tally transaction = vote.tally( (input_obj,), None, None, pack(tally_priv), pack(tally_pub) ) result = transaction['transaction']['outputs'][0] # read result transaction = vote.read( None, (result,), None, ) # print result print transaction['transaction']['returns'] ## ## submit transaction ## response = requests.post( 'http://127.0.0.1:5000/' + vote_contract.contract_name + '/read', json=transaction_to_solution(transaction) ) self.assertTrue(response.json()['success']) ## ## stop service ## checker_service_process.terminate() checker_service_process.join()