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