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)
