def test_13_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") for i, cl in enumerate(clients): user = cl['user_id'] txobj = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) txobj.events[0].asset.add(user_id=user, asset_body=b"data2=%d" % i) other_user = (i + 1) % client_num txobj.events[0].add( reference_index=0, mandatory_approver=clients[other_user]['user_id']) reference = bbclib.add_reference_to_transaction( asset_group_id, txobj, transactions[i], 0) ret = cl['app'].gather_signatures(txobj, reference_obj=reference) assert ret dat = msg_processor[i].synchronize() assert dat[KeyType.status] == ESUCCESS result = dat[KeyType.result] txobj.references[result[0]].add_signature(user_id=result[1], signature=result[2]) txobj.digest() cl['app'].insert_transaction(txobj) dat = msg_processor[i].synchronize() assert KeyType.transaction_id in dat assert dat[KeyType.transaction_id] == txobj.transaction_id transactions[i] = txobj
def test_02_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") user = clients[0]['user_id'] global transactions transactions[0] = bbclib.make_transaction_for_base_asset(asset_group_id=asset_group_id, event_num=2) transactions[0].events[0].asset.add(user_id=user, asset_body=b'123456') transactions[0].events[1].asset.add(user_id=user, asset_file=b'abcdefg')
def test_12_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") for i, cl in enumerate(clients): print("---- start transaction ---") user = cl['user_id'] transactions[i] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) transactions[i].events[0].asset.add(user_id=user, asset_body="data=%d" % i) other_user = (i + 1) % client_num transactions[i].events[0].add( mandatory_approver=clients[other_user]['user_id']) sig = transactions[i].sign(keypair=cl['keypair']) transactions[i].add_signature(user_id=cl['user_id'], signature=sig) transactions[i].digest() print("register transaction=", binascii.b2a_hex(transactions[i].transaction_id)) cl['app'].insert_transaction(transactions[i]) print(" ----> wait insert") dat = msg_processor[i].synchronize() assert KeyType.transaction_id in dat assert dat[ KeyType.transaction_id] == transactions[i].transaction_id print(" ==> got insert")
def update(self, user_id, public_keys_to_add=None, public_keys_to_remove=None, public_keys_to_replace=None, keypair=None): reftx = self.__update_local_database(user_id) dat = bytearray(b'') if public_keys_to_add is not None: dat.extend( Directive(Directive.CMD_ADD, public_keys_to_add).serialize()) if public_keys_to_remove is not None: dat.extend( Directive(Directive.CMD_REMOVE, public_keys_to_remove).serialize()) if public_keys_to_replace is not None: dat.extend( Directive(Directive.CMD_REPLACE, public_keys_to_replace).serialize()) tx = bbclib.make_transaction_for_base_asset( asset_group_id=self.namespace_id, event_num=1) tx.events[0].asset.add(user_id=user_id, asset_body=dat) tx.events[0].add(mandatory_approver=user_id) bbclib.add_reference_to_transaction(self.namespace_id, tx, reftx, 0) if keypair is None: return tx return self.sign_and_insert(tx, user_id, keypair)
def test_12_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") for i, cl in enumerate(clients): print("---- start transaction ---") user = cl['user_id'] transactions[i] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) cl['app'].get_cross_refs(asset_group_id=asset_group_id, number=2) print(" ----> wait cross_ref") dat = msg_processor[i].synchronize() cross_ref_list[i].extend(dat) print(" ==> got cross_ref") if len(cross_ref_list[i]) > 0: transactions[i].add(cross_ref=cross_ref_list[i].pop(0)) transactions[i].events[0].asset.add(user_id=user, asset_body="data=%d" % i) other_user = (i + 1) % client_num transactions[i].events[0].add( mandatory_approver=clients[other_user]['user_id']) sig = transactions[i].sign(keypair=cl['keypair']) transactions[i].add_signature(user_id=cl['user_id'], signature=sig) transactions[i].digest() print("register transaction=", binascii.b2a_hex(transactions[i].transaction_id)) ret = cl['app'].insert_transaction(asset_group_id, transactions[i]) assert ret print(" ----> wait insert") msg_processor[i].synchronize() print(" ==> got insert") for i in range(len(cores)): print("[%d] cross_ref_list=%d" % (i, len(cores[i].cross_ref_list)))
def test_13_gather_signature(self): print("\n-----", sys._getframe().f_code.co_name, "-----") prev_tx = transactions[0] user = clients[1]['user_id'] transactions[1] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) transactions[1].events[0].asset.add(user_id=user, asset_body=b'123456') if len(cross_ref_list) > 0: transactions[1].add(cross_ref=cross_ref_list.pop(0)) reference = bbclib.add_reference_to_transaction( asset_group_id, transactions[1], prev_tx, 0) ret = clients[1]['app'].gather_signatures(asset_group_id, transactions[1], reference_obj=reference) assert ret dat = msg_processor[1].synchronize() assert dat[KeyType.status] == ESUCCESS result = dat[KeyType.result] transactions[1].references[result[0]].add_signature( user_id=result[1], signature=result[2]) transactions[1].dump() transactions[1].digest() print("register transaction=", binascii.b2a_hex(transactions[1].transaction_id)) ret = clients[1]['app'].insert_transaction(asset_group_id, transactions[1]) assert ret msg_processor[1].synchronize()
def test_13_insert_first_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") user = clients[0]['user_id'] transactions[0] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transactions[0].events[0].asset.add(user_id=user, asset_body=b'123456') transactions[0].events[1].asset.add(user_id=user, asset_file=b'abcdefg') transactions[0].events[0].add(reference_index=0, mandatory_approver=user) if len(cross_ref_list) > 0: transactions[0].add(cross_ref=cross_ref_list.pop(0)) sig = transactions[0].sign(keypair=clients[0]['keypair']) assert sig is not None if sig is None: print(bbclib.error_text) import os os._exit(1) transactions[0].add_signature(signature=sig) transactions[0].dump() transactions[0].digest() print("register transaction=", binascii.b2a_hex(transactions[0].transaction_id)) ret = clients[0]['app'].insert_transaction(asset_group_id, transactions[0]) assert ret msg_processor[0].synchronize()
def test_05_1_search_transaction_by_txid_other_node_not_found(self): print("\n-----", sys._getframe().f_code.co_name, "-----") print("-- insert transaction only at core_node_2 --") global transaction user1 = clients[2]['user_id'] transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transaction.events[0].asset.add(user_id=user1, asset_body=b'aaddbbdd') transaction.events[1].asset.add(user_id=user1, asset_file=b'112423') for i, user in enumerate(clients): sig = transaction.sign(keypair=clients[i]['keypair']) transaction.add_signature(user_id=clients[i]['user_id'], signature=sig) transaction.digest() print("register transaction=", binascii.b2a_hex(transaction.transaction_id)) asset_file = dict() asset_file[transaction.events[1].asset. asset_id] = transaction.events[1].asset.asset_file ret = cores[2].insert_transaction(domain_id, transaction.serialize(), asset_file) assert ret[KeyType.transaction_id] == transaction.transaction_id # -- search the transaction at core_node_0 ret = cores[0].search_transaction_by_txid(domain_id, transaction.transaction_id) print(ret) assert ret is None
def test_13_insert_first_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") user = clients[3]['user_id'] transactions[0] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transactions[0].events[0].asset.add(user_id=user, asset_body=b'123456') transactions[0].events[1].asset.add(user_id=user, asset_file=b'abcdefg') transactions[0].events[0].add(reference_index=0, mandatory_approver=user) transactions[0].get_sig_index(user) sig = transactions[0].sign(keypair=clients[0]['keypair']) assert sig is not None if sig is None: print(bbclib.error_text) import os os._exit(1) transactions[0].add_signature(user_id=user, signature=sig) transactions[0].digest() print(transactions[0]) global transaction_dat transaction_dat = transactions[0].serialize() print("register transaction=", binascii.b2a_hex(transactions[0].transaction_id)) clients[0]['app'].insert_transaction(transactions[0]) dat = msg_processor[0].synchronize() assert KeyType.reason in dat print("Failed: reason is", dat[KeyType.reason]) time.sleep(2)
def create_user_id(self, num_pubkeys=1, public_keys=None): keypair = bbclib.KeyPair() user_id = hashlib.sha256(bytes(keypair.public_key)).digest() # FIXME: detect collision initial_keypairs = [] if public_keys is None: public_keys = [] for i in range(num_pubkeys): new_keypair = bbclib.KeyPair() initial_keypairs.append(new_keypair) public_keys.append(new_keypair.public_key) directive = Directive(Directive.CMD_REPLACE, public_keys) tx = bbclib.make_transaction_for_base_asset( asset_group_id=self.namespace_id, event_num=1) tx.events[0].asset.add(user_id=user_id, asset_body=directive.serialize()) tx.events[0].add(mandatory_approver=user_id) tx.add(witness=bbclib.BBcWitness()) tx.witness.add_witness(user_id) self.sign_and_insert(tx, user_id, keypair) return (user_id, initial_keypairs)
def test_03_transaction_insert(self): print("-----", sys._getframe().f_code.co_name, "-----") global transaction user1 = clients[1]['user_id'] transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) if len(cross_refs) > 0: transaction.add(cross_ref=cross_refs.pop(0)) transaction.events[0].asset.add(user_id=user1, asset_body=b'123456') transaction.events[1].asset.add(user_id=user1, asset_file=b'abcdefg') sig = transaction.sign(keypair=clients[1]['keypair']) transaction.add_signature(user_id=user1, signature=sig) transaction.digest() print("register transaction=", binascii.b2a_hex(transaction.transaction_id)) transaction.dump() asset_file = dict() asset_file[transaction.events[1].asset. asset_id] = transaction.events[1].asset.asset_file ret = cores[1].insert_transaction(asset_group_id, transaction.serialize(), asset_file) print(ret) for i in range(len(cores)): print("[%d] cross_ref_list=%d" % (i, len(cores[i].cross_ref_list)))
def test_23_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") for i, cl in enumerate(clients): print("---- start transaction at node %d---" % i) user = cl['user_id'] transactions[i] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) transactions[i].events[0].asset.add(user_id=user, asset_body="data=%d" % i) other_user = (i + 1) % client_num transactions[i].events[0].add( mandatory_approver=clients[other_user]['user_id']) sig = transactions[i].sign(keypair=cl['keypair']) transactions[i].add_signature(user_id=cl['user_id'], signature=sig) transactions[i].digest() print("insert_transaction=", binascii.b2a_hex(transactions[i].transaction_id)) cl['app'].insert_transaction(transactions[i]) print(" ----> wait for notification") for j in range(client_num): check_insert_response(j, transactions[i].transaction_id) if i == j: check_insert_response(j, transactions[i].transaction_id)
def set_mint_data(self, index, asset_body, update=False, keypair=None, idPublickeyMap=None): store_id = self.store_ids[index] if update: self.app.search_transaction_with_condition( asset_group_id=self.mint_id, user_id=store_id) res = self.app.callback.synchronize() if res[KeyType.status] >= ESUCCESS: reftx = bbclib.BBcTransaction( deserialize=res[KeyType.transactions][0]) else: reftx = None tx = bbclib.make_transaction_for_base_asset( asset_group_id=self.mint_id, event_num=1) tx.events[0].asset.add(user_id=store_id, asset_body=asset_body) tx.events[0].add(mandatory_approver=self.mint_id) if reftx is None: tx.add(witness=bbclib.BBcWitness()) tx.witness.add_witness(self.mint_id) else: bbclib.add_reference_to_transaction(self.mint_id, tx, reftx, 0) if keypair is None: return tx return self.sign_and_insert(tx, self.mint_id, keypair, idPublickeyMap)
def create_transaction_object_and_send_sign_req(idx, receiver_user_id, ref_txids=None, file_data=None): if ref_txids is None or ref_txids[0] is None: ref_txids = [] txobj = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) txobj.events[0].asset.add(user_id=receiver_user_id, asset_body="transferred", asset_file=file_data) txobj.events[0].add(mandatory_approver=receiver_user_id) for i, ref_txid in enumerate(ref_txids): clients[idx].search_transaction(ref_txid) response_data = clients[idx].callback.synchronize() assert response_data[KeyType.status] == ESUCCESS prev_tx = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) bbclib.add_reference_to_transaction(asset_group_id, txobj, prev_tx, 0) sig_mine = txobj.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=keypairs[idx].private_key, public_key=keypairs[idx].public_key) txobj.references[0].add_signature(user_id=user_ids[idx], signature=sig_mine) asset_id = txobj.events[0].asset.asset_id asset_files = {asset_id: file_data} ret = clients[idx].gather_signatures(txobj, destinations=[receiver_user_id], asset_files=asset_files) assert ret return txobj
def test_10_store_file(self): print("\n-----", sys._getframe().f_code.co_name, "-----") # -- first file store by user_0 store_transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) store_transaction.events[0].add(mandatory_approver=user_ids[0]) store_transaction.events[0].asset.add(user_id=user_ids[0], asset_body="Owner is 0", asset_file=large_data) sig = store_transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=keypairs[0].private_key, public_key=keypairs[0].public_key) store_transaction.get_sig_index(user_ids[0]) store_transaction.add_signature(user_id=user_ids[0], signature=sig) store_transaction.digest() print(store_transaction) global transaction_id, asset_id transaction_id = store_transaction.transaction_id asset_id = store_transaction.events[0].asset.asset_id clients[0].insert_transaction(store_transaction) response_data = clients[0].callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) assert False time.sleep(1)
def store_proc(data, approver_id, txid=None): # make transaction object transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) transaction.events[0].add(mandatory_approver=approver_id, asset_group_id=asset_group_id) transaction.events[0].asset.add(user_id=user_id, asset_body=data) if txid: obj = { "jsonrpc": "2.0", "method": "bbc1_GetTransaction", "params": { "asset_group_id": bbclib.bin2str_base64(asset_group_id), "tx_id": txid, "user_id": bbclib.bin2str_base64(user_id), }, "id": 114514 } response = json_post(obj) prevtx = response["result"] prevtx = bbclib.BBcTransaction(jsonload=prevtx) bbclib.add_reference_to_transaction(asset_group_id, transaction, prevtx, 0) # get transaction digest jsontx = transaction.jsondump() obj = { "jsonrpc": "2.0", "method": "bbc1_GetTransactionDigest", "params": jsontx, "id": 114514 } response = json_post(obj) # add sign to transaction json sig = bbclib.bin2str_base64( key_pair.sign( binascii.a2b_base64(response["result"]["digest"].encode("utf-8")))) jsontx = json.loads(response["result"]["tx"]) sig = { "type": 1, "signature": sig, "pubkey": bbclib.bin2str_base64(key_pair.public_key) } jsontx["Signature"].append(sig) # Insert Transaction obj = { "jsonrpc": "2.0", "method": "bbc1_InsertTransaction", "params": json.dumps(jsontx), "id": 114514 } response = json_post(obj) print("TXID: %s" % response["result"]) print("ASID: %s" % jsontx["Event"][0]["Asset"]["asset_id"]) return response["result"]
def test_02_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") user = clients[0]['user_id'] transactions[0] = bbclib.make_transaction_for_base_asset(asset_group_id=asset_group_id, event_num=2) transactions[0].events[0].asset.add(user_id=user, asset_body=b'123456') transactions[0].events[1].asset.add(user_id=user, asset_file=b'abcdefg') ret = clients[0]['app'].get_cross_refs(asset_group_id=asset_group_id, number=2) assert ret wait_check_result_msg_type(msg_processor[0], bbclib.ServiceMessageType.RESPONSE_CROSS_REF)
def test_12_make_transaction(self): print("-----", sys._getframe().f_code.co_name, "-----") user = clients[0]['user_id'] transactions[0] = bbclib.make_transaction_for_base_asset(asset_group_id=asset_group_id, event_num=1) transactions[0].events[0].asset.add(user_id=user, asset_file=b"data=1") sig = transactions[0].sign(keypair=clients[0]['keypair']) transactions[0].add_signature(user_id=clients[0]['user_id'], signature=sig) ret = clients[0]['app'].insert_transaction(asset_group_id, transactions[0]) assert ret msg_processor[0].synchronize() print("txid:", binascii.b2a_hex(transactions[0].digest()))
def store_proc(data, approver_id,txid=None): bbc_app_client = setup_bbc_client() store_transaction = bbclib.make_transaction_for_base_asset(asset_group_id=asset_group_id, event_num=1) store_transaction.events[0].add(mandatory_approver=approver_id, asset_group_id=asset_group_id) store_transaction.events[0].asset.add(user_id=user_id, asset_body=data) LAB_id = bbclib.get_new_id("LegalAffairsBureau", include_timestamp=False) store_transaction.events[0].add(option_approver=LAB_id) if txid: bbc_app_client.search_transaction(asset_group_id, txid) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) prev_tx = bbclib.recover_transaction_object_from_rawdata(response_data[KeyType.transaction_data]) reference = bbclib.add_reference_to_transaction(asset_group_id, store_transaction, prev_tx, 0) sig = store_transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1_XY, private_key=key_pair.private_key, public_key=key_pair.public_key) store_transaction.references[0].add_signature(user_id=user_id, signature=sig) else: sig = store_transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1_XY, private_key=key_pair.private_key, public_key=key_pair.public_key) store_transaction.add_signature(signature=sig) store_transaction.add_signature(user_id=user_id, signature=sig) # Get signature from LegalAffairsBureau bbc_app_client.gather_signatures(asset_group_id, store_transaction,destinations=[LAB_id]) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("Rejected because ", response_data[KeyType.reason].decode(), "") sys.exit(0) result = response_data[KeyType.result] store_transaction.get_sig_index(result[1]) store_transaction.add_signature(user_id=result[1], signature=result[2]) store_transaction.digest() store_transaction.dump() ret = bbc_app_client.insert_transaction(asset_group_id, store_transaction) assert ret response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) print("TxID: %s", binascii.b2a_hex(response_data[KeyType.transaction_id])) print("AsID: %s", binascii.b2a_hex(store_transaction.events[0].asset.asset_id)) txinfo = [store_transaction.transaction_id, store_transaction.events[0].asset.asset_id] return txinfo
def create_transaction_object_for_filedata(receiver_name, receiver_user_id, ref_txids=None, file_data=None, bbc_app_client=None): if ref_txids is None or ref_txids[0] is None: ref_txids = [] transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1, witness=True) user_info_msg = "Ownership is transfered from %s to %s" % (user_name, receiver_name) transaction.events[0].asset.add(user_id=receiver_user_id, asset_body=user_info_msg, asset_file=file_data) transaction.events[0].add(mandatory_approver=receiver_user_id) witness = transaction.witness witness.add_witness(receiver_user_id) for i, ref_txid in enumerate(ref_txids): bbc_app_client.search_transaction(ref_txid) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) prev_tx = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) bbclib.add_reference_to_transaction(asset_group_id, transaction, prev_tx, 0) asset_id = transaction.events[0].asset.asset_id asset_files = {asset_id: file_data} ret = bbc_app_client.gather_signatures(transaction, destinations=[receiver_user_id], asset_files=asset_files) if not ret: print("Failed to send sign request") sys.exit(0) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("Rejected because ", response_data[KeyType.reason].decode(), "") sys.exit(0) result = response_data[KeyType.result] transaction.get_sig_index(receiver_user_id) transaction.add_signature(user_id=result[1], signature=result[2]) sig_mine = transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=key_pair.private_key, public_key=key_pair.public_key) transaction.references[0].add_signature(user_id=user_id, signature=sig_mine) transaction.digest() return transaction
def test_16_forge_transaction(self): print("-----", sys._getframe().f_code.co_name, "-----") cores[2].ledger_manager.remove(domain_id, asset_group_id, transactions[0].digest()) transactions[1] = bbclib.make_transaction_for_base_asset(asset_group_id=asset_group_id) transactions[1].events[0].asset.add(user_id=clients[1]['user_id'], asset_file=b"data=2") sig = transactions[0].sign(keypair=clients[0]['keypair']) transactions[1].add_signature(user_id=clients[0]['user_id'], signature=sig) txdata = transactions[1].serialize() cores[2].ledger_manager.insert_locally(domain_id, asset_group_id, transactions[0].digest(), ResourceType.Transaction_data, txdata) ret = cores[2].ledger_manager.find_locally(domain_id, asset_group_id, transactions[0].digest(), ResourceType.Transaction_data) print("forged_transaction:", binascii.b2a_hex(ret)) print("forged_txid:", binascii.b2a_hex(transactions[1].digest()))
def test_02_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") user = clients[0]['user_id'] transactions[0] = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transactions[0].events[0].asset.add(user_id=user, asset_body=b'123456') transactions[0].events[1].asset.add(user_id=user, asset_file=b'abcdefg') transactions[0].events[1].add(mandatory_approver=clients[1]['user_id']) for i, cl in enumerate(clients): ret = cl['app'].get_cross_refs(asset_group_id=asset_group_id, number=2) assert ret dat = msg_processor[i].synchronize() cross_ref_list[i].extend(dat)
def store_proc(file, txid=None): with open(file, "rb") as fin: data = fin.read() bbc_app_client = setup_bbc_client() store_transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) user_info = "Owner is %s" % user_name store_transaction.events[0].add(mandatory_approver=user_id) store_transaction.events[0].asset.add(user_id=user_id, asset_body=user_info, asset_file=data) if txid: bbc_app_client.search_transaction(txid) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) prev_tx = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) reference = bbclib.add_reference_to_transaction( asset_group_id, store_transaction, prev_tx, 0) sig = store_transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=key_pair.private_key, public_key=key_pair.public_key) store_transaction.references[0].add_signature(user_id=user_id, signature=sig) else: sig = store_transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=key_pair.private_key, public_key=key_pair.public_key) store_transaction.get_sig_index(user_id) store_transaction.add_signature(user_id=user_id, signature=sig) store_transaction.digest() ret = bbc_app_client.insert_transaction(store_transaction) assert ret response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) bbc_app.store_id_mappings( os.path.basename(file), asset_group_id, transaction_id=response_data[KeyType.transaction_id], asset_ids=store_transaction.events[0].asset.asset_id)
def store_proc(data, approver_id, txid=None): bbc_app_client = setup_bbc_client() transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) transaction.events[0].add(mandatory_approver=approver_id, asset_group_id=asset_group_id) transaction.events[0].asset.add(user_id=user_id, asset_body=data) if txid: bbc_app_client.search_transaction(txid) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) prev_tx = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) reference = bbclib.add_reference_to_transaction( asset_group_id, transaction, prev_tx, 0) sig = transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=key_pair.private_key, public_key=key_pair.public_key) transaction.references[0].add_signature(user_id=user_id, signature=sig) else: sig = transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1, private_key=key_pair.private_key, public_key=key_pair.public_key) transaction.add_signature(signature=sig) transaction.digest() print(transaction) ret = bbc_app_client.insert_transaction(transaction) assert ret response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) print("TxID: %s", binascii.b2a_hex(response_data[KeyType.transaction_id])) print("AsID: %s", binascii.b2a_hex(transaction.events[0].asset.asset_id)) bbc_app.store_id_mappings( data, asset_group_id, transaction_id=response_data[KeyType.transaction_id], asset_ids=transaction.events[0].asset.asset_id) txinfo = [transaction.transaction_id, transaction.events[0].asset.asset_id] return txinfo
def test_11_put(self): print("\n-----", sys._getframe().f_code.co_name, "-----") global transaction transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transaction.events[0].asset.add(user_id=users[1], asset_body=b'123456') transaction.events[1].asset.add(user_id=users[1], asset_file=b'abcdefg') sig = transaction.sign(keypair=keypair) transaction.add_signature(user_id=users[0], signature=sig) transaction.digest() ret = cores[3].ledger_manager.insert_locally( domain_id, asset_group_id, transaction.transaction_id, ResourceType.Transaction_data, transaction.serialize()) time.sleep(2) ret = cores[3].ledger_manager.find_locally( domain_id, asset_group_id, transaction.transaction_id, ResourceType.Transaction_data) assert ret is not None
def test_05_1_search_transaction_by_txid_other_node_not_found(self): print("-----", sys._getframe().f_code.co_name, "-----") # -- insert transaction only at core_node_2 global transaction user1 = clients[2]['user_id'] transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) if len(cross_refs) > 0: transaction.add(cross_ref=cross_refs.pop(0)) transaction.events[0].asset.add(user_id=user1, asset_body=b'aaddbbdd') transaction.events[1].asset.add(user_id=user1, asset_file=b'112423') for i, user in enumerate(clients): sig = transaction.sign(keypair=clients[i]['keypair']) transaction.add_signature(user_id=clients[i]['user_id'], signature=sig) transaction.digest() print("register transaction=", binascii.b2a_hex(transaction.transaction_id)) transaction.dump() asset_file = dict() asset_file[transaction.events[1].asset. asset_id] = transaction.events[1].asset.asset_file cores[2].ledger_manager.insert_locally(domain_id, asset_group_id, transaction.transaction_id, ResourceType.Transaction_data, transaction.serialize()) asid1 = transaction.events[0].asset.asset_id cores[2].ledger_manager.insert_locally(domain_id, asset_group_id, asid1, ResourceType.Asset_ID, transaction.transaction_id) # -- search the transaction at core_node_0 ret = cores[0].search_transaction_by_txid(asset_group_id, transaction.transaction_id, clients[2]['user_id'], b'bbbb') print(ret) assert ret is None print("wait queue: 1") total = wait_results(1) assert total == 0
def sendback_exception_asset(approver_id, asset_group, asid): asset = json.loads(get_data(asset_group, asid).decode("UTF-8")) asset["owner"] = approver_id asset["date"] = datetime.now().strftime('%s') data = json.dumps(asset) bbc_app_client = setup_bbc_client(asset_group) transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group, event_num=1) transaction.events[0].add( mandatory_approver=binascii.unhexlify(approver_id), asset_group_id=asset_group) transaction.events[0].asset.add(user_id=user_id, asset_body=data) ref_tx = get_txid_from_asid(asset_group, asid) transaction = add_ref_tx(asset_group, transaction, ref_tx, 0) transaction.digest() transaction.dump() ret = bbc_app_client.insert_transaction(asset_group, transaction) assert ret response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: print("ERROR: ", response_data[KeyType.reason].decode()) sys.exit(0) print("TxID: %s", binascii.b2a_hex(response_data[KeyType.transaction_id])) print("AsID: %s", binascii.b2a_hex(transaction.events[0].asset.asset_id)) bbc_app.store_id_mappings( data, asset_group, transaction_id=response_data[KeyType.transaction_id], asset_ids=transaction.events[0].asset.asset_id) txinfo = [transaction.transaction_id, transaction.events[0].asset.asset_id] bbc_app_client.send_message(transaction_info, binascii.unhexlify(new_owner), asset_group) print("Transfer is done.....")
def test_13_make_transaction(self): print("\n-----", sys._getframe().f_code.co_name, "-----") for i, cl in enumerate(clients): user = cl['user_id'] txobj = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=1) cl['app'].get_cross_refs(asset_group_id=asset_group_id, number=2) dat = msg_processor[i].synchronize() cross_ref_list[i].extend(dat) if len(cross_ref_list[i]) > 0: txobj.add(cross_ref=cross_ref_list[i].pop(0)) txobj.events[0].asset.add(user_id=user, asset_body=b"data2=%d" % i) other_user = (i + 1) % client_num txobj.events[0].add( reference_index=0, mandatory_approver=clients[other_user]['user_id']) reference = bbclib.add_reference_to_transaction( asset_group_id, txobj, transactions[i], 0) ret = cl['app'].gather_signatures(asset_group_id, txobj, reference_obj=reference) assert ret dat = msg_processor[i].synchronize() assert dat[KeyType.status] == ESUCCESS result = dat[KeyType.result] txobj.references[result[0]].add_signature(user_id=result[1], signature=result[2]) txobj.digest() txobj.dump() ret = cl['app'].insert_transaction(asset_group_id, txobj) assert ret msg_processor[i].synchronize() transactions[i] = txobj for i in range(len(cores)): print("[%d] cross_ref_list=%d" % (i, len(cores[i].cross_ref_list)))
def test_03_transaction_insert(self): print("\n-----", sys._getframe().f_code.co_name, "-----") global transaction print("-- insert transaction only at core_node_1 --") user1 = clients[1]['user_id'] transaction = bbclib.make_transaction_for_base_asset( asset_group_id=asset_group_id, event_num=2) transaction.events[0].asset.add(user_id=user1, asset_body=b'123456') transaction.events[1].asset.add(user_id=user1, asset_file=b'abcdefg') transaction.get_sig_index(user1) sig = transaction.sign(keypair=clients[1]['keypair']) transaction.add_signature(user_id=user1, signature=sig) transaction.digest() print(transaction) print("register transaction=", binascii.b2a_hex(transaction.transaction_id)) asset_file = dict() asset_file[transaction.events[1].asset. asset_id] = transaction.events[1].asset.asset_file ret = cores[1].insert_transaction(domain_id, transaction.serialize(), asset_file) assert ret[KeyType.transaction_id] == transaction.transaction_id
def issue(self, to_user_id, amount, time_of_origin=None, keypair=None): if self.user_id != self.mint_id: raise RuntimeError('issuer must be the mint') tx = bbclib.make_transaction_for_base_asset( asset_group_id=self.mint_id, event_num=1) if time_of_origin is None: time_of_origin = tx.timestamp tx.events[0].asset.add( user_id=to_user_id, asset_body=IssuedAssetBody( amount, time_of_origin, self.currency_spec.variation_specs).serialize()) tx.events[0].add(mandatory_approver=self.mint_id) tx.events[0].add(mandatory_approver=to_user_id) tx.add(witness=bbclib.BBcWitness()) tx.witness.add_witness(self.mint_id) if keypair is None: return tx return self.store.sign_and_insert(tx, self.mint_id, keypair, self.idPublickeyMap)