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()
