def test_update_state(nym_request: Request, nym_handler: NymHandler):
seq_no = 1
txn_time = 1560241033
nym = nym_request.operation.get(TARGET_NYM)
txn = reqToTxn(nym_request)
append_txn_metadata(txn, seq_no, txn_time)
path = nym_to_state_key(nym)
result = nym_handler.update_state(txn, None, nym_request)
state_value = nym_handler.get_from_state(path)
assert state_value == result
assert state_value[IDENTIFIER] == nym_request.identifier
assert state_value[F.seqNo.name] == seq_no
assert state_value[ROLE] == nym_request.operation.get(ROLE)
assert state_value[VERKEY] == nym_request.operation.get(VERKEY)
def get_nym_verify_proof(read_manager, db_manager, nym, data, multi_sig):
request = Request(operation={
TARGET_NYM: nym,
TXN_TYPE: GET_NYM,
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = read_manager.get_result(request)
proof = extract_proof(result, multi_sig)
result_data = None
assert proof
if data:
assert result[DATA]
result_data = domain_state_serializer.deserialize(result[DATA])
data_from_req = copy.copy(result_data)
data_from_req.pop(f.IDENTIFIER.nm, None)
data_from_req.pop(f.SEQ_NO.nm, None)
data_from_req.pop(TXN_TIME, None)
assert data_from_req == data
# Verifying signed state proof
path = nym_to_state_key(nym)
# If the value does not exist, serialization should be null and
# verify_state_proof needs to be given null (None). This is done to
# differentiate between absence of value and presence of empty string value
if result_data:
data.pop(TARGET_NYM, None)
data.update({
f.IDENTIFIER.nm: result_data[f.IDENTIFIER.nm],
f.SEQ_NO.nm: result_data[f.SEQ_NO.nm],
TXN_TIME: result_data[TXN_TIME]
})
serialized_value = domain_state_serializer.serialize(
data) if data else None
proof_nodes = base64.b64decode(proof[PROOF_NODES])
root_hash = base58.b58decode(proof[ROOT_HASH])
return db_manager.get_state(DOMAIN_LEDGER_ID).verify_state_proof(
root_hash, path, serialized_value, proof_nodes, serialized=True)
def update_state(self, txn, prev_result, is_committed=False):
self._validate_txn_type(txn)
nym = get_payload_data(txn).get(TARGET_NYM)
existing_data = get_nym_details(self.state, nym,
is_committed=is_committed)
txn_data = get_payload_data(txn)
new_data = {}
if not existing_data:
new_data[f.IDENTIFIER.nm] = get_from(txn)
new_data[ROLE] = None
new_data[VERKEY] = None
if ROLE in txn_data:
new_data[ROLE] = txn_data[ROLE]
if VERKEY in txn_data:
new_data[VERKEY] = txn_data[VERKEY]
new_data[F.seqNo.name] = get_seq_no(txn)
new_data[TXN_TIME] = get_txn_time(txn)
existing_data.update(new_data)
val = self.state_serializer.serialize(existing_data)
key = nym_to_state_key(nym)
self.state.set(key, val)
return existing_data
def update_nym(state, identifier, role):
state.set(
nym_to_state_key(identifier),
domain_state_serializer.serialize(
create_nym_txn(identifier, role)['txn']['data']))
def gen_state_key(self, txn):
nym = get_payload_data(txn).get(TARGET_NYM)
return nym_to_state_key(nym)