def set_aml(txn_author_agreement_handler): txn_author_agreement_handler.state.set( StaticTAAHelper.state_path_taa_aml_latest(), encode_state_value("value", "seqNo", "txnTime", serializer=config_state_serializer))
def make_context_exist(context_request, context_handler): identifier, req_id, operation = get_request_data(context_request) context_name = get_write_context_name(context_request) context_version = get_write_context_version(context_request) path = ContextHandler.make_state_path_for_context(identifier, context_name, context_version) context_handler.state.set(path, encode_state_value("value", "seqNo", "txnTime"))
def test_revoc_reg_def_dynamic_validation_passes(revoc_reg_def_handler, revoc_reg_def_request): add_to_idr(revoc_reg_def_handler.database_manager.idr_cache, revoc_reg_def_request.identifier, TRUSTEE) cred_def_id = revoc_reg_def_request.operation.get(CRED_DEF_ID) revoc_reg_def_handler.state.set( cred_def_id.encode(), encode_state_value("value", "seqNo", "txnTime")) revoc_reg_def_handler.dynamic_validation(revoc_reg_def_request)
def test_revoc_reg_entry_dynamic_validation_passes(revoc_reg_entry_handler, revoc_reg_entry_request): revoc_reg_entry_handler.state.set( revoc_reg_entry_request.operation[REVOC_REG_DEF_ID].encode(), encode_state_value({VALUE: { ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT }}, "seqNo", "txnTime")) revoc_reg_entry_handler.dynamic_validation(revoc_reg_entry_request)
def make_schema_exist(schema_request, schema_handler): identifier, req_id, operation = get_request_data(schema_request) schema_name = get_write_schema_name(schema_request) schema_version = get_write_schema_version(schema_request) path = SchemaHandler.make_state_path_for_schema(identifier, schema_name, schema_version) schema_handler.state.set(path, encode_state_value("value", "seqNo", "txnTime"))
def _update_txn_author_agreement_acceptance_mechanisms( self, payload, seq_no, txn_time): serialized_data = encode_state_value( payload, seq_no, txn_time, serializer=config_state_serializer) version = payload[AML_VERSION] self.state.set(StaticTAAHelper.state_path_taa_aml_latest(), serialized_data) self.state.set(StaticTAAHelper.state_path_taa_aml_version(version), serialized_data)
def update_state(self, txn, prev_result, request, is_committed=False): self._validate_txn_type(txn) payload = get_payload_data(txn) seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) serialized_data = encode_state_value(payload, seq_no, txn_time, serializer=config_state_serializer) version = payload[AML_VERSION] self.state.set(StaticTAAHelper.state_path_taa_aml_latest(), serialized_data) self.state.set(StaticTAAHelper.state_path_taa_aml_version(version), serialized_data)
def update_txn_author_agreement(self, text, version, seq_no, txn_time): digest = self._taa_digest(text, version) data = encode_state_value({ TXN_AUTHOR_AGREEMENT_TEXT: text, TXN_AUTHOR_AGREEMENT_VERSION: version }, seq_no, txn_time, serializer=config_state_serializer) self.state.set(self._state_path_taa_digest(digest), data) self.state.set(self._state_path_taa_latest(), digest) self.state.set(self._state_path_taa_version(version), digest)
def test_revoc_reg_def_dynamic_validation_without_permission( revoc_reg_def_handler, revoc_reg_def_request): add_to_idr(revoc_reg_def_handler.database_manager.idr_cache, revoc_reg_def_request.identifier, None) cred_def_id = revoc_reg_def_request.operation.get(CRED_DEF_ID) revoc_reg_def_handler.state.set( cred_def_id.encode(), encode_state_value("value", "seqNo", "txnTime")) with pytest.raises(UnauthorizedClientRequest, match="Not enough TRUSTEE signatures"): revoc_reg_def_handler.dynamic_validation(revoc_reg_def_request)
def update_state(self, txn, prev_result, request, is_committed=False): self._validate_txn_type(txn) seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) ledgers_ids = get_payload_data(txn)[LEDGERS_IDS] frozen_ledgers = self.make_frozen_ledgers_list(ledgers_ids) self.state.set( StaticLedgersFreezeHelper.make_state_path_for_frozen_ledgers(), encode_state_value(frozen_ledgers, seq_no, txn_time)) return txn
def test_revoc_reg_entry_dynamic_validation_passes(revoc_reg_entry_handler, revoc_reg_entry_request): add_to_idr(revoc_reg_entry_handler.database_manager.idr_cache, revoc_reg_entry_request.identifier, TRUSTEE) revoc_reg_entry_handler.state.set( revoc_reg_entry_request.operation[REVOC_REG_DEF_ID].encode(), encode_state_value({VALUE: { ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT }}, "seqNo", "txnTime")) revoc_reg_entry_handler.dynamic_validation(revoc_reg_entry_request, 0)
def test_revoc_reg_entry_dynamic_validation_fail_in_strategy( revoc_reg_entry_handler, revoc_reg_entry_request): revoc_reg_entry_handler.state.set( revoc_reg_entry_request.operation[REVOC_REG_DEF_ID].encode(), encode_state_value({VALUE: { ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT }}, "seqNo", "txnTime")) revoc_reg_entry_request.operation[VALUE] = {ISSUED: [1], REVOKED: [1]} with pytest.raises(InvalidClientRequest, match="Can not have an index in both " "'issued' and 'revoked' lists"): revoc_reg_entry_handler.dynamic_validation(revoc_reg_entry_request)
def prepare_schema_for_state(txn, path_only=False): origin = get_from(txn) schema_name = get_txn_schema_name(txn) schema_version = get_txn_schema_version(txn) value = {SCHEMA_ATTR_NAMES: get_txn_schema_attr_names(txn)} path = SchemaHandler.make_state_path_for_schema( origin, schema_name, schema_version) if path_only: return path seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) value_bytes = encode_state_value(value, seq_no, txn_time) return path, value_bytes
def prepare_state(txn, path_only=False): payload = txn["txn"] meta, data = payload["data"][RS_META], payload["data"][RS_DATA] name, version = meta[RS_META_NAME], meta[RS_META_VERSION] did_author = payload["metadata"][RS_SCHEMA_FROM] _id = RsSchemaHandler.make_state_path(did_author, name, version) if path_only: return _id value = {RS_META: meta, RS_DATA: data} seq_no = txn["txnMetadata"].get("seqNo", None) txn_time = txn["txnMetadata"].get("txnTime", None) value_bytes = encode_state_value(value, seq_no, txn_time) return _id, value_bytes
def prepare_context_for_state(txn, path_only=False): origin = get_from(txn) context_name = get_txn_context_name(txn) context_version = get_txn_context_version(txn) value = { CONTEXT_CONTEXT_ARRAY: get_txn_context_context_array(txn) } path = ContextHandler.make_state_path_for_context(origin, context_name, context_version) if path_only: return path seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) value_bytes = encode_state_value(value, seq_no, txn_time) return path, value_bytes
def update_state(self, txn, prev_result, request, is_committed=False): self._validate_txn_type(txn) payload = get_payload_data(txn) text = payload[TXN_AUTHOR_AGREEMENT_TEXT] version = payload[TXN_AUTHOR_AGREEMENT_VERSION] seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) digest = StaticTAAHelper.taa_digest(text, version) data = encode_state_value({ TXN_AUTHOR_AGREEMENT_TEXT: text, TXN_AUTHOR_AGREEMENT_VERSION: version }, seq_no, txn_time, serializer=config_state_serializer) self.state.set(StaticTAAHelper.state_path_taa_digest(digest), data) self.state.set(StaticTAAHelper.state_path_taa_latest(), digest) self.state.set(StaticTAAHelper.state_path_taa_version(version), digest)
def test_revoc_reg_entry_dynamic_validation_without_permission( revoc_reg_entry_handler, revoc_reg_entry_request): add_to_idr(revoc_reg_entry_handler.database_manager.idr_cache, revoc_reg_entry_request.identifier, None) revoc_reg_entry_handler.state.set( revoc_reg_entry_request.operation[REVOC_REG_DEF_ID].encode(), encode_state_value({VALUE: { ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT }}, "seqNo", "txnTime")) revoc_reg_entry_request.operation[VALUE] = {ISSUED: [1], REVOKED: [1]} with pytest.raises( UnauthorizedClientRequest, match="1 TRUSTEE signature is required and needs to be owner OR " "1 STEWARD signature is required and needs to be owner OR " "1 ENDORSER signature is required and needs to be owner"): revoc_reg_entry_handler.dynamic_validation(revoc_reg_entry_request, 0)
def prepare_attr_for_state(txn, path_only=False): """ Make key(path)-value pair for state from ATTRIB or GET_ATTR :return: state path, state value, value for attribute store """ assert get_type(txn) == ATTRIB txn_data = get_payload_data(txn) nym = txn_data[TARGET_NYM] attr_type, attr_key, value = AttributeHandler.parse_attr_txn(txn_data) path = AttributeHandler.make_state_path_for_attr(nym, attr_key, attr_type == HASH) if path_only: return path hashed_value = domain.hash_of(value) if value else '' seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) value_bytes = encode_state_value(hashed_value, seq_no, txn_time) return attr_type, path, value, hashed_value, value_bytes
def prepare_revoc_reg_entry_accum_for_state(txn): author_did = get_from(txn) txn_data = get_payload_data(txn) revoc_reg_def_id = txn_data.get(REVOC_REG_DEF_ID) seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) assert author_did assert revoc_reg_def_id assert seq_no assert txn_time path = RevocRegEntryHandler.make_state_path_for_revoc_reg_entry_accum(revoc_reg_def_id) # TODO: do not duplicate seqNo here # doing this now just for backward-compatibility txn_data = deepcopy(txn_data) txn_data[f.SEQ_NO.nm] = seq_no txn_data[TXN_TIME] = txn_time value_bytes = encode_state_value(txn_data, seq_no, txn_time) return path, value_bytes
def prepare_claim_def_for_state(txn, path_only=False): origin = get_from(txn) schema_seq_no = get_txn_claim_def_schema_ref(txn) if schema_seq_no is None: raise ValueError("'{}' field is absent, " "but it must contain schema seq no".format(CLAIM_DEF_SCHEMA_REF)) data = get_txn_claim_def_public_keys(txn) if data is None: raise ValueError("'{}' field is absent, " "but it must contain components of keys" .format(CLAIM_DEF_PUBLIC_KEYS)) signature_type = get_txn_claim_def_signature_type(txn) tag = get_txn_claim_def_tag(txn) path = ClaimDefHandler.make_state_path_for_claim_def(origin, schema_seq_no, signature_type, tag) if path_only: return path seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) value_bytes = encode_state_value(data, seq_no, txn_time) return path, value_bytes
def prepare_revoc_def_for_state(txn, path_only=False): author_did = get_from(txn) txn_data = get_payload_data(txn) cred_def_id = txn_data.get(CRED_DEF_ID) revoc_def_type = txn_data.get(REVOC_TYPE) revoc_def_tag = txn_data.get(TAG) assert author_did assert cred_def_id assert revoc_def_type assert revoc_def_tag path = RevocRegDefHandler.make_state_path_for_revoc_def( author_did, cred_def_id, revoc_def_type, revoc_def_tag) if path_only: return path seq_no = get_seq_no(txn) txn_time = get_txn_time(txn) assert seq_no assert txn_time value_bytes = encode_state_value(txn_data, seq_no, txn_time) return path, value_bytes
def test_update_taa_aml(taa_aml_handler, taa_aml_input_data, taa_handler, write_manager, taa_aml_expected_state_data, taa_aml_expected_data): """ `update_txn_author_agreement` updates state properly """ state = write_manager.database_manager.get_state(CONFIG_LEDGER_ID) written = [] def _check_state(version): expected_data = taa_aml_expected_data[version] _data = state.get( WriteRequestManager._state_path_taa_aml_version(version), isCommitted=False) if version in written: assert (config_state_serializer.deserialize(_data)[VALUE] == config_state_serializer.deserialize(expected_data)) else: assert _data is None for data in taa_aml_input_data: taa_aml_handler._update_txn_author_agreement_acceptance_mechanisms( { AML_VERSION: data.version, AML: data.aml, AML_CONTEXT: data.amlContext }, data.seq_no, data.txn_time) written.append(data.version) data_d = data._asdict() assert state.get(WriteRequestManager._state_path_taa_aml_latest(), isCommitted=False) == encode_state_value( { AML_CONTEXT: data_d[AML_CONTEXT], AML: data_d[AML], AML_VERSION: data_d[AML_VERSION] }, data_d['seq_no'], data_d['txn_time']) for version in taa_aml_expected_state_data: _check_state(version)
def _set_taa_to_state(self, digest, seq_no, txn_time, text, version, ratification_ts, retirement_ts=None): state_value = { TXN_AUTHOR_AGREEMENT_TEXT: text, TXN_AUTHOR_AGREEMENT_VERSION: version, TXN_AUTHOR_AGREEMENT_RATIFICATION_TS: ratification_ts, TXN_AUTHOR_AGREEMENT_DIGEST: digest } if retirement_ts: state_value[TXN_AUTHOR_AGREEMENT_RETIREMENT_TS] = retirement_ts data = encode_state_value(state_value, seq_no, txn_time, serializer=config_state_serializer) self.state.set(StaticTAAHelper.state_path_taa_digest(digest), data)
def test_revoc_reg_def_dynamic_validation_passes(revoc_reg_def_handler, revoc_reg_def_request): cred_def_id = revoc_reg_def_request.operation.get(CRED_DEF_ID) revoc_reg_def_handler.state.set(cred_def_id, encode_state_value("value", "seqNo", "txnTime")) revoc_reg_def_handler.dynamic_validation(revoc_reg_def_request)