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']
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')
# Retrieve the encrypted state from the enclave's block store
# Note that this channel is untrusted - must verify the retrieved data has the correct hash!
# This is intentionally done after the signature verification
encrypted_state_u_b64 = self.enclave_service.block_store_get(state_hash_b64)
encrypted_state_u_hash_b64 = ContractState.compute_hash(encrypted_state_u_b64, encoding='b64')
if (state_hash_b64 != encrypted_state_u_hash_b64):
raise Exception('Encrypted state from block store has incorrect hash!')
self.encrypted_state = encrypted_state_u_b64;
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']
if self.status and self.state_changed:
self.signature = response['Signature']
self.encrypted_state = response['State']
# 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 = ContractState.compute_hash(
self.encrypted_state)
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')
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
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