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
"""
__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