def _send_healthcare_txn(self, txn_key, batch_key, inputs, outputs, payload, wait, auth_user, auth_password): txn_header_bytes, signature = self._transaction_header(txn_key, inputs, outputs, payload) txn = Transaction( header=txn_header_bytes, header_signature=signature, payload=payload.SerializeToString() ) transactions = [txn] batch_header_bytes, signature = self._batch_header(batch_key, transactions) batch = Batch( header=batch_header_bytes, header_signature=signature, transactions=transactions ) batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature if wait and wait > 0: wait_time = 0 start_time = time.time() response = self._send_request( "batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password) while wait_time < wait: status = self._get_status( batch_id, wait - int(wait_time), auth_user=auth_user, auth_password=auth_password) wait_time = time.time() - start_time if status != 'PENDING': return response return response return self._send_request( "batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password)
def _wrap_and_send(self, action, kycCategoryAddress, *values): # Generate a csv utf-8 encoded string as payload rawPayload = action for val in values: rawPayload = "$".join([rawPayload, str(val), str(kycCategoryAddress)]) payload = rawPayload.encode() # Construct the address where we'll store our state address = self._address + _hash(KYC_CATEGORY.encode('utf-8'))[0:6] + _hash(kycCategoryAddress.encode('utf-8'))[0:58] inputAddressList = [address] outputAddressList = [address] # Create a TransactionHeader header = TransactionHeader( signer_public_key=self._publicKey, family_name=FAMILY_NAME, family_version="1.0", inputs=inputAddressList, outputs=outputAddressList, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._publicKey, nonce=time.time().hex().encode() ).SerializeToString() # Create a Transaction from the header and payload above transaction = Transaction( header=header, payload=payload, header_signature=self._signer.sign(header) ) transactionList = [transaction] # Create a BatchHeader from transactionList above header = BatchHeader( signer_public_key=self._publicKey, transaction_ids=[txn.header_signature for txn in transactionList] ).SerializeToString() #Create Batch using the BatchHeader and transactionList above batch = Batch( header=header, transactions=transactionList, header_signature=self._signer.sign(header)) #Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) # Send batch_list to rest-api return self._send_to_restapi( "batches", batch_list.SerializeToString(), 'application/octet-stream')
def bat_gen(self, txns: TransactionList) -> bytes: """ Generates a valid batch for testing submissions, optional arguments are for payment transactions. Args: :arg txns: the list of transactions to be included Returns: :arg batch_list: A serialized BatchList """ Transactions = [txn.header_signature for txn in txns.transactions] batch_header = BatchHeader( signer_public_key=self.signer.get_public_key().as_hex(), transaction_ids=Transactions) # encode batch header batch_header_bytes = batch_header.SerializeToString() # sign batch header batch_signature_hex = self.signer.sign(batch_header_bytes) # build the batch batch = Batch(header=batch_header_bytes, header_signature=batch_signature_hex, transactions=[txn for txn in txns.transactions]) batch_list = BatchList(batches=[batch]) # return the batch and the header signatures of the transactions # included return batch_list.SerializeToString()
def _wrap_and_send(self, action, *values): '''Erstellt eine Transaktion, verpackt sie in ein Batch ''' # Generate a csv utf-8 encoded string as payload rawPayload = action for val in values: rawPayload = ",".join([rawPayload, str(val)]) payload = rawPayload.encode() # Construct the address where we'll store our state address = self._address inputAddressList = [address] outputAddressList = [address] if "transfer" == action: toAddress = _hash(FAMILY_NAME.encode('utf-8'))[0:6] + \ _hash(values[1].encode('utf-8'))[0:64] inputAddressList.append(toAddress) outputAddressList.append(toAddress) # Create a TransactionHeader header = TransactionHeader( signer_public_key=self._publicKey, family_name=FAMILY_NAME, family_version="1.0", inputs=inputAddressList, outputs=outputAddressList, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._publicKey, nonce=random.random().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above transaction = Transaction(header=header, payload=payload, header_signature=self._signer.sign(header)) transactionList = [transaction] # Create a BatchHeader from transactionList above header = BatchHeader( signer_public_key=self._publicKey, transaction_ids=[txn.header_signature for txn in transactionList]).SerializeToString() #Create Batch using the BatchHeader and transactionList above batch = Batch(header=header, transactions=transactionList, header_signature=self._signer.sign(header)) #Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) # Send batch_list to rest-api return self._send_to_restapi("batches", batch_list.SerializeToString(), 'application/octet-stream')
def _wrap_and_send(self, buyer, seller, house, wait=None): """ Create a transaction, then wrap it in a batch. Even single transactions must be wrapped into a batch. """ # Generate a CSV UTF-8 encoded string as the payload. raw_payload = "{".join([buyer, seller, house]) payload = raw_payload.encode() # Convert Unicode to bytes # Construct the address where we'll store our state. # We just have one input and output address (the same one). input_and_output_address_list = [self._address] # Create a TransactionHeader. header = TransactionHeader( signer_public_key=self._public_key, family_name=FAMILY_NAME, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode() ).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction( header=header, payload=payload, header_signature=self._signer.sign(header) ) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch( header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = self._send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait, result)
def _wrap_and_send(self, action, data, input_and_output_address_list, wait=None): '''Create a transaction, then wrap it in a batch. Even single transactions must be wrapped into a batch. Called by all submission methods. ''' # Assemble an action and the actual payload in a dictionary transactionDictionary = {'Action': action, 'Payload': data} payload = cbor.dumps(transactionDictionary) # Create a TransactionHeader. header = TransactionHeader( signer_public_key=self._public_key, family_name=FAMILY_NAME, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction(header=header, payload=payload, header_signature=self._signer.sign(header)) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list]).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch(header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = self._send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait, result)
def wrap_and_send(action, data='', wait=None): # Generate a CSV UTF-8 encoded string as the payload. raw_payload = ",".join([action,data]) payload = raw_payload # Convert Unicode to bytes # Construct the address where we'll store our state. # We just have one input and output address (the same one). input_and_output_address_list = [namespace] # Create a TransactionHeader. header = TransactionHeader( signer_public_key=public_key, family_name="bidding", family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=hash(payload), batcher_public_key=public_key, nonce=random.random().hex().encode() ).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction( header=header, payload=payload.encode(), header_signature=signer.sign(header) ) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader( signer_public_key=public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch( header=header, transactions=transaction_list, header_signature=signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') # Wait until transaction status is COMMITTED, error, or timed out return wait_for_status(batch_id, wait, result)
def _wrap_and_send(self, *values): payload = ",".join(values) print(" Payload ") print(payload) # Construct the address where we'll store our state address = self._address inputAddressList = [address] outputAddressList = [address] if "transfer" == values[0]: toAddress = get_wallet_address(values[2]) inputAddressList.append(toAddress) outputAddressList.append(toAddress) print("Inside the block") # Create a TransactionHeader header = TransactionHeader( signer_public_key=self._publicKey, family_name=FAMILY_NAME, family_version="1.0", inputs=inputAddressList, outputs=outputAddressList, dependencies=[], payload_sha512=hashlib.sha512(payload.encode()).hexdigest(), batcher_public_key=self._publicKey, nonce=random.random().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above transaction = Transaction(header=header, payload=payload.encode(), header_signature=self._signer.sign(header)) transactionList = [transaction] # Create a BatchHeader from transactionList above header = BatchHeader( signer_public_key=self._publicKey, transaction_ids=[txn.header_signature for txn in transactionList]).SerializeToString() # Create Batch using the BatchHeader and transactionList above batch = Batch(header=header, transactions=transactionList, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature print(batch_id) # Send batch_list to rest-api return self._send_to_restapi("batches", batch_list.SerializeToString(), 'application/octet-stream')
def wrap_and_send(action, data, input_address_list, output_address_list, wait=None): '''Create a transaction, then wrap it in a batch. ''' payload = ",".join([action, str(data)]) logging.info('payload: {}'.format(payload)) # Construct the address where we'll store our state. # Create a TransactionHeader. header = TransactionHeader( signer_public_key=public_key, family_name=family_name, family_version="1.0", inputs=input_address_list, # input_and_output_address_list, outputs=output_address_list, # input_and_output_address_list, dependencies=[], payload_sha512=hash(payload), batcher_public_key=public_key, nonce=random.random().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction( header=header, payload=payload.encode(), # encode the payload header_signature=signer.sign(header)) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader(signer_public_key=public_key, transaction_ids=[ txn.header_signature for txn in transaction_list ]).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch(header=header, transactions=transaction_list, header_signature=signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') # Wait until transaction status is COMMITTED, error, or timed out return wait_for_status(batch_id, result, wait=wait)
def encode(self, batches): """Wraps one or more Batch messages in a BatchList and serializes it for transmission to a validator. Args: batches (list of Batch or Batch): The Batch or Batches to wrap in a BatchList Returns: bytes: a serialized BatchList """ batches = _listify(batches) batch_list = BatchList(batches=batches) return batch_list.SerializeToString()
def _wrap_and_send(self,address,action, amount, wait=None,uaddress=''): ''' create and send transactions in batches ''' raw_payload = ",".join([action, str(amount)]) payload = raw_payload.encode() input_and_output_address_list=[] if uaddress=='': input_and_output_address_list = [address] else: input_and_output_address_list=[address,uaddress] header = TransactionHeader( signer_public_key=self._public_key, family_name=FAMILY_NAME, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode() ).SerializeToString() transaction = Transaction( header=header, payload=payload, header_signature=self._signer.sign(header) ) transaction_list = [transaction] header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() batch = Batch( header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature result = self._send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') return self._wait_for_status(batch_id, wait, result)
def _wrap_and_send(self, action, value): # Generate a csv utf-8 encoded string as payload payload = ",".join([action, str(value)]).encode() # Construct the address where we'll store our state address = self._address # Create a TransactionHeader header = TransactionHeader( signer_public_key=self._publicKey, family_name=FAMILY_NAME, family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._publicKey, nonce=time.time().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above transaction = Transaction(header=header, payload=payload, header_signature=self._signer.sign(header)) transactionList = [transaction] # Create a BatchHeader from TransactionList above header = BatchHeader( signer_public_key=self._publicKey, transaction_ids=[txn.header_signature for txn in transactionList]).SerializeToString() #Create Batch using the BatchHeader and transactionList above batch = Batch(header=header, transactions=transactionList, header_signature=self._signer.sign(header)) #Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) # Create a batch id # batch_id = batch_list.batches[0].header_signature # Send batch_list to rest-api return self._send_to_restapi("batches", batch_list.SerializeToString(), 'application/octet-stream')
def wrap_and_send(self, data_dict): # rawPayload = action # for val in values: # rawPayload = ",".join([rawPayload, str(val)]) payload = json.dumps(data_dict).encode() address = self._address inputAddressList = [address] outputAddressList = [address] header = TransactionHeader( signer_public_key=self._publicKey, family_name=FAMILY_NAME, family_version="1.0", inputs=inputAddressList, outputs=outputAddressList, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._publicKey, nonce=time.time().hex().encode() ).SerializeToString() transaction = Transaction( header=header, payload=payload, header_signature=self._signer.sign(header) ) transactionList = [transaction] header = BatchHeader( signer_public_key=self._publicKey, transaction_ids=[txn.header_signature for txn in transactionList] ).SerializeToString() batch = Batch( header=header, transactions=transactionList, header_signature=self._signer.sign(header)) batch_list = BatchList(batches=[batch]) return self._send_to_restapi( "batches", batch_list.SerializeToString(), 'application/octet-stream')
def construct_payload_and_send(self, action, amount, wait_time=None): raw_payload = ",".join([action, str(amount)]) input_and_output_address_list = [self._address] print(self._address) header = TransactionHeader( signer_public_key=self._public_key, family_name=constants.FAMILY_NAME, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=generate_hash(raw_payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode() ).SerializeToString() transaction = Transaction( header=header, payload=raw_payload.encode(), header_signature=self._signer.sign(header) ) transaction_list = [transaction] header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() batch = Batch( header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature print(batch_id) result = self.talk_to_validator("batches", batch_list.SerializeToString(), 'application/octet-stream') # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait_time, result)
def create_batch(self, transactions): # Transactions have a header_signature; # TpProcessRequests have a signature try: txn_signatures = [txn.header_signature for txn in transactions] except AttributeError: txn_signatures = [txn.signature for txn in transactions] header = BatchHeader( signer_public_key=self._signer.get_public_key().as_hex(), transaction_ids=txn_signatures).SerializeToString() signature = self._signer.sign(header) batch = Batch(header=header, transactions=transactions, header_signature=signature) batch_list = BatchList(batches=[batch]) return batch_list.SerializeToString()
def submit_omi_transaction(base_url, private_key, action, message_type, natural_key_field, omi_obj, additional_inputs=None): obj = message_type(**omi_obj) if additional_inputs is None: additional_inputs = [] public_key_hex = signing.generate_pubkey(private_key) address = get_object_address(omi_obj[natural_key_field], TAG_MAP[message_type]) data = obj.SerializeToString() payload = OMITransactionPayload( action=action, data=data, ) payload_bytes = payload.SerializeToString() payload_sha512 = hashlib.sha512(payload_bytes).hexdigest() txn_header = TransactionHeader( batcher_pubkey=public_key_hex, family_name=FAMILY_NAME, family_version='1.0', inputs=[address] + additional_inputs, outputs=[address], nonce=str(randint(0, 1000000000)), payload_encoding='application/protobuf', payload_sha512=payload_sha512, signer_pubkey=public_key_hex, ) txn_header_bytes = txn_header.SerializeToString() key_handler = signing.secp256k1_signer._decode_privkey(private_key) # ecdsa_sign automatically generates a SHA-256 hash txn_signature = key_handler.ecdsa_sign(txn_header_bytes) txn_signature_bytes = key_handler.ecdsa_serialize_compact(txn_signature) txn_signature_hex = txn_signature_bytes.hex() # print([txn_signature_hex]) txn = Transaction( header=txn_header_bytes, header_signature=txn_signature_hex, payload=payload_bytes, ) batch_header = BatchHeader( signer_pubkey=public_key_hex, transaction_ids=[txn.header_signature], ) batch_header_bytes = batch_header.SerializeToString() batch_signature = key_handler.ecdsa_sign(batch_header_bytes) batch_signature_bytes = key_handler.ecdsa_serialize_compact( batch_signature) batch_signature_hex = batch_signature_bytes.hex() batch = Batch( header=batch_header_bytes, header_signature=batch_signature_hex, transactions=[txn], ) batch_list = BatchList(batches=[batch]) batch_bytes = batch_list.SerializeToString() batch_id = batch_signature_hex url = "%s/batches" % base_url headers = { 'Content-Type': 'application/octet-stream', } r = requests.post(url, data=batch_bytes, headers=headers) r.raise_for_status() link = r.json()['link'] return BatchStatus(batch_id, link)
def _wrap_and_send(self, payload_data, wait=None): """ Create a transaction, then wrap it in a batch. Even single transactions must be wrapped into a batch. Called by create() and check(). """ transaction_list = [] # Create a transaction list from payload data for data in payload_data: # Construct the address where we'll store our state. # We just have one input and output address (the same one). product_id = data["Id"] # generate product address hash with Id product_address = addresser.get_product_address(product_id) # if product already exist with this ID, go next # TODO: remove in final version if self.is_product_already_exist(product_address): logger.info("product already exists") continue # create proto-buff object and encode data payload = payload_pb2.ProductInfoPayload(**data) payload_bytes = payload.SerializeToString() # Create a TransactionHeader. header = TransactionHeader( signer_public_key=self._public_key, family_name=FAMILY_NAME, family_version=FAMILY_VERSION, inputs=[product_address], outputs=[product_address], dependencies=[], payload_sha512=_hash(payload_bytes), batcher_public_key=self._public_key, nonce=random.random().hex().encode() ).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction( header=header, payload=payload_bytes, header_signature=self._signer.sign(header) ) # Append all transaction to transaction_list transaction_list.append(transaction) # Create a BatchHeader from transaction_list above. if len(transaction_list) == 0: logger.info("no transaction found. existing...") raise TransactionNotFound("Data Already exists.") header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch( header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = self._send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') # # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait, result)
def write_bc(self, family_name, args, wait=10): '''Create a transaction, then wrap it in a batch. Even single transactions must be wrapped into a batch. ''' self.init_bc(family_name=family_name) _logger.info( 'Wrapping and sending to blockchain with TP {} and Public Key {}'. format(self._family_name, self._public_key)) payload = str(json.dumps(args)) payload = payload.encode() # Convert Unicode to bytes # Construct the address where we'll store our state. # We just have one input and output address (the same one). input_and_output_address_list = [self._address] # Create a TransactionHeader. header = TransactionHeader( signer_public_key=self._public_key, family_name=self._family_name, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode()).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction(header=header, payload=payload, header_signature=self._signer.sign(header)) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list]).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch(header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature _logger.info('Transaction builded') # Send batch_list to the REST API result = self._send_to_rest_api( suffix="batches", data=batch_list.SerializeToString(), content_type='application/octet-stream', timeout=wait) _logger.info('Request sended') # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait, result)
def _wrap_and_send(self, action, amount, wait=None): '''Create a transaction, then wrap it in a batch. Even single transactions must be wrapped into a batch. Called by bake() and eat(). ''' amount=str(amount) amount=amount.replace('[','') amount=amount.replace(']','') print(amount) payload = str(amount).encode('utf-8') # Construct the address where we'll store our state. # We just have one input and output address (the same one). input_and_output_address_list = [self._address] # Create a TransactionHeader. header = TransactionHeader( signer_public_key=self._public_key, family_name=FAMILY_NAME, family_version="1.0", inputs=input_and_output_address_list, outputs=input_and_output_address_list, dependencies=[], payload_sha512=_hash(payload), batcher_public_key=self._public_key, nonce=random.random().hex().encode() ).SerializeToString() # Create a Transaction from the header and payload above. transaction = Transaction( header=header, payload=payload, header_signature=self._signer.sign(header) ) transaction_list = [transaction] # Create a BatchHeader from transaction_list above. header = BatchHeader( signer_public_key=self._public_key, transaction_ids=[txn.header_signature for txn in transaction_list] ).SerializeToString() # Create Batch using the BatchHeader and transaction_list above. batch = Batch( header=header, transactions=transaction_list, header_signature=self._signer.sign(header)) # Create a Batch List from Batch above batch_list = BatchList(batches=[batch]) batch_id = batch_list.batches[0].header_signature # Send batch_list to the REST API result = self._send_to_rest_api("batches", batch_list.SerializeToString(), 'application/octet-stream') filters = [events_pb2.EventFilter(key="address", match_string= TP_ADDRESS_PREFIX + ".*", filter_type=events_pb2. EventFilter.REGEX_ANY)] try: # To listen to all events, pass delta_filters=None : #listen_to_events(delta_filters=None) notification=listen_to_events(delta_filters=filters) #print(notification) except KeyboardInterrupt: pass except SystemExit as err: raise err except BaseException as err: traceback.print_exc(file=sys.stderr) sys.exit(1) # Wait until transaction status is COMMITTED, error, or timed out return self._wait_for_status(batch_id, wait, result),notification