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
