def test_update_state(revoc_reg_entry_handler, revoc_reg_entry_request, revoc_reg_def_handler, revoc_reg_def_request): # create revoc_req_def seq_no = 1 txn_time = 1560241030 revoc_reg_def_request.operation[ISSUANCE_TYPE] = ISSUANCE_BY_DEFAULT txn = reqToTxn(revoc_reg_def_request) append_txn_metadata(txn, seq_no, txn_time) path = RevocRegDefHandler.prepare_revoc_def_for_state(txn, path_only=True) revoc_reg_def_handler.update_state(txn, None, revoc_reg_def_request) # create revoc_req_entry seq_no = 2 txn_time = 1560241033 revoc_reg_entry_request.operation[REVOC_REG_DEF_ID] = path.decode() txn = reqToTxn(revoc_reg_entry_request) append_txn_metadata(txn, seq_no, txn_time) revoc_reg_entry_handler.update_state(txn, None, revoc_reg_entry_request) # check state for revoc_reg_entry txn_data = get_payload_data(txn) txn_data[f.SEQ_NO.nm] = seq_no txn_data[TXN_TIME] = txn_time assert revoc_reg_entry_handler.get_from_state( RevocRegEntryHandler.prepare_revoc_reg_entry_for_state( txn, path_only=True)) == (txn_data, seq_no, txn_time) # check state for revoc_reg_entry txn_data[VALUE] = {ACCUM: txn_data[VALUE][ACCUM]} path, _ = RevocRegEntryHandler.prepare_revoc_reg_entry_accum_for_state(txn) assert revoc_reg_entry_handler.get_from_state(path) == (txn_data, seq_no, txn_time)
def test_write_request_manager_handles_request( write_req_manager: WriteRequestManager, node_req): write_req_manager.static_validation(node_req) write_req_manager.dynamic_validation(node_req) write_req_manager.update_state(reqToTxn(node_req)) write_req_manager.apply_request(node_req, None) write_req_manager.apply_forced_request(node_req) write_req_manager.transform_txn_for_ledger(reqToTxn(node_req))
def add_revoc_def_by_demand(create_node_and_not_start, looper, sdk_wallet_steward): node = create_node_and_not_start data = { ID: randomString(50), TXN_TYPE: REVOC_REG_DEF, REVOC_TYPE: "CL_ACCUM", TAG: randomString(5), CRED_DEF_ID: ":".join(4 * [randomString(10)]), VALUE: { ISSUANCE_TYPE: ISSUANCE_ON_DEMAND, MAX_CRED_NUM: 1000000, TAILS_HASH: randomString(50), TAILS_LOCATION: 'http://tails.location.com', PUBLIC_KEYS: {}, } } req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) req_handler = node.getDomainReqHandler() txn = append_txn_metadata(reqToTxn(Request(**req)), txn_time=int(time.time()), seq_no=node.domainLedger.seqNo + 1) req_handler._addRevocDef(txn) return req
def add_revoc_def_by_demand(create_node_and_not_start, looper, sdk_wallet_steward): node = create_node_and_not_start data = { "id": randomString(50), "type": REVOC_REG_DEF, "tag": randomString(5), "credDefId": randomString(50), "value":{ "issuanceType": ISSUANCE_ON_DEMAND, "maxCredNum": 1000000, "tailsHash": randomString(50), "tailsLocation": 'http://tails.location.com', "publicKeys": {}, } } req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) req_handler = node.getDomainReqHandler() req_handler.validate(Request(**req)) txn = reqToTxn(Request(**req)) txn[f.SEQ_NO.nm] = node.domainLedger.seqNo + 1 txn[TXN_TIME] = int(time.time()) req_handler._addRevocDef(txn) return req
def _add_txns_to_ledger(node, looper, sdk_wallet_client, num_txns_in_reply, reply_count): ''' Add txn_count transactions to node's ledger and return ConsistencyProof for all new transactions and list of CatchupReplies :return: ConsistencyProof, list of CatchupReplies ''' txn_count = num_txns_in_reply * reply_count ledger_manager = node.ledgerManager ledger = ledger_manager.ledgerRegistry[ledger_id].ledger catchup_rep_service = ledger_manager._node_leecher._leechers[ledger_id]._catchup_rep_service reqs = sdk_signed_random_requests(looper, sdk_wallet_client, txn_count) # add transactions to ledger for req in reqs: txn = append_txn_metadata(reqToTxn(req), txn_time=12345678) catchup_rep_service._add_txn(txn) # generate CatchupReps replies = [] for i in range(ledger.seqNo - txn_count + 1, ledger.seqNo + 1, num_txns_in_reply): start = i end = i + num_txns_in_reply - 1 cons_proof = ledger_manager._node_seeder._make_consistency_proof(ledger, end, ledger.size) txns = {} for seq_no, txn in ledger.getAllTxn(start, end): txns[str(seq_no)] = ledger_manager.owner.update_txn_with_extra_data(txn) replies.append(CatchupRep(ledger_id, SortedDict(txns), cons_proof)) three_pc_key = node.three_phase_key_for_txn_seq_no(ledger_id, ledger.seqNo) view_no, pp_seq_no = three_pc_key if three_pc_key else (0, 0) return CatchupTill(start_size=ledger.seqNo - txn_count, final_size=ledger.seqNo, final_hash=Ledger.hashToStr(ledger.tree.merkle_tree_hash(0, ledger.seqNo)), view_no=view_no, pp_seq_no=pp_seq_no), replies
def _add_txns_to_ledger(node, looper, sdk_wallet_client, num_txns_in_reply, reply_count): ''' Add txn_count transactions to node's ledger and return ConsistencyProof for all new transactions and list of CatchupReplies :return: ConsistencyProof, list of CatchupReplies ''' txn_count = num_txns_in_reply * reply_count ledger_manager = node.ledgerManager ledger = ledger_manager.ledgerRegistry[ledger_id].ledger ledger_info = ledger_manager.getLedgerInfoByType(ledger_id) reqs = sdk_signed_random_requests(looper, sdk_wallet_client, txn_count) # add transactions to ledger for req in reqs: txn = append_txn_metadata(reqToTxn(req), txn_time=12345678) ledger_manager._add_txn(ledger_id, ledger, ledger_info, txn) # generate CatchupReps replies = [] for i in range(ledger.seqNo - txn_count + 1, ledger.seqNo + 1, num_txns_in_reply): start = i end = i + num_txns_in_reply - 1 cons_proof = ledger_manager._make_consistency_proof( ledger, end, ledger.size) txns = {} for seq_no, txn in ledger.getAllTxn(start, end): txns[str( seq_no)] = ledger_manager.owner.update_txn_with_extra_data(txn) replies.append(CatchupRep(ledger_id, SortedDict(txns), cons_proof)) return ledger_manager._buildConsistencyProof(ledger_id, ledger.seqNo - txn_count, ledger.seqNo), replies
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 test_no_state_proofs_if_protocol_version_less(write_manager, read_manager, db_manager): nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv' role = "2" verkey = "~7TYfekw4GUagBnBVCqPjiC" identifier = "6ouriXMZkLeHsuXrN1X1fd" seq_no = 0 txn_time = int(time.time()) # Adding nym data = { TARGET_NYM: nym, ROLE: role, VERKEY: verkey, } txn = append_txn_metadata(reqToTxn( Request(operation=data, protocolVersion=CURRENT_PROTOCOL_VERSION, identifier=identifier)), seq_no=seq_no, txn_time=txn_time) txn = set_type(txn, NYM) txn = append_payload_metadata(txn, frm=nym) write_manager.update_state(txn) db_manager.get_state(DOMAIN_LEDGER_ID).commit() multi_sig = save_multi_sig(db_manager) # Getting nym request = Request(operation={ TARGET_NYM: nym, TXN_TYPE: GET_NYM, }, signatures={}) result = read_manager.get_result(request) assert STATE_PROOF not in result
def apply(self, req: Request, cons_time): txn = append_txn_metadata(reqToTxn(req), txn_time=cons_time) self.ledger.append_txns_metadata([txn]) (start, _), _ = self.ledger.appendTxns([txn]) self.updateState([txn], isCommitted=False) return start, txn
def test_update_state(handler_and_request): handler, request = handler_and_request seq_no = 1 txn_time = 1560241033 txn = reqToTxn(request) append_txn_metadata(txn, seq_no, txn_time) op = request.operation handler.update_state(txn, None, context_request) value = { 'id': op[RS_ID], 'rsType': op[RS_TYPE], 'rsName': op[RS_NAME], 'rsVersion': op[RS_VERSION], 'content': op[RS_CONTENT], 'from': request.identifier, 'endorser': request.endorser, 'ver': op[OP_VER], } primary_key = op[RS_ID] secondary_key = "{RS_TYPE}:{RS_NAME}:{RS_VERSION}".format( RS_TYPE=op['rsType'], RS_NAME=op['rsName'], RS_VERSION=op['rsVersion']).encode() value_from_state = handler.get_from_state(primary_key) assert SortedDict(value_from_state[0]) == SortedDict(value) assert value_from_state[1] == seq_no assert value_from_state[2] == txn_time assert handler.state.get(secondary_key, isCommitted=False) == op[RS_ID].encode()
def add_another_reg_id(looper, sdk_wallet_steward, create_node_and_not_start): node = create_node_and_not_start data = { ID: randomString(50), TXN_TYPE: REVOC_REG_DEF, REVOC_TYPE: "CL_ACCUM", TAG: randomString(5), CRED_DEF_ID: randomString(50), VALUE:{ ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT, MAX_CRED_NUM: 1000000, TAILS_HASH: randomString(50), TAILS_LOCATION: 'http://tails.location.com', PUBLIC_KEYS: {}, } } req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) looper.runFor(2) txn = append_txn_metadata(reqToTxn(Request(**req)), txn_time=FIRST_ID_TS, seq_no=node.domainLedger.seqNo + 1) node.write_manager.update_state(txn) return req
def test_update_state(txn_author_agreement_handler, taa_request): seq_no = 1 txn_time = 1560241033 txn_id = "id" txn = reqToTxn(taa_request) payload = get_payload_data(txn) text = payload[TXN_AUTHOR_AGREEMENT_TEXT] version = payload[TXN_AUTHOR_AGREEMENT_VERSION] digest = StaticTAAHelper.taa_digest(text, version) append_txn_metadata(txn, seq_no, txn_time, txn_id) state_value = { TXN_AUTHOR_AGREEMENT_TEXT: text, TXN_AUTHOR_AGREEMENT_VERSION: version } txn_author_agreement_handler.update_state(txn, None, taa_request) assert txn_author_agreement_handler.get_from_state( StaticTAAHelper.state_path_taa_digest(digest)) == (state_value, seq_no, txn_time) assert txn_author_agreement_handler.state.get( StaticTAAHelper.state_path_taa_latest()) == digest assert txn_author_agreement_handler.state.get( StaticTAAHelper.state_path_taa_version(version)) == digest
def add_txn_to_ledger(txn_time: Optional[int]) -> dict: nonlocal node req = sdk_random_request_objects(1, CURRENT_PROTOCOL_VERSION, identifier='someidentifier')[0] txn = reqToTxn(req) node.domainLedger.append_txns_metadata([txn], txn_time=txn_time) node.domainLedger.appendTxns([txn]) return txn
def test_init_state_from_ledger(config_ledger, config_state, config_req_handler, constraint_serializer, prepare_request): req_count = 1 action, constraint, request = prepare_request txn = reqToTxn(request) txn[TXN_METADATA][TXN_METADATA_SEQ_NO] = 1 """Add txn to ledger""" config_ledger.appendTxns([txn]) config_ledger.commitTxns(req_count) init_state_from_ledger = functools.partial( Node.init_state_from_ledger, FakeSomething(update_txn_with_extra_data=lambda txn: txn)) """Check that txn is not exist in state""" assert config_state.get(action.get_action_id().encode(), isCommitted=False) is None assert config_state.get(action.get_action_id().encode(), isCommitted=True) is None txns_from_ledger = [t for t in config_ledger.getAllTxn()] """Check, that txn exist in ledger""" assert len(txns_from_ledger) == 1 assert get_payload_data(txns_from_ledger[0][1]) == get_payload_data(txn) """Emulating node starting""" init_state_from_ledger(config_state, config_ledger, config_req_handler) """Check that txn was added into state""" from_state = config_state.get(action.get_action_id().encode(), isCommitted=True) assert constraint_serializer.deserialize(from_state) == constraint
def add_revoc_def_by_default(create_node_and_not_start, looper, sdk_wallet_steward): node = create_node_and_not_start data = { ID: randomString(50), TXN_TYPE: REVOC_REG_DEF, REVOC_TYPE: "CL_ACCUM", TAG: randomString(5), CRED_DEF_ID: randomString(50), VALUE:{ ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT, MAX_CRED_NUM: 1000000, TAILS_HASH: randomString(50), TAILS_LOCATION: 'http://tails.location.com', PUBLIC_KEYS: {}, } } req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) req_handler = node.getDomainReqHandler() txn = reqToTxn(Request(**req)) txn[f.SEQ_NO.nm] = node.domainLedger.seqNo + 1 txn[TXN_TIME] = int(time.time()) req_handler._addRevocDef(txn) return req
def apply_request(self, request: Request, batch_ts, prev_result): txn_type = request.operation[TXN_TYPE] seq_no = get_seq_no(prev_result) cons_time = get_txn_time(prev_result) if FeesAuthorizer.has_fees(request): inputs, outputs, signatures = getattr(request, f.FEES.nm) # This is correct since FEES is changed from config ledger whose # transactions have no fees fees = FeesAuthorizer.calculate_fees_from_req( self.utxo_cache, request) sigs = {i[ADDRESS]: s for i, s in zip(inputs, signatures)} txn = { OPERATION: { TXN_TYPE: FEE_TXN, INPUTS: inputs, OUTPUTS: outputs, REF: self._get_ref_for_txn_fees(seq_no), FEES: fees, }, f.SIGS.nm: sigs, f.REQ_ID.nm: get_req_id(prev_result), f.PROTOCOL_VERSION.nm: 2, } txn = reqToTxn(txn) self.token_ledger.append_txns_metadata([txn], txn_time=cons_time) _, txns = self.token_ledger.appendTxns([txn]) self.update_token_state(txn, request) self._fees_tracker.fees_in_current_batch += 1 self._fees_tracker.add_deducted_fees(txn_type, seq_no, fees) return None, None, prev_result
def deduct_fees(self, request, cons_time, ledger_id, seq_no, txn): txn_type = request.operation[TXN_TYPE] fees_key = "{}#{}".format(txn_type, seq_no) if txn_type != XFER_PUBLIC and FeesAuthorizer.has_fees(request): inputs, outputs, signatures = getattr(request, f.FEES.nm) # This is correct since FEES is changed from config ledger whose # transactions have no fees fees = FeesAuthorizer.calculate_fees_from_req( self.utxo_cache, request) sigs = {i[ADDRESS]: s for i, s in zip(inputs, signatures)} txn = { OPERATION: { TXN_TYPE: FEE_TXN, INPUTS: inputs, OUTPUTS: outputs, REF: self.get_ref_for_txn_fees(ledger_id, seq_no), FEES: fees, }, f.SIGS.nm: sigs, f.REQ_ID.nm: get_req_id(txn), f.PROTOCOL_VERSION.nm: 2, } txn = reqToTxn(txn) self.token_ledger.append_txns_metadata([txn], txn_time=cons_time) _, txns = self.token_ledger.appendTxns( [TokenReqHandler.transform_txn_for_ledger(txn)]) self.updateState(txns) self.fee_txns_in_current_batch += 1 self.deducted_fees[fees_key] = fees return txn
def _reqToTxn(self, req: Request, cons_time: int): txn = reqToTxn(req, cons_time) for processor in self.reqProcessors: res = processor.process(req) txn.update(res) return txn
def tryOrderAndAddTxns(self, commit): canOrder, _ = self.canOrder(commit) node = replica.node if not replica.added and canOrder: pp = self.getPrePrepare(commit.viewNo, commit.ppSeqNo) ledger_manager = node.ledgerManager ledger_id = DOMAIN_LEDGER_ID catchup_rep_service = ledger_manager._leechers[ ledger_id].catchup_rep_service # simulate audit ledger catchup three_pc_batch = ThreePcBatch.from_pre_prepare( pre_prepare=pp, valid_txn_count=len(reqs), state_root=pp.stateRootHash, txn_root=pp.txnRootHash) node.audit_handler.post_batch_applied(three_pc_batch) node.audit_handler.commit_batch(ledger_id, len(reqs), pp.stateRootHash, pp.txnRootHash, pp.ppTime) ledger_manager.preCatchupClbk(ledger_id) pp = self.getPrePrepare(commit.viewNo, commit.ppSeqNo) for req in reqs: txn = append_txn_metadata(reqToTxn(req), txn_time=pp.ppTime) catchup_rep_service._add_txn(txn) ledger_manager.catchupCompleted(DOMAIN_LEDGER_ID, (node.viewNo, commit.ppSeqNo)) replica.added = True return origMethod(commit)
def add_revoc_def_by_default(create_node_and_not_start, looper, sdk_wallet_steward): node = create_node_and_not_start data = { ID: randomString(50), TXN_TYPE: REVOC_REG_DEF, REVOC_TYPE: "CL_ACCUM", TAG: randomString(5), CRED_DEF_ID: ":".join(4*[randomString(10)]), VALUE:{ ISSUANCE_TYPE: ISSUANCE_BY_DEFAULT, MAX_CRED_NUM: 1000000, TAILS_HASH: randomString(50), TAILS_LOCATION: 'http://tails.location.com', PUBLIC_KEYS: {}, } } req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) req_handler = node.getDomainReqHandler() txn = append_txn_metadata(reqToTxn(Request(**req)), txn_time=int(time.time()), seq_no=node.domainLedger.seqNo + 1) req_handler._addRevocDef(txn) return req
def test_get_delta_with_other_reg_def_in_state(looper, create_node_and_not_start, reg_entry_with_other_reg_id, build_txn_for_revoc_def_entry_by_default, build_get_revoc_reg_delta): entry_second_id = build_txn_for_revoc_def_entry_by_default delta_req = build_get_revoc_reg_delta node = create_node_and_not_start # need for different txnTime looper.runFor(2) req_handler = node.getDomainReqHandler() txn = append_txn_metadata(reqToTxn(entry_second_id), txn_time=SECOND_TS_ID, seq_no=node.domainLedger.seqNo + 1) req_handler._addRevocRegEntry(txn) req_handler.ts_store.set(get_txn_time(txn), req_handler.state.headHash) # timestamp beetween FIRST_ID_TS and SECOND_ID_TS delta_req['operation'][FROM] = FIRST_ID_TS + 10 path_to_reg_entry = domain.make_state_path_for_revoc_reg_entry( revoc_reg_def_id=entry_second_id['operation'][REVOC_REG_DEF_ID]) reg_entry = req_handler._get_reg_entry_by_timestamp( delta_req['operation'][FROM], path_to_reg_entry) # we found root_hash in txRevoc storage but there is not corresponded reg_entry by path assert reg_entry.root_hash is not None assert reg_entry.value is None path_to_reg_entry_accum = domain.make_state_path_for_revoc_reg_entry( revoc_reg_def_id=entry_second_id['operation'][REVOC_REG_DEF_ID]) reg_entry_accum = req_handler._get_reg_entry_accum_by_timestamp( delta_req['operation'][FROM], path_to_reg_entry_accum) assert reg_entry_accum.root_hash is not None assert reg_entry_accum.value is None
def _add_txns_to_ledger(node, looper, sdk_wallet_client, num_txns_in_reply, reply_count): ''' Add txn_count transactions to node's ledger and return ConsistencyProof for all new transactions and list of CatchupReplies :return: ConsistencyProof, list of CatchupReplies ''' txn_count = num_txns_in_reply * reply_count ledger_manager = node.ledgerManager ledger = ledger_manager.ledgerRegistry[ledger_id].ledger ledger_info = ledger_manager.getLedgerInfoByType(ledger_id) reqs = sdk_signed_random_requests(looper, sdk_wallet_client, txn_count) # add transactions to ledger for req in reqs: txn = append_txn_metadata(reqToTxn(req), txn_time=12345678) ledger_manager._add_txn( ledger_id, ledger, ledger_info, txn) # generate CatchupReps replies = [] for i in range(ledger.seqNo - txn_count + 1, ledger.seqNo + 1, num_txns_in_reply): start = i end = i + num_txns_in_reply - 1 cons_proof = ledger_manager._make_consistency_proof(ledger, end, ledger.size) txns = {} for seq_no, txn in ledger.getAllTxn(start, end): txns[str(seq_no)] = ledger_manager.owner.update_txn_with_extra_data(txn) replies.append(CatchupRep(ledger_id, SortedDict(txns), cons_proof)) return ledger_manager._buildConsistencyProof(ledger_id, ledger.seqNo - txn_count, ledger.seqNo), replies
def test_get_delta_with_other_reg_def_in_state( looper, create_node_and_not_start, reg_entry_with_other_reg_id, build_txn_for_revoc_def_entry_by_default, build_get_revoc_reg_delta): entry_second_id = build_txn_for_revoc_def_entry_by_default delta_req = build_get_revoc_reg_delta node = create_node_and_not_start # need for different txnTime looper.runFor(2) req_handler = node.getDomainReqHandler() txn = append_txn_metadata(reqToTxn(entry_second_id), txn_time=SECOND_TS_ID, seq_no=node.domainLedger.seqNo + 1) req_handler._addRevocRegEntry(txn) req_handler.ts_store.set(get_txn_time(txn), req_handler.state.headHash) # timestamp beetween FIRST_ID_TS and SECOND_ID_TS delta_req['operation'][FROM] = FIRST_ID_TS + 10 path_to_reg_entry = domain.make_state_path_for_revoc_reg_entry( revoc_reg_def_id=entry_second_id['operation'][REVOC_REG_DEF_ID]) reg_entry = req_handler._get_reg_entry_by_timestamp( delta_req['operation'][FROM], path_to_reg_entry) # we found root_hash in txRevoc storage but there is not corresponded reg_entry by path assert reg_entry.root_hash is not None assert reg_entry.value is None path_to_reg_entry_accum = domain.make_state_path_for_revoc_reg_entry( revoc_reg_def_id=entry_second_id['operation'][REVOC_REG_DEF_ID]) reg_entry_accum = req_handler._get_reg_entry_accum_by_timestamp( delta_req['operation'][FROM], path_to_reg_entry_accum) assert reg_entry_accum.root_hash is not None assert reg_entry_accum.value is None
def test_init_state_from_ledger(write_manager, db_manager, constraint_serializer, prepare_request): reset_state(db_manager, CONFIG_LEDGER_ID) req_count = 1 action, constraint, request = prepare_request txn = reqToTxn(request) txn[TXN_METADATA][TXN_METADATA_SEQ_NO] = 1 """Add txn to ledger""" db_manager.get_ledger(CONFIG_LEDGER_ID).appendTxns([txn]) db_manager.get_ledger(CONFIG_LEDGER_ID).commitTxns(req_count) # ToDo: ugly fix... Refactor this on pluggable req handler integration phase init_state_from_ledger = functools.partial( LedgersBootstrap._init_state_from_ledger, FakeSomething( db_manager=db_manager, write_manager=write_manager, _update_txn_with_extra_data=lambda txn: txn)) """Check that txn is not exist in state""" assert db_manager.get_state(CONFIG_LEDGER_ID).get(config.make_state_path_for_auth_rule(action.get_action_id()), isCommitted=False) is None assert db_manager.get_state(CONFIG_LEDGER_ID).get(config.make_state_path_for_auth_rule(action.get_action_id()), isCommitted=True) is None txns_from_ledger = [t for t in db_manager.get_ledger(CONFIG_LEDGER_ID).getAllTxn()] """Check, that txn exist in ledger""" assert len(txns_from_ledger) == 1 assert get_payload_data(txns_from_ledger[0][1]) == get_payload_data(txn) """Emulating node starting""" init_state_from_ledger(CONFIG_LEDGER_ID) """Check that txn was added into state""" from_state = db_manager.get_state(CONFIG_LEDGER_ID) .get( config.make_state_path_for_auth_rule(action.get_action_id()), isCommitted=True) assert constraint_serializer.deserialize(from_state) == constraint
def test_req_to_txn_with_seq_no(req_and_expected): req, new_expected = req_and_expected new = SortedDict( append_txn_metadata(reqToTxn(req), seq_no=143, txn_time=2613945121)) new_expected["txnMetadata"]["txnTime"] = 2613945121 new_expected["txnMetadata"]["seqNo"] = 143 assert new == new_expected
def _transform(self, txn): # Certain transactions other than pool ledger might need to be # transformed to certain format before applying to the ledger txn = reqToTxn(txn) z = txn if not self.ownedByNode else \ self.owner.transform_txn_for_ledger(txn) return z
def test_no_state_proofs_if_protocol_version_less(request_handler): nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv' role = "2" verkey = "~7TYfekw4GUagBnBVCqPjiC" seq_no = 0 txn_time = int(time.time()) # Adding nym data = { f.IDENTIFIER.nm: nym, ROLE: role, VERKEY: verkey, f.SEQ_NO.nm: seq_no, TXN_TIME: txn_time, } txn = append_txn_metadata(reqToTxn(Request(operation=data)), seq_no=seq_no, txn_time=txn_time) txn = append_payload_metadata(txn, frm=nym) request_handler.updateNym(nym, txn) request_handler.state.commit() multi_sig = save_multi_sig(request_handler) # Getting nym request = Request(operation={TARGET_NYM: nym}, signatures={}) result = request_handler.handleGetNymReq(request) assert STATE_PROOF not in result
def test_process_invalid_catchup_reply(txnPoolNodeSet, looper, sdk_wallet_client): ''' Test correct work of method processCatchupRep and that sending replies in reverse order will call a few iterations of cycle in _processCatchupRep ''' ledger_manager = txnPoolNodeSet[0].ledgerManager catchup_rep_service = ledger_manager._leechers[ ledger_id].catchup_rep_service ledger = ledger_manager.ledgerRegistry[ledger_id].ledger ledger_size = ledger.size num_txns_in_reply = 3 reply_count = 2 cons_proof, catchup_reps = _add_txns_to_ledger(txnPoolNodeSet[1], looper, sdk_wallet_client, num_txns_in_reply, reply_count) catchup_rep_service._catchup_till = cons_proof catchup_rep_service._is_working = True # make invalid catchup reply by dint of adding new transaction in it reply2 = catchup_reps[1] txns = OrderedDict(getattr(reply2, f.TXNS.nm)) req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)[0] txns[str(ledger_size + 4)] = append_txn_metadata(reqToTxn(req), txn_time=12345678) invalid_reply2 = CatchupRep(ledger_id, txns, getattr(reply2, f.CONS_PROOF.nm)) # process 2nd interval with invalid catchup reply ledger_manager.processCatchupRep(invalid_reply2, sdk_wallet_client[1]) # check that invalid transaction was not added to ledger, but add to ledger_info.receivedCatchUpReplies check_reply_not_applied(ledger_size, ledger, catchup_rep_service, sdk_wallet_client[1], invalid_reply2) # process valid reply from 1st interval reply1 = catchup_reps[0] ledger_manager.processCatchupRep(reply1, sdk_wallet_client[1]) # check that only valid reply added to ledger ledger_size = check_replies_applied(ledger_size, ledger, catchup_rep_service, sdk_wallet_client[1], [reply1]) # check that invalid reply was removed from ledger_info.receivedCatchUpReplies received_replies = { str(seq_no) for seq_no, _ in catchup_rep_service._received_catchup_txns } assert not set(reply2.txns.keys()).issubset(received_replies) assert not catchup_rep_service._received_catchup_replies_from[ sdk_wallet_client[1]] # check that valid reply for 2nd interval was added to ledger reply2 = catchup_reps[1] ledger_manager.processCatchupRep(reply2, sdk_wallet_client[1]) ledger_size = check_replies_applied(ledger_size, ledger, catchup_rep_service, sdk_wallet_client[1], [reply2]) assert not catchup_rep_service._received_catchup_replies_from assert not catchup_rep_service._received_catchup_txns
def make_rich_schema_object_exist(handler, request, commit=False): seq_no = 1 txn_time = 1560241033 txn = reqToTxn(request) append_txn_metadata(txn, seq_no, txn_time) handler.update_state(txn, None, context_request) if commit: handler.state.commit()
def create_nym_txn(identifier, role, nym="TARGET_NYM"): return reqToTxn( Request(identifier=identifier, operation={ ROLE: role, TXN_TYPE: NYM, TARGET_NYM: nym }))
def test_process_invalid_catchup_reply(txnPoolNodeSet, looper, sdk_wallet_client): ''' Test correct work of method processCatchupRep and that sending replies in reverse order will call a few iterations of cycle in _processCatchupRep ''' ledger_manager = txnPoolNodeSet[0].ledgerManager ledger_info = ledger_manager.getLedgerInfoByType(ledger_id) ledger = ledger_manager.ledgerRegistry[ledger_id].ledger ledger_size = ledger.size num_txns_in_reply = 3 reply_count = 2 cons_proof, catchup_reps = _add_txns_to_ledger(txnPoolNodeSet[1], looper, sdk_wallet_client, num_txns_in_reply, reply_count) ledger_info.catchUpTill = cons_proof ledger_info.state = LedgerState.syncing # make invalid catchup reply by dint of adding new transaction in it reply2 = catchup_reps[1] txns = OrderedDict(getattr(reply2, f.TXNS.nm)) req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)[0] txns[str(ledger_size + 4)] = append_txn_metadata(reqToTxn(req), txn_time=12345678) invalid_reply2 = CatchupRep(ledger_id, txns, getattr(reply2, f.CONS_PROOF.nm)) # process 2nd interval with invalid catchup reply ledger_manager.processCatchupRep(invalid_reply2, sdk_wallet_client[1]) # check that invalid transaction was not added to ledger, but add to ledger_info.receivedCatchUpReplies check_reply_not_applied(ledger_size, ledger, ledger_info, sdk_wallet_client[1], invalid_reply2) # process valid reply from 1st interval reply1 = catchup_reps[0] ledger_manager.processCatchupRep(reply1, sdk_wallet_client[1]) # check that only valid reply added to ledger ledger_size = check_replies_applied(ledger_size, ledger, ledger_info, sdk_wallet_client[1], [reply1]) # check that invalid reply was removed from ledger_info.receivedCatchUpReplies received_replies = {str(seq_no) for seq_no, _ in ledger_info.receivedCatchUpReplies} assert not set(getattr(reply2, f.TXNS.nm).keys()).issubset(received_replies) assert not ledger_info.recvdCatchupRepliesFrm[sdk_wallet_client[1]] # check that valid reply for 2nd interval was added to ledger reply2 = catchup_reps[1] ledger_manager.processCatchupRep(reply2, sdk_wallet_client[1]) ledger_size = check_replies_applied(ledger_size, ledger, ledger_info, sdk_wallet_client[1], [reply2]) assert not ledger_info.receivedCatchUpReplies assert not ledger_info.recvdCatchupRepliesFrm
def test_update_state(auth_rule_request, auth_rule_handler: AuthRuleHandler): txn = reqToTxn(auth_rule_request) payload = get_payload_data(txn) constraint = StaticAuthRuleHelper.get_auth_constraint(payload) auth_key = StaticAuthRuleHelper.get_auth_key(payload) path = AbstractAuthRuleHandler.make_state_path_for_auth_rule(auth_key) auth_rule_handler.update_state(txn, None, auth_rule_request) assert auth_rule_handler.get_from_state(path) == constraint.as_dict
def test_claim_def_dynamic_validation_without_ref_to_not_schema(claim_def_request, schema_request, claim_def_handler: ClaimDefHandler, creator): nym = reqToTxn(Request(identifier=creator, operation={'type': NYM})) claim_def_request.operation[REF] = get_seq_no(nym) claim_def_handler.ledger.appendTxns([nym]) with pytest.raises(InvalidClientRequest) as e: claim_def_handler.dynamic_validation(claim_def_request) assert "Mentioned seqNo ({}) isn't seqNo of the schema.".format(claim_def_request.operation[REF]) \ in e._excinfo[1].args[0]
def test_update_state(revoc_reg_entry_handler, revoc_reg_entry_request): seq_no = 1 txn_time = 1560241033 txn = reqToTxn(revoc_reg_entry_request) append_txn_metadata(txn, seq_no, txn_time) with pytest.raises(InvalidClientRequest, match="There is no any REVOC_REG_DEF by path"): revoc_reg_entry_handler.update_state(txn, None, revoc_reg_entry_request)
def test_req_to_txn_with_seq_no(req_and_expected): req, new_expected = req_and_expected new = SortedDict( append_txn_metadata( reqToTxn(req), seq_no=143, txn_time=2613945121) ) new_expected["txnMetadata"]["txnTime"] = 2613945121 new_expected["txnMetadata"]["seqNo"] = 143 assert new == new_expected
def reg_entry_with_other_reg_id(looper, sdk_wallet_steward, add_another_reg_id, create_node_and_not_start): node = create_node_and_not_start revoc_def_txn = add_another_reg_id data = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_txn) req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data) looper.runFor(2) req_handler = node.getDomainReqHandler() txn = append_txn_metadata(reqToTxn(Request(**req)), txn_time=FIRST_ID_TS, seq_no=node.domainLedger.seqNo + 1) req_handler._addRevocRegEntry(txn) req_handler.ts_store.set(get_txn_time(txn), req_handler.state.headHash) return txn
def tryOrderAndAddTxns(self, commit): canOrder, _ = self.canOrder(commit) node = replica.node if not replica.added and canOrder: ledger_manager = node.ledgerManager ledger_id = DOMAIN_LEDGER_ID ledger = ledger_manager.ledgerRegistry[ledger_id].ledger ledgerInfo = ledger_manager.getLedgerInfoByType(ledger_id) ledger_manager.preCatchupClbk(ledger_id) pp = self.getPrePrepare(commit.viewNo, commit.ppSeqNo) for req in reqs: txn = append_txn_metadata(reqToTxn(req), txn_time=pp.ppTime) ledger_manager._add_txn( ledger_id, ledger, ledgerInfo, txn) ledger_manager.catchupCompleted( DOMAIN_LEDGER_ID, (node.viewNo, commit.ppSeqNo)) replica.added = True return origMethod(commit)
def create_txns(looper, sdk_wallet_client): reqs = sdk_signed_random_requests(looper, sdk_wallet_client, TXNS_IN_BATCH) return [reqToTxn(req) for req in reqs]
def _reqToTxn(self, req: Request): return reqToTxn(req)
def prepare_for_state_read(req: Request): if req.txn_type == "buy": from plenum.test.test_node import TestDomainRequestHandler txn = reqToTxn(req) key, value = TestDomainRequestHandler.prepare_buy_for_state(txn) return key, value
wallet_h, did = sdk_wallet reqs_str = [json.dumps(req.as_dict) for req in reqs] resp = [looper.loop.run_until_complete(sign_request(wallet_h, did, req)) for req in reqs_str] return resp def sdk_signed_random_requests(looper, sdk_wallet, count): _, did = sdk_wallet reqs_obj = sdk_random_request_objects(count, identifier=did, protocol_version=CURRENT_PROTOCOL_VERSION) return sdk_sign_request_objects(looper, sdk_wallet, reqs_obj) if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument('count', help="Count of generated txns", type=int) parser.add_argument('outfpath', help="Path to save generated txns", type=str, default='/tmp/generated_txns') args = parser.parse_args() path_to_save = os.path.realpath(args.outfpath) with ExitStack() as exit_stack: with Looper() as looper: sdk_wallet, DID = looper.loop.run_until_complete(get_wallet_and_pool()) with open(path_to_save, 'w') as outpath: for i in range(args.count): req = sdk_signed_random_requests(looper, (sdk_wallet, DID), 1)[0] txn = reqToTxn(req) append_txn_metadata(txn, txn_time=int(time.time())) outpath.write(json.dumps(txn)) outpath.write(os.linesep) looper.stopall()
def apply(self, req: Request): txn = reqToTxn(req) self.ledger.appendTxns([txn]) return txn
def apply(self, req: Request, cons_time): txn = append_txn_metadata(reqToTxn(req), txn_time=cons_time) self.ledger.append_txns_metadata([txn]) (start, _), _ = self.ledger.appendTxns([txn]) return start, txn
def apply(self, req: Request, cons_time): txn = reqToTxn(req, cons_time) (start, _), _ = self.ledger.appendTxns([txn]) return start, txn
def applyForced(self, req: Request): if req.isForced(): txn = reqToTxn(req) self.upgrader.handleUpgradeTxn(txn) self.poolCfg.handleConfigTxn(txn)
def test_req_to_txn(req_and_expected): req, new_expected = req_and_expected txn = append_txn_metadata(reqToTxn(req), txn_time=1513945121) new = SortedDict(txn) assert new == new_expected