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 __get_transaction(self, tx_id): ret = self.__app.search_transaction(tx_id) res = self.__app.callback.sync_by_queryid(ret) if res[KeyType.status] < ESUCCESS: raise RuntimeError(res[KeyType.reason].decode()) return bbclib.recover_transaction_object_from_rawdata( res[KeyType.transaction_data])
def get_file(file): fileinfo = bbc_app.get_id_from_mappings(os.path.basename(file), asset_group_id) if fileinfo is None: print( "Not exists in local mapping cache. So, asset_id is not known...") sys.exit(1) bbc_app_client = setup_bbc_client() ret = bbc_app_client.search_asset(asset_group_id, fileinfo["asset_id"]) 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) get_transaction = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) if KeyType.all_asset_files in response_data: asset_file_dict = response_data[KeyType.asset_file] asset_id = get_transaction.events[0].asset.asset_id data = asset_file_dict[asset_id] else: data = get_transaction.events[0].asset.asset_body out_file_name = file if os.path.exists(out_file_name): current_datetime = datetime.datetime.now() time_str = current_datetime.strftime('_%Y%m%d%H%M%S') out_file_name += time_str with open(out_file_name, "wb") as outfile: outfile.write(data) print("done get %s" % out_file_name)
def verify_file(file): fileinfo = bbc_app.get_id_from_mappings(os.path.basename(file), asset_group_id) if fileinfo is None: print( "Not exists in local mapping cache. So, asset_id is not known...") sys.exit(1) bbc_app_client = setup_bbc_client() ret = bbc_app_client.search_asset(asset_group_id, fileinfo["asset_id"]) 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) transaction = bbclib.recover_transaction_object_from_rawdata( response_data[KeyType.transaction_data]) digest = transaction.digest() ret = transaction.signatures[0].verify(digest) if not ret: print("Transaction data is invalid.") sys.exit(1) with open(file, "rb") as fin: data = fin.read() file_digest = hashlib.sha256(data).digest() if file_digest == transaction.events[0].asset.asset_file_digest: print("%s is valid" % file) else: print("%s is invalid" % file) print("done verify %s" % os.path.basename(file)) print("Content of the transaction:::") print(transaction)
def get_tx(self, tx_id): self.app.search_transaction(tx_id) res = self.app.callback.synchronize() if res[KeyType.status] < ESUCCESS: raise ValueError('not found') tx = bbclib.recover_transaction_object_from_rawdata( res[KeyType.transaction_data]) return tx
def test_17_search_transaction(self): print("-----", sys._getframe().f_code.co_name, "-----") ret = clients[2]['app'].search_transaction(asset_group_id, transactions[0].digest()) assert ret dat = wait_check_result_msg_type(msg_processor[2], bbclib.ServiceMessageType.RESPONSE_SEARCH_TRANSACTION) assert dat[KeyType.status] == ESUCCESS print("transaction:", binascii.b2a_hex(dat[KeyType.transaction_data])) tx_obj = bbclib.recover_transaction_object_from_rawdata(dat[KeyType.transaction_data]) print("txid:", binascii.b2a_hex(tx_obj.digest()))
def proc_resp_search_asset(self, dat): if KeyType.transaction_data in dat: self.logger.info("OK: Asset [%s] is found." % binascii.b2a_hex(dat[KeyType.asset_id])) tx_obj = bbclib.recover_transaction_object_from_rawdata(dat[KeyType.transaction_data]) for evt in tx_obj.events: if evt.asset.asset_body_size > 0: self.logger.info(" [%s] asset_body --> %s" % (binascii.b2a_hex(evt.asset.asset_id[:4]), evt.asset.asset_body)) else: self.logger.info("NG.....") self.queue.put(dat)
def test_15_search_transaction(self): ret = clients[1]['app'].search_transaction(asset_group_id, transactions[0].digest()) assert ret dat = msg_processor[1].synchronize() assert dat[KeyType.status] == 0 print("transaction:", binascii.b2a_hex(dat[KeyType.transaction_data])) tx_obj = bbclib.recover_transaction_object_from_rawdata(dat[KeyType.transaction_data]) print("txid:", binascii.b2a_hex(tx_obj.digest())) print("--- find_locally again ---") ret = cores[1].ledger_manager.find_locally(domain_id, asset_group_id, transactions[0].digest(), ResourceType.Transaction_data) assert ret is not None
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_31_search_asset(self): print("-----", sys._getframe().f_code.co_name, "-----") asset_id = transactions[0].events[0].asset.asset_id ret = clients[3]['app'].search_asset(asset_group_id, asset_id) assert ret dat = wait_check_result_msg_type(msg_processor[3], bbclib.ServiceMessageType.RESPONSE_SEARCH_ASSET) assert dat[KeyType.status] == ESUCCESS print(dat[KeyType.asset_file]) print("transaction:", binascii.b2a_hex(dat[KeyType.transaction_data])) tx_obj = bbclib.recover_transaction_object_from_rawdata(dat[KeyType.transaction_data]) print("txid:", binascii.b2a_hex(tx_obj.digest())) ret = cores[3].storage_manager.get_locally(domain_id, asset_group_id, asset_id) assert ret is not None print(ret)
def proc_resp_search_transaction(self, dat): if KeyType.transaction_data in dat: tx_obj = bbclib.recover_transaction_object_from_rawdata( dat[KeyType.transaction_data]) tx_obj.digest() digest = tx_obj.digest() for i in range(len(tx_obj.signatures)): result = tx_obj.signatures[i].verify(digest) if not result: dat = { KeyType.status: EBADTXSIGNATURE, KeyType.reason: "Verify failure", KeyType.transaction_data: tx_obj } break self.queue.put(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_store_file(self): print("\n-----", sys._getframe().f_code.co_name, "-----") # -- verify by user_1 ret = clients[1].search_asset(asset_group_id, asset_id) assert ret response_data = clients[1].callback.synchronize() assert response_data[KeyType.status] == ESUCCESS txobj = bbclib.recover_transaction_object_from_rawdata(response_data[KeyType.transaction_data]) digest = txobj.digest() ret = txobj.signatures[0].verify(digest) assert ret file_digest = hashlib.sha256(large_data).digest() if file_digest == txobj.events[0].asset.asset_file_digest: print("oooo valid") else: print("xxxx invalid") txobj.dump()
def add_ref_tx(asset_group, transaction, ref_tx, ref_index): bbc_app_client = setup_bbc_client(asset_group) bbc_app_client.search_transaction(asset_group, ref_tx) 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, transaction, prev_tx, 0) sig = transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1_XY, private_key=key_pair.private_key, public_key=key_pair.public_key) transaction.references[ref_index].add_signature(user_id=user_id, signature=sig) if asset_group == land_asset_group: print("ref to land asset") return transaction
def execute_escrow(): coinasset = json.loads( get_data(coin_asset_group, coinasid).decode("UTF-8")) coinasset["owner"] = escrow["owner"] coinasset["date"] = datetime.now().strftime('%s') coinasset = json.dumps(coinasset) cointx_id = get_txid_from_asid(coin_asset_group, coinasid) landasset = json.loads( get_data(land_asset_group, landasid).decode("UTF-8")) landasset["owner"] = escrow["newowner"] landasset["date"] = datetime.now().strftime('%s') landasset = json.dumps(landasset) landtx_id = get_txid_from_asid(land_asset_group, landasid) # Make TX land_client = setup_bbc_client(land_asset_group) transaction = bbclib.make_transaction_for_base_asset( asset_group_id=land_asset_group, event_num=2) # Add event and asset print("Add event and asset") transaction.events[0].add(mandatory_approver=binascii.unhexlify( escrow["newowner"]), asset_group_id=land_asset_group) transaction.events[0].asset.add(user_id=user_id, asset_body=landasset) LAB_id = bbclib.get_new_id("LegalAffairsBureau", include_timestamp=False) transaction.events[0].add(option_approver=LAB_id) coin_client = setup_bbc_client(coin_asset_group) transaction.events[1].add(mandatory_approver=binascii.unhexlify( escrow["owner"]), asset_group_id=coin_asset_group) transaction.events[1].asset.add(user_id=user_id, asset_body=coinasset) # Add reference print("Add reference") land_client.search_transaction(land_asset_group, landtx_id) response_data = land_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(land_asset_group, transaction, prev_tx, 0) coin_client.search_transaction(coin_asset_group, cointx_id) response_data = coin_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(coin_asset_group, transaction, prev_tx, 0) # Add signature print("Add signature to escrow TX") sig = transaction.sign(key_type=bbclib.KeyType.ECDSA_SECP256k1_XY, private_key=key_pair.private_key, public_key=key_pair.public_key) transaction.references[0].add_signature(user_id=user_id, signature=sig) print("Get signature from LegalAffairsBureau") land_client.gather_signatures(land_asset_group, transaction, destinations=[LAB_id]) response_data = land_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(result[1]) transaction.add_signature(user_id=result[1], signature=result[2]) transaction.digest() transaction.dump() print("insert coin asset group") ret = coin_client.insert_transaction(coin_asset_group, transaction) assert ret response_data = coin_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("coinAsID: %s", binascii.b2a_hex(transaction.events[0].asset.asset_id)) print("landAsID: %s", binascii.b2a_hex(transaction.events[1].asset.asset_id)) cointxinfo = [ transaction.transaction_id, transaction.events[0].asset.asset_id ] landtxinfo = [ transaction.transaction_id, transaction.events[1].asset.asset_id ] print("insert land asset group") ret = land_client.insert_transaction(land_asset_group, transaction) assert ret response_data = land_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("coinAsID: %s", binascii.b2a_hex(transaction.events[0].asset.asset_id)) print("landAsID: %s", binascii.b2a_hex(transaction.events[1].asset.asset_id)) txinfo = [transaction.transaction_id, transaction.events[0].asset.asset_id] coin_client.send_message(txinfo, binascii.unhexlify(escrow["owner"]), coin_asset_group) txinfo = [transaction.transaction_id, transaction.events[1].asset.asset_id] land_client.send_message(txinfo, binascii.unhexlify(escrow["newowner"]), land_asset_group) print("Transfer is done.....")