def _send_txn(self, action, action_payload, inputs=None, outputs=None, wait=None): payload = _pb_dumps( SupplyChainPayload(action=action, data=_pb_dumps(action_payload))) header = TransactionHeader( signer_pubkey=self._public_key, family_name="sawtooth_supplychain", family_version="0.5", inputs=inputs or [], outputs=outputs or [], dependencies=[], payload_encoding='application/protobuf', payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode() ).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction( header=header, payload=payload, header_signature=signature ) batch_list = self._create_batch_list([transaction]) result = self._send_post( "batches", batch_list.SerializeToString(), 'application/octet-stream', wait=wait) return result
def create_wait_timer(cls, validator_address, previous_certificate_id, local_mean, minimum_wait_time): with cls._lock: # If we don't have a PoET private key, then the enclave has not # been properly initialized (either by calling create_signup_info # or unseal_signup_data) if cls._poet_private_key is None: raise \ ValueError( 'Enclave must be initialized before attempting to ' 'create a wait timer') # Create some value from the cert ID. We are just going to use # the seal key to sign the cert ID. We will then use the # low-order 64 bits to change that to a number [0, 1] tag = \ base64.b64decode( signing.sign( previous_certificate_id, cls._seal_private_key)) tagd = float(struct.unpack('Q', tag[-8:])[0]) / (2**64 - 1) # Now compute the duration with a minimum wait time guaranteed duration = minimum_wait_time - local_mean * math.log(tagd) # Create and sign the wait timer wait_timer = \ EnclaveWaitTimer( validator_address=validator_address, duration=duration, previous_certificate_id=previous_certificate_id, local_mean=local_mean) wait_timer.signature = \ signing.sign( wait_timer.serialize(), cls._poet_private_key) # Keep track of the active wait timer cls._active_wait_timer = wait_timer return wait_timer
def _generate_genesis_block(self): genesis_header = BlockHeader(previous_block_id=NULL_BLOCK_IDENTIFIER, signer_pubkey=self.public_key, block_num=0) block = BlockBuilder(genesis_header) block.add_batches([self._generate_batch("Genesis")]) header_bytes = block.block_header.SerializeToString() signature = signing.sign(header_bytes, self.identity_signing_key) block.set_signature(signature) return BlockWrapper(block.build_block())
def _sign_block(self, block): """ The block should be complete and the final signature from the publishing validator(this validator) needs to be added. """ block.block_header.signer_pubkey = self._identity_public_key block_header = block.block_header header_bytes = block_header.SerializeToString() signature = signing.sign(header_bytes, self._identity_signing_key) block.set_signature(signature) return block
def _send_xo_txn(self, name, action, space="", wait=None): # Serialization is just a delimited utf-8 encoded string payload = ",".join([name, action, str(space)]).encode() # Construct the address address = self._get_address(name) header = TransactionHeader( signer_pubkey=self._public_key, family_name="xo", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) batch_id = batch_list.batches[0].header_signature if wait and wait > 0: wait_time = 0 start_time = time.time() self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream') while wait_time < wait: status = self._get_status(batch_id, wait - int(wait_time)) wait_time = time.time() - start_time if status[batch_id] == 'COMMITTED': return 'Game created in {:.6} sec'.format(wait_time) elif status[batch_id] == 'INVALID': return ('Error: You chose an invalid game name. ' 'Try again with a different name') elif status[batch_id] == 'UNKNOWN': return ('Error: Something went wrong with your game. ' 'Try again with a different name.') # Wait a moment so as not to hammer the Rest Api time.sleep(0.2) return ('Timed out while waiting for game to be created. ' 'It may need to be resubmitted.') return self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream')
def _create_batch_list(self, transactions): transaction_signatures = [t.header_signature for t in transactions] header = BatchHeader( signer_pubkey=self._public_key, transaction_ids=transaction_signatures).SerializeToString() signature = signing.sign(header, self._private_key) batch = Batch(header=header, transactions=transactions, header_signature=signature) return BatchList(batches=[batch])
def _generate_block(self, payload, previous_block_id, block_num): header = BlockHeader(previous_block_id=previous_block_id, signer_pubkey=self.public_key, block_num=block_num) block_builder = BlockBuilder(header) block_builder.add_batches([self._generate_batch(payload)]) header_bytes = block_builder.block_header.SerializeToString() signature = signing.sign(header_bytes, self.identity_signing_key) block_builder.set_signature(signature) return BlockWrapper(block_builder.build_block())
def create_organization_transaction(self, id, alias, name, type, description, url, action, privatekey, publickey, part_id=""): self._public_key = publickey self._private_key = privatekey payload = ",".join([ id, str(alias), str(name), str(type), str(description), str(url), action, str(part_id) ]).encode() # Construct the address address = self._get_address(id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="organization", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) return self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream')
def test_deserialized_wait_certificate(self): wait_timer = \ EnclaveWaitTimer( validator_address='1600 Pennsylvania Avenue NW', duration=3.14159, previous_certificate_id='Smart, Maxwell Smart', local_mean=2.71828) wait_certificate = \ EnclaveWaitCertificate.wait_certificate_with_wait_timer( wait_timer=wait_timer, nonce='Eeny, meeny, miny, moe.', block_hash='Indigestion. Pepto Bismol.') serialized = wait_certificate.serialize() signing_key = self._create_random_key() wait_certificate.signature = \ signing.sign(serialized, signing_key) copy_wait_certificate = \ EnclaveWaitCertificate.wait_certificate_from_serialized( serialized, wait_certificate.signature) self.assertAlmostEqual( wait_certificate.request_time, copy_wait_certificate.request_time) self.assertAlmostEqual( wait_certificate.duration, copy_wait_certificate.duration) self.assertEqual( wait_certificate.previous_certificate_id, copy_wait_certificate.previous_certificate_id) self.assertAlmostEqual( wait_certificate.local_mean, copy_wait_certificate.local_mean) self.assertEqual( wait_certificate.validator_address, copy_wait_certificate.validator_address) self.assertEqual( wait_certificate.nonce, copy_wait_certificate.nonce) self.assertEqual( wait_certificate.block_hash, copy_wait_certificate.block_hash) self.assertEqual( wait_certificate.signature, copy_wait_certificate.signature) self.assertEqual(serialized, copy_wait_certificate.serialize())
def create_intkey_transaction(verb, name, value, deps, private_key, public_key): """Creates a signed intkey transaction. Args: verb (str): the action the transaction takes, either 'set', 'inc', or 'dec' name (str): the variable name which is altered by verb and value value (int): the amount to set, increment, or decrement deps ([str]): a list of transaction header_signatures which are required dependencies which must be processed prior to processing this transaction private_key (str): the private key used to sign the transaction public_key (str): the public key associated with the private key - the public key is included in the transaction as signer_pubkey Returns: transaction (transaction_pb2.Transaction): the signed intkey transaction """ payload = IntKeyPayload(verb=verb, name=name, value=value) # The prefix should eventually be looked up from the # validator's namespace registry. intkey_prefix = hashlib.sha512('intkey'.encode('utf-8')).hexdigest()[0:6] addr = intkey_prefix + hashlib.sha512(name.encode('utf-8')).hexdigest() header = transaction_pb2.TransactionHeader( signer_pubkey=public_key, family_name='intkey', family_version='1.0', inputs=[addr], outputs=[addr], dependencies=deps, payload_encoding="application/cbor", payload_sha512=payload.sha512(), batcher_pubkey=public_key, nonce=time.time().hex().encode()) header_bytes = header.SerializeToString() signature = signing.sign(header_bytes, private_key) transaction = transaction_pb2.Transaction(header=header_bytes, payload=payload.to_cbor(), header_signature=signature) return transaction
def create_supplier_transaction(self, supplier_id, short_id="", supplier_name="", passwd="", supplier_url="", action="", part_id="", auth_user=None, auth_password=None): payload = ",".join([ supplier_id, str(short_id), str(supplier_name), str(passwd), str(supplier_url), action, str(part_id) ]).encode() # Construct the address address = self._get_address(supplier_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="supplier", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) batch_id = batch_list.batches[0].header_signature return self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password)
def create_batch(transactions, private_key, public_key): transaction_ids = [t.header_signature for t in transactions] header = batch_pb2.BatchHeader(signer_pubkey=public_key, transaction_ids=transaction_ids) header_bytes = header.SerializeToString() signature = signing.sign(header_bytes, private_key) batch = batch_pb2.Batch(header=header_bytes, transactions=transactions, header_signature=signature) return batch
def _sign_message_with_transaction(transaction, message_type, key): """ Signs a transaction message or transaction :param transaction (dict): :param key (str): A signing key returns message, txnid (tuple): The first 16 characters of a sha256 hexdigest. """ transaction['Nonce'] = time.time() pub = signing.encode_pubkey(signing.generate_pubkey(key), "hex") transaction["PublicKey"] = pub sig = signing.sign(_dict2cbor(transaction), key) transaction['Signature'] = sig txnid = hashlib.sha256(transaction['Signature'].encode()).hexdigest()[:16] message = { 'Transaction': transaction, '__TYPE__': message_type, '__NONCE__': time.time(), } cbor_serialized_message = _dict2cbor(message) signature = signing.sign(cbor_serialized_message, key) message['__SIGNATURE__'] = signature return message, txnid
def _create_batch_list(self, transactions): transaction_signatures = [t.header_signature for t in transactions] header = BatchHeader( signer_pubkey=self._public_key, transaction_ids=transaction_signatures ).SerializeToString() signature = signing.sign(header, self._private_key) batch = Batch( header=header, transactions=transactions, header_signature=signature ) return BatchList(batches=[batch])
def create_part_transaction(self, pt_id, pt_name, checksum, version, alias, licensing, label, description, action, private_key, public_key, artifact_id, category_id, supplier_id): self._public_key = public_key self._private_key = private_key payload = ",".join([ pt_id, str(pt_name), str(checksum), str(version), str(alias), str(licensing), str(label), str(description), action, str(artifact_id), str(category_id), str(supplier_id) ]).encode() # Construct the address address = self._get_address(pt_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="pt", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) return self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream')
def test_invalid_verfication_report(self): """ Test that a transaction whose verication report is invalid returns an invalid transaction. """ signup_info = self.factory.create_signup_info(self.factory.pubkey_hash, "000") # Verifcation Report is None proof_data = signup_info.proof_data signup_info.proof_data = json.dumps({}) self._test_bad_signup_info(signup_info) # ------------------------------------------------------ # No verification signature proof_data_dict = json.loads(proof_data) del proof_data_dict["signature"] signup_info.proof_data = json.dumps(proof_data_dict) self._test_bad_signup_info(signup_info) # ------------------------------------------------------ # Bad verification signature proof_data_dict["signature"] = "bads" signup_info.proof_data = json.dumps(proof_data_dict) self._test_bad_signup_info(signup_info) # ------------------------------------------------------ # No Nonce verification_report = \ json.loads(proof_data_dict["verification_report"]) verification_report["nonce"] = None proof_data_dict = { 'verification_report': json.dumps(verification_report), 'signature': signing.sign(json.dumps(verification_report), self._report_private_key) } signup_info.proof_data = json.dumps(proof_data_dict) self._test_bad_signup_info(signup_info)
def send_category_transaction_request(self, category_id, category_name="", description="", action, wait=None, auth_user=None, auth_password=None): # Serialization is just a delimited utf-8 encoded string payload = ",".join( [category_id, str(category_name), str(description), action]).encode() # Construct the address address = self._get_address(category_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="category", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) batch_id = batch_list.batches[0].header_signature result = self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password) return result
def _create_transactions(self, count, valid=True, valid_batcher=True): txn_list = [] for i in range(count): payload = { 'Verb': 'set', 'Name': 'name' + str(random.randint(0, 100)), 'Value': random.randint(0, 100) } intkey_prefix = \ hashlib.sha512('intkey'.encode('utf-8')).hexdigest()[0:6] addr = intkey_prefix + \ hashlib.sha512(payload["Name"].encode('utf-8')).hexdigest() payload_encode = hashlib.sha512(cbor.dumps(payload)).hexdigest() header = TransactionHeader(signer_pubkey=self.public_key, family_name='intkey', family_version='1.0', inputs=[addr], outputs=[addr], dependencies=[], payload_encoding="application/cbor", payload_sha512=payload_encode) if valid_batcher: header.batcher_pubkey = self.public_key else: header.batcher_pubkey = "bad_batcher" header_bytes = header.SerializeToString() if valid: signature = signing.sign(header_bytes, self.private_key) else: signature = "bad_signature" transaction = Transaction(header=header_bytes, payload=cbor.dumps(payload), header_signature=signature) txn_list.append(transaction) return txn_list
def send(self, transactions): """ Package up transactions into a batch and send them to the network via the provided batch_sender. :param transactions: list of transactions to package and broadcast. :return: None """ txn_signatures = [txn.header_signature for txn in transactions] header = BatchHeader( signer_pubkey=self._identity_public_key, transaction_ids=txn_signatures ).SerializeToString() signature = signing.sign(header, self._identity_signing_key) batch = Batch( header=header, transactions=transactions, header_signature=signature) self._batch_sender.send(batch)
def _create_batch(pubkey, signing_key, transactions): """Creates a batch from a list of transactions and a public key, and signs the resulting batch with the given signing key. Args: pubkey (str): The public key associated with the signing key. signing_key (str): The private key for signing the batch. transactions (list of `Transaction`): The transactions to add to the batch. Returns: `Batch`: The constructed and signed batch. """ txn_ids = [txn.header_signature for txn in transactions] batch_header = BatchHeader(signer_pubkey=pubkey, transaction_ids=txn_ids).SerializeToString() return Batch(header=batch_header, header_signature=signing.sign(batch_header, signing_key), transactions=transactions)
def _make_txn(pubkey, signing_key, setting_key, payload): """Creates and signs a sawtooth_config transaction with with a payload. """ serialized_payload = payload.SerializeToString() header = TransactionHeader( signer_pubkey=pubkey, family_name='sawtooth_config', family_version='1.0', inputs=_config_inputs(setting_key), outputs=_config_outputs(setting_key), dependencies=[], payload_encoding='application/protobuf', payload_sha512=hashlib.sha512(serialized_payload).hexdigest(), batcher_pubkey=pubkey).SerializeToString() signature = signing.sign(header, signing_key) return Transaction(header=header, header_signature=signature, payload=serialized_payload)
def create_jvm_sc_transaction(verb, private_key, public_key, bytecode=None, methods=None, byte_addr=None, method=None, parameters=None, addresses=None): payload = JVM_SC_Payload(verb=verb, bytecode=bytecode, methods=methods, byte_addr=byte_addr, method=method, parameters=parameters) if addresses is None: addresses = [] # The prefix should eventually be looked up from the # validator's namespace registry. if byte_addr is not None: addr = byte_addr elif bytecode is not None: addr = get_address('jvm_sc', bytecode) else: raise Exception addresses.append(addr) header = transaction_pb2.TransactionHeader( signer=public_key, family_name='jvm_sc', family_version='1.0', inputs=addresses, outputs=addresses, dependencies=[], payload_encoding="application/protobuf", payload_sha512=payload.sha512(), batcher=public_key) header_bytes = header.SerializeToString() signature = signing.sign(header_bytes, private_key) transaction = transaction_pb2.Transaction( header=header_bytes, payload=payload.payload_bytes, signature=signature) return transaction
def _create_blocks(self, block_count, batch_count, missing_predecessor=False, missing_batch=False, find_batch=True): block_list = [] pred = 0 for i in range(0, block_count): batch_list = self._create_batches(batch_count, 2) batch_ids = [batch.header_signature for batch in batch_list] if missing_predecessor: predecessor = "Missing" else: predecessor = (block_list[i - 1].header_signature if i > 0 else NULL_BLOCK_IDENTIFIER) block_header = BlockHeader(signer_pubkey=self.public_key, batch_ids=batch_ids, block_num=i, previous_block_id=predecessor) header_bytes = block_header.SerializeToString() signature = signing.sign(header_bytes, self.private_key) if missing_batch: if find_batch: self.completer.add_batch(batch_list[-1]) batch_list = batch_list[:-1] block = Block(header=header_bytes, batches=batch_list, header_signature=signature) block_list.append(block) return block_list
def send_envelope_transaction_request(self,artifact_id,short_id="",artifact_name="",artifact_type="",artifact_checksum="",path="",uri="",label="",openchain="", action="", sub_artifact_id="", auth_user=None, auth_password=None): # Serialization is just a delimited utf-8 encoded string payload = ",".join([artifact_id,str(short_id),str(artifact_name),str(artifact_type),str(artifact_checksum),str(path),str(uri),str(label),str(openchain), action,str(sub_artifact_id)]).encode() # Construct the address address = self._get_address(artifact_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="envelope", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode() ).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction( header=header, payload=payload, header_signature=signature ) batch_list = self._create_batch_list([transaction]) batch_id = batch_list.batches[0].header_signature result = self._send_request( "batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password ) return result
def send_user_transactions(self, user_public_key, user_name, email_address, authorized, role, action, adprivatekey, adpublickey): self._public_key = adpublickey self._private_key = adprivatekey payload = ",".join([ user_public_key, user_name, email_address, authorized, role, action ]).encode() # Form the address address = self._get_address(user_public_key) header = TransactionHeader( signer_pubkey=self._public_key, family_name="user", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) return self._send_request( "batches", batch_list.SerializeToString(), 'application/octet-stream', )
def test_deserialized_wait_timer(self): wait_timer = \ EnclaveWaitTimer( validator_address='1600 Pennsylvania Avenue NW', duration=3.14159, previous_certificate_id='Bond. James Bond.', local_mean=2.71828) serialized = wait_timer.serialize() signing_key = self._create_random_key() wait_timer.signature = \ signing.sign(serialized, signing_key) copy_wait_timer = \ EnclaveWaitTimer.wait_timer_from_serialized( serialized, wait_timer.signature) self.assertEqual( wait_timer.validator_address, copy_wait_timer.validator_address) self.assertAlmostEqual( wait_timer.request_time, copy_wait_timer.request_time) self.assertAlmostEqual( wait_timer.duration, copy_wait_timer.duration) self.assertEqual( wait_timer.previous_certificate_id, copy_wait_timer.previous_certificate_id) self.assertAlmostEqual( wait_timer.local_mean, copy_wait_timer.local_mean) self.assertEqual( wait_timer.signature, copy_wait_timer.signature) self.assertEqual(serialized, copy_wait_timer.serialize())
def create_part_transaction(self, pt_id,pt_name="",checksum="",version="",src_uri="",licensing="",label="",description="", action="", envelope_id="",category_id="",supplier_id="", auth_user=None, auth_password=None): payload = ",".join([pt_id,str(pt_name),str(checksum),str(version),str(src_uri),str(licensing),str(label),str(description), action,str(envelope_id),str(category_id),str(supplier_id)]).encode() # Construct the address address = self._get_address(pt_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="pt", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode() ).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction( header=header, payload=payload, header_signature=signature ) batch_list = self._create_batch_list([transaction]) batch_id = batch_list.batches[0].header_signature return self._send_request( "batches", batch_list.SerializeToString(), 'application/octet-stream', auth_user=auth_user, auth_password=auth_password )
def _create_batches(self, batch_count, txn_count, missing_dep=False): batch_list = [] for i in range(batch_count): txn_list = self._create_transactions(txn_count, missing_dep=missing_dep) txn_sig_list = [txn.header_signature for txn in txn_list] batch_header = BatchHeader(signer_pubkey=self.public_key) batch_header.transaction_ids.extend(txn_sig_list) header_bytes = batch_header.SerializeToString() signature = signing.sign(header_bytes, self.private_key) batch = Batch(header=header_bytes, transactions=txn_list, header_signature=signature) batch_list.append(batch) return batch_list
def create_transaction(name, private_key, public_key): payload = name addr = '000000' + hashlib.sha512(name.encode()).hexdigest() header = transaction_pb2.TransactionHeader( signer_pubkey=public_key, family_name='scheduler_test', family_version='1.0', inputs=[addr], outputs=[addr], dependencies=[], payload_encoding="application/cbor", payload_sha512=hashlib.sha512(payload.encode()).hexdigest(), batcher_pubkey=public_key) header_bytes = header.SerializeToString() signature = signing.sign(header_bytes, private_key) transaction = transaction_pb2.Transaction(header=header_bytes, payload=payload.encode(), header_signature=signature) return transaction
def _sign(content, private): return signing.sign(content, private)
def artifact_transaction(self, private_key, public_key, artifact_id, alias="", artifact_name="", artifact_type="", artifact_checksum="", label="", openchain="", timestamp="", action="", sub_artifact_id="", version="", checksum="", content_type="", size="", uri_type="", location="", path=""): self._public_key = public_key self._private_key = private_key payload = ",".join([ artifact_id, str(alias), str(artifact_name), str(artifact_type), str(artifact_checksum), str(label), str(openchain), str(timestamp), action, str(sub_artifact_id), str(version), str(checksum), str(content_type), size, str(uri_type), str(location), str(path) ]).encode() address = self._get_address(artifact_id) header = TransactionHeader( signer_pubkey=self._public_key, family_name="artifact", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode()).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction(header=header, payload=payload, header_signature=signature) batch_list = self._create_batch_list([transaction]) return self._send_request("batches", batch_list.SerializeToString(), 'application/octet-stream')
def _send_xo_txn(self, name, action, space="", wait=None, auth_user=None, auth_password=None): # Serialization is just a delimited utf-8 encoded string payload = ",".join([name, action, str(space)]).encode() # Construct the address address = self._get_address(name) header = TransactionHeader( signer_pubkey=self._public_key, family_name="xo", family_version="1.0", inputs=[address], outputs=[address], dependencies=[], payload_encoding="csv-utf8", payload_sha512=_sha512(payload), batcher_pubkey=self._public_key, nonce=time.time().hex().encode() ).SerializeToString() signature = signing.sign(header, self._private_key) transaction = Transaction( header=header, payload=payload, header_signature=signature ) batch_list = self._create_batch_list([transaction]) 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 get_signature(message, private_key, privkey_format='wif'): signature = signing.sign(message, private_key, privkey_format) return signature