def _make_batch(payload_bytes,
inputs,
outputs,
transaction_signer,
batch_signer):
transaction_header = transaction_pb2.TransactionHeader(
family_name=addresser.FAMILY_NAME,
family_version=addresser.FAMILY_VERSION,
inputs=inputs,
outputs=outputs,
signer_public_key=transaction_signer.get_public_key().as_hex(),
batcher_public_key=batch_signer.get_public_key().as_hex(),
dependencies=[],
payload_sha512=hashlib.sha512(payload_bytes).hexdigest())
transaction_header_bytes = transaction_header.SerializeToString()
transaction = transaction_pb2.Transaction(
header=transaction_header_bytes,
header_signature=transaction_signer.sign(transaction_header_bytes),
payload=payload_bytes)
batch_header = batch_pb2.BatchHeader(
signer_public_key=batch_signer.get_public_key().as_hex(),
transaction_ids=[transaction.header_signature])
batch_header_bytes = batch_header.SerializeToString()
batch = batch_pb2.Batch(
header=batch_header_bytes,
header_signature=batch_signer.sign(batch_header_bytes),
transactions=[transaction])
return batch
def make_header_and_batch(payload, inputs, outputs, txn_key, batch_key):
payload_sha512 = hashlib.sha512(payload.SerializeToString()).hexdigest()
header = transaction_pb2.TransactionHeader(
inputs=inputs,
outputs=outputs,
batcher_public_key=batch_key.get_public_key().as_hex(),
dependencies=[],
family_name=addresshandler.FAMILY_NAME,
family_version='1.0',
nonce=uuid4().hex,
signer_public_key=txn_key.get_public_key().as_hex(),
payload_sha512=payload_sha512)
transaction = transaction_pb2.Transaction(
payload=payload.SerializeToString(),
header=header.SerializeToString(),
header_signature=txn_key.sign(header.SerializeToString()))
batch_header = batch_pb2.BatchHeader(
signer_public_key=batch_key.get_public_key().as_hex(),
transaction_ids=[transaction.header_signature]).SerializeToString()
batch = batch_pb2.Batch(
header=batch_header,
header_signature=batch_key.sign(batch_header),
transactions=[transaction])
return [batch], batch.header_signature
def make_header(inputs, outputs, payload_sha512, signer_pubkey,
batcher_pubkey):
header = transaction_pb2.TransactionHeader(
inputs=inputs,
outputs=outputs,
batcher_public_key=batcher_pubkey,
dependencies=[],
family_name=addresser.FAMILY_NAME,
family_version=addresser.FAMILY_VERSION,
nonce=uuid4().hex,
signer_public_key=signer_pubkey,
payload_sha512=payload_sha512)
return header
def make_header(inputs, outputs, payload_sha512, signer_pubkey,
batcher_pubkey):
header = transaction_pb2.TransactionHeader(
inputs=inputs,
outputs=outputs,
batcher_public_key=batcher_pubkey,
dependencies=[],
family_name='rbac',
family_version='1.0',
nonce=uuid4().hex,
signer_public_key=signer_pubkey,
payload_sha512=payload_sha512)
return header
def create_user_transaction(self, name, username, metadata):
txn_private_key = Secp256k1PrivateKey.new_random()
batch_private_key = Secp256k1PrivateKey.new_random()
txn_key = Key(txn_private_key.as_hex())
batch_key = Key(batch_private_key.as_hex())
batchlist, sig = create_user(
txn_key, batch_key, name, username, txn_key.public_key, metadata
)
self.assertEqual(type(sig), str)
self.assertEqual(type(batchlist), batch_pb2.BatchList)
self.assertEqual(len(sig), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(sig))
batch_count = 0
for batch in batchlist.batches:
batch_count += 1
self.assertEqual(type(batch), batch_pb2.Batch)
self.assertEqual(type(batch.header_signature), str)
self.assertEqual(len(batch.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(batch.header_signature))
trans_count = 0
for transaction in batch.transactions:
trans_count += 1
self.assertEqual(type(transaction.header), bytes)
self.assertEqual(type(transaction.header_signature), str)
self.assertEqual(type(transaction.payload), bytes)
self.assertEqual(len(transaction.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(transaction.header_signature))
header = transaction_pb2.TransactionHeader()
header.ParseFromString(transaction.header)
self.assertEqual(type(header), transaction_pb2.TransactionHeader)
self.assertEqual(header.family_name, addresser.FAMILY_NAME)
self.assertEqual(header.family_version, addresser.FAMILY_VERSION)
self.assertEqual(header.batcher_public_key, batch_key.public_key)
self.assertEqual(header.signer_public_key, txn_key.public_key)
self.assertEqual(len(header.payload_sha512), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(header.payload_sha512))
input_count = 0
for address in header.inputs:
input_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertTrue(addresser.is_address(address))
self.assertTrue(addresser.namespace_ok(address))
self.assertTrue(addresser.is_family_address(address))
self.assertEqual(addresser.address_is(address), AddressSpace.USER)
self.assertEqual(input_count, 1)
output_count = 0
for address in header.outputs:
output_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertTrue(addresser.is_address(address))
self.assertTrue(addresser.namespace_ok(address))
self.assertTrue(addresser.is_family_address(address))
self.assertEqual(addresser.address_is(address), AddressSpace.USER)
self.assertEqual(output_count, 1)
payload = rbac_payload_pb2.RBACPayload()
payload.ParseFromString(transaction.payload)
self.assertEqual(type(payload), rbac_payload_pb2.RBACPayload)
self.assertEqual(
payload.message_type, rbac_payload_pb2.RBACPayload.CREATE_USER
)
self.assertEqual(type(payload.content), bytes)
user = user_transaction_pb2.CreateUser()
user.ParseFromString(payload.content)
self.assertEqual(type(user), user_transaction_pb2.CreateUser)
self.assertEqual(user.name, name)
self.assertEqual(user.user_name, username)
self.assertEqual(type(user.user_id), str)
self.assertEqual(user.user_id, txn_key.public_key)
self.assertEqual(trans_count, 1)
self.assertEqual(batch_count, 1)