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.....")
