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)
