def wrap_and_send(self, data_dict):
payload = json.dumps(data_dict).encode()
address = self._address
inputAddressList = [address]
outputAddresslist = [address]
relate_address = data_dict.get('address', [])
for re_address in relate_address:
# if relate_address:
inputAddressList.append(wrap_address(re_address))
outputAddresslist.append(wrap_address(re_address))
header = TransactionHeader(
signer_public_key=self._public_key,
family_name=FAMILY_NAME,
family_version='1.0',
inputs=inputAddressList,
outputs=outputAddresslist,
dependencies=[],
payload_sha512=_hash(payload.decode()),
batcher_public_key=self._public_key,
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._public_key,
transaction_ids=[txn.header_signature for txn in transactionList]
).SerializeToString()
batch = Batch(
header=header,
transactions=transactionList,
header_signature=self._signer.sign(header)
)
batch_list_serialize = BatchList(batches=[batch]).SerializeToString()
return self._send_to_restapi('batches', batch_list_serialize,
'application/octet-stream')
def _send_transaction(self, action, action_payload, addresses, wait=None):
payload = cbor.dumps({'action': action, 'payload': action_payload})
header = TransactionHeader(
signer_public_key=self._signer.get_public_key().as_hex(),
family_name="billing-crdt",
family_version="0.0.1",
inputs=addresses,
outputs=addresses,
dependencies=[],
payload_sha512=self._sha512(payload),
batcher_public_key=self._signer.get_public_key().as_hex(),
nonce=self._nonce()).SerializeToString()
signature = self._signer.sign(header)
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',
)
while wait_time < wait:
status = self._get_status(
batch_id,
wait - int(wait_time),
)
wait_time = time.time() - start_time
if status != 'PENDING':
return response
return response
return self._send_request(
"batches",
batch_list.SerializeToString(),
'application/octet-stream',
)
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 _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 _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 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 send_category_transactions(self, category_id, category_name,
description, action, private_key,
public_key, prev, cur, timestamp):
self._public_key = public_key
self._private_key = private_key
payload = {
"category_id": str(category_id),
"category_name": str(category_name),
"description": str(description),
"action": str(action),
"prev_block": str(prev),
"cur_block": str(cur),
"timestamp": str(timestamp)
}
payload = json.dumps(payload).encode()
# Form the address
address = self._get_address(category_id)
header = TransactionHeader(
signer_public_key=self._public_key,
family_name="category",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
payload_sha512=_sha512(payload),
batcher_public_key=self._public_key,
nonce=time.time().hex().encode()).SerializeToString()
signature = CryptoFactory(create_context("secp256k1")) \
.new_signer(Secp256k1PrivateKey.from_hex(self._private_key))\
.sign(header)
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 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 _send_wal_txn(self, name, action, pubkey, wait=None):
payload = ",".join([name, action, pubkey]).encode()
address = self._get_address(name)
sec_address = self._get_address(pubkey)
header = TransactionHeader(
signer_public_key=self._signer.get_public_key().as_hex(),
family_name="wal",
family_version="1.0",
inputs=[address, sec_address],
outputs=[address, sec_address],
dependencies=[],
payload_sha512=_sha512(payload),
batcher_public_key=self._signer.get_public_key().as_hex(),
nonce=time.time().hex().encode()).SerializeToString()
signature = self._signer.sign(header)
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')
while wait_time < wait:
status = self._get_status(batch_id, wait - int(wait_time))
wait_time = time.time() - start_time
if status != 'PENDING':
return response
return response
return self._send_request("batches", batch_list.SerializeToString(),
'application/octet-stream')
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_public_key=self._public_key,
family_name="user",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
# payload_encoding="csv-utf8",
payload_sha512=_sha512(payload),
batcher_public_key=self._public_key,
nonce=time.time().hex().encode()).SerializeToString()
# signature = signing.sign(header, self._private_key)
signature = CryptoFactory(create_context('secp256k1')) \
.new_signer(Secp256k1PrivateKey.from_hex(self._private_key)).sign(header)
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 create_transaction(ingest):
"""Creates and signs a hashblock transaction with a payload."""
signatore, address, permissions, payload = ingest
serialized_payload = payload.SerializeToString()
submitter = valid_submitter(signatore)
signer = valid_signer(signatore)
header = TransactionHeader(
nonce=str(datetime.datetime.utcnow().timestamp()),
signer_public_key=signer,
family_name=address.family_ns_name,
family_version=address.family_current_version,
inputs=permissions.get('inputs', []),
outputs=permissions.get('outputs', []),
dependencies=permissions.get('dependencies', []),
payload_sha512=hashlib.sha512(serialized_payload).hexdigest(),
batcher_public_key=signer).SerializeToString()
return (signatore,
Transaction(header=header,
header_signature=submitter.sign(header),
payload=serialized_payload))
def make_batch_list(self, payload_pb, addresses_input, addresses_output):
payload = payload_pb.SerializeToString()
signer = self._signer
header = TransactionHeader(
signer_public_key=signer.get_public_key().as_hex(),
family_name=self._family_handler.family_name,
family_version=self._family_handler.family_versions[-1],
inputs=addresses_input,
outputs=addresses_output,
dependencies=[],
payload_sha512=hash512(payload),
batcher_public_key=signer.get_public_key().as_hex(),
nonce=time.time().hex().encode()).SerializeToString()
signature = signer.sign(header)
transaction = Transaction(header=header,
payload=payload,
header_signature=signature)
return self._sign_batch_list(signer, [transaction])
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 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_public_key=self._public_key,
family_name="artifact",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
# payload_encoding="csv-utf8",
payload_sha512=_sha512(payload),
batcher_public_key=self._public_key,
nonce=time.time().hex().encode()
).SerializeToString()
# signature = signing.sign(header, self._private_key)
signature = CryptoFactory(create_context('secp256k1')) \
.new_signer(Secp256k1PrivateKey.from_hex(self._private_key)).sign(header)
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 _build_transaction(self, action, entry):
payload = build_payload(action, entry)
address = make_ccellular_address(entry.key())
header = TransactionHeader(
signer_public_key=self._signer.get_public_key().as_hex(),
family_name=self.conf.FAMILY_NAME,
family_version=self.conf.FAMILY_VERSION,
inputs=[address],
outputs=[address],
dependencies=[],
payload_sha512=_sha512(payload),
batcher_public_key=self._signer.get_public_key().as_hex(),
nonce=hex(random.randint(0, 2**64))).SerializeToString()
signature = self._signer.sign(header)
transaction = Transaction(header=header,
payload=payload,
header_signature=signature)
self.pending_transactions.append(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._signer.get_public_key().as_hex(),
family_name="supplier",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
payload_encoding="csv-utf8",
payload_sha512=_sha512(payload),
batcher_pubkey=self._signer.get_public_key().as_hex(),
nonce=time.time().hex().encode()
).SerializeToString()
signature = self._signer.sign(header)
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_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 _transaction_header(self, txn_key, inputs, outputs, payload):
txn_header_bytes = TransactionHeader(
family_name=helper.TP_FAMILYNAME,
family_version=helper.TP_VERSION,
inputs=inputs,
outputs=outputs,
signer_public_key=txn_key, # signer.get_public_key().as_hex(),
# In this example, we're signing the batch with the same private key,
# but the batch can be signed by another party, in which case, the
# public key will need to be associated with that key.
batcher_public_key=txn_key, # signer.get_public_key().as_hex(),
# In this example, there are no dependencies. This list should include
# an previous transaction header signatures that must be applied for
# this transaction to successfully commit.
# For example,
# dependencies=['540a6803971d1880ec73a96cb97815a95d374cbad5d865925e5aa0432fcf1931539afe10310c122c5eaae15df61236079abbf4f258889359c4d175516934484a'],
dependencies=[],
nonce=random.random().hex().encode(),
payload_sha512=hashlib.sha512(payload.SerializeToString()).hexdigest()
).SerializeToString()
signature = self._signer.sign(txn_header_bytes)
return txn_header_bytes, signature
def _create_transaction_header(self, payload, inputs, outputs, deps,
set_nonce=True, batcher_pub_key=None):
if set_nonce:
nonce = str(time.time())
else:
nonce = ""
txn_pub_key = self._signer.get_public_key().as_hex()
if batcher_pub_key is None:
batcher_pub_key = txn_pub_key
header = TransactionHeader(
signer_public_key=txn_pub_key,
family_name=self.family_name,
family_version=self.family_version,
inputs=inputs,
outputs=outputs,
dependencies=deps,
payload_sha512=self.sha512(payload),
batcher_public_key=batcher_pub_key,
nonce=nonce
)
return header
def create_transaction(self, payload, family_name, family_version,
address):
payload_bytes = cbor2.dumps(payload)
txn_header = TransactionHeader(
batcher_public_key=self.signer.get_public_key().as_hex(),
inputs=[address],
outputs=[address],
dependencies=[],
family_name=family_name,
family_version=family_version,
nonce=hex(randint(0, 2**64)),
payload_sha512=sha512(payload_bytes).hexdigest(),
signer_public_key=self.signer.get_public_key().as_hex(),
).SerializeToString()
txn = Transaction(
header=txn_header,
header_signature=self.signer.sign(txn_header),
payload=payload_bytes,
)
return [txn]
def _create_transaction(self,payload,inputs,outputs,dependencies=[]):
"""
make transaction
"""
LOGGER.debug('BgxRouteHandler: _create_transaction make Transaction')
txn_header = TransactionHeader(
signer_public_key=self._signer.get_public_key().as_hex(),
family_name=SMART_BGX_FAMILY,
family_version=SMART_BGX_VER,
inputs=inputs,
outputs=outputs,
dependencies=dependencies,
payload_sha512=_sha512(payload),
batcher_public_key=self._signer.get_public_key().as_hex(),
nonce=hex(random.randint(0, 2**64))
).SerializeToString()
signature = self._signer.sign(txn_header)
transaction = Transaction(
header=txn_header,
payload=payload,
header_signature=signature
)
return transaction
#encode payload
#simple payload, name and owner
payload = {'action': 'create', 'asset': 'test', 'owner': 'test1'}
payload_bytes = cbor.dumps(payload)
#create transaction headers
txn_header_bytes = TransactionHeader(
family_name='code-smell',
family_version='0.1',
inputs=['19d832'],
outputs=['19d832'],
signer_public_key=signer.get_public_key().as_hex(),
# In this example, we're signing the batch with the same private key,
# but the batch can be signed by another party, in which case, the
# public key will need to be associated with that key.
batcher_public_key=signer.get_public_key().as_hex(),
# In this example, there are no dependencies. This list should include
# an previous transaction header signatures that must be applied for
# this transaction to successfully commit.
# For example,
# dependencies=['540a6803971d1880ec73a96cb97815a95d374cbad5d865925e5aa0432fcf1931539afe10310c122c5eaae15df61236079abbf4f258889359c4d175516934484a'],
dependencies=[],
payload_sha512=sha512(payload_bytes).hexdigest()).SerializeToString()
#create transaction
signature = signer.sign(txn_header_bytes)
txn = Transaction(header=txn_header_bytes,
header_signature=signature,
payload=payload_bytes)
def _process(self, msg):
if msg.message_type != Message.TP_PROCESS_REQUEST:
LOGGER.debug(
"Transaction Processor recieved invalid message type. "
"Message type should be TP_PROCESS_REQUEST,"
" but is %s", Message.MessageType.Name(msg.message_type))
return
request = TpProcessRequest()
request.ParseFromString(msg.content)
state = State(self._stream, request.context_id)
header = TransactionHeader()
header.ParseFromString(request.header)
try:
if not self._stream.is_ready():
raise ValidatorConnectionError()
handler = self._find_handler(header)
if handler is None:
return
handler.apply(request, state)
self._stream.send_back(
message_type=Message.TP_PROCESS_RESPONSE,
correlation_id=msg.correlation_id,
content=TpProcessResponse(
status=TpProcessResponse.OK).SerializeToString())
except InvalidTransaction as it:
LOGGER.warning("Invalid Transaction %s", it)
try:
self._stream.send_back(
message_type=Message.TP_PROCESS_RESPONSE,
correlation_id=msg.correlation_id,
content=TpProcessResponse(
status=TpProcessResponse.INVALID_TRANSACTION,
message=str(it),
extended_data=it.extended_data).SerializeToString())
except ValidatorConnectionError as vce:
# TP_PROCESS_REQUEST has made it through the
# handler.apply and an INVALID_TRANSACTION would have been
# sent back but the validator has disconnected and so it
# doesn't care about the response.
LOGGER.warning("during invalid transaction response: %s", vce)
except InternalError as ie:
LOGGER.warning("internal error: %s", ie)
try:
self._stream.send_back(
message_type=Message.TP_PROCESS_RESPONSE,
correlation_id=msg.correlation_id,
content=TpProcessResponse(
status=TpProcessResponse.INTERNAL_ERROR,
message=str(ie),
extended_data=ie.extended_data).SerializeToString())
except ValidatorConnectionError as vce:
# Same as the prior except block, but an internal error has
# happened, but because of the disconnect the validator
# probably doesn't care about the response.
LOGGER.warning("during internal error response: %s", vce)
except ValidatorConnectionError as vce:
# Somewhere within handler.apply a future resolved with an
# error status that the validator has disconnected. There is
# nothing left to do but reconnect.
LOGGER.warning(
"during handler.apply a future was resolved "
"with error status: %s", vce)
def create_transaction(self, signer, payload_bytes):
txn_header_bytes = TransactionHeader(
family_name='lace',
family_version='0.1',
inputs=[addressing.NAMESPACE],
outputs=[addressing.NAMESPACE],
signer_public_key = signer.pubkey.serialize().hex(),
# In this example, we're signing the batch with the same private key,
# but the batch can be signed by another party, in which case, the
# public key will need to be associated with that key.
batcher_public_key = signer.pubkey.serialize().hex(),
# In this example, there are no dependencies. This list should include
# an previous transaction header signatures that must be applied for
# this transaction to successfully commit.
# For example,
# dependencies=['540a6803971d1880ec73a96cb97815a95d374cbad5d865925e5aa0432fcf1931539afe10310c122c5eaae15df61236079abbf4f258889359c4d175516934484a'],
dependencies=[],
payload_sha512=sha512(payload_bytes).hexdigest()
).SerializeToString()
# Ecdsa signing standard, then remove extra ecdsa bytes using compact.
txn_signature = signer.ecdsa_sign(txn_header_bytes)
txn_signature_bytes = signer.ecdsa_serialize_compact(txn_signature)
signature = txn_signature_bytes.hex()
print("txn_signature" + str(signature))
txn = Transaction(
header=txn_header_bytes,
header_signature=signature,
payload=payload_bytes
)
txns = [txn]
for txn in txns:
print(txn)
print("signer.pubkey " + str(signer.pubkey.serialize().hex()))
batch_header_bytes = BatchHeader(
signer_public_key = signer.pubkey.serialize().hex(),
transaction_ids=[txn.header_signature for txn in txns],
).SerializeToString()
batch_signature = signer.ecdsa_sign(batch_header_bytes)
batch_signature_bytes = signer.ecdsa_serialize_compact(batch_signature)
signature = batch_signature_bytes.hex()
print("batch signature: " + str(batch_signature))
batch = Batch(
header=batch_header_bytes,
header_signature=signature,
transactions=txns
)
batch_list_bytes = BatchList(batches=[batch]).SerializeToString()
print("batches:\n", batch_list_bytes)
# ship it out and scrape
url = "http://localhost:8008/batches"
headers = { 'Content-Type' : 'application/octet-stream' }
payload = batch_list_bytes
resp = requests.post(url, data=payload, headers=headers)
time.sleep(2) # let the transactions be committed.
json_url = json.loads(resp.text)
# print("Batch status link: \n\n" + json_url["link"] + "\n")
resp = requests.get(json_url["link"])
json_batch_status = json.loads(resp.text)
print("Batch status: " + json_batch_status["data"][0]["status"])
def test_expire_atomic_swap_before_invalid_withdrawal_by_bot():
"""
Case: to expire atomic swap by bot if 48 hasn't been passed from atomic swap initialization timestamp.
Expect: invalid transaction error is raised with signer is not the one who opened the swap. error message.
"""
atomic_swap_close_payload = AtomicSwapExpirePayload(swap_id=SWAP_ID, )
transaction_payload = TransactionPayload()
transaction_payload.method = AtomicSwapMethod.EXPIRE
transaction_payload.data = atomic_swap_close_payload.SerializeToString()
serialized_transaction_payload = transaction_payload.SerializeToString()
transaction_header = TransactionHeader(
signer_public_key=BOT_PUBLIC_KEY,
family_name=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get(
'family_name'),
family_version=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get(
'family_version'),
inputs=INPUTS,
outputs=OUTPUTS,
dependencies=[],
payload_sha512=hash512(data=serialized_transaction_payload),
batcher_public_key=RANDOM_NODE_PUBLIC_KEY,
nonce=time.time().hex().encode(),
)
serialized_header = transaction_header.SerializeToString()
transaction_request = TpProcessRequest(
header=transaction_header,
payload=serialized_transaction_payload,
signature=create_signer(
private_key=BOT_PRIVATE_KEY).sign(serialized_header),
)
existing_swap_info_to_expire = AtomicSwapInfo()
existing_swap_info_to_expire.swap_id = SWAP_ID
existing_swap_info_to_expire.state = AtomicSwapInfo.OPENED
existing_swap_info_to_expire.sender_address = BOT_ADDRESS
existing_swap_info_to_expire.created_at = CURRENT_TIMESTAMP
existing_swap_info_to_expire.is_initiator = True
serialized_existing_swap_info_to_expire = existing_swap_info_to_expire.SerializeToString(
)
mock_context = StubContext(inputs=INPUTS,
outputs=OUTPUTS,
initial_state={
ADDRESS_TO_STORE_SWAP_INFO_BY:
serialized_existing_swap_info_to_expire,
BLOCK_INFO_CONFIG_ADDRESS:
SERIALIZED_BLOCK_INFO_CONFIG,
BLOCK_INFO_ADDRESS: SERIALIZED_BLOCK_INFO,
})
with pytest.raises(InvalidTransaction) as error:
AtomicSwapHandler().apply(transaction=transaction_request,
context=mock_context)
assert f'Swap initiator needs to wait 24 hours since timestamp {CURRENT_TIMESTAMP} to withdraw.' == \
str(error.value)
def test_expire_atomic_swap():
"""
Case: to expire atomic swap.
Expect: increase bot address balance by swap amount. Leave commission on zero address.
"""
atomic_swap_expire_payload = AtomicSwapExpirePayload(swap_id=SWAP_ID, )
transaction_payload = TransactionPayload()
transaction_payload.method = AtomicSwapMethod.EXPIRE
transaction_payload.data = atomic_swap_expire_payload.SerializeToString()
serialized_transaction_payload = transaction_payload.SerializeToString()
transaction_header = TransactionHeader(
signer_public_key=BOT_PUBLIC_KEY,
family_name=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get(
'family_name'),
family_version=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get(
'family_version'),
inputs=INPUTS,
outputs=OUTPUTS,
dependencies=[],
payload_sha512=hash512(data=serialized_transaction_payload),
batcher_public_key=RANDOM_NODE_PUBLIC_KEY,
nonce=time.time().hex().encode(),
)
serialized_header = transaction_header.SerializeToString()
transaction_request = TpProcessRequest(
header=transaction_header,
payload=serialized_transaction_payload,
signature=create_signer(
private_key=BOT_PRIVATE_KEY).sign(serialized_header),
)
bot_account = Account()
bot_account.balance = 4700
serialized_bot_account = bot_account.SerializeToString()
genesis_members_setting = Setting()
genesis_members_setting.entries.add(key=SETTINGS_KEY_ZERO_ADDRESS_OWNERS,
value=f'{BOT_PUBLIC_KEY},')
serialized_genesis_members_setting = genesis_members_setting.SerializeToString(
)
existing_swap_info = AtomicSwapInfo()
existing_swap_info.swap_id = SWAP_ID
existing_swap_info.state = AtomicSwapInfo.OPENED
existing_swap_info.amount = TOKENS_AMOUNT_TO_SWAP
existing_swap_info.created_at = CURRENT_TIMESTAMP // 2
existing_swap_info.sender_address = BOT_ADDRESS
existing_swap_info.receiver_address = ALICE_ADDRESS
existing_swap_info.is_initiator = True
serialized_existing_swap_info = existing_swap_info.SerializeToString()
mock_context = StubContext(inputs=INPUTS,
outputs=OUTPUTS,
initial_state={
BLOCK_INFO_CONFIG_ADDRESS:
SERIALIZED_BLOCK_INFO_CONFIG,
BLOCK_INFO_ADDRESS:
SERIALIZED_BLOCK_INFO,
BOT_ADDRESS:
serialized_bot_account,
ADDRESS_TO_STORE_SWAP_INFO_BY:
serialized_existing_swap_info,
ADDRESS_TO_GET_GENESIS_MEMBERS_AS_STRING_BY:
serialized_genesis_members_setting,
})
expected_bot_account = Account()
expected_bot_account.balance = 4700 + TOKENS_AMOUNT_TO_SWAP
serialized_expected_bot_account = expected_bot_account.SerializeToString()
expected_swap_info = AtomicSwapInfo()
expected_swap_info.swap_id = SWAP_ID
expected_swap_info.state = AtomicSwapInfo.EXPIRED
expected_swap_info.amount = TOKENS_AMOUNT_TO_SWAP
expected_swap_info.created_at = CURRENT_TIMESTAMP // 2
expected_swap_info.sender_address = BOT_ADDRESS
expected_swap_info.receiver_address = ALICE_ADDRESS
expected_swap_info.is_initiator = True
serialized_expected_swap_info = expected_swap_info.SerializeToString()
expected_state = {
BOT_ADDRESS: serialized_expected_bot_account,
ADDRESS_TO_STORE_SWAP_INFO_BY: serialized_expected_swap_info,
}
AtomicSwapHandler().apply(transaction=transaction_request,
context=mock_context)
state_as_list = mock_context.get_state(addresses=[
ADDRESS_TO_STORE_SWAP_INFO_BY,
BOT_ADDRESS,
])
state_as_dict = {entry.address: entry.data for entry in state_as_list}
assert expected_state == state_as_dict
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 _send_xo_txn(self,
name,
address,
payload_object,
action,
wait=None,
auth_user=None,
auth_password=None):
if payload_object is None:
payload_object = name
json_payload = json.dumps({'action': action, 'payload': payload_object})
payload = json_payload.encode()
header = TransactionHeader(
signer_public_key=self._signer.get_public_key().as_hex(),
family_name="hdfssb",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
payload_sha512=_sha512(payload),
batcher_public_key=self._signer.get_public_key().as_hex(),
nonce=hex(random.randint(0, 2 ** 64))
).SerializeToString()
signature = self._signer.sign(header)
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 create_part_transaction(self, pt_id, pt_name, checksum, version, alias,
licensing, label, description, action,
private_key, public_key, artifact_id,
category_id, organization_id, prev, cur,
timestamp):
"""
Constructs the Batch to be posted and sent the request to be posted on
the ledger.
Args:
pt_id (str): The uuid of the part
pt_name (str): The name of the part
checksum (str): The checksum of the part
version (str): The version of the part
alias (str): The alias of the part
licensing (str): The licensing of the part
label (str): The label of the part
description (str): The description of the part
private_key (str): The private key of the user
public_key (str): The public key of the user
artifact_id (list of str):
The list of the artifact uuid associated with the part
category_id (list of str):
The list of the category uuid associated with the part
organization_id (list str):
The list of the organization uuid associated with the part
prev (str): The previous block id of the transaction (default "0")
cur (str): the current block id of the transaction
timestamp (str): The UTC time for when the transaction was submitted
action (str): The action performed
Returns:
type: str
Data associated with suffix as a string.
or
type: None
None object if _send_request failed.
"""
# Constructing Batch to be sent and stored
self._public_key = public_key
self._private_key = private_key
payload = {
"uuid": str(pt_id),
"name": str(pt_name),
"checksum": str(checksum),
"version": str(version),
"alias": str(alias),
"licensing": str(licensing),
"label": str(label),
"description": str(description),
"action": str(action),
"prev_block": str(prev),
"cur_block": str(cur),
"timestamp": str(timestamp),
"artifact_list": artifact_id,
"category_list": category_id,
"organization_list": organization_id
}
payload = json.dumps(payload).encode()
address = self._get_address(pt_id)
header = TransactionHeader(
signer_public_key=self._public_key,
family_name="pt",
family_version="1.0",
inputs=[address],
outputs=[address],
dependencies=[],
payload_sha512=_sha512(payload),
batcher_public_key=self._public_key,
nonce=time.time().hex().encode()).SerializeToString()
signature = CryptoFactory(create_context("secp256k1")) \
.new_signer(Secp256k1PrivateKey.from_hex(self._private_key)) \
.sign(header)
transaction = Transaction(header=header,
payload=payload,
header_signature=signature)
# Creating batch list
batch_list = self._create_batch_list([transaction])
return self._send_request("batches", batch_list.SerializeToString(),
"application/octet-stream")
