def prepare_buy_for_state(txn): from common.serializers.serialization import domain_state_serializer identifier = get_from(txn) req_id = get_req_id(txn) value = domain_state_serializer.serialize({"amount": get_payload_data(txn)['amount']}) key = TestDomainRequestHandler.prepare_buy_key(identifier, req_id) return key, value
def prepare_buy_for_state(txn): identifier = get_from(txn) req_id = get_req_id(txn) value = domain_state_serializer.serialize( {"amount": get_payload_data(txn)['amount']}) key = BuyHandler.prepare_buy_key(identifier, req_id) return key, value
def prepare_buy_for_state(txn): from common.serializers.serialization import domain_state_serializer identifier = txn.get(f.IDENTIFIER.nm) req_id = txn.get(f.REQ_ID.nm) value = domain_state_serializer.serialize({"amount": txn['amount']}) key = TestDomainRequestHandler.prepare_buy_key(identifier, req_id) return key, value
def prepare_for_state_read(req: Request): if req.txn_type == "buy": txn = reqToTxn(req) key = BuyHandler.prepare_buy_key(req.identifier, req.reqId) value = domain_state_serializer.serialize( {"amount": get_payload_data(txn)['amount']}) return key, value
def get_result(self, request: Request): self._validate_request_type(request) nym = request.operation[TARGET_NYM] path = domain.make_state_path_for_nym(nym) nym_data, proof = self._get_value_from_state(path, with_proof=True) if nym_data: nym_data = domain_state_serializer.deserialize(nym_data) nym_data[TARGET_NYM] = nym data = domain_state_serializer.serialize(nym_data) seq_no = nym_data[f.SEQ_NO.nm] update_time = nym_data[TXN_TIME] else: data = None seq_no = None update_time = None # TODO: add update time here! result = self.make_result(request=request, data=data, last_seq_no=seq_no, update_time=update_time, proof=proof) result.update(request.operation) return result
def update_state(self, txn, prev_result, request, is_committed=False): self._validate_txn_type(txn) key = self.gen_state_key(txn) value = domain_state_serializer.serialize({"amount": get_payload_data(txn)['amount']}) self.state.set(key, value) logger.trace('{} after adding to state, headhash is {}'. format(self, self.state.headHash))
def prepare_buy_for_state(txn): from common.serializers.serialization import domain_state_serializer identifier = get_from(txn) req_id = get_req_id(txn) value = domain_state_serializer.serialize({"amount": get_payload_data(txn)['amount']}) key = TestDomainRequestHandler.prepare_buy_key(identifier, req_id) return key, value
def prepare_nym_for_state(txn): # TODO: this is semi-duplicated in plenum.DomainRequestHandler data = txn.get(DATA) parsed = domain_state_serializer.deserialize(data) parsed.pop(TARGET_NYM, None) value = domain_state_serializer.serialize(parsed) nym = txn[TARGET_NYM] key = make_state_path_for_nym(nym) return key, value
def prepare_get_nym_for_state(txn): data = txn.get(DATA) value = None if data is not None: parsed = domain_state_serializer.deserialize(data) parsed.pop(TARGET_NYM, None) value = domain_state_serializer.serialize(parsed) nym = txn[TARGET_NYM] key = make_state_path_for_nym(nym) return key, value
def prepare_get_nym_for_state(reply): data = reply.get(DATA) value = None if data is not None: parsed = domain_state_serializer.deserialize(data) parsed.pop(TARGET_NYM, None) value = domain_state_serializer.serialize(parsed) nym = reply[TARGET_NYM] key = make_state_path_for_nym(nym) return key, value
def add_txns(db_manager, ledger_id, count, txn_time): ledger = db_manager.get_ledger(ledger_id) state = db_manager.get_state(ledger_id) txns = [do_req_to_txn({}, {"ledger_id": ledger_id, "num": i}) for i in range(count)] ledger.append_txns_metadata(txns, txn_time) ledger.appendTxns(txns) for i, txn in enumerate(txns): state.set(bytes(ledger_id + i), domain_state_serializer.serialize(txn))
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 hash_of(text) -> str: if not isinstance(text, (str, bytes)): text = domain_state_serializer.serialize(text) if not isinstance(text, bytes): text = text.encode() return sha256(text).hexdigest()
def encode_state_value(value, seqNo, txnTime): return domain_state_serializer.serialize({ LAST_SEQ_NO: seqNo, LAST_UPDATE_TIME: txnTime, VALUE: value })
def _reset_fees(self, node): empty_fees = domain_state_serializer.serialize({}) node.db_manager.get_state(CONFIG_LEDGER_ID).set(build_path_for_set_fees().encode(), empty_fees)
def encode_state_value(value, seqNo, txnTime): return domain_state_serializer.serialize({ LAST_SEQ_NO: seqNo, LAST_UPDATE_TIME: txnTime, VALUE: value })
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 hash_of(text) -> str: if not isinstance(text, (str, bytes)): text = domain_state_serializer.serialize(text) if not isinstance(text, bytes): text = text.encode() return sha256(text).hexdigest()