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
