def test_state_proof_returned_for_get_attr(looper, sdk_added_raw_attribute, attributeName, attributeData, sdk_pool_handle, sdk_wallet_client): """ Tests that state proof is returned in the reply for GET_ATTR transactions. Use different submitter and reader! """ get_attr_operation = { TARGET_NYM: sdk_added_raw_attribute['operation']['dest'], TXN_TYPE: GET_ATTR, RAW: attributeName } replies = sdk_submit_operation_and_get_replies(looper, sdk_pool_handle, sdk_wallet_client, get_attr_operation) expected_data = attrib_raw_data_serializer.deserialize(attributeData) for reply in replies: result = reply[1]['result'] assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(reply[1])
def test_state_proof_returned_for_get_attr(looper, nodeSetWithOneNodeResponding, sdk_added_raw_attribute, attributeName, attributeData, sdk_pool_handle, sdk_wallet_client): """ Tests that state proof is returned in the reply for GET_ATTR transactions. Use different submitter and reader! """ get_attr_operation = { TARGET_NYM: sdk_added_raw_attribute['result']['txn']['data']['dest'], TXN_TYPE: GET_ATTR, RAW: attributeName } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_attr_operation) expected_data = attrib_raw_data_serializer.deserialize(attributeData) assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(result)
def test_state_proof_returned_for_get_attr(looper, addedRawAttribute, attributeName, attributeData, trustAnchor, trustAnchorWallet): """ Tests that state proof is returned in the reply for GET_ATTR transactions """ client = trustAnchor get_attr_operation = { TARGET_NYM: addedRawAttribute.dest, TXN_TYPE: GET_ATTR, RAW: attributeName } get_attr_request = trustAnchorWallet.signOp(get_attr_operation) trustAnchorWallet.pendRequest(get_attr_request) pending = trustAnchorWallet.preparePending() client.submitReqs(*pending) waitForSufficientRepliesForRequests(looper, trustAnchor, requests=pending) replies = getRepliesFromClientInbox(client.inBox, get_attr_request.reqId) expected_data = attrib_raw_data_serializer.deserialize(attributeData) for reply in replies: result = reply['result'] assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(reply, client)
def test_state_proof_returned_for_get_attr(looper, addedRawAttribute, attributeName, attributeData, client1, wallet1): """ Tests that state proof is returned in the reply for GET_ATTR transactions. Use different submitter and reader! """ get_attr_operation = { TARGET_NYM: addedRawAttribute.dest, TXN_TYPE: GET_ATTR, RAW: attributeName } replies = submit_operation_and_get_replies(looper, wallet1, client1, get_attr_operation) expected_data = attrib_raw_data_serializer.deserialize(attributeData) for reply in replies: result = reply['result'] assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(reply, client1)
def _validateAttrib(self, req: Request): origin = req.identifier op = req.operation if not (not op.get(TARGET_NYM) or self.hasNym(op[TARGET_NYM], isCommitted=False)): raise InvalidClientRequest(origin, req.reqId, '{} should be added before adding ' 'attribute for it'. format(TARGET_NYM)) is_owner = self.idrCache.getOwnerFor(op[TARGET_NYM], isCommitted=False) == origin field = None value = None for key in (RAW, ENC, HASH): if key in op: field = key value = op[key] break if field is None or value is None: raise LogicError('Attribute data cannot be empty') get_key = None if field == RAW: try: get_key = attrib_raw_data_serializer.deserialize(value) if len(get_key) == 0: raise InvalidClientRequest(origin, req.reqId, '"row" attribute field must contain non-empty dict'. format(TARGET_NYM)) get_key = next(iter(get_key.keys())) except JSONDecodeError: raise InvalidClientRequest(origin, req.reqId, 'Attribute field must be dict while adding it as a row field'. format(TARGET_NYM)) else: get_key = value if get_key is None: raise LogicError('Attribute data must be parsed') old_value, seq_no, _, _ = self.getAttr(op[TARGET_NYM], get_key, field, isCommitted=False) if seq_no is not None: self.write_req_validator.validate(req, [AuthActionEdit(txn_type=ATTRIB, field=field, old_value=old_value, new_value=value, is_owner=is_owner)]) else: self.write_req_validator.validate(req, [AuthActionAdd(txn_type=ATTRIB, field=field, value=value, is_owner=is_owner)])
def _getAttrReply(self, result, preparedReq): # TODO: Confirm if we need to add the retrieved attribute to the wallet. # If yes then change the graph query on node to return the sequence # number of the attribute txn too. attr_type, attr_key = domain._extract_attr_typed_value(result) for attrib in self.getAttributesForNym(result[TARGET_NYM]): if attrib.name == attr_key: attrib.seqNo = result[f.SEQ_NO.nm] attrib.value = result[DATA] if attr_type == 'raw': attrib.value = attrib_raw_data_serializer.deserialize(attrib.value) attrib.value = attrib_raw_data_serializer.serialize(attrib.value, toBytes=False)
def _getAttrReply(self, result, preparedReq): # TODO: Confirm if we need to add the retrieved attribute to the wallet. # If yes then change the graph query on node to return the sequence # number of the attribute txn too. attr_type, attr_key = domain._extract_attr_typed_value(result) for attrib in self.getAttributesForNym(result[TARGET_NYM]): if attrib.name == attr_key: attrib.seqNo = result[f.SEQ_NO.nm] attrib.value = result[DATA] if attr_type == 'raw': attrib.value = attrib_raw_data_serializer.deserialize(attrib.value) attrib.value = attrib_raw_data_serializer.serialize(attrib.value, toBytes=False)
def parse_attr_txn(txn): attr_type, attr = _extract_attr_typed_value(txn) if attr_type == RAW: data = attrib_raw_data_serializer.deserialize(attr) # To exclude user-side formatting issues re_raw = attrib_raw_data_serializer.serialize(data, toBytes=False) key, _ = data.popitem() return attr_type, key, re_raw if attr_type == ENC: return attr_type, attr, attr if attr_type == HASH: return attr_type, attr, None
def test_state_proof_returned_for_get_attr(looper, addedRawAttribute, attributeName, attributeData, client1, wallet1): """ Tests that state proof is returned in the reply for GET_ATTR transactions. Use different submitter and reader! """ get_attr_operation = { TARGET_NYM: addedRawAttribute.dest, TXN_TYPE: GET_ATTR, RAW: attributeName } replies = submit_operation_and_get_replies(looper, wallet1, client1, get_attr_operation) expected_data = attrib_raw_data_serializer.deserialize(attributeData) for reply in replies: result = reply['result'] assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(reply, client1)
def parse_attr_txn(txn_data): attr_type, attr = _extract_attr_typed_value(txn_data) if attr_type == RAW: data = attrib_raw_data_serializer.deserialize(attr) # To exclude user-side formatting issues re_raw = attrib_raw_data_serializer.serialize(data, toBytes=False) key, _ = data.popitem() return attr_type, key, re_raw if attr_type == ENC: return attr_type, attr, attr if attr_type == HASH: return attr_type, attr, None
def additional_dynamic_validation(self, request: Request, req_pp_time: Optional[int]): self._validate_request_type(request) identifier, req_id, operation = get_request_data(request) if not (not operation.get(TARGET_NYM) or self.__has_nym(operation[TARGET_NYM], is_committed=False)): raise InvalidClientRequest( identifier, request.reqId, '{} should be added before adding ' 'attribute for it'.format(TARGET_NYM)) is_owner = self.database_manager.idr_cache.getOwnerFor( operation[TARGET_NYM], isCommitted=False) == identifier field = None value = None for key in (RAW, ENC, HASH): if key in operation: field = key value = operation[key] break if field == RAW: get_key = attrib_raw_data_serializer.deserialize(value) get_key = list(get_key.keys())[0] else: get_key = value old_value, seq_no, _ = self._get_attr(operation[TARGET_NYM], get_key, field) if seq_no is not None: self.write_req_validator.validate(request, [ AuthActionEdit(txn_type=ATTRIB, field=field, old_value=old_value, new_value=value, is_owner=is_owner) ]) else: self.write_req_validator.validate(request, [ AuthActionAdd(txn_type=ATTRIB, field=field, value=value, is_owner=is_owner) ])
def static_validation(self, request: Request): self._validate_request_type(request) identifier, req_id, operation = get_request_data(request) if not validate_attrib_keys(operation): raise InvalidClientRequest(identifier, req_id, '{} should have one and only one of ' '{}, {}, {}' .format(ATTRIB, RAW, ENC, HASH)) if RAW in operation: try: get_key = attrib_raw_data_serializer.deserialize(operation[RAW]) if len(get_key) == 0: raise InvalidClientRequest(identifier, request.reqId, '"row" attribute field must contain non-empty dict'. format(TARGET_NYM)) except JSONDecodeError: raise InvalidClientRequest(identifier, request.reqId, 'Attribute field must be dict while adding it as a row field'. format(TARGET_NYM))