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 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 build_txn_for_revoc_def_entry_by_default(looper,
sdk_wallet_steward,
add_revoc_def_by_default):
revoc_def_req = add_revoc_def_by_default
data = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req)
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return req
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_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 build_get_revoc_reg_entry(looper,
sdk_wallet_steward):
data = {
REVOC_REG_DEF_ID: randomString(10),
TXN_TYPE: GET_REVOC_REG,
TIMESTAMP: int(time.time())
}
revoc_reg_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return revoc_reg_req
def build_get_revoc_reg_delta(looper,
sdk_wallet_steward):
data = {
REVOC_REG_DEF_ID: randomString(10),
TXN_TYPE: GET_REVOC_REG_DELTA,
FROM: 10,
TO: 20,
}
revoc_reg_delta_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return revoc_reg_delta_req
def testRequestStaticValidation(tconf, looper, txnPoolNodeSet,
sdk_wallet_client):
"""
Check that for requests which fail static validation, REQNACK is sent
:return:
"""
node = txnPoolNodeSet[0]
req = sdk_sign_request_from_dict(looper, sdk_wallet_client, {'something': 'nothing'})
req = Request(**req)
with pytest.raises(InvalidClientRequest):
node.doStaticValidation(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_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 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)
txn = append_txn_metadata(reqToTxn(Request(**req)),
txn_time=FIRST_ID_TS,
seq_no=node.domainLedger.seqNo + 1)
node.write_manager.update_state(txn)
node.db_manager.ts_store.set(
get_txn_time(txn),
node.db_manager.get_state(DOMAIN_LEDGER_ID).headHash)
return txn
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 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 send_revoc_reg_entry_by_default(looper,
txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
send_revoc_reg_def_by_default):
revoc_def_req, _ = send_revoc_reg_def_by_default
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_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_incorrect_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[0]
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()
# test incorrect ISSUANCE_TYPE
revoc_reg['operation'][VALUE][ISSUANCE_TYPE] = "incorrect_type"
revoc_req = sdk_sign_request_from_dict(looper, sdk_wallet_steward,
revoc_reg['operation'])
with pytest.raises(RequestNackedException, match='unknown value'):
sdk_send_and_check([json.dumps(revoc_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
# test correct ISSUANCE_TYPE
revoc_reg['operation'][VALUE][ISSUANCE_TYPE] = ISSUANCE_BY_DEFAULT
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)
# send revoc_reg_entry to check that revoc_reg_def ordered correctly
rev_reg_entry = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_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_steward,
rev_reg_entry)
sdk_send_and_check([json.dumps(rev_entry_req)], looper, txnPoolNodeSet,
sdk_pool_handle)
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(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_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 build_revoc_def_by_default(looper, sdk_wallet_steward):
data = {
"id": randomString(50),
"type": REVOC_REG_DEF,
"tag": randomString(5),
"credDefId": randomString(50),
"value": {
"issuanceType": ISSUANCE_BY_DEFAULT,
"maxCredNum": 1000000,
"tailsHash": randomString(50),
"tailsLocation": 'http://tails.location.com',
"publicKeys": {},
}
}
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return req
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 build_revoc_def_by_demand(looper, sdk_wallet_steward):
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)
return req
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 build_revoc_def_by_demand(looper, sdk_wallet_steward):
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)
return req
def req(request, looper, sdk_wallet_client, endorser):
op = {'type': '1', 'something': 'nothing'}
taaa = {'a': 'b', 'c': 3}
if request.param.endswith('_sdk'):
request.param = request.param[:-4]
if request.param == 'sigs_only':
req = sdk_multisign_request_from_dict(looper,
sdk_wallet_client,
op,
reqId=1513945121191691,
taa_acceptance=taaa,
endorser=endorser)
else:
req = sdk_sign_request_from_dict(looper,
sdk_wallet_client,
op,
reqId=1513945121191691,
taa_acceptance=taaa,
endorser=endorser)
if request.param == 'no_protocol_vers': # TODO INDY-2072 always false here
req.pop('protocolVersion')
req = Request(req.get(f.IDENTIFIER.nm, None),
req.get(f.REQ_ID.nm, None), req.get(OPERATION, None),
req.get(f.SIG.nm, None), req.get(f.SIGS.nm, None),
req.get(f.PROTOCOL_VERSION.nm, None),
req.get(f.TAA_ACCEPTANCE.nm, None),
req.get(f.ENDORSER.nm, None))
else:
req = Request(operation=op,
reqId=1513945121191691,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier="6ouriXMZkLeHsuXrN1X1fd",
taaAcceptance=taaa,
endorser=endorser)
sign = "2DaRm3nt6H5fJu2TP5vxqbaDCtABPYmUTSX4ocnY8fVGgyJMVNaeh2z6JZhcW1gbmGKJcZopZMKZJwADuXFFJobM"
req.signature = sign
req.add_signature("6ouriXMZkLeHsuXrN1X1fd", sign)
if request.param == 'sig_only':
req.signatures = None
if request.param == 'sigs_only':
req.signature = None
if request.param == 'no_protocol_vers':
req.protocolVersion = None
return 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 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
revoc_req = build_revoc_def_by_default
revoc_req['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_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 send_revoc_def(looper, sdk_wallet_steward, sdk_pool_handle,
txnPoolNodeSet):
data = {
"id": randomString(50),
"type": REVOC_REG_DEF,
"tag": randomString(5),
"credDefId": randomString(50),
"value": {
"issuanceType": "issuance type",
"maxCredNum": 1000000,
"tailsHash": randomString(50),
"tailsLocation": 'http://tails.location.com',
"publicKeys": {},
}
}
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
sdk_send_and_check([json.dumps(req)], looper, txnPoolNodeSet,
sdk_pool_handle)
return req
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)
_, reply = sdk_send_and_check([json.dumps(get_revoc_reg_def_req)], looper,
txnPoolNodeSet, sdk_pool_handle)[0]
check_valid_proof(reply)
def build_txn_for_revoc_def_entry_by_demand(looper, sdk_wallet_steward,
add_revoc_def_by_demand):
revoc_def_req = add_revoc_def_by_demand
path = ":".join([
revoc_def_req[f.IDENTIFIER.nm], domain.MARKER_REVOC_DEF,
revoc_def_req[OPERATION][CRED_DEF_ID],
revoc_def_req[OPERATION][REVOC_TYPE], revoc_def_req[OPERATION][TAG]
])
data = {
REVOC_REG_DEF_ID: path,
TXN_TYPE: REVOC_REG_ENTRY,
VALUE: {
PREV_ACCUM: randomString(10),
ACCUM: randomString(10),
ISSUED: [],
REVOKED: [],
}
}
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return req
def build_txn_for_revoc_def_entry_by_demand(looper,
sdk_wallet_steward,
add_revoc_def_by_demand):
revoc_def_req = add_revoc_def_by_demand
path = ":".join([revoc_def_req[f.IDENTIFIER.nm],
domain.MARKER_REVOC_DEF,
revoc_def_req[OPERATION][CRED_DEF_ID],
revoc_def_req[OPERATION][REVOC_TYPE],
revoc_def_req[OPERATION][TAG]])
data = {
REVOC_REG_DEF_ID: path,
TXN_TYPE: REVOC_REG_ENTRY,
VALUE: {
PREV_ACCUM: randomString(10),
ACCUM: randomString(10),
ISSUED: [],
REVOKED: [],
}
}
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return 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,
}
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 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 build_revoc_def_by_default(self, claim_def_req, author_did=None, wallet=None, req_def_id=None):
wallet = wallet if wallet else self.trustee_wallet
author_did = author_did if author_did else self.trustee_wallet[1]
data = {
ID: req_def_id if req_def_id else randomString(50),
TXN_TYPE: REVOC_REG_DEF,
REVOC_TYPE: "CL_ACCUM",
TAG: randomString(5),
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(),
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(self.looper, wallet, data)
return req
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)
req_handler = node.getDomainReqHandler()
txn = reqToTxn(Request(**req))
txn[f.SEQ_NO.nm] = node.domainLedger.seqNo + 1
txn[TXN_TIME] = FIRST_ID_TS
req_handler._addRevocDef(txn)
return req
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 add_revoc_def_by_default(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_BY_DEFAULT,
"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()
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 build_txn_for_revoc_def_entry_by_default(looper, sdk_wallet_steward,
add_revoc_def_by_default):
revoc_def_req = add_revoc_def_by_default
data = build_revoc_reg_entry_for_given_revoc_reg_def(revoc_def_req)
req = sdk_sign_request_from_dict(looper, sdk_wallet_steward, data)
return req
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 req_and_expected(request, looper, sdk_wallet_client, endorser):
op = {'type': '1',
'something': 'nothing'}
taaa = {
'a': 'b',
'c': 3
}
if request.param.endswith('_sdk'):
request.param = request.param[:-4]
if request.param == 'sigs_only':
req = sdk_multisign_request_from_dict(looper, sdk_wallet_client,
op, reqId=1513945121191691,
taa_acceptance=taaa,
endorser=endorser)
else:
req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
op, reqId=1513945121191691,
taa_acceptance=taaa,
endorser=endorser)
if request.param == 'no_protocol_vers': # TODO INDY-2072 always false here
req.pop('protocolVersion')
r = Request(
req.get(f.IDENTIFIER.nm, None),
req.get(f.REQ_ID.nm, None),
req.get(OPERATION, None),
req.get(f.SIG.nm, None),
req.get(f.SIGS.nm, None),
req.get(f.PROTOCOL_VERSION.nm, None),
req.get(f.TAA_ACCEPTANCE.nm, None),
req.get(f.ENDORSER.nm, None)
)
digest = r.digest
payload_digest = r.payload_digest
sign = req.get(f.SIG.nm) if request.param != 'sigs_only' else next(iter(req.get(f.SIGS.nm).values()))
else:
req = Request(operation=op, reqId=1513945121191691,
protocolVersion=CURRENT_PROTOCOL_VERSION, identifier="6ouriXMZkLeHsuXrN1X1fd",
taaAcceptance=taaa, endorser=endorser)
sign = "2DaRm3nt6H5fJu2TP5vxqbaDCtABPYmUTSX4ocnY8fVGgyJMVNaeh2z6JZhcW1gbmGKJcZopZMKZJwADuXFFJobM"
req.signature = sign
req.add_signature("6ouriXMZkLeHsuXrN1X1fd",
sign)
if request.param == 'sig_only':
req.signatures = None
if request.param == 'sigs_only':
req.signature = None
if request.param == 'no_protocol_vers':
req.protocolVersion = None
digest = req.digest
payload_digest = req.payload_digest
new_expected = SortedDict({
"reqSignature": {
"type": "ED25519",
"values": [{
"from": "6ouriXMZkLeHsuXrN1X1fd",
"value": sign
}]
},
"txn": {
"data": {
"something": "nothing",
},
"metadata": {
"from": "6ouriXMZkLeHsuXrN1X1fd",
"reqId": 1513945121191691,
"taaAcceptance": {
"a": "b",
"c": 3
}
},
"protocolVersion": CURRENT_PROTOCOL_VERSION,
"type": "1",
},
"txnMetadata": {
"txnTime": 1513945121,
},
"ver": CURRENT_TXN_VERSION
})
if request.param == 'no_protocol_vers':
new_expected["txn"].pop("protocolVersion", None)
if digest is not None:
new_expected["txn"]["metadata"]["digest"] = digest
if payload_digest is not None:
new_expected["txn"]["metadata"]["payloadDigest"] = payload_digest
if endorser is not None:
new_expected["txn"]["metadata"]["endorser"] = endorser
return req, new_expected
def send_taa_disable_req(self, wallet):
operation = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_DISABLE}
req = sdk_sign_request_from_dict(self.looper, wallet, operation)
self.send_and_check(json.dumps(req), wallet)
def build_txn_for_revoc_def_entry_by_default(self, wallet, data):
req = sdk_sign_request_from_dict(self.looper, wallet, data)
return req
def req_and_expected(request, looper, sdk_wallet_client):
op = {'type': '1',
'something': 'nothing'}
if request.param.endswith('_sdk'):
req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
op, reqId=1513945121191691)
request.param = request.param[:-4]
# TODO: support multi-sig in SDK
# if request.param == 'sig_only':
# req.pop('signatures')
# if request.param == 'sigs_only':
# req.pop('signature')
if request.param == 'no_protocol_vers':
req.pop('protocolVersion')
digest = Request(
req.get(f.IDENTIFIER.nm, None),
req.get(f.REQ_ID.nm, None),
req.get(OPERATION, None),
req.get(f.SIG.nm, None),
req.get(f.SIGS.nm, None),
req.get(f.PROTOCOL_VERSION.nm, None)
).digest
sign = req.get(f.SIG.nm)
else:
req = Request(operation=op, reqId=1513945121191691,
protocolVersion=CURRENT_PROTOCOL_VERSION, identifier="6ouriXMZkLeHsuXrN1X1fd")
sign = "2DaRm3nt6H5fJu2TP5vxqbaDCtABPYmUTSX4ocnY8fVGgyJMVNaeh2z6JZhcW1gbmGKJcZopZMKZJwADuXFFJobM"
req.signature = sign
req.add_signature("6ouriXMZkLeHsuXrN1X1fd",
sign)
if request.param == 'sig_only':
req.signatures = None
if request.param == 'sigs_only':
req.signature = None
if request.param == 'no_protocol_vers':
req.protocolVersion = None
digest = req.digest
new_expected = SortedDict({
"reqSignature": {
"type": "ED25519",
"values": [{
"from": "6ouriXMZkLeHsuXrN1X1fd",
"value": sign
}]
},
"txn": {
"data": {
"something": "nothing",
},
"metadata": {
"from": "6ouriXMZkLeHsuXrN1X1fd",
"reqId": 1513945121191691
},
"protocolVersion": CURRENT_PROTOCOL_VERSION,
"type": "1",
},
"txnMetadata": {
"txnTime": 1513945121,
},
"ver": "1"
})
if request.param == 'no_protocol_vers':
new_expected["txn"].pop("protocolVersion", None)
if digest is not None:
new_expected["txn"]["metadata"]["digest"] = digest
return req, new_expected
def req_and_expected(request, looper, sdk_wallet_client):
op = {'type': '1',
'something': 'nothing'}
if request.param.endswith('_sdk'):
req = sdk_sign_request_from_dict(looper, sdk_wallet_client,
op, reqId=1513945121191691)
request.param = request.param[:-4]
# TODO: support multi-sig in SDK
# if request.param == 'sig_only':
# req.pop('signatures')
# if request.param == 'sigs_only':
# req.pop('signature')
if request.param == 'no_protocol_vers':
req.pop('protocolVersion')
r = Request(
req.get(f.IDENTIFIER.nm, None),
req.get(f.REQ_ID.nm, None),
req.get(OPERATION, None),
req.get(f.SIG.nm, None),
req.get(f.SIGS.nm, None),
req.get(f.PROTOCOL_VERSION.nm, None)
)
digest = r.digest
payload_digest = r.payload_digest
sign = req.get(f.SIG.nm)
else:
req = Request(operation=op, reqId=1513945121191691,
protocolVersion=CURRENT_PROTOCOL_VERSION, identifier="6ouriXMZkLeHsuXrN1X1fd")
sign = "2DaRm3nt6H5fJu2TP5vxqbaDCtABPYmUTSX4ocnY8fVGgyJMVNaeh2z6JZhcW1gbmGKJcZopZMKZJwADuXFFJobM"
req.signature = sign
req.add_signature("6ouriXMZkLeHsuXrN1X1fd",
sign)
if request.param == 'sig_only':
req.signatures = None
if request.param == 'sigs_only':
req.signature = None
if request.param == 'no_protocol_vers':
req.protocolVersion = None
digest = req.digest
payload_digest = req.payload_digest
new_expected = SortedDict({
"reqSignature": {
"type": "ED25519",
"values": [{
"from": "6ouriXMZkLeHsuXrN1X1fd",
"value": sign
}]
},
"txn": {
"data": {
"something": "nothing",
},
"metadata": {
"from": "6ouriXMZkLeHsuXrN1X1fd",
"reqId": 1513945121191691
},
"protocolVersion": CURRENT_PROTOCOL_VERSION,
"type": "1",
},
"txnMetadata": {
"txnTime": 1513945121,
},
"ver": "1"
})
if request.param == 'no_protocol_vers':
new_expected["txn"].pop("protocolVersion", None)
if digest is not None:
new_expected["txn"]["metadata"]["digest"] = digest
if payload_digest is not None:
new_expected["txn"]["metadata"]["payloadDigest"] = payload_digest
return req, new_expected
