def client_send_revoc_reg_def(looper, txnPoolNodeSet, sdk_wallet_client,
sdk_pool_handle, build_revoc_def_by_default,
claim_def, tconf):
# We need to have claim_def to send revocation txns
Authoriser.auth_map = None
OLD_ANYONE_CAN_WRITE = tconf.ANYONE_CAN_WRITE
tconf.ANYONE_CAN_WRITE = True
claim_def_req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
claim_def)
sdk_send_and_check([json.dumps(claim_def_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
tconf.ANYONE_CAN_WRITE = OLD_ANYONE_CAN_WRITE
Authoriser.auth_map = None
_, author_did = sdk_wallet_client
revoc_reg = build_revoc_def_by_default
revoc_reg['operation'][CRED_DEF_ID] = \
make_state_path_for_claim_def(author_did,
str(claim_def_req['operation'][CLAIM_DEF_SCHEMA_REF]),
claim_def_req['operation'][CLAIM_DEF_SIGNATURE_TYPE],
claim_def_req['operation'][CLAIM_DEF_TAG]
).decode()
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
revoc_reg['operation'])
_, revoc_reply = sdk_send_and_check([json.dumps(revoc_req)], looper,
txnPoolNodeSet, sdk_pool_handle)[0]
return revoc_req
def do_transfer(txnPoolNodeSet,
sdk_pool_handle,
helpers,
looper,
sdk_wallet,
addresses,
amount,
sign=False):
[address_giver, address_receiver] = addresses
inputs = helpers.general.get_utxo_addresses([address_giver])[0]
change = sum([utxo["amount"] for utxo in inputs]) - amount
outputs = [
{
ADDRESS: address_receiver,
AMOUNT: amount
},
{
ADDRESS: address_giver,
AMOUNT: change
},
]
request = helpers.request.transfer(inputs, outputs)
_, request._identifier = sdk_wallet
requests = sdk_sign_request_objects(looper, sdk_wallet, [request]) \
if sign else [json.dumps(request.as_dict)]
sdk_send_and_check(requests, looper, txnPoolNodeSet, sdk_pool_handle)
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle,
sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes
are disconnected: disconnect 2 of 6 nodes
'''
faulties = nodes_by_rank(txnPoolNodeSet)[-faultyNodes:]
current_node_set = set(txnPoolNodeSet)
for node in faulties:
for r in node.replicas.values():
assert not r.isPrimary
disconnect_node_and_ensure_disconnected(
looper, current_node_set, node, stopNode=False)
current_node_set.remove(node)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(PoolLedgerTimeoutException):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
# The following reconnection of nodes is needed in this test to avoid
# pytest process hangup
for node in faulties:
current_node_set.add(node)
reconnect_node_and_ensure_connected(looper, current_node_set, node)
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle,
sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes
are disconnected: disconnect 2 of 6 nodes
'''
faulties = nodes_by_rank(txnPoolNodeSet)[-faultyNodes:]
current_node_set = set(txnPoolNodeSet)
for node in faulties:
for r in node.replicas:
assert not r.isPrimary
disconnect_node_and_ensure_disconnected(
looper, current_node_set, node, stopNode=False)
current_node_set.remove(node)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(TimeoutError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
# The following reconnection of nodes is needed in this test to avoid
# pytest process hangup
for node in faulties:
current_node_set.add(node)
reconnect_node_and_ensure_connected(looper, current_node_set, node)
def test_revoc_send_twice(send_revoc_def, sdk_pool_handle, looper,
txnPoolNodeSet):
# 1. Send revocation definition
req = send_revoc_def
# 2. Resend revocation definition
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet,
sdk_pool_handle)
def send_claim_def(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
claim_def):
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, claim_def)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet, sdk_pool_handle)
return req
def test_6_nodes_pool_cannot_reach_quorum_with_2_faulty(afterElection, looper,
txnPoolNodeSet, prepared1,
sdk_wallet_client, sdk_pool_handle):
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(PoolLedgerTimeoutException):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def test_6_nodes_pool_cannot_reach_quorum_with_2_faulty(
afterElection, looper, txnPoolNodeSet, prepared1, sdk_wallet_client,
sdk_pool_handle):
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(TimeoutError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def create_revoc_reg_entry(looper, txnPoolNodeSet, sdk_pool_handle, build_revoc, claim_def, wallet):
revoc_def_req = create_revoc_reg_def(looper, txnPoolNodeSet, sdk_pool_handle, build_revoc,
claim_def, wallet)
rev_reg_entry = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req)
rev_reg_entry[VALUE][REVOKED] = [1, 2, 3, 4, 5]
del rev_reg_entry[VALUE][PREV_ACCUM]
rev_entry_req = sdk_sign_request_from_dict(looper, wallet, rev_reg_entry)
sdk_send_and_check([json.dumps(rev_entry_req)], looper, txnPoolNodeSet, sdk_pool_handle)
return rev_entry_req
def test_client_can_send_revoc_reg_entry(looper,
client_send_revoc_reg_def,
sdk_wallet_client,
txnPoolNodeSet,
sdk_pool_handle):
revoc_def_req = client_send_revoc_reg_def
rev_reg_entry = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req)
rev_reg_entry[VALUE][REVOKED] = [1, 2, 3, 4, 5]
del rev_reg_entry[VALUE][PREV_ACCUM]
rev_entry_req = sdk_sign_request_from_dict(looper, sdk_wallet_client, rev_reg_entry)
sdk_send_and_check([json.dumps(rev_entry_req)], looper, txnPoolNodeSet, sdk_pool_handle)
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle, sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes are disconnected:
disconnect 2 of 6 nodes
'''
stop_nodes(looper, txnPoolNodeSet)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(AssertionError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def test_repeated_request_not_processed_if_already_ordered(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
sdk_send_signed_requests(sdk_pool_handle, one_req)
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def test_repeated_request_not_processed_if_already_ordered(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
sdk_send_signed_requests(sdk_pool_handle, one_req)
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def test_client_can_send_claim_def(looper, txnPoolNodeSet, sdk_wallet_client,
sdk_wallet_trust_anchor, sdk_pool_handle,
claim_def):
# Trust anchor can create claim_def in any case
req = sdk_sign_request_from_dict(looper, sdk_wallet_trust_anchor,
claim_def)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet,
sdk_pool_handle)
# Client can create claim_def if ANYONE_CAN_WRITE flag set to False
req = sdk_sign_request_from_dict(looper, sdk_wallet_client, claim_def)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet,
sdk_pool_handle)
def test_catchup_during_3pc(tconf, looper, txnPoolNodeSet, sdk_wallet_client,
sdk_pool_handle):
reqs = sdk_signed_random_requests(looper, sdk_wallet_client,
tconf.Max3PCBatchSize)
non_primary_replica = getNonPrimaryReplicas(txnPoolNodeSet, instId=0)[0]
# Simulate catch-up (add txns to ledger):
# add txns corresponding to the requests after we got enough COMMITs to
# order, but before ordering.
add_txns_to_ledger_before_order(
non_primary_replica,
[json.loads(req) for req in reqs[:tconf.Max3PCBatchSize]])
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
checkNodesHaveSameRoots(txnPoolNodeSet)
def test_belated_propagate_not_processed_if_already_ordered(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
delta.nodeIbStasher.delay(ppgDelay(300, 'Gamma'))
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
delta.nodeIbStasher.reset_delays_and_process_delayeds()
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def test_client_cant_send_claim_def(looper,
txnPoolNodeSet,
sdk_wallet_client,
sdk_wallet_endorser,
sdk_pool_handle,
claim_def):
# Endorser can create claim_def
req = sdk_sign_request_from_dict(looper, sdk_wallet_endorser, claim_def)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet, sdk_pool_handle)
# Client cant send create
req = sdk_sign_request_from_dict(looper, sdk_wallet_client, claim_def)
req = sdk_send_signed_requests(sdk_pool_handle, [json.dumps(req)])
sdk_get_bad_response(looper, req, RequestRejectedException, 'Rule for this action is')
def send_revoc_reg_def_by_demand(looper, txnPoolNodeSet, sdk_wallet_steward,
sdk_pool_handle, send_claim_def,
build_revoc_def_by_demand):
_, author_did = sdk_wallet_steward
claim_def_req = send_claim_def
revoc_reg = build_revoc_def_by_demand
revoc_reg['operation'][CRED_DEF_ID] = build_path_for_claim_def(
author_did, claim_def_req['operation']["signature_type"],
str(claim_def_req['operation']["ref"]))
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward,
revoc_reg['operation'])
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
return revoc_req
def test_belated_propagate_not_processed_if_already_ordered(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
delta.nodeIbStasher.delay(ppgDelay(300, 'Gamma'))
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
delta.nodeIbStasher.reset_delays_and_process_delayeds()
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def test_client_cant_send_claim_def(looper, txnPoolNodeSet, sdk_wallet_client,
sdk_wallet_trust_anchor, sdk_pool_handle,
claim_def):
# Trust anchor can create claim_def in any case
req = sdk_sign_request_from_dict(looper, sdk_wallet_trust_anchor,
claim_def)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet,
sdk_pool_handle)
# Client cant send create if ANYONE_CAN_WRITE flag set to True
req = sdk_sign_request_from_dict(looper, sdk_wallet_client, claim_def)
req = sdk_send_signed_requests(sdk_pool_handle, [json.dumps(req)])
sdk_get_bad_response(looper, req, RequestRejectedException,
'None role cannot add claim def')
def send_revoc_reg_def_by_demand(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_claim_def,
build_revoc_def_by_demand):
_, author_did = sdk_wallet_steward
claim_def_req = send_claim_def
revoc_reg = build_revoc_def_by_demand
revoc_reg['operation'][CRED_DEF_ID] = build_path_for_claim_def(author_did,
claim_def_req['operation']["signature_type"],
str(claim_def_req['operation']["ref"]))
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, revoc_reg['operation'])
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet, sdk_pool_handle)
return revoc_req
def send_revoc_reg_def_by_demand(looper, txnPoolNodeSet, sdk_wallet_steward,
sdk_pool_handle, send_claim_def,
build_revoc_def_by_demand):
_, author_did = sdk_wallet_steward
claim_def_req = send_claim_def
revoc_reg = build_revoc_def_by_demand
revoc_reg['operation'][CRED_DEF_ID] = make_state_path_for_claim_def(
author_did, str(claim_def_req['operation'][CLAIM_DEF_SCHEMA_REF]),
claim_def_req['operation'][CLAIM_DEF_SIGNATURE_TYPE],
claim_def_req['operation'][CLAIM_DEF_TAG]).decode()
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward,
revoc_reg['operation'])
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
return revoc_req
def test_send_get_revoc_reg_def(looper, txnPoolNodeSet, sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_default):
_, author_did = sdk_wallet_steward
revoc_req, _ = send_revoc_reg_def_by_default
revoc_reg_def_id = revoc_req['operation'][ID]
get_revoc_reg_def_req = {
ID:
":".join([
author_did, domain.MARKER_REVOC_DEF,
revoc_req['operation'][CRED_DEF_ID],
revoc_req['operation'][REVOC_TYPE], revoc_req['operation'][TAG]
]),
TXN_TYPE:
GET_REVOC_REG_DEF,
REVOC_TYPE:
revoc_req['operation'][REVOC_TYPE],
}
get_revoc_reg_def_req = sdk_sign_request_from_dict(looper,
sdk_wallet_steward,
get_revoc_reg_def_req)
replies = sdk_send_and_check([json.dumps(get_revoc_reg_def_req)], looper,
txnPoolNodeSet, sdk_pool_handle)
req, reply = replies[0]
compare_request_reply(revoc_req, reply)
def test_send_get_revoc_reg_def(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_default):
_, author_did = sdk_wallet_steward
revoc_req, _ = send_revoc_reg_def_by_default
revoc_reg_def_id = revoc_req['operation'][ID]
get_revoc_reg_def_req = {
ID: ":".join([author_did,
domain.MARKER_REVOC_DEF,
revoc_req['operation'][CRED_DEF_ID],
revoc_req['operation'][REVOC_TYPE],
revoc_req['operation'][TAG]]),
TXN_TYPE: GET_REVOC_REG_DEF,
}
get_revoc_reg_def_req = sdk_sign_request_from_dict(looper,
sdk_wallet_steward,
get_revoc_reg_def_req)
replies = sdk_send_and_check([json.dumps(get_revoc_reg_def_req)],
looper,
txnPoolNodeSet,
sdk_pool_handle)
req, reply = replies[0]
compare_request_reply(revoc_req, reply)
def send_revoc_reg_def(self, claim_def_req=None, author_did=None, wallet=None, revoc_reg_def=None):
claim_def_req = claim_def_req if claim_def_req else self.claim_def_req
wallet = wallet or self.trustee_wallet
req = revoc_reg_def if revoc_reg_def else self.build_revoc_def_by_default(claim_def_req,
author_did=author_did,
wallet=wallet)
return sdk_send_and_check([json.dumps(req)], self.looper, self.env.txnPoolNodeSet, self.sdk_pool_handle)
def test_trust_anchor_not_owner_cant_create_revoc_reg_entry(looper,
txnPoolNodeSet,
sdk_wallet_trustee,
sdk_wallet_trust_anchor,
sdk_pool_handle,
build_revoc_def_by_default,
claim_def, tconf):
revoc_def_req_trustee = create_revoc_reg_def(looper, txnPoolNodeSet, sdk_pool_handle, build_revoc_def_by_default,
claim_def, sdk_wallet_trustee)
rev_reg_entry = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req_trustee)
rev_reg_entry[VALUE][REVOKED] = [1, 2, 3, 4, 5]
del rev_reg_entry[VALUE][PREV_ACCUM]
rev_entry_req_trust_anchor = sdk_sign_request_from_dict(looper, sdk_wallet_trust_anchor, rev_reg_entry)
with pytest.raises(RequestRejectedException):
sdk_send_and_check([json.dumps(rev_entry_req_trust_anchor)], looper, txnPoolNodeSet, sdk_pool_handle)
def send_revoc_reg_def(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_claim_def,
build_revoc_def_by_default):
_, author_did = sdk_wallet_steward
claim_def_req = send_claim_def
revoc_reg = build_revoc_def_by_default
revoc_reg['operation'][CRED_DEF_ID] = ":".join([author_did,
domain.MARKER_CLAIM_DEF,
claim_def_req['operation']["signature_type"],
str(claim_def_req['operation']["ref"])])
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, revoc_reg['operation'])
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet, sdk_pool_handle)
return revoc_req
def test_send_with_from_by_demand(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_steward,
send_revoc_reg_entry_by_demand,
build_get_revoc_reg_delta):
# We save timestamp of state changes.
# looper and txnPoolNodeSet has "module", therefore,
# when we send request with FROM section, it's not a clean situation
looper.runFor(3)
# Assume, that send_revoc_reg_entry_by_demand will add into issued [1,2,3,4,5]
rev_reg_req1, rev_reg_reply1 = send_revoc_reg_entry_by_demand
rev_reg_req1['operation'][VALUE][ISSUED] = []
# Revoked [1,2,3], Issued now must be [4,5]
rev_reg_req1['operation'][VALUE][REVOKED] = [1, 2, 3]
rev_reg_req1['operation'][VALUE][PREV_ACCUM] = rev_reg_req1['operation'][
VALUE][ACCUM]
rev_reg_req1['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req2, rev_reg_reply2 = sdk_send_and_check([
json.dumps(
sdk_sign_request_from_dict(looper, sdk_wallet_steward,
rev_reg_req1['operation']))
], looper, txnPoolNodeSet, sdk_pool_handle)[0]
# Issued [10, 11]
rev_reg_req2['operation'][VALUE][ISSUED] = [10, 11]
rev_reg_req2['operation'][VALUE][REVOKED] = []
rev_reg_req2['operation'][VALUE][PREV_ACCUM] = rev_reg_req2['operation'][
VALUE][ACCUM]
rev_reg_req2['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req3, rev_reg_reply3 = sdk_send_and_check([
json.dumps(
sdk_sign_request_from_dict(looper, sdk_wallet_steward,
rev_reg_req2['operation']))
], looper, txnPoolNodeSet, sdk_pool_handle)[0]
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req1['operation'][
REVOC_REG_DEF_ID]
reg_delta_req['operation'][FROM] = get_txn_time(rev_reg_reply1['result'])
reg_delta_req['operation'][TO] = get_txn_time(
rev_reg_reply3['result']) + 1000
get_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper,
txnPoolNodeSet, sdk_pool_handle)[0][1]
assert get_reply['result'][DATA][STATE_PROOF_FROM]
assert get_reply['result'][DATA][VALUE][REVOKED] == [1, 2, 3]
assert get_reply['result'][DATA][VALUE][ISSUED] == [10, 11]
assert get_reply['result'][DATA][VALUE][ACCUM_TO][VALUE][
ACCUM] == rev_reg_req3['operation'][VALUE][ACCUM]
assert get_reply['result'][DATA][VALUE][ACCUM_FROM][VALUE][ACCUM] == \
get_payload_data(rev_reg_reply1['result'])[VALUE][ACCUM]
def test_not_owner_steward_cant_edit_revoc_reg_entry(
looper, txnPoolNodeSet, sdk_wallet_steward, sdk_wallet_trust_anchor,
sdk_pool_handle, build_revoc_def_by_steward, claim_def, tconf):
revoc_entry_req_steward = create_revoc_reg_entry(
looper, txnPoolNodeSet, sdk_pool_handle, build_revoc_def_by_steward,
claim_def, sdk_wallet_trust_anchor)
revoc_entry_req_steward['operation'][VALUE][REVOKED] = [6, 7, 8]
revoc_entry_req_steward['operation'][VALUE][
PREV_ACCUM] = revoc_entry_req_steward['operation'][VALUE][ACCUM]
revoc_entry_req_steward['operation'][VALUE][ACCUM] = randomString(10)
revoc_entry_req_steward = sdk_sign_request_from_dict(
looper, sdk_wallet_steward, revoc_entry_req_steward['operation'])
with pytest.raises(RequestRejectedException):
sdk_send_and_check([json.dumps(revoc_entry_req_steward)], looper,
txnPoolNodeSet, sdk_pool_handle)
def test_belated_request_not_processed_after_view_change(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
delta.clientIbStasher.delay(req_delay(300))
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
ensure_view_change(looper, txnPoolNodeSet)
ensureElectionsDone(looper, txnPoolNodeSet)
delta.clientIbStasher.reset_delays_and_process_delayeds()
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def sdk_send_and_check(self, requests_signed, timeout=None):
return plenum_helper.sdk_send_and_check(
requests_signed,
self._looper,
self._node_pool,
self._pool_handle,
timeout
)
def test_belated_request_not_processed_after_view_change(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
delta = txnPoolNodeSet[3]
initial_ledger_size = delta.domainLedger.size
delta.clientIbStasher.delay(req_delay(300))
one_req = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
sdk_send_and_check(one_req, looper, txnPoolNodeSet, sdk_pool_handle)
ensure_view_change(looper, txnPoolNodeSet)
ensureElectionsDone(looper, txnPoolNodeSet)
delta.clientIbStasher.reset_delays_and_process_delayeds()
looper.runFor(waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)))
for node in txnPoolNodeSet:
assert node.domainLedger.size - initial_ledger_size == 1
def test_send_with_from_by_demand(looper,
txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_steward,
send_revoc_reg_entry_by_demand,
build_get_revoc_reg_delta):
# We save timestamp of state changes.
# looper and txnPoolNodeSet has "module", therefore,
# when we send request with FROM section, it's not a clean situation
looper.runFor(3)
# Assume, that send_revoc_reg_entry_by_demand will add into issued [1,2,3,4,5]
rev_reg_req1, rev_reg_reply1 = send_revoc_reg_entry_by_demand
rev_reg_req1['operation'][VALUE][ISSUED] = []
# Revoked [1,2,3], Issued now must be [4,5]
rev_reg_req1['operation'][VALUE][REVOKED] = [1, 2, 3]
rev_reg_req1['operation'][VALUE][PREV_ACCUM] = rev_reg_req1['operation'][VALUE][ACCUM]
rev_reg_req1['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req2, rev_reg_reply2 = sdk_send_and_check(
[json.dumps(sdk_sign_request_from_dict(
looper, sdk_wallet_steward, rev_reg_req1['operation']))],
looper,
txnPoolNodeSet,
sdk_pool_handle)[0]
# Issued [10, 11]
rev_reg_req2['operation'][VALUE][ISSUED] = [10, 11]
rev_reg_req2['operation'][VALUE][REVOKED] = []
rev_reg_req2['operation'][VALUE][PREV_ACCUM] = rev_reg_req2['operation'][VALUE][ACCUM]
rev_reg_req2['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req3, rev_reg_reply3 = sdk_send_and_check(
[json.dumps(sdk_sign_request_from_dict(
looper, sdk_wallet_steward, rev_reg_req2['operation']))],
looper,
txnPoolNodeSet,
sdk_pool_handle)[0]
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req1['operation'][REVOC_REG_DEF_ID]
reg_delta_req['operation'][FROM] = get_txn_time(rev_reg_reply1['result'])
reg_delta_req['operation'][TO] = get_txn_time(rev_reg_reply3['result']) + 1000
get_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper, txnPoolNodeSet, sdk_pool_handle)[0][1]
assert get_reply['result'][DATA][STATE_PROOF_FROM]
assert get_reply['result'][DATA][VALUE][REVOKED] == [1, 2, 3]
assert get_reply['result'][DATA][VALUE][ISSUED] == [10, 11]
assert get_reply['result'][DATA][VALUE][ACCUM_TO][VALUE][ACCUM] == rev_reg_req3['operation'][VALUE][ACCUM]
assert get_reply['result'][DATA][VALUE][ACCUM_FROM][VALUE][ACCUM] == \
get_payload_data(rev_reg_reply1['result'])[VALUE][ACCUM]
def create_revoc_reg_def(looper, txnPoolNodeSet, sdk_pool_handle, build_revoc,
claim_def, wallet):
# We need to have claim_def to send revocation txns
# must be signed by trust anchor since ANYONE_CAN_WRITE is false
claim_def_req = sdk_sign_request_from_dict(looper, wallet, claim_def)
sdk_send_and_check([json.dumps(claim_def_req)], looper, txnPoolNodeSet, sdk_pool_handle)
_, author_did = wallet
revoc_reg = build_revoc
revoc_reg['operation'][CRED_DEF_ID] = \
make_state_path_for_claim_def(author_did,
str(claim_def_req['operation'][CLAIM_DEF_SCHEMA_REF]),
claim_def_req['operation'][CLAIM_DEF_SIGNATURE_TYPE],
claim_def_req['operation'][CLAIM_DEF_TAG]
).decode()
revoc_req = sdk_sign_request_from_dict(looper, wallet, revoc_reg['operation'])
_, revoc_reply = sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet, sdk_pool_handle)[0]
return revoc_req
def test_send_revoc_reg_def(looper, txnPoolNodeSet, sdk_wallet_steward,
sdk_pool_handle, build_revoc_def_by_default,
send_claim_def):
txns_count_before = set([n.domainLedger.size for n in txnPoolNodeSet])
assert len(txns_count_before) == 1, "Ledger size for nodes are not equal"
_, author_did = sdk_wallet_steward
claim_def_req = send_claim_def[0]
revoc_req = build_revoc_def_by_default
revoc_req['operation'][CRED_DEF_ID] = make_state_path_for_claim_def(
author_did, str(claim_def_req['operation'][CLAIM_DEF_SCHEMA_REF]),
claim_def_req['operation'][CLAIM_DEF_SIGNATURE_TYPE],
claim_def_req['operation'][CLAIM_DEF_TAG]).decode()
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward,
revoc_req['operation'])
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
txns_count_after = set([n.domainLedger.size for n in txnPoolNodeSet])
assert len(txns_count_after) == 1, "Ledger size for nodes are not equal"
# REVOC_REG_DEF transaction was written
assert txns_count_after.pop() - txns_count_before.pop() == 1
def client_send_revoc_reg_def(looper,
txnPoolNodeSet,
sdk_wallet_client,
sdk_pool_handle,
build_revoc_def_by_default,
claim_def):
claim_def_req = sdk_sign_request_from_dict(looper, sdk_wallet_client, claim_def)
sdk_send_and_check([json.dumps(claim_def_req)], looper, txnPoolNodeSet, sdk_pool_handle)
_, author_did = sdk_wallet_client
revoc_reg = build_revoc_def_by_default
revoc_reg['operation'][CRED_DEF_ID] = \
make_state_path_for_claim_def(author_did,
str(claim_def_req['operation'][CLAIM_DEF_SCHEMA_REF]),
claim_def_req['operation'][CLAIM_DEF_SIGNATURE_TYPE],
claim_def_req['operation'][CLAIM_DEF_TAG]
).decode()
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_client, revoc_reg['operation'])
_, revoc_reply = sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet, sdk_pool_handle)[0]
return revoc_req
def test_state_proof_returned_for_get_revoc_reg_delta(looper,
txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_steward,
send_revoc_reg_entry_by_default,
build_get_revoc_reg_delta):
# We save timestamp of state changes.
# looper and txnPoolNodeSet has "module" scope, therefore,
# when we send request with FROM section, it's not a clean situation
looper.runFor(3)
# Assume, that send_revoc_reg_entry_by_default will add into revoked [1,2,3,4,5]
rev_reg_req1, rev_reg_reply1 = send_revoc_reg_entry_by_default
rev_reg_req1['operation'][VALUE][REVOKED] = []
# Issue [1,2,3], Revoked now must be [4,5]
rev_reg_req1['operation'][VALUE][ISSUED] = [1, 2, 3]
rev_reg_req1['operation'][VALUE][PREV_ACCUM] = rev_reg_req1['operation'][VALUE][ACCUM]
rev_reg_req1['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req2, rev_reg_reply2 = sdk_send_and_check(
[json.dumps(sdk_sign_request_from_dict(
looper, sdk_wallet_steward, rev_reg_req1['operation']))],
looper,
txnPoolNodeSet,
sdk_pool_handle)[0]
# Revoke [10, 11]
rev_reg_req2['operation'][VALUE][REVOKED] = [10, 11]
rev_reg_req2['operation'][VALUE][ISSUED] = []
rev_reg_req2['operation'][VALUE][PREV_ACCUM] = rev_reg_req2['operation'][VALUE][ACCUM]
rev_reg_req2['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req3, rev_reg_reply3 = sdk_send_and_check(
[json.dumps(sdk_sign_request_from_dict(
looper, sdk_wallet_steward, rev_reg_req2['operation']))],
looper,
txnPoolNodeSet,
sdk_pool_handle)[0]
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req1['operation'][REVOC_REG_DEF_ID]
reg_delta_req['operation'][FROM] = get_txn_time(rev_reg_reply1['result'])
reg_delta_req['operation'][TO] = get_txn_time(rev_reg_reply3['result']) + 1000
sdk_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
check_valid_proof(reply)
def test_state_proof_returned_for_get_revoc_reg_delta(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward,
send_revoc_reg_entry_by_default, build_get_revoc_reg_delta):
# We save timestamp of state changes.
# looper and txnPoolNodeSet has "module" scope, therefore,
# when we send request with FROM section, it's not a clean situation
looper.runFor(3)
# Assume, that send_revoc_reg_entry_by_default will add into revoked [1,2,3,4,5]
rev_reg_req1, rev_reg_reply1 = send_revoc_reg_entry_by_default
rev_reg_req1['operation'][VALUE][REVOKED] = []
# Issue [1,2,3], Revoked now must be [4,5]
rev_reg_req1['operation'][VALUE][ISSUED] = [1, 2, 3]
rev_reg_req1['operation'][VALUE][PREV_ACCUM] = rev_reg_req1['operation'][
VALUE][ACCUM]
rev_reg_req1['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req2, rev_reg_reply2 = sdk_send_and_check([
json.dumps(
sdk_sign_request_from_dict(looper, sdk_wallet_steward,
rev_reg_req1['operation']))
], looper, txnPoolNodeSet, sdk_pool_handle)[0]
# Revoke [10, 11]
rev_reg_req2['operation'][VALUE][REVOKED] = [10, 11]
rev_reg_req2['operation'][VALUE][ISSUED] = []
rev_reg_req2['operation'][VALUE][PREV_ACCUM] = rev_reg_req2['operation'][
VALUE][ACCUM]
rev_reg_req2['operation'][VALUE][ACCUM] = randomString(10)
rev_reg_req3, rev_reg_reply3 = sdk_send_and_check([
json.dumps(
sdk_sign_request_from_dict(looper, sdk_wallet_steward,
rev_reg_req2['operation']))
], looper, txnPoolNodeSet, sdk_pool_handle)[0]
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req1['operation'][
REVOC_REG_DEF_ID]
reg_delta_req['operation'][FROM] = get_txn_time(rev_reg_reply1['result'])
reg_delta_req['operation'][TO] = get_txn_time(
rev_reg_reply3['result']) + 1000
sdk_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper,
txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
check_valid_proof(reply)
def test_state_proof_returned_for_get_revoc_reg(looper,
txnPoolNodeSet,
sdk_pool_handle,
send_revoc_reg_entry_by_default,
build_get_revoc_reg_entry):
rev_entry_req, reg_reply = send_revoc_reg_entry_by_default
get_revoc_reg = copy.deepcopy(build_get_revoc_reg_entry)
get_revoc_reg['operation'][REVOC_REG_DEF_ID] = rev_entry_req['operation'][REVOC_REG_DEF_ID]
get_revoc_reg['operation'][TIMESTAMP] = get_utc_epoch() + 1000
sdk_reply = sdk_send_and_check([json.dumps(get_revoc_reg)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
check_valid_proof(reply)
def test_state_proof_returned_for_get_revoc_reg_delta_with_only_to(
looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward,
send_revoc_reg_entry_by_default, build_get_revoc_reg_delta):
rev_reg_req, rev_reg_reply = send_revoc_reg_entry_by_default
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
del reg_delta_req['operation'][FROM]
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req['operation'][
REVOC_REG_DEF_ID]
reg_delta_req['operation'][TO] = get_utc_epoch() + 1000
get_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper,
txnPoolNodeSet, sdk_pool_handle)[0][1]
check_valid_proof(get_reply)
def test_send_get_revoc_reg_later_then_first_entry(looper,
txnPoolNodeSet,
sdk_pool_handle,
send_revoc_reg_entry_by_default,
build_get_revoc_reg_entry):
rev_entry_req, reg_reply = send_revoc_reg_entry_by_default
get_revoc_reg = copy.deepcopy(build_get_revoc_reg_entry)
get_revoc_reg['operation'][REVOC_REG_DEF_ID] = rev_entry_req['operation'][REVOC_REG_DEF_ID]
get_revoc_reg['operation'][TIMESTAMP] = get_utc_epoch() + 1000
sdk_reply = sdk_send_and_check([json.dumps(get_revoc_reg)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
assert rev_entry_req['operation'][REVOC_REG_DEF_ID] == reply['result'][REVOC_REG_DEF_ID]
assert rev_entry_req['operation'][VALUE][ACCUM] == reply['result']['data'][VALUE][ACCUM]
def test_state_proof_returned_for_get_revoc_reg_delta_with_only_to(
looper,
txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_steward,
send_revoc_reg_entry_by_default,
build_get_revoc_reg_delta):
rev_reg_req, rev_reg_reply = send_revoc_reg_entry_by_default
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
del reg_delta_req['operation'][FROM]
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req['operation'][REVOC_REG_DEF_ID]
reg_delta_req['operation'][TO] = get_utc_epoch() + 1000
sdk_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
check_valid_proof(reply)
def test_send_with_only_to_by_demand(looper,
txnPoolNodeSet,
sdk_pool_handle,
send_revoc_reg_entry_by_demand,
build_get_revoc_reg_delta):
rev_entry_req, reg_reply = send_revoc_reg_entry_by_demand
get_revoc_reg_delta = copy.deepcopy(build_get_revoc_reg_delta)
del get_revoc_reg_delta['operation'][FROM]
get_revoc_reg_delta['operation'][REVOC_REG_DEF_ID] = rev_entry_req['operation'][REVOC_REG_DEF_ID]
get_revoc_reg_delta['operation'][TO] = get_utc_epoch() + 1000
sdk_reply = sdk_send_and_check([json.dumps(get_revoc_reg_delta)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
assert rev_entry_req['operation'][REVOC_REG_DEF_ID] == reply['result'][REVOC_REG_DEF_ID]
assert rev_entry_req['operation'][VALUE][ACCUM] == reply['result'][DATA][VALUE][ACCUM_TO][VALUE][ACCUM]
assert rev_entry_req['operation'][VALUE][ISSUED] == reply['result'][DATA][VALUE][ISSUED]
def send_revoc_reg_entry_by_demand(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_demand):
revoc_def_req = send_revoc_reg_def_by_demand
rev_reg_entry = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req)
rev_reg_entry[VALUE][ISSUED] = [1, 2, 3, 4, 5]
del rev_reg_entry[VALUE][PREV_ACCUM]
rev_entry_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, rev_reg_entry)
reg_entry_replies = sdk_send_and_check([json.dumps(rev_entry_req)],
looper,
txnPoolNodeSet,
sdk_pool_handle)
return reg_entry_replies[0]
def test_state_proof_returned_for_delta_with_None_reply(
looper,
txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_steward,
send_revoc_reg_entry_by_default,
build_get_revoc_reg_delta):
rev_reg_req, rev_reg_reply = send_revoc_reg_entry_by_default
reg_delta_req = copy.deepcopy(build_get_revoc_reg_delta)
del reg_delta_req['operation'][FROM]
reg_delta_req['operation'][REVOC_REG_DEF_ID] = rev_reg_req['operation'][REVOC_REG_DEF_ID]
reg_delta_req['operation'][TO] = get_utc_epoch() - 1000
sdk_reply = sdk_send_and_check([json.dumps(reg_delta_req)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
assert STATE_PROOF not in reply['result']
def test_send_earlier_then_first_entry_by_demand(
looper,
txnPoolNodeSet,
sdk_pool_handle,
send_revoc_reg_entry_by_demand,
build_get_revoc_reg_delta):
rev_entry_req, reg_reply = send_revoc_reg_entry_by_demand
get_revoc_reg_delta = copy.deepcopy(build_get_revoc_reg_delta)
del get_revoc_reg_delta['operation'][FROM]
get_revoc_reg_delta['operation'][REVOC_REG_DEF_ID] = rev_entry_req['operation'][REVOC_REG_DEF_ID]
get_revoc_reg_delta['operation'][TO] = get_utc_epoch() - 1000
sdk_reply = sdk_send_and_check([json.dumps(get_revoc_reg_delta)], looper, txnPoolNodeSet, sdk_pool_handle)
reply = sdk_reply[0][1]
assert reply['result'][DATA][REVOC_REG_DEF_ID] == rev_entry_req['operation'][REVOC_REG_DEF_ID]
assert VALUE not in reply['result'][DATA]
assert REVOC_TYPE not in reply['result'][DATA]
assert reply['result'][f.SEQ_NO.nm] is None
assert reply['result'][TXN_TIME] is None
def test_get_revoc_reg_def_from_uncommited(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_default):
# REVOC_REG_DEF was added into pool by send_revoc_reg_def_by_default fixture
_, author_did = sdk_wallet_steward
revoc_req, _ = send_revoc_reg_def_by_default
new_maxCredNum = 100
revoc_req['operation'][VALUE][MAX_CRED_NUM] = new_maxCredNum
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, revoc_req['operation'])
# We apply transacttion, which will be not commited
for node in txnPoolNodeSet:
node.getDomainReqHandler().apply(Request(**revoc_req), int(time.time()))
get_revoc_reg_def_req = {
ID: ":".join([author_did,
domain.MARKER_REVOC_DEF,
revoc_req['operation'][CRED_DEF_ID],
revoc_req['operation'][REVOC_TYPE],
revoc_req['operation'][TAG]]),
TXN_TYPE: GET_REVOC_REG_DEF,
}
get_revoc_reg_def_req = sdk_sign_request_from_dict(looper,
sdk_wallet_steward,
get_revoc_reg_def_req)
# Send GET_REVOC_REG_DEF query.
# We expects that commited REVOC_REG_DEF transaction will be returned
replies = sdk_send_and_check([json.dumps(get_revoc_reg_def_req)],
looper,
txnPoolNodeSet,
sdk_pool_handle)
req, reply = replies[0]
assert new_maxCredNum != reply['result']['data'][VALUE][MAX_CRED_NUM]
def test_state_proof_returned_for_get_revoc_reg_def(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_default):
_, author_did = sdk_wallet_steward
revoc_req, _ = send_revoc_reg_def_by_default
get_revoc_reg_def_req = {
ID: ":".join([author_did,
domain.MARKER_REVOC_DEF,
revoc_req['operation'][CRED_DEF_ID],
revoc_req['operation'][REVOC_TYPE],
revoc_req['operation'][TAG]]),
TXN_TYPE: GET_REVOC_REG_DEF,
}
get_revoc_reg_def_req = sdk_sign_request_from_dict(looper,
sdk_wallet_steward,
get_revoc_reg_def_req)
sdk_reply = sdk_send_and_check([json.dumps(get_revoc_reg_def_req)],
looper,
txnPoolNodeSet,
sdk_pool_handle)
reply = sdk_reply[0][1]
check_valid_proof(reply)
def test_unordered_state_reverted_before_catchup(
tconf, looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle):
"""
Check that unordered state is reverted before starting catchup:
- save the initial state on a node
- slow down processing of COMMITs
- send requests
- wait until other nodes come to consensus
- call start of catch-up
- check that the state of the slow node is reverted and equal to the initial one.
"""
# CONFIG
ledger_id = DOMAIN_LEDGER_ID
non_primary_node = getNonPrimaryReplicas(txnPoolNodeSet, instId=0)[0].node
non_primary_ledger = non_primary_node.getLedger(ledger_id)
non_primary_state = non_primary_node.getState(ledger_id)
# send reqs and make sure we are at the same state
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 10)
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
checkNodesHaveSameRoots(txnPoolNodeSet)
# the state of the node before
committed_ledger_before = non_primary_ledger.tree.root_hash
uncommitted_ledger_before = non_primary_ledger.uncommittedRootHash
committed_state_before = non_primary_state.committedHeadHash
uncommitted_state_before = non_primary_state.headHash
# EXECUTE
# Delay commit requests on the node
delay_c = 60
non_primary_node.nodeIbStasher.delay(cDelay(delay_c))
# send requests
reqs = sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, tconf.Max3PCBatchSize)
sdk_get_replies(looper, reqs, timeout=40)
committed_ledger_during_3pc = non_primary_node.getLedger(
ledger_id).tree.root_hash
uncommitted_ledger_during_3pc = non_primary_node.getLedger(
ledger_id).uncommittedRootHash
committed_state_during_3pc = non_primary_node.getState(
ledger_id).committedHeadHash
uncommitted_state_during_3pc = non_primary_node.getState(
ledger_id).headHash
# start catchup
non_primary_node.ledgerManager.preCatchupClbk(ledger_id)
committed_ledger_reverted = non_primary_ledger.tree.root_hash
uncommitted_ledger_reverted = non_primary_ledger.uncommittedRootHash
committed_state_reverted = non_primary_state.committedHeadHash
uncommitted_state_reverted = non_primary_state.headHash
# CHECK
# check that initial uncommitted state differs from the state during 3PC
# but committed does not
assert committed_ledger_before == committed_ledger_during_3pc
assert uncommitted_ledger_before != uncommitted_ledger_during_3pc
assert committed_state_before == committed_state_during_3pc
assert uncommitted_state_before != uncommitted_state_during_3pc
assert committed_ledger_before == committed_ledger_reverted
assert uncommitted_ledger_before == uncommitted_ledger_reverted
assert committed_state_before == committed_state_reverted
assert uncommitted_state_before == uncommitted_state_reverted
