def handleGetRevocRegReq(self, request: Request): req_ts = request.operation.get(TIMESTAMP) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) author_did = request.identifier # Get root hash corresponding with given timestamp past_root = self.tsRevoc_store.get_equal_or_prev(req_ts) # Path to corresponding ACCUM record in state path = domain.make_state_path_for_revoc_reg_entry_accum( authors_did=author_did, revoc_reg_def_id=revoc_reg_def_id) if past_root is None: reply_data = None seq_no = None last_update_time = None proof = None else: encoded_entry = self.state.get_for_root_hash(past_root, path) revoc_reg_entry_accum, seq_no, last_update_time = domain.decode_state_value( encoded_entry) reply_data = None if revoc_reg_entry_accum is None else revoc_reg_entry_accum proof = self.make_proof(path, head_hash=past_root) return self.make_result(request=request, data=reply_data, last_seq_no=seq_no, update_time=last_update_time, proof=proof)
def handleGetRevocRegReq(self, request: Request): req_ts = request.operation.get(TIMESTAMP) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) # Get root hash corresponding with given timestamp past_root = self.ts_store.get_equal_or_prev(req_ts) # Path to corresponding ACCUM record in state path = domain.make_state_path_for_revoc_reg_entry_accum(revoc_reg_def_id=revoc_reg_def_id) entry_state = StateValue() if past_root is not None: encoded_entry, proof = self.get_value_from_state(path, head_hash=past_root, with_proof=True) entry_state.proof = proof if encoded_entry: revoc_reg_entry_accum, seq_no, last_update_time = domain.decode_state_value(encoded_entry) entry_state = StateValue(root_hash=past_root, value=revoc_reg_entry_accum, seq_no=seq_no, update_time=last_update_time, proof=proof) return self.make_result(request=request, data=entry_state.value, last_seq_no=entry_state.seq_no, update_time=entry_state.update_time, proof=entry_state.proof)
def handleGetRevocRegReq(self, request: Request): req_ts = request.operation.get(TIMESTAMP) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) # Get root hash corresponding with given timestamp past_root = self.ts_store.get_equal_or_prev(req_ts) # Path to corresponding ACCUM record in state path = domain.make_state_path_for_revoc_reg_entry_accum(revoc_reg_def_id=revoc_reg_def_id) if past_root is None: reply_data = None seq_no = None last_update_time = None proof = None else: encoded_entry, proof = self.get_value_from_state(path, head_hash=past_root, with_proof=True) revoc_reg_entry_accum, seq_no, last_update_time = domain.decode_state_value(encoded_entry) reply_data = None if revoc_reg_entry_accum is None else revoc_reg_entry_accum return self.make_result(request=request, data=reply_data, last_seq_no=seq_no, update_time=last_update_time, proof=proof)
def handleGetRevocRegDelta(self, request: Request): """ For getting reply we need: 1. Get REVOC_REG_ENTRY by "TO" timestamp from state 2. If FROM is given in request, then Get REVOC_REG_ENTRY by "FROM" timestamp from state 3. Get ISSUANCE_TYPE for REVOC_REG_DEF (revoked/issued strategy) 4. Compute issued and revoked indices by corresponding strategy 5. Make result 5.1 Now, if "FROM" is presented in request, then STATE_PROOF_FROM and ACCUM (revocation entry for "FROM" timestamp) will added into data section 5.2 If not, then only STATE_PROOF for "TO" revocation entry will added :param request: :return: Reply """ req_ts_from = request.operation.get(FROM, None) req_ts_to = request.operation.get(TO) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) author_did = request.identifier reply = None # Get root hash for "to" timestamp # Get REVOC_REG_ENTRY and ACCUM record for timestamp "to" path_to_reg_entry = domain.make_state_path_for_revoc_reg_entry( authors_did=author_did, revoc_reg_def_id=revoc_reg_def_id) path_to_reg_entry_accum = domain.make_state_path_for_revoc_reg_entry_accum( authors_did=author_did, revoc_reg_def_id=revoc_reg_def_id) past_root_to, reg_entry_to = self._get_reg_entry_by_timestamp( req_ts_to, path_to_reg_entry) reg_entry_accum_to, \ seq_no_to, \ last_update_time_to, \ reg_entry_accum_proof_to = self._get_reg_entry_accum_by_timestamp(req_ts_to, path_to_reg_entry_accum) if past_root_to: # Get issuance type from REVOC_REG_DEF encoded_revoc_reg_def = self.state.get_for_root_hash( past_root_to, revoc_reg_def_id) assert encoded_revoc_reg_def revoc_reg_def, _, _ = domain.decode_state_value( encoded_revoc_reg_def) strategy_cls = self.get_revocation_strategy( revoc_reg_def[VALUE][ISSUANCE_TYPE]) if req_ts_from: past_root_from, reg_entry_from = self._get_reg_entry_by_timestamp( req_ts_from, path_to_reg_entry) req_entry_accum_from, \ seq_no_from, \ last_update_time_from, \ reg_entry_accum_proof_from = self._get_reg_entry_accum_by_timestamp(req_ts_from, path_to_reg_entry_accum) # Compute issued/revoked lists corresponding with ISSUANCE_TYPE strategy result_issued, result_revoked = strategy_cls.get_delta( { ISSUED: reg_entry_to[VALUE][ISSUED], REVOKED: reg_entry_to[VALUE][REVOKED] }, { ISSUED: reg_entry_from[VALUE][ISSUED], REVOKED: reg_entry_from[VALUE][REVOKED] }) else: result_issued, result_revoked = strategy_cls.get_delta( { ISSUED: reg_entry_to[VALUE][ISSUED], REVOKED: reg_entry_to[VALUE][REVOKED] }, None) reply = { REVOC_REG_ID: str(path_to_reg_entry), REVOC_TYPE: revoc_reg_def.get(REVOC_TYPE), VALUE: { ACCUM_TO: reg_entry_accum_to, ISSUED: result_issued, REVOKED: result_revoked } } # If we got "from" timestamp, then add state proof into "data" section of reply if req_ts_from: reply[STATE_PROOF_FROM] = reg_entry_accum_proof_from reply[VALUE][ACCUM_FROM] = req_entry_accum_from return self.make_result(request=request, data=reply, last_seq_no=seq_no_to, update_time=last_update_time_to, proof=reg_entry_accum_proof_to)
def handleGetRevocRegDelta(self, request: Request): """ For getting reply we need: 1. Get REVOC_REG_ENTRY by "TO" timestamp from state 2. If FROM is given in request, then Get REVOC_REG_ENTRY by "FROM" timestamp from state 3. Get ISSUANCE_TYPE for REVOC_REG_DEF (revoked/issued strategy) 4. Compute issued and revoked indices by corresponding strategy 5. Make result 5.1 Now, if "FROM" is presented in request, then STATE_PROOF_FROM and ACCUM (revocation entry for "FROM" timestamp) will added into data section 5.2 If not, then only STATE_PROOF for "TO" revocation entry will added :param request: :return: Reply """ req_ts_from = request.operation.get(FROM, None) req_ts_to = request.operation.get(TO) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) reply = None """ Get root hash for "to" timestamp Get REVOC_REG_ENTRY and ACCUM record for timestamp "to" """ path_to_reg_entry = domain.make_state_path_for_revoc_reg_entry(revoc_reg_def_id=revoc_reg_def_id) path_to_reg_entry_accum = domain.make_state_path_for_revoc_reg_entry_accum(revoc_reg_def_id=revoc_reg_def_id) entry_to = self._get_reg_entry_by_timestamp(req_ts_to, path_to_reg_entry) accum_to = self._get_reg_entry_accum_by_timestamp(req_ts_to, path_to_reg_entry_accum) entry_from = StateValue() accum_from = StateValue() if accum_to.value and entry_to.value: """Get issuance type from REVOC_REG_DEF""" encoded_revoc_reg_def = self.state.get_for_root_hash(entry_to.root_hash, revoc_reg_def_id) if encoded_revoc_reg_def: revoc_reg_def, _, _ = domain.decode_state_value(encoded_revoc_reg_def) strategy_cls = self.get_revocation_strategy(revoc_reg_def[VALUE][ISSUANCE_TYPE]) issued_to = entry_to.value[VALUE].get(ISSUED, []) revoked_to = entry_to.value[VALUE].get(REVOKED, []) if req_ts_from: """Get REVOC_REG_ENTRY and ACCUM records for timestamp from if exist""" entry_from = self._get_reg_entry_by_timestamp(req_ts_from, path_to_reg_entry) accum_from = self._get_reg_entry_accum_by_timestamp(req_ts_from, path_to_reg_entry_accum) if req_ts_from and entry_from.value and accum_from.value: """Compute issued/revoked lists corresponding with ISSUANCE_TYPE strategy""" issued_from = entry_from.value[VALUE].get(ISSUED, []) revoked_from = entry_from.value[VALUE].get(REVOKED, []) result_issued, result_revoked = strategy_cls.get_delta({ISSUED: issued_to, REVOKED: revoked_to}, {ISSUED: issued_from, REVOKED: revoked_from}) else: result_issued, result_revoked = strategy_cls.get_delta({ISSUED: issued_to, REVOKED: revoked_to}, None) reply = { REVOC_REG_DEF_ID: revoc_reg_def_id, REVOC_TYPE: revoc_reg_def.get(REVOC_TYPE), VALUE: { ACCUM_TO: accum_to.value if entry_from.value else entry_to.value, ISSUED: result_issued, REVOKED: result_revoked } } """If we got "from" timestamp, then add state proof into "data" section of reply""" if req_ts_from and accum_from.value: reply[STATE_PROOF_FROM] = accum_from.proof reply[VALUE][ACCUM_FROM] = accum_from.value if accum_to and entry_to: seq_no = accum_to.seq_no if entry_from.value else entry_to.seq_no update_time = accum_to.update_time if entry_from.value else entry_to.update_time proof = accum_to.proof if entry_from.value else entry_to.proof else: seq_no = None update_time = None proof = None return self.make_result(request=request, data=reply, last_seq_no=seq_no, update_time=update_time, proof=proof)
def handleGetRevocRegDelta(self, request: Request): """ For getting reply we need: 1. Get REVOC_REG_ENTRY by "TO" timestamp from state 2. If FROM is given in request, then Get REVOC_REG_ENTRY by "FROM" timestamp from state 3. Get ISSUANCE_TYPE for REVOC_REG_DEF (revoked/issued strategy) 4. Compute issued and revoked indices by corresponding strategy 5. Make result 5.1 Now, if "FROM" is presented in request, then STATE_PROOF_FROM and ACCUM (revocation entry for "FROM" timestamp) will added into data section 5.2 If not, then only STATE_PROOF for "TO" revocation entry will added :param request: :return: Reply """ req_ts_from = request.operation.get(FROM, None) req_ts_to = request.operation.get(TO) revoc_reg_def_id = request.operation.get(REVOC_REG_DEF_ID) reply = { REVOC_REG_DEF_ID: revoc_reg_def_id, } """ Get root hash for "to" timestamp Get REVOC_REG_ENTRY and ACCUM record for timestamp "to" """ path_to_reg_entry = domain.make_state_path_for_revoc_reg_entry(revoc_reg_def_id=revoc_reg_def_id) path_to_reg_entry_accum = domain.make_state_path_for_revoc_reg_entry_accum(revoc_reg_def_id=revoc_reg_def_id) entry_to = self._get_reg_entry_by_timestamp(req_ts_to, path_to_reg_entry) accum_to = self._get_reg_entry_accum_by_timestamp(req_ts_to, path_to_reg_entry_accum) entry_from = StateValue() accum_from = StateValue() if accum_to.value and entry_to.value: """Get issuance type from REVOC_REG_DEF""" encoded_revoc_reg_def = self.state.get_for_root_hash(entry_to.root_hash, revoc_reg_def_id) if encoded_revoc_reg_def: revoc_reg_def, _, _ = domain.decode_state_value(encoded_revoc_reg_def) strategy_cls = self.get_revocation_strategy(revoc_reg_def[VALUE][ISSUANCE_TYPE]) issued_to = entry_to.value[VALUE].get(ISSUED, []) revoked_to = entry_to.value[VALUE].get(REVOKED, []) if req_ts_from: """Get REVOC_REG_ENTRY and ACCUM records for timestamp from if exist""" entry_from = self._get_reg_entry_by_timestamp(req_ts_from, path_to_reg_entry) accum_from = self._get_reg_entry_accum_by_timestamp(req_ts_from, path_to_reg_entry_accum) if req_ts_from and entry_from.value and accum_from.value: """Compute issued/revoked lists corresponding with ISSUANCE_TYPE strategy""" issued_from = entry_from.value[VALUE].get(ISSUED, []) revoked_from = entry_from.value[VALUE].get(REVOKED, []) result_issued, result_revoked = strategy_cls.get_delta({ISSUED: issued_to, REVOKED: revoked_to}, {ISSUED: issued_from, REVOKED: revoked_from}) else: result_issued, result_revoked = strategy_cls.get_delta({ISSUED: issued_to, REVOKED: revoked_to}, None) reply = { REVOC_REG_DEF_ID: revoc_reg_def_id, REVOC_TYPE: revoc_reg_def.get(REVOC_TYPE), VALUE: { ACCUM_TO: accum_to.value if entry_from.value else entry_to.value, ISSUED: result_issued, REVOKED: result_revoked } } """If we got "from" timestamp, then add state proof into "data" section of reply""" if req_ts_from and accum_from.value: reply[STATE_PROOF_FROM] = accum_from.proof reply[VALUE][ACCUM_FROM] = accum_from.value if accum_to and entry_to: seq_no = accum_to.seq_no if entry_from.value else entry_to.seq_no update_time = accum_to.update_time if entry_from.value else entry_to.update_time proof = accum_to.proof if entry_from.value else entry_to.proof else: seq_no = None update_time = None proof = None return self.make_result(request=request, data=reply, last_seq_no=seq_no, update_time=update_time, proof=proof)