class UpdateStateResponse(ContractResponse):
def __init__(self, request, response, **kwargs):
super().__init__(request, response, **kwargs)
self.state_changed = True
self.request_number = request.request_number
self.operation = 'update'
self.signature = response['Signature']
# we have another mismatch between the field names in the enclave
# and the field names expected in the transaction; this needs to
# be fixed at some point
for dependency in response['Dependencies']:
contract_id = dependency['ContractID']
state_hash = dependency['StateHash']
self.dependencies.append({
'contract_id': contract_id,
'state_hash': state_hash
})
# save the information we will need for the transaction
state_hash_b64 = response['StateHash']
self.new_state_hash = crypto.base64_to_byte_array(state_hash_b64)
self.old_state_hash = ContractState.compute_hash(
request.contract_state.raw_state)
message = self.serialize_for_signing()
if not self.verify_enclave_signature(message, request.enclave_keys):
raise Exception('failed to verify enclave signature')
self.raw_state = self.enclave_service.get_block(state_hash_b64)
self.new_state_object = ContractState(self.contract_id, self.raw_state)
self.new_state_object.pull_state_from_eservice(self.enclave_service)
# compute ids of blocks in the change set (used for replication)
self.new_state_object.compute_ids_of_newblocks(
request.contract_state.component_block_ids)
self.replication_params = request.replication_params
# -------------------------------------------------------
def serialize_for_signing(self):
"""serialize the response for enclave signature verification"""
message = super().serialize_for_signing()
message += self.old_state_hash
message += self.new_state_hash
for dependency in self.dependencies:
message += crypto.string_to_byte_array(dependency['contract_id'])
message += crypto.string_to_byte_array(dependency['state_hash'])
return message
class InitializeStateResponse(ContractResponse):
def __init__(self, request, response, **kwargs):
super().__init__(request, response, **kwargs)
self.state_changed = True
self.request_number = request.request_number
self.operation = 'initialize'
self.metadata_hash = crypto.base64_to_byte_array(
response['MetadataHash'])
self.signature = response['Signature']
# save the information we will need for the transaction
state_hash_b64 = response['StateHash']
self.new_state_hash = crypto.base64_to_byte_array(state_hash_b64)
message = self.serialize_for_signing()
if not self.verify_enclave_signature(message, request.enclave_keys):
raise InvocationException('failed to verify enclave signature')
self.raw_state = self.enclave_service.get_block(state_hash_b64)
self.new_state_object = ContractState(self.contract_id, self.raw_state)
self.new_state_object.pull_state_from_eservice(self.enclave_service)
# compute ids of blocks in the change set (used for replication)
self.new_state_object.compute_ids_of_newblocks(
request.contract_state.component_block_ids)
self.replication_params = request.replication_params
# -------------------------------------------------------
def serialize_for_signing(self):
"""serialize the response for enclave signature verification"""
message = super().serialize_for_signing()
message += crypto.string_to_byte_array(self.creator_id)
message += self.metadata_hash
message += self.new_state_hash
return message
class ContractResponse(object) :
"""
Class for managing the contract operation response from an enclave service
"""
# -------------------------------------------------------
def __init__(self, request, response) :
"""
Initialize a contract response object
:param request: the ContractRequest object corresponding to the response
:param response: diction containing the response from the enclave
"""
self.status = response['Status']
self.result = response['Result']
self.state_changed = response['StateChanged']
self.new_state_object = request.contract_state
if self.status and self.state_changed :
self.signature = response['Signature']
state_hash_b64 = response['StateHash']
# we have another mismatch between the field names in the enclave
# and the field names expected in the transaction; this needs to
# be fixed at some point
self.dependencies = []
for dependency in response['Dependencies'] :
contract_id = dependency['ContractID']
state_hash = dependency['StateHash']
self.dependencies.append({'contract_id' : contract_id, 'state_hash' : state_hash})
# save the information we will need for the transaction
self.channel_keys = request.channel_keys
self.contract_id = request.contract_id
self.creator_id = request.creator_id
self.code_hash = request.contract_code.compute_hash()
self.message_hash = request.message.compute_hash()
self.new_state_hash = crypto.base64_to_byte_array(state_hash_b64)
self.originator_keys = request.originator_keys
self.enclave_service = request.enclave_service
self.old_state_hash = ()
if request.operation != 'initialize' :
self.old_state_hash = ContractState.compute_hash(request.contract_state.encrypted_state)
if not self.__verify_enclave_signature(request.enclave_keys) :
raise Exception('failed to verify enclave signature')
self.encrypted_state = self.enclave_service.block_store_get(state_hash_b64)
self.new_state_object = ContractState(self.contract_id, self.encrypted_state)
self.new_state_object.pull_state_from_eservice(self.enclave_service)
# -------------------------------------------------------
def __verify_enclave_signature(self, enclave_keys) :
"""verify the signature of the response
"""
message = self.__serialize_for_signing()
return enclave_keys.verify(message, self.signature, encoding = 'b64')
# -------------------------------------------------------
def __serialize_for_signing(self) :
"""serialize the response for enclave signature verification"""
message = crypto.string_to_byte_array(self.channel_keys.txn_public)
message += crypto.string_to_byte_array(self.contract_id)
message += crypto.string_to_byte_array(self.creator_id)
message += self.code_hash
message += self.message_hash
message += self.new_state_hash
message += self.old_state_hash
for dependency in self.dependencies :
message += crypto.string_to_byte_array(dependency['contract_id'])
message += crypto.string_to_byte_array(dependency['state_hash'])
return message
# -------------------------------------------------------
def submit_initialize_transaction(self, ledger_config, **extra_params) :
"""submit the initialize transaction to the ledger
"""
if self.status is False :
raise Exception('attempt to submit failed initialization transactions')
global transaction_dependencies
# an initialize operation has no previous state
assert not self.old_state_hash
initialize_submitter = Submitter(
ledger_config['LedgerURL'],
key_str = self.channel_keys.txn_private)
b64_message_hash = crypto.byte_array_to_base64(self.message_hash)
b64_new_state_hash = crypto.byte_array_to_base64(self.new_state_hash)
b64_code_hash = crypto.byte_array_to_base64(self.code_hash)
txnid = initialize_submitter.submit_ccl_initialize_from_data(
self.originator_keys.signing_key,
self.originator_keys.verifying_key,
self.channel_keys.txn_public,
self.enclave_service.enclave_id,
self.signature,
self.contract_id,
b64_message_hash,
b64_new_state_hash,
self.encrypted_state,
b64_code_hash,
**extra_params)
if txnid :
transaction_dependencies.SaveDependency(self.contract_id, b64_new_state_hash, txnid)
return txnid
# -------------------------------------------------------
def submit_update_transaction(self, ledger_config, **extra_params):
"""submit the update transaction to the ledger
"""
if self.status is False :
raise Exception('attempt to submit failed update transaction')
global transaction_dependencies
# there must be a previous state hash if this is
# an update
assert self.old_state_hash
update_submitter = Submitter(
ledger_config['LedgerURL'],
key_str = self.channel_keys.txn_private)
b64_message_hash = crypto.byte_array_to_base64(self.message_hash)
b64_new_state_hash = crypto.byte_array_to_base64(self.new_state_hash)
b64_old_state_hash = crypto.byte_array_to_base64(self.old_state_hash)
# convert contract dependencies into transaction dependencies
# to ensure that the sawtooth validator does not attempt to
# re-order the transactions since it is unaware of the semantics
# of the contract dependencies
txn_dependencies = set()
if extra_params.get('transaction_dependency_list') :
txn_dependencies.update(extra_params['transaction_dependency_list'])
txnid = transaction_dependencies.FindDependency(ledger_config, self.contract_id, b64_old_state_hash)
if txnid :
txn_dependencies.add(txnid)
for dependency in self.dependencies :
contract_id = dependency['contract_id']
state_hash = dependency['state_hash']
txnid = transaction_dependencies.FindDependency(ledger_config, contract_id, state_hash)
if txnid :
txn_dependencies.add(txnid)
else :
raise Exception('failed to find dependency; {0}:{1}'.format(contract_id, state_hash))
if txn_dependencies :
extra_params['transaction_dependency_list'] = list(txn_dependencies)
# now send off the transaction to the ledger
txnid = update_submitter.submit_ccl_update_from_data(
self.originator_keys.verifying_key,
self.channel_keys.txn_public,
self.enclave_service.enclave_id,
self.signature,
self.contract_id,
b64_message_hash,
b64_new_state_hash,
b64_old_state_hash,
self.encrypted_state,
self.dependencies,
**extra_params)
if txnid :
transaction_dependencies.SaveDependency(self.contract_id, b64_new_state_hash, txnid)
return txnid
class ContractResponse(object) :
"""
Class for managing the contract operation response from an enclave service
"""
__start_commit_service__ = True
# -------------------------------------------------------
@staticmethod
def exit_commit_workers():
"""Set the global variable stop_commit_service to True. This will be picked by the workers"""
if ContractResponse.__start_commit_service__ is False: #if True no service has yet been started
stop_replication_service()
stop_transacion_processing_service()
# -------------------------------------------------------
def __init__(self, request, response) :
"""
Initialize a contract response object
:param request: the ContractRequest object corresponding to the response
:param response: diction containing the response from the enclave
"""
self.status = response['Status']
self.invocation_response_raw = response['InvocationResponse']
self.invocation_response = invocation_response(response['InvocationResponse'])
self.state_changed = response['StateChanged']
self.new_state_object = request.contract_state
#if the new state is same as the old state, then change set is empty
self.new_state_object.changed_block_ids=[]
self.request_number = request.request_number
self.operation = request.operation
if self.status and self.state_changed :
self.signature = response['Signature']
state_hash_b64 = response['StateHash']
# we have another mismatch between the field names in the enclave
# and the field names expected in the transaction; this needs to
# be fixed at some point
self.dependencies = []
for dependency in response['Dependencies'] :
contract_id = dependency['ContractID']
state_hash = dependency['StateHash']
self.dependencies.append({'contract_id' : contract_id, 'state_hash' : state_hash})
# save the information we will need for the transaction
self.channel_keys = request.channel_keys
self.channel_id = request.channel_id
self.contract_id = request.contract_id
self.creator_id = request.creator_id
self.code_hash = request.contract_code.compute_hash()
self.message_hash = request.message.compute_hash()
self.new_state_hash = crypto.base64_to_byte_array(state_hash_b64)
self.originator_keys = request.originator_keys
self.enclave_service = request.enclave_service
self.old_state_hash = ()
if request.operation != 'initialize' :
self.old_state_hash = ContractState.compute_hash(request.contract_state.raw_state)
if not self.__verify_enclave_signature(request.enclave_keys) :
raise Exception('failed to verify enclave signature')
self.raw_state = self.enclave_service.get_block(state_hash_b64)
self.new_state_object = ContractState(self.contract_id, self.raw_state)
self.new_state_object.pull_state_from_eservice(self.enclave_service)
# compute ids of blocks in the change set (used for replication)
self.new_state_object.compute_ids_of_newblocks(request.contract_state.component_block_ids)
self.replication_params = request.replication_params
# -------------------------------------------------------
@property
@deprecated
def result(self):
return self.invocation_response
# -------------------------------------------------------
@property
def commit_id(self):
if self.status and self.state_changed:
return (self.contract_id, self.new_state_hash, self.request_number)
else:
return None
# -------------------------------------------------------
def commit_asynchronously(self, ledger_config=None, wait_parameter_for_ledger=30):
"""Commit includes two steps: First, replicate the change set to
all provisioned encalves. Second, commit the transaction to the
ledger. In this method, we add a job to the replication queue to
enable the first step. The job will be picked by a replication
worker thead. A call_back_after_replication function (see below)
is automatically invoked to add a task for the second step
"""
#start threads for commiting response if not done before
if ContractResponse.__start_commit_service__:
# start replication service
start_replication_service()
start_transaction_processing_service()
ContractResponse.__start_commit_service__ = False
#create the replication request
self.replication_request = ReplicationRequest(self.replication_params, self.contract_id, \
self.new_state_object.changed_block_ids, self.commit_id)
#create the transaction request if ledger is enabled
if ledger_config:
self.transaction_request = TransactionRequest(ledger_config, self.commit_id, wait_parameter_for_ledger)
else:
self.transaction_request = None
#submit the replication task
add_replication_task(self)
# -------------------------------------------------------
def call_back_after_replication(self):
"""this is the call back function after replication. Currently,
the call-back's role is to add a new task to the pending
transactions queue, which will be processed by a "submit
transaction" thread whose job is to submit transactions
corresponding to completed replication tasks
"""
if self.transaction_request:
add_transaction_task(self)
# -------------------------------------------------------
def wait_for_commit(self):
"""Wait for completion of the commit task corresponding to the
response. Return transaction id if ledger is used, else return
None"""
# wait for the completion of the replication task
try:
self.replication_request.wait_for_completion()
except Exception as e:
raise Exception(str(e))
# wait for the completion of the transaction processing if ledger is in use
if self.transaction_request:
try:
txn_id = self.transaction_request.wait_for_completion()
except Exception as e:
raise Exception(str(e))
else:
txn_id = None
return txn_id
# -------------------------------------------------------
def __verify_enclave_signature(self, enclave_keys) :
"""verify the signature of the response
"""
message = self.__serialize_for_signing()
return enclave_keys.verify(message, self.signature, encoding = 'b64')
# -------------------------------------------------------
def __serialize_for_signing(self) :
"""serialize the response for enclave signature verification"""
message = crypto.string_to_byte_array(self.channel_id)
message += crypto.string_to_byte_array(self.contract_id)
message += crypto.string_to_byte_array(self.creator_id)
message += self.code_hash
message += self.message_hash
message += self.new_state_hash
message += self.old_state_hash
for dependency in self.dependencies :
message += crypto.string_to_byte_array(dependency['contract_id'])
message += crypto.string_to_byte_array(dependency['state_hash'])
return message
