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 node_txn(steward_nym,
node_name,
nym,
ip,
node_port,
client_port,
client_ip=None,
blskey=None,
services=None,
txn_id=None,
seq_no=None):
txn = init_empty_txn(txn_type=NODE)
txn = append_payload_metadata(txn, frm=steward_nym)
txn_data = {
TARGET_NYM: nym,
DATA: {
CLIENT_IP: client_ip or ip,
ALIAS: node_name,
CLIENT_PORT: client_port,
NODE_IP: ip,
NODE_PORT: node_port,
SERVICES: services or [VALIDATOR],
BLS_KEY: blskey
},
}
txn = set_payload_data(txn, txn_data)
txn_id = txn_id or sha256(node_name.encode()).hexdigest()
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def test_append_txn_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn, frm="DID1", req_id=12345)
append_txn_metadata(txn, seq_no=144, txn_time=12345678, txn_id="dddd")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {
"somekey": "somevalue"
},
"metadata": {
"from": "DID1",
"reqId": 12345,
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {
"seqNo": 144,
"txnId": "dddd",
"txnTime": 12345678,
},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
def _append_seq_no(self, txns, start_seq_no):
# TODO: Fix name `start_seq_no`, it is misleading. The seq no start from `start_seq_no`+1
seq_no = start_seq_no
for txn in txns:
seq_no += 1
append_txn_metadata(txn, seq_no=seq_no)
return txns
def append_txns_metadata(self, txns: List, txn_time=None):
if txn_time is not None:
# All transactions have the same time since all these
# transactions belong to the same 3PC batch
for txn in txns:
append_txn_metadata(txn, txn_time=txn_time)
self._append_seq_no(txns, self.seqNo + len(self.uncommittedTxns))
def _append_seq_no(self, txns, start_seq_no):
# TODO: Fix name `start_seq_no`, it is misleading. The seq no start from `start_seq_no`+1
seq_no = start_seq_no
for txn in txns:
seq_no += 1
append_txn_metadata(txn, seq_no=seq_no)
return txns
def append_txns_metadata(self, txns: List, txn_time=None):
if txn_time is not None:
# All transactions have the same time since all these
# transactions belong to the same 3PC batch
for txn in txns:
append_txn_metadata(txn, txn_time=txn_time)
self._append_seq_no(txns, self.seqNo + len(self.uncommittedTxns))
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 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 nym_txn(nym,
name=None,
verkey=None,
role=None,
creator=None,
txn_id=None,
seq_no=None):
txn = init_empty_txn(NYM)
txn_data = {
TARGET_NYM: nym,
}
if verkey is not None:
txn_data[VERKEY] = verkey
if role is not None:
txn_data[ROLE] = role
if name is not None:
txn_data[ALIAS] = name
set_payload_data(txn, txn_data)
txn = append_payload_metadata(txn, frm=creator)
if txn_id:
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def node_txn(steward_nym, node_name, nym, ip, node_port, client_port,
client_ip=None, blskey=None, services=None, txn_id=None,
seq_no=None,
protocol_version=CURRENT_PROTOCOL_VERSION, bls_key_proof=None):
txn = init_empty_txn(txn_type=NODE, protocol_version=protocol_version)
txn = append_payload_metadata(txn, frm=steward_nym)
txn_data = {
TARGET_NYM: nym,
DATA: {
CLIENT_IP: client_ip or ip,
ALIAS: node_name,
CLIENT_PORT: client_port,
NODE_IP: ip,
NODE_PORT: node_port,
SERVICES: services or [VALIDATOR],
BLS_KEY: blskey,
BLS_KEY_PROOF: bls_key_proof
},
}
txn = set_payload_data(txn, txn_data)
txn_id = txn_id or sha256(node_name.encode()).hexdigest()
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
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 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_update_state(schema_request, schema_handler):
seq_no = 1
txn_time = 1560241033
txn = reqToTxn(schema_request)
append_txn_metadata(txn, seq_no, txn_time)
path, value_bytes = SchemaHandler.prepare_schema_for_state(txn)
value = {SCHEMA_ATTR_NAMES: get_txn_schema_attr_names(txn)}
schema_handler.update_state(txn, None, schema_request)
assert schema_handler.get_from_state(path) == (value, seq_no, txn_time)
def test_update_state(context_request, context_handler):
seq_no = 1
txn_time = 1560241033
txn = reqToTxn(context_request)
append_txn_metadata(txn, seq_no, txn_time)
path, value_bytes = ContextHandler.prepare_context_for_state(txn)
value = {META: get_txn_context_meta(txn), DATA: get_txn_context_data(txn)}
context_handler.update_state(txn, None, context_request)
assert context_handler.get_from_state(path) == (value, seq_no, txn_time)
def test_update_state(revoc_reg_def_handler, revoc_reg_def_request):
seq_no = 1
txn_time = 1560241033
txn = reqToTxn(revoc_reg_def_request)
append_txn_metadata(txn, seq_no, txn_time)
value = get_payload_data(txn)
path = RevocRegDefHandler.prepare_revoc_def_for_state(txn, path_only=True)
revoc_reg_def_handler.update_state(txn, None, revoc_reg_def_request)
assert revoc_reg_def_handler.get_from_state(path) == (value, seq_no,
txn_time)
def test_update_state(attrib_handler, attrib_request):
seq_no = 1
txn_time = 1560241033
txn_id = "id"
txn = reqToTxn(attrib_request)
append_txn_metadata(txn, seq_no, txn_time, txn_id)
attr_type, path, value, hashed_value, value_bytes = AttributeHandler.prepare_attr_for_state(
txn)
attrib_handler.update_state(txn, None, attrib_request)
assert attrib_handler.get_from_state(path) == (hashed_value, seq_no,
txn_time)
def test_update_state_with_incorrect_schema_seq_no(
claim_def_request, claim_def_handler: ClaimDefHandler, schema_handler,
schema_request):
claim_def_seq_no = 1
claim_def_txn_time = 1560241033
claim_def_txn = reqToTxn(claim_def_request)
append_txn_metadata(claim_def_txn, claim_def_seq_no, claim_def_txn_time)
with pytest.raises(
ValueError,
match="'{}' field is absent, "
"but it must contain schema seq no".format(CLAIM_DEF_SCHEMA_REF)):
claim_def_handler.update_state(claim_def_txn, None, claim_def_request)
def test_update_state(node_handler, node_request):
seq_no = 1
txn_time = 1560241033
txn_id = "id"
txn = reqToTxn(node_request)
append_txn_metadata(txn, seq_no, txn_time, txn_id)
expected_data = node_request.operation[DATA]
expected_data.update({IDENTIFIER: node_request.identifier})
node_handler.update_state(txn, None, node_request)
tmp = node_handler.get_from_state(node_handler.gen_state_key(txn))
assert set(tmp.items()) == set(expected_data.items())
def test_update_state(rs_schema_request, rs_schema_handler):
seq_no = 1
txn_time = 1560241033
txn = reqToTxn(rs_schema_request)
append_txn_metadata(txn, seq_no, txn_time)
path, value_bytes = RsSchemaHandler.prepare_state(txn)
payload = txn[TXN_PAYLOAD][RS_DATA]
meta, data = payload[RS_META], payload[RS_DATA]
value = {
RS_META: meta,
RS_DATA: data
}
rs_schema_handler.update_state(txn, None, rs_schema_request)
assert rs_schema_handler.get_from_state(path) == (value, seq_no, txn_time)
def test_update_state(txn_author_agreement_disable_handler,
taa_disable_request, txn_author_agreement_handler, tconf,
domain_state, taa_pp_time):
# create TAAs
taa_txns = []
taa_digests = []
taa_state_datas = []
for _ in list(range(5)):
txn, digest, state_data = create_taa_txn(
taa_request(tconf, domain_state, taa_pp_time), taa_pp_time)
taa_txns.append(txn)
taa_digests.append(digest)
taa_state_datas.append(state_data)
assert taa_txns
# create a disable txn
disable_seq_no = 1
disable_txn_time = get_utc_epoch()
taa_disable_txn = reqToTxn(taa_disable_request)
append_txn_metadata(taa_disable_txn, disable_seq_no, disable_txn_time)
# set a TAAs
for index, taa_txn in enumerate(taa_txns):
txn_author_agreement_handler.update_state(taa_txn, None, None)
check_taa_in_state(
handler=txn_author_agreement_handler,
digest=taa_digests[index],
version=taa_state_datas[index][0][TXN_AUTHOR_AGREEMENT_VERSION],
state_data=taa_state_datas[index])
assert txn_author_agreement_disable_handler.state.get(
StaticTAAHelper.state_path_taa_latest(),
isCommitted=False) == taa_digests[index].encode()
# disable TAAs
txn_author_agreement_disable_handler.update_state(taa_disable_txn, None,
None)
assert txn_author_agreement_disable_handler.state.get(
StaticTAAHelper.state_path_taa_latest(), isCommitted=False) is None
# set a TAAs
for index, state_data in enumerate(taa_state_datas):
state_value = state_data[0]
state_value[TXN_AUTHOR_AGREEMENT_RETIREMENT_TS] = disable_txn_time
check_taa_in_state(handler=txn_author_agreement_handler,
digest=taa_digests[index],
version=state_value[TXN_AUTHOR_AGREEMENT_VERSION],
state_data=(state_data[0], disable_seq_no,
disable_txn_time))
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 _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 apply_request(self, request: Request, batch_ts, prev_result):
txn = self._req_to_txn(request)
txn = append_txn_metadata(txn,
seq_no=prev_result.get(f.SEQ_NO.nm),
txn_time=prev_result.get(TXN_TIME))
return self.update_state(txn, prev_result, request)
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_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_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_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 db_manager(tconf):
_db_manager = DatabaseManager()
storage = initKeyValueStorage(
KeyValueStorageType.Memory,
None,
"tokenInMemoryStore",
txn_serializer=serialization.multi_sig_store_serializer)
ledger = get_fake_ledger()
def commit_txns(count):
ledger.committed_root_hash = ledger.uncommitted_root_hash
return None, [1]
ledger.commitTxns = commit_txns
ledger.root_hash = txn_root_serializer.serialize("1")
ledger.uncommitted_root_hash = "1"
ledger.uncommitted_size = 1
ledger.size = 0
ledger.discardTxns = lambda x: None
ledger.committed_root_hash = "-1"
ledger.append_txns_metadata = lambda txns, txn_time: [
append_txn_metadata(txn, 2, txn_time, 2) for txn in txns
]
ledger.appendTxns = lambda x: (None, x)
_db_manager.register_new_database(TOKEN_LEDGER_ID, ledger,
PruningState(storage))
return _db_manager
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 _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_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 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_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 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 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 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 apply_request(self, request: Request, batch_ts):
txn = self._reqToTxn(request)
txn = append_txn_metadata(txn, txn_id=self.gen_txn_path(txn))
db = self.get_db_by_request(request)
db.ledger.append_txns_metadata([txn], batch_ts)
(start, end), _ = db.ledger.appendTxns(
[self.transform_txn_for_ledger(txn)])
self.updateState([txn])
return start, txn
def apply(self, req: Request, cons_time: int):
txn = self._reqToTxn(req)
txn = append_txn_metadata(txn, txn_id=self.gen_txn_path(txn))
self.ledger.append_txns_metadata([txn], cons_time)
(start, end), _ = self.ledger.appendTxns(
[self.transform_txn_for_ledger(txn)])
self.updateState([txn])
return start, txn
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 nym_txn(nym, name=None, verkey=None, role=None, creator=None, txn_id=None, seq_no=None,
protocol_version=CURRENT_PROTOCOL_VERSION):
txn = init_empty_txn(NYM, protocol_version=protocol_version)
txn_data = {
TARGET_NYM: nym,
}
if verkey is not None:
txn_data[VERKEY] = verkey
if role is not None:
txn_data[ROLE] = role
if name is not None:
txn_data[ALIAS] = name
set_payload_data(txn, txn_data)
txn = append_payload_metadata(txn,
frm=creator)
if txn_id:
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def test_append_txn_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn, frm="DID1", req_id=12345)
append_txn_metadata(txn, seq_no=144, txn_time=12345678, txn_id="dddd")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {"somekey": "somevalue"},
"metadata": {
"from": "DID1",
"reqId": 12345,
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {
"seqNo": 144,
"txnId": "dddd",
"txnTime": 12345678,
},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
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 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
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 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
