def define_user():
if request.method == 'POST':
password = request.json.get('password_digest_str')
if password is None:
abort_by_missing_param('password_digest_str')
username = request.json.get('username')
if username is None:
abort_by_missing_param('username')
if g.store.user_exists(username, 'user_table'):
return jsonify(
message='user {0} is already defined.'.format(username)), 409
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, username, password, keypairs[0]),
'user_table')
return jsonify(public_key_str=bbclib.convert_id_to_string(
keypairs[0].public_key),
private_key_str=bbclib.convert_id_to_string(
keypairs[0].private_key)), 200
def define_user():
name = request.form.get('name')
if name is None:
abort_by_missing_param('name')
if g.store.user_exists(name, 'user_table'):
abort(
409, {
'code': 'Conflict',
'message': 'user {0} is already defined'.format(name)
})
if g.store.user_exists(name, 'currency_table'):
abort(
409, {
'code': 'Conflict',
'message':
'{0} is already defined as a currency name'.format(name)
})
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
user_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, name, keypairs[0]), 'user_table')
return jsonify({
'name': name,
'user_id': binascii.b2a_hex(user_id).decode()
}), 201
def swap_between_users(name, amount1, amount2, currency_name, dic_currencies,
dic_users):
_, currency = get_selected(dic_currencies)
_, user = get_selected(dic_users)
counter_currency = dic_currencies[currency_name]
counter_user = dic_users[name]
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
idPubkeyMap)
counter_mint = token_lib.BBcMint(domain_id,
counter_currency.user_id, counter_currency.user_id, idPubkeyMap)
currency_spec = mint.get_currency_spec()
counter_currency_spec = counter_mint.get_currency_spec()
value1 = int(amount1 * (10 ** currency_spec.decimal))
value2 = int(amount2 * (10 ** counter_currency_spec.decimal))
mint.swap(counter_mint, user.user_id, counter_user.user_id,
value1, value2,
keypair_this=user.keypair, keypair_that=counter_user.keypair,
keypair_mint=currency.keypair,
keypair_counter_mint=counter_currency.keypair)
time.sleep(1) # this should be unnecessary but token_lib is incomplete now.
value1_string = ("{0:.%df}" % (currency_spec.decimal)).format(
value1 / (10 ** currency_spec.decimal))
value2_string = ("{0:.%df}" % (counter_currency_spec.decimal)).format(
value2 / (10 ** counter_currency_spec.decimal))
print("%s%s is transferred to %s." % (value1_string,
currency_spec.symbol, name))
print("%s%s is transferred from %s." % (value2_string,
counter_currency_spec.symbol, name))
def define_currency(name, symbol, file, dic_currencies):
if name in dic_currencies:
print("currency %s is already defined." % (name))
return
if name in dic_users:
print("%s is already defined as a user name." % (name))
return
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
f = open(file, 'r')
j_currency_spec = json.load(f)
f.close()
j_currency_spec['name'] = name
j_currency_spec['symbol'] = symbol
currency_spec = token_lib.CurrencySpec(j_currency_spec)
mint = token_lib.BBcMint(domain_id, mint_id, mint_id, idPubkeyMap)
mint.set_condition(0, keypair=keypairs[0])
mint.set_currency_spec(currency_spec, keypair=keypairs[0])
clear_selected(dic_currencies)
dic_currencies[currency_spec.name] = User(mint_id, keypairs[0], True)
write_dic(F_JSON_CURRENCIES, dic_currencies)
print("currency %s/%s is defined." % (name, symbol))
def replace_keypair():
username = request.json.get('username')
password_digest_str = request.json.get('password_digest_str')
if username is None:
return jsonify(message="user name is nothing."), 404
user = g.store.read_user(username, 'user_table')
if user is None:
return jsonify(message='user {0} is not found'.format(username)), 404
if user.password != password_digest_str:
return jsonify(message='password is incorrect.'), 404
keypair_old = user.keypair
keypair = bbclib.KeyPair()
keypair.generate()
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
g.idPubkeyMap.update(user.user_id,
public_key_to_replace=[keypair.public_key],
keypair=keypair_old)
user.keypair = keypair
g.store.update(user, 'user_table')
return jsonify(
pulic_key_str=bbclib.convert_id_to_string(keypair.public_key),
private_key_str=bbclib.convert_id_to_string(keypair.private_key)), 200
def show_user(name, dic_services, dic_users):
_, service_user = get_selected(dic_services)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
service = ticket_lib.BBcTicketService(domain_id, service_user.user_id,
service_user.user_id, idPubkeyMap)
ticket_list = service.get_balance_of(dic_users[name].user_id)
for ticket in ticket_list:
print("Ticket id: %s" % binascii.b2a_hex(ticket[0]).decode())
print("Ticket State: %s" % ticket[1])
def define_user(name, dic_users):
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
(user_id, keypairs) = idPubkeyMap.create_user_id(num_pubkeys=1)
clear_selected(dic_users)
dic_users[name] = User(user_id, keypairs[0], True)
write_dic(F_JSON_USERS, dic_users)
print("user %s is defined." % (name))
def test_default_map_creation(default_domain_id):
NUM_KEYPAIRS = 5
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=NUM_KEYPAIRS)
assert len(keypairs) == NUM_KEYPAIRS
for i in range(NUM_KEYPAIRS):
assert idPubkeyMap.is_mapped(user_id, keypairs[i].public_key) == True
def show_user(name, dic_currencies, dic_users):
_, currency = get_selected(dic_currencies)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
idPubkeyMap)
currency_spec = mint.get_currency_spec()
value = mint.get_balance_of(dic_users[name].user_id)
print("balance = %f%s." %
(value / (10**currency_spec.decimal), currency_spec.symbol))
def transfer_to_user(hex_mint_id=None):
if hex_mint_id is None:
abort_by_missing_param('mint_id')
currency = from_hex_to_user(g, hex_mint_id, 'currency_table')
hex_from_user_id = request.form.get('from_user_id')
hex_to_user_id = request.form.get('to_user_id')
amount = request.form.get('amount')
s_label = request.form.get('label')
if s_label is None or len(s_label) <= 0:
s_label = ''
label = None
else:
label_id = TransactionLabel.create_label_id(s_label, LABEL_SALT)
label = TransactionLabel(label_group_id, label_id=label_id)
if hex_from_user_id is None:
abort_by_missing_param('from_user_id')
if hex_to_user_id is None:
abort_by_missing_param('to_user_id')
if amount is None:
abort_by_missing_param('amount')
from_user = from_hex_to_user(g, hex_from_user_id, 'user_table')
to_user = from_hex_to_user(g, hex_to_user_id, 'user_table')
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
g.mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
g.idPubkeyMap)
currency_spec = g.mint.get_currency_spec()
value = int(float(amount) * (10**currency_spec.decimal))
tx = g.mint.transfer(from_user.user_id,
to_user.user_id,
value,
keypair_from=from_user.keypair,
keypair_mint=currency.keypair)
g.store.write_tx(tx.transaction_id, get_timestamp_in_seconds(tx),
currency.user_id, from_user.name, to_user.name, amount,
s_label)
return jsonify({
'amount': ('{0:.%df}' % (currency_spec.decimal)).format(
value / (10**currency_spec.decimal)),
'symbol':
currency_spec.symbol
})
def issue_to_user(name, amount, dic_currencies, dic_users):
_, currency = get_selected(dic_currencies)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
idPubkeyMap)
currency_spec = mint.get_currency_spec()
value = int(amount * (10**currency_spec.decimal))
mint.issue(dic_users[name].user_id, value, keypair=currency.keypair)
print("%f%s is issued to %s." %
(value / (10**currency_spec.decimal), currency_spec.symbol, name))
def issue_to_user(name, description, dic_services, dic_users):
_, service_user = get_selected(dic_services)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
service = ticket_lib.BBcTicketService(domain_id, service_user.user_id,
service_user.user_id, idPubkeyMap)
spec = ticket_lib.TicketSpec(description=description, value=1, unit="x")
ticket_id, _ = service.issue(dic_users[name].user_id,
spec,
keypair=service_user.keypair)
print("ticket %s is issued to %s." %
(bbclib.convert_id_to_string(ticket_id), name))
def replace_keypair(name, dic, file_name):
for name0, user in dic.items():
if name0 == name:
keypair_old = user.keypair
keypair = bbclib.KeyPair()
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
idPubkeyMap.update(user.user_id,
public_keys_to_replace=[keypair.public_key],
keypair=keypair_old)
user.keypair = keypair
break
write_dic(file_name, dic)
print("public key for %s is renewed:" % (name))
print("old:", binascii.b2a_hex(keypair_old.public_key).decode())
print("new:", binascii.b2a_hex(keypair.public_key).decode())
def define_user(name, dic_users):
if name in dic_users:
print("user %s is already defined." % (name))
return
if name in dic_services:
print("%s is already defined as a service name." % (name))
return
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
clear_selected(dic_users)
dic_users[name] = User(user_id, keypairs[0], True)
write_dic(F_JSON_USERS, dic_users)
print("user %s is defined." % (name))
def test_map_creation_with_pubkeys(default_domain_id):
NUM_KEYPAIRS = 3
public_keys = []
for i in range(NUM_KEYPAIRS):
keypair = bbclib.KeyPair()
keypair.generate()
public_keys.append(keypair.public_key)
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(public_keys=public_keys)
assert len(keypairs) == 0
for i in range(NUM_KEYPAIRS):
assert idPubkeyMap.is_mapped(user_id, public_keys[i]) == True
def test_get_map(default_domain_id):
NUM_KEYPAIRS = 3
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=NUM_KEYPAIRS)
assert len(keypairs) == NUM_KEYPAIRS
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id)
assert len(public_keys) == NUM_KEYPAIRS
assert len(key_types) == NUM_KEYPAIRS
for i in range(NUM_KEYPAIRS):
assert bytes(keypairs[i].public_key) == public_keys[i]
assert keypairs[i].curvetype == key_types[i]
def transfer_to_user(name, amount, dic_currencies, dic_users):
_, currency = get_selected(dic_currencies)
_, user = get_selected(dic_users)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
idPubkeyMap)
currency_spec = mint.get_currency_spec()
value = int(amount * (10 ** currency_spec.decimal))
mint.transfer(user.user_id, dic_users[name].user_id, value,
keypair_from=user.keypair, keypair_mint=currency.keypair)
value_string = ("{0:.%df}" % (currency_spec.decimal)).format(
value / (10 ** currency_spec.decimal))
print("%s%s is transferred to %s." % (value_string,
currency_spec.symbol, name))
def test_key_types(default_domain_id):
idPubkeyMap = id_lib.BBcIdPublickeyMap(
default_domain_id, default_key_type=bbclib.KeyType.ECDSA_SECP256k1)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
assert len(keypairs) == 1
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == True
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id)
assert len(key_types) == 1
assert key_types[0] == bbclib.KeyType.ECDSA_SECP256k1
public_keys = []
key_types = []
for i in range(3):
if i == 1:
key_type = bbclib.KeyType.ECDSA_SECP256k1
else:
key_type = bbclib.KeyType.ECDSA_P256v1
keypair = bbclib.KeyPair(key_type)
keypair.generate()
public_keys.append(keypair.public_key)
key_types.append(key_type)
tx = idPubkeyMap.update(user_id,
public_keys_to_replace=public_keys,
key_types_to_replace=key_types,
keypair=keypairs[0])
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == False
for i in range(3):
assert idPubkeyMap.is_mapped(user_id, public_keys[i]) == True
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id)
assert len(key_types) == 3
for i, key_type in enumerate(key_types):
if i == 1:
assert key_type == bbclib.KeyType.ECDSA_SECP256k1
else:
assert key_type == bbclib.KeyType.ECDSA_P256v1
def get_balances_of(user_id, currencies):
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
dics = []
for currency in currencies:
mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
g.idPubkeyMap)
currency_spec = mint.get_currency_spec()
value = mint.get_balance_of(user_id)
mint.close()
dics.append({
'balance': ("{0:.%df}" % (currency_spec.decimal)).format(
value / (10 ** currency_spec.decimal)),
'symbol': currency_spec.symbol,
'mint_id': binascii.b2a_hex(currency.user_id).decode()
})
return dics
def redeem_from_user(ticket_id, dic_services, dic_users):
_, service_user = get_selected(dic_services)
name, user = get_selected(dic_users)
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
service = ticket_lib.BBcTicketService(domain_id, service_user.user_id,
service_user.user_id, idPubkeyMap)
if not service.is_valid_holder(user.user_id, ticket_id):
print("%s is not the valid holder." % (name))
return
service.redeem(user.user_id,
ticket_id,
keypair_from=user.keypair,
keypair_service=service_user.keypair)
print("%s is redeemed from %s." %
(bbclib.convert_id_to_string(ticket_id), name))
def setup():
g.store.setup()
tmpclient = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
user_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, NAME_REGISTRY, keypair=keypairs[0]))
user_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, NAME_USER, keypair=keypairs[0]))
return jsonify({'domain_id': binascii.b2a_hex(domain_id).decode()})
def define_service(name, dic_services):
if name in dic_services:
print("service %s is already defined." % (name))
return
if name in dic_users:
print("%s is already defined as a user name." % (name))
return
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
service_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
service = ticket_lib.BBcTicketService(domain_id, service_id, service_id,
idPubkeyMap)
clear_selected(dic_services)
dic_services[name] = User(service_id, keypairs[0], True)
write_dic(F_JSON_SERVICES, dic_services)
print("service %s is defined." % (name))
def replace_keypair(hex_user_id=None):
if hex_user_id is None:
abort_by_missing_param('user_id')
user = from_hex_to_user(g, hex_user_id, 'user_table')
keypair_old = user.keypair
keypair = bbclib.KeyPair()
keypair.generate()
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
g.idPubkeyMap.update(user.user_id,
public_keys_to_replace=[keypair.public_key], keypair=keypair_old)
user.keypair = keypair
g.store.update_user(user, 'user_table')
return jsonify({
'old_pubkey': binascii.b2a_hex(keypair_old.public_key).decode(),
'new_pubkey': binascii.b2a_hex(keypair.public_key).decode()
})
def __init__(self,
is_test=False,
is_verbose=False,
domain_id_string=None,
workingdir=bbc_config.DEFAULT_WORKING_DIR):
self.is_test = is_test
self.is_verbose = is_verbose
if domain_id_string is None:
self.domain_id = None
else:
self.domain_id = bytes(binascii.a2b_hex(domain_id_string))
self.workingdir = workingdir
self.run_client()
self.dic = read_dic(self.domain_id)
self.idPubkeyMap = id_lib.BBcIdPublickeyMap(self.domain_id)
self.registry = self.get_registry()
def define_currency():
if request.headers['Content-Type'] != 'application/json':
abort_by_bad_content_type(request.headers['Content-Type'])
name = request.json.get('name')
symbol = request.json.get('symbol')
if name is None:
abort_by_missing_param('name')
if symbol is None:
abort_by_missing_param('symbol')
if g.store.user_exists(name, 'currency_table'):
abort(
409, {
'code': 'Conflict',
'message': 'currency {0} is already defined'.format(name)
})
if g.store.user_exists(name, 'user_table'):
abort(
409, {
'code': 'Conflict',
'message': '{0} is already defined as a user name'.format(name)
})
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
mint_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
currency_spec = token_lib.CurrencySpec(request.json)
g.mint = token_lib.BBcMint(domain_id, mint_id, mint_id, g.idPubkeyMap)
g.mint.set_condition(0, keypair=keypairs[0])
g.mint.set_currency_spec(currency_spec, keypair=keypairs[0])
g.store.write_user(User(mint_id, name, keypairs[0]), 'currency_table')
return jsonify({
'name': name,
'symbol': symbol,
'mint_id': binascii.b2a_hex(mint_id).decode()
})
def test_map_update(default_domain_id):
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
user_id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
assert len(keypairs) == 1
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == True
public_keys = []
for i in range(3):
keypair = bbclib.KeyPair()
keypair.generate()
public_keys.append(keypair.public_key)
tx = idPubkeyMap.update(user_id,
public_keys_to_replace=public_keys,
keypair=keypairs[0])
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == False
for i in range(3):
assert idPubkeyMap.is_mapped(user_id, public_keys[i]) == True
def create_new_domain():
domain_id = bbclib.get_new_id("certificate domain")
tmpclient = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
print("domain_id:")
print(bbclib.convert_id_to_string(domain_id))
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
dic = {}
id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
dic[KEY_REGISTRY] = User(id, keypairs[0])
id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
dic[KEY_USER] = User(id, keypairs[0])
write_dic(domain_id, dic)
def register_document():
document = get_document(request)
registry = g.store.read_user(NAME_REGISTRY)
user = g.store.read_user(NAME_USER)
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
g.registry = registry_lib.BBcRegistry(domain_id, registry.user_id,
registry.user_id, g.idPubkeyMap)
g.registry.register_document(
user.user_id,
document,
registry_lib.DocumentSpec(description="certificate"),
keypair=registry.keypair)
g.client = run_client()
g.client.register_in_ledger_subsystem(
None, g.registry.get_document_digest(document.document_id))
dat = wait_check_result_msg_type(
g.client.callback, bbclib.MsgType.RESPONSE_REGISTER_HASH_IN_SUBSYS)
return jsonify({'success': 'true'})
def test_map_eval(default_domain_id):
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
label_group_id = bbclib.get_new_id('test_label_group',
include_timestamp=False)
label_id = TransactionLabel.create_label_id('test_map_eval:c', '0')
label = TransactionLabel(label_group_id, label_id)
user_id, keypairs0 = idPubkeyMap.create_user_id(label=label)
time0 = int(time.time())
print("\n2-second interval.")
time.sleep(2)
keypairs1 = []
public_keys = []
for i in range(3):
kp = bbclib.KeyPair()
kp.generate()
keypairs1.append(kp)
public_keys.append(keypairs1[i].public_key)
label_id = TransactionLabel.create_label_id('test_map_eval:u', '0')
label = TransactionLabel(label_group_id, label_id)
tx = idPubkeyMap.update(user_id,
public_keys_to_add=public_keys,
keypair=keypairs0[0],
label=label)
time1 = int(time.time())
print("2-second interval.")
time.sleep(2)
tx = idPubkeyMap.update(user_id,
public_keys_to_remove=public_keys,
keypair=keypairs0[0])
time2 = int(time.time())
print("2-second interval.")
time.sleep(2)
tx = idPubkeyMap.update(user_id,
public_keys_to_replace=public_keys,
keypair=keypairs0[0])
time3 = int(time.time())
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id, time3)
assert len(public_keys) == 3
assert len(key_types) == 3
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time3) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time3) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time3) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time3) == True
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id, time2)
assert len(public_keys) == 1
assert len(key_types) == 1
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time2) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time2) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time2) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time2) == False
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id, time1)
assert len(public_keys) == 4
assert len(key_types) == 4
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time1) == True
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id, time0)
assert len(public_keys) == 1
assert len(key_types) == 1
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time0) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time0) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time0) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time0) == False
idPubkeyMap._BBcIdPublickeyMap__clear_local_database(user_id)
print("cleared local database entries for the user for reconstruction.")
public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id)
assert len(public_keys) == 3
assert len(key_types) == 3
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
for key_type in key_types:
assert key_type == bbclib.DEFAULT_CURVETYPE
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key) == True
idPubkeyMap.close()
def swap_between_users(hex_mint_id=None, hex_counter_mint_id=None):
if hex_mint_id is None:
abort_by_missing_param('mint_id')
if hex_counter_mint_id is None:
abort_by_missing_param('counter_mint_id')
currency = from_hex_to_user(g, hex_mint_id, 'currency_table')
counter_currency = from_hex_to_user(g, hex_counter_mint_id,
'currency_table')
hex_user_id = request.form.get('user_id')
hex_counter_user_id = request.form.get('counter_user_id')
amount = request.form.get('amount')
counter_amount = request.form.get('counter_amount')
s_label = request.form.get('label')
if s_label is None or len(s_label) <= 0:
s_label = ''
label = None
else:
label_id = TransactionLabel.create_label_id(s_label, LABEL_SALT)
label = TransactionLabel(label_group_id, label_id=label_id)
if hex_user_id is None:
abort_by_missing_param('user_id')
if hex_counter_user_id is None:
abort_by_missing_param('counter_user_id')
if amount is None:
abort_by_missing_param('amount')
if counter_amount is None:
abort_by_missing_param('counter_amount')
user = from_hex_to_user(g, hex_user_id, 'user_table')
counter_user = from_hex_to_user(g, hex_counter_user_id, 'user_table')
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
g.mint = token_lib.BBcMint(domain_id, currency.user_id, currency.user_id,
g.idPubkeyMap)
counter_mint = token_lib.BBcMint(domain_id, counter_currency.user_id,
counter_currency.user_id, g.idPubkeyMap)
currency_spec = g.mint.get_currency_spec()
counter_currency_spec = counter_mint.get_currency_spec()
value = int(float(amount) * (10**currency_spec.decimal))
counter_value = int(
float(counter_amount) * (10**counter_currency_spec.decimal))
tx = g.mint.swap(counter_mint,
user.user_id,
counter_user.user_id,
value,
counter_value,
keypair_this=user.keypair,
keypair_that=counter_user.keypair,
keypair_mint=currency.keypair,
keypair_counter_mint=counter_currency.keypair)
counter_mint.close()
g.store.write_tx(tx.transaction_id, get_timestamp_in_seconds(tx),
currency.user_id, user.user_id, counter_user.user_id,
amount, s_label)
counter_txid = bytearray(tx.transaction_id)
counter_txid.extend(b'00')
g.store.write_tx(bytes(counter_tx_id), get_timestamp_in_seconds(tx),
counter_currency.user_id, counter_user.user_id,
user.user_id, counter_amount, s_label)
return jsonify({
'amount': ('{0:.%df}' % (currency_spec.decimal)).format(
value / (10**currency_spec.decimal)),
'symbol':
currency_spec.symbol,
'counter_amount':
('{0:.%df}' % (counter_currency_spec.decimal)).format(
counter_value / (10**counter_currency_spec.decimal)),
'counter_symbol':
counter_currency_spec.symbol
})
