def create_vote(inputs, reference_inputs, parameters, options, participants,
tally_priv, tally_pub):
# genrate param
params = setup()
pub = unpack(tally_pub)
# encrypt initial score
(a, b, k) = binencrypt(params, pub, 0) # encryption of a zero
c = (a, b)
scores = [pack(c) for _ in loads(options)]
# new vote object
new_vote = {
'type': 'VoteObject',
'options': loads(options),
'scores': scores,
'participants': loads(participants),
'tally_pub': tally_pub
}
# proof that all init values are zero
proof_init = provezero(params, pub, c, unpack(tally_priv))
# return
return {
'outputs': (inputs[0], dumps(new_vote)),
'extra_parameters': {
'proof_init': pack(proof_init)
}
}
def add_reading(inputs, reference_inputs, parameters, meter_priv, reading,
opening):
# compute output
old_meter = loads(inputs[0])
new_meter = loads(inputs[0])
# create commitement to the reading
(G, g, (h0, _, _, _), _) = setup()
commitment = loads(reading) * g + unpack(opening) * h0
# update readings
new_meter['readings'].append(pack(commitment))
# hash message to sign
hasher = sha256()
hasher.update(dumps(old_meter).encode('utf8'))
hasher.update(dumps(pack(commitment)).encode('utf8'))
# sign message
sig = do_ecdsa_sign(G, unpack(meter_priv), hasher.digest())
# return
return {
'outputs': (dumps(new_meter), ),
'extra_parameters': {
'reading': pack(commitment),
'signature': pack(sig)
}
}
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_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 cast_csc_vote(self, client_pub):
cast_csc_vote_txn = cast_csc_vote(
(self.vote_slip, ),
None,
None,
pack(self.priv),
pack(client_pub),
)
vote_token = cast_csc_vote_txn['transaction']['outputs'][0]
self.vote_slip = cast_csc_vote_txn['transaction']['outputs'][1]
self.cs_client.process_transaction(cast_csc_vote_txn)
return vote_token
def add_signature(inputs, reference_inputs, parameters, added_signature):
old_signature = loads(inputs[0])
new_signature = loads(inputs[0])
added_signature = loads(added_signature)
params = setup()
tally_pub = unpack(old_signature['tally_pub'])
# encrypt signatures & proofs to build
enc_added_signatures = [] # encrypted signatures
proof_bin = [
] # signatures are binary, well-formed, and the prover know the signature's value
sum_a, sum_b, sum_k = (0, 0, 0) # sum of signatures equals 1
# loop over signatures
for i in range(0, len(added_signature)):
# encrypt added signature
(a, b, k) = binencrypt(params, tally_pub, added_signature[i])
c = (a, b)
enc_added_signatures.append(pack(c))
# update new scores
new_c = add(unpack(old_signature['scores'][i]), c)
new_signature['scores'][i] = pack(new_c)
# construct proof of binary
tmp1 = provebin(params, tally_pub, (a, b), k, added_signature[i])
proof_bin.append(pack(tmp1))
# update sum of signature
if i == 0:
sum_a, sum_b, sum_k = (a, b, k)
else:
sum_c = (sum_a, sum_b)
sum_a, sum_b, sum_k = add_side(sum_c, c, sum_k, k)
# build proof that sum of signatures equals 1
sum_c = (sum_a, sum_b)
proof_sum = proveone(params, tally_pub, sum_c, sum_k)
# compute signature
(G, _, _, _) = params
hasher = sha256()
hasher.update(dumps(old_signature).encode('utf8'))
hasher.update(dumps(enc_added_signatures).encode('utf8'))
# return
return {
'outputs': (dumps(new_signature), ),
'extra_parameters':
(dumps(enc_added_signatures), dumps(proof_bin), pack(proof_sum))
}
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 create_centra_client(self, token):
if type(token) is not tuple:
token = (token, )
create_centra_client_txn = create_centra_client(
token,
None,
(pack(self.pub), ),
pack(self.priv),
)
self.centra_client = create_centra_client_txn['transaction'][
'outputs'][0]
self.vote_slip = create_centra_client_txn['transaction']['outputs'][1]
self.ebtoken = create_centra_client_txn['transaction']['outputs'][2]
self.cs_client.process_transaction(create_centra_client_txn)
def cast_lrep_vote(self, rep_pub, queue=None):
cast_lrep_vote_txn = cast_lrep_vote(
(self.vote_slip, ),
None,
None,
pack(self.priv),
pack(rep_pub),
)
vote_token = cast_lrep_vote_txn['transaction']['outputs'][0]
self.vote_slip = cast_lrep_vote_txn['transaction']['outputs'][1]
self.cs_client.process_transaction(cast_lrep_vote_txn)
if queue:
queue.put(vote_token)
return vote_token
def compute_bill(inputs, reference_inputs, parameters, readings, openings,
tariffs):
# get meter
meter = loads(inputs[0])
# compute total bill
G = setup()[0]
total_bill = sum(r * t for r, t in zip(loads(readings), loads(tariffs)))
sum_openings = sum(
o * t for o, t in zip(unpack(openings), loads(tariffs))) % G.order()
# new bill
bill = {
'type': 'SMBill',
'info': meter['info'],
'total_bill': total_bill,
'billing_period': meter['billing_period'],
'tariffs': meter['tariffs']
}
# return
return {
'outputs': (dumps(bill), ),
'extra_parameters': {
'total_bill': dumps(total_bill),
'sum_openings': pack(sum_openings),
}
}
def create_lrep_client(self,
host='127.0.0.1',
lrep_port=5000,
vote_tokens=None):
self.lrep_cs_client = ChainspaceClient(host=host,
port=lrep_port,
max_wait=lrep_port - 5000)
create_lrep_client_txn = create_lrep_client(
vote_tokens,
None,
(pack(self.pub), ),
pack(self.priv),
)
self.vote_slip = create_lrep_client_txn['transaction']['outputs'][1]
self.lrep_client = create_lrep_client_txn['transaction']['outputs'][0]
self.lrep_cs_client.process_transaction(create_lrep_client_txn)
def transfer(inputs, reference_inputs, parameters, *args):
# compute outputs
amount = loads(parameters[0])
new_from_account = loads(inputs[0])
new_to_account = loads(inputs[1])
new_from_account["balance"] -= amount
new_to_account["balance"] += amount
if loads(inputs[0])['callback'] == None:
hasher = sha256()
hasher.update(dumps(inputs).encode('utf8'))
hasher.update(dumps(parameters[0]).encode('utf8'))
G = setup()[0]
priv = args[0]
sig = do_ecdsa_sign(G, priv, hasher.digest())
else:
# create dependency
# @Mustafa: we need to modify the framework to make possible to pass a callback here;
# i.e., make possible to execute callback_function(args) for any function passed as argument
hello_contract.init()
sig = setup()[0].order().random() # dump
# return
return {
'outputs': (dumps(new_from_account), dumps(new_to_account)),
'extra_parameters' : (pack(sig),)
}
def accept_bids(self):
time.sleep(DELTA)
bid_proofs = self.lrep_cs_client.get_objects({
'location':
loads(self.lrep_client)['location'],
'type':
'BidProof'
})
bidders = {}
for bid in bid_proofs:
bid = loads(bid)
bidders[str(bid['quantity_sig'])] = True
time.sleep(2 * DELTA)
buy_bids = self.lrep_cs_client.get_objects({
'location':
loads(self.lrep_client)['location'],
'type':
'EBBuy'
})
sell_bids = self.lrep_cs_client.get_objects({
'location':
loads(self.lrep_client)['location'],
'type':
'EBSell'
})
# process bid
accepted_bids = []
for bid in buy_bids:
if not bidders.has_key(loads(bid)['quantity_sig']):
continue
accepted_bids.append(bid)
for bid in sell_bids:
if not bidders.has_key(loads(bid)['quantity_sig']):
continue
accepted_bids.append(bid)
if len(accepted_bids) == 0:
return None
accept_bids_txn = accept_bids(
tuple(accepted_bids),
None,
(pack(self.pub), ),
pack(self.priv),
)
bid_accept = accept_bids_txn['transaction']['outputs'][0]
self.lrep_cs_client.process_transaction(accept_bids_txn)
return bid_accept
def add_signature_checker(inputs, reference_inputs, parameters, outputs,
returns, dependencies):
try:
print "CHECKING - parameters " + str(parameters)
# retrieve petition
old_signature = loads(inputs[0])
new_signature = loads(outputs[0])
num_options = len(old_signature['options'])
# check format
if len(inputs) != 1 or len(reference_inputs) != 0 or len(
outputs) != 1 or len(returns) != 0:
return False
if num_options != len(new_signature['scores']) or num_options != len(
new_signature['scores']):
return False
if old_signature['tally_pub'] != new_signature['tally_pub']:
return False
print "CHECKING - tokens"
if new_signature['type'] != 'PetitionEncObject':
return False
print "CHECKING - Generate params"
# generate params, retrieve tally's public key and the parameters
params = setup()
tally_pub = unpack(old_signature['tally_pub'])
added_signature = loads(parameters[0])
proof_bin = loads(parameters[1])
proof_sum = unpack(parameters[2])
print "CHECKING - verify proofs of binary (Signatures have to be bin values)"
for i in range(0, num_options):
if not verifybin(params, tally_pub, unpack(added_signature[i]),
unpack(proof_bin[i])):
return False
print "CHECKING - verify proof of sum of signatures (sum of signatures has to be 1)"
sum_a, sum_b = unpack(added_signature[-1])
sum_c = (sum_a, sum_b)
for i in range(0, num_options - 1):
sum_c = add(sum_c, unpack(added_signature[i]))
if not verifyone(params, tally_pub, sum_c, proof_sum):
return False
print "CHECKING - verify that output == input + signature"
for i in range(0, num_options):
tmp_c = add(unpack(old_signature['scores'][i]),
unpack(added_signature[i]))
if not new_signature['scores'][i] == pack(tmp_c):
return False
# otherwise
return True
except (KeyError, Exception):
return False
def generate_sig(priv, msg="proof"):
hasher = sha256()
hasher.update(msg)
# sign message
G = setup()[0]
sig = do_ecdsa_sign(G, unpack(priv), hasher.digest())
return pack(sig)
def __create_petition(self, petition_token):
inputs = (petition_token, )
votes = ['YES', 'NO']
gender = ['ANY', 'M', 'F', 'U']
age = ['ANY', '0-19', '20-29', '30-39', '40+']
options = [
"%s-%s-%s" % (v, g, a) for v in votes for g in gender for a in age
]
options = json.dumps(options)
transaction = self.contract.create_petition(inputs,
self.reference_inputs,
self.parameters, options,
pack(self.private_key),
pack(self.public_key))
self.chainspace_repository.process_transaction(transaction)
return transaction['transaction']['outputs'][1]
def tally(inputs, reference_inputs, parameters, tally_priv, tally_pub):
# retrieve last vote
vote = loads(inputs[0])
# generate params & retrieve tally's public key
params = setup()
table = make_table(params)
(G, _, (h0, _, _, _), _) = params
# decrypt aggregated results
outcome = []
for item in vote['scores']:
outcome.append(dec(params, table, unpack(tally_priv), unpack(item)))
# proof of decryption
proof_dec = []
for i in range(0, len(vote['scores'])):
a, b = unpack(vote['scores'][i])
ciphertext = (a, b - outcome[i] * h0)
tmp = provezero(params, unpack(tally_pub), ciphertext,
unpack(tally_priv))
proof_dec.append(pack(tmp))
# signature
hasher = sha256()
hasher.update(dumps(vote).encode('utf8'))
hasher.update(dumps(outcome).encode('utf8'))
sig = do_ecdsa_sign(G, unpack(tally_priv), hasher.digest())
# pack result
result = {'type': 'VoteResult', 'outcome': outcome}
# return
return {
'outputs': (dumps(result), ),
'extra_parameters': {
'proof_dec': dumps(proof_dec),
'signature': pack(sig)
}
}
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 get_results(self):
inputs = [self.__get_chainspace_objects_of_last_transaction()[-1]]
try:
transaction = self.contract.tally(inputs, self.reference_inputs,
self.parameters,
pack(self.private_key),
pack(self.public_key))
except Exception as err:
if str(err) == "'scores'":
raise TallyClosedPetitionException()
raise
self.chainspace_repository.process_transaction(transaction)
outcome = json.loads(
transaction['transaction']['outputs'][0])['outcome']
result_yes = reduce((lambda x, y: x + y), outcome[:len(outcome) / 2])
result_no = reduce((lambda x, y: x + y), outcome[len(outcome) / 2:])
return [result_yes, result_no]
def create_account(inputs, reference_inputs, parameters, pub, callback):
# new account
new_account = {
'type' : 'BankAccount',
'pub' : pack(pub),
'balance' : 10,
'callback' : callback
}
# return
return {
'outputs': (inputs[0], dumps(new_account))
}
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_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 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 submit_bid(inputs, reference_inputs, parameters, meter_priv):
# Extract bid object from paramters
bid = loads(parameters[0])
smart_meter = loads(reference_inputs[0])
token = loads(inputs[0])
bid['pub'] = smart_meter['pub']
# Create a hash digest of inputs and parameters
hasher = sha256()
hasher.update(dumps(token).encode('utf8'))
hasher.update(dumps(smart_meter).encode('utf8'))
hasher.update(dumps(bid).encode('utf8'))
# sign message
G = setup()[0]
sig = do_ecdsa_sign(G, unpack(meter_priv), hasher.digest())
# return
return {
'outputs': (inputs[0],dumps(bid)),
'extra_parameters' : (
pack(sig),
)
}
def auth_transfer(inputs, reference_inputs, parameters, priv):
# compute outputs
amount = loads(parameters[0])
new_from_account = loads(inputs[0])
new_to_account = loads(inputs[1])
new_from_account["balance"] -= amount
new_to_account["balance"] += amount
# hash message to sign
hasher = sha256()
hasher.update(dumps(inputs).encode('utf8'))
hasher.update(dumps(reference_inputs).encode('utf8'))
hasher.update(dumps(parameters[0]).encode('utf8'))
# sign message
G = setup()[0]
sig = do_ecdsa_sign(G, unpack(priv), hasher.digest())
# return
return {
'outputs': (dumps(new_from_account), dumps(new_to_account)),
'extra_parameters' : (pack(sig),)
}
def submit_bid(self, bid_type, quantity):
bid_proof_txn = submit_bid_proof((self.ebtoken, ), None, (bid_type, ),
pack(self.priv), quantity)
bid_proof = bid_proof_txn['transaction']['outputs'][0]
self.ebtoken = bid_proof_txn['transaction']['outputs'][1]
self.cs_client.process_transaction(bid_proof_txn)
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'],
)
