def test_client_can_send_schema(looper, txnPoolNodeSet, sdk_wallet_client,
sdk_wallet_trust_anchor, sdk_pool_handle,
tconf):
# Trust anchor can create schema in any case
_, identifier = sdk_wallet_trust_anchor
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0",
json.dumps(["first", "last"])))
request = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trust_anchor,
request)
])
# Client can create schema if WRITES_REQUIRE_TRUST_ANCHOR flag set to False
_, identifier = sdk_wallet_client
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0",
json.dumps(["first", "last"])))
request = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
sdk_get_and_check_replies(
looper,
[sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, request)])
def test_write_same_object_with_different_reqid_fails(looper, sdk_pool_handle,
sdk_wallet_endorser,
txn_type, rs_type,
content):
request1 = sdk_build_rich_schema_request(looper,
sdk_wallet_endorser,
txn_type,
rs_id=randomString(),
rs_name=randomString(),
rs_version='1.0',
rs_type=rs_type,
rs_content=json.dumps(content))
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_endorser,
request1)
sdk_get_and_check_replies(looper, [req])
request2 = json.loads(request1)
request2[TXN_PAYLOAD_METADATA_REQ_ID] = random.randint(10, 1000000000)
request2 = json.dumps(request2)
with pytest.raises(RequestRejectedException,
match=str(AuthConstraintForbidden())):
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_endorser,
request2)
sdk_get_and_check_replies(looper, [req])
def test_can_send_same_claim_def_by_different_issuers(looper, sdk_pool_handle,
nodeSet,
sdk_wallet_trustee,
sdk_wallet_steward,
schema_json):
wallet_handle, identifier = sdk_wallet_trustee
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag4", "CL",
json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)
])
wallet_handle, identifier = sdk_wallet_steward
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag4", "CL",
json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, request)
])
def test_send_claim_def_schema_and_claim_def_in_one_batch(
looper, tconf, sdk_pool_handle, nodeSet, sdk_wallet_trustee):
with max_3pc_batch_limits(tconf, size=2) as tconf:
initial_seq_no = nodeSet[0].domainLedger.size
wallet_handle, identifier = sdk_wallet_trustee
# send SCHEMA
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name2", "2.0",
json.dumps(["first", "last"])))
schema_req_json = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
schema_req = sdk_sign_and_submit_req(sdk_pool_handle,
sdk_wallet_trustee,
schema_req_json)
# send CLAIM_DEF
_, claim_def_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag", "CL",
json.dumps({"support_revocation": True})))
claim_def_req_json = looper.loop.run_until_complete(
build_cred_def_request(identifier, claim_def_json))
claim_def_req_json = modify_field(claim_def_req_json,
initial_seq_no + 1, OPERATION, REF)
claim_def_req = sdk_sign_and_submit_req(sdk_pool_handle,
sdk_wallet_trustee,
claim_def_req_json)
# check both are written
sdk_get_and_check_replies(looper, [schema_req, claim_def_req])
def test_claim_def_reply_is_valid(looper, sdk_pool_handle, sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
schema_json, _ = sdk_write_schema(looper, sdk_pool_handle,
sdk_wallet_steward)
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(
build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
_, schema_json = looper.loop.run_until_complete(
parse_get_schema_response(json.dumps(reply)))
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag", "CL",
json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_claim_def_txn(reply['result']['txn'])
def test_client_cant_send_schema(looper, txnPoolNodeSet, sdk_wallet_client,
sdk_wallet_trust_anchor, sdk_pool_handle):
# Trust anchor can create schema in any case
_, identifier = sdk_wallet_trust_anchor
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "another_name", "2.0",
json.dumps(["first", "last"])))
request = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trust_anchor,
request)
])
# Client cant create schema if ANYONE_CAN_WRITE flag set to True
_, identifier = sdk_wallet_client
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "another_name", "2.0",
json.dumps(["first", "last"])))
request = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
sdk_get_bad_response(
looper,
[sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, request)],
RequestRejectedException, 'None role cannot add schema')
def send_revoc_reg_entry(looper, sdk_wallet_handle, sdk_pool_handle, sdk_wallet_steward, send_claim_def):
revoc_reg, revoc_entry = create_revoc_reg_entry(looper, sdk_wallet_handle, sdk_wallet_steward[1], randomString(5),
get_cred_def_id(send_claim_def[0][f.IDENTIFIER.nm],
send_claim_def[0]['operation']['ref'],
send_claim_def[0]['operation']['tag']),
ISSUANCE_BY_DEFAULT)
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, revoc_reg)
revoc_reg = sdk_get_and_check_replies(looper, [req])[0]
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, revoc_entry)
revoc_entry = sdk_get_and_check_replies(looper, [req])[0]
return revoc_reg, revoc_entry
def test_update_claim_def_for_same_schema_and_signature_type(
looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, schema_json):
wallet_handle, identifier = sdk_wallet_trustee
_, definition_json = looper.loop.run_until_complete(issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag3", "CL", json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
definition_json = modify_field(definition_json, '999', 'value', 'primary', 'n')
request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
def sdk_write_schema_and_check(looper, sdk_pool_handle, sdk_wallet_client,
attributes=[], name="", version=""):
request = sdk_build_schema_request(looper, sdk_wallet_client,
attributes, name, version)
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, request)
rep = sdk_get_and_check_replies(looper, [req])
return rep
def test_send_get_rs_schema_succeeds(
looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, send_rs_schema):
_, did = sdk_wallet_trustee
schema_txnId = send_rs_schema
request = build_get_rs_schema_request(did, schema_txnId)
rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
assert rep[0][1]['result']['seqNo']
def sdk_write_context_and_check(looper,
sdk_pool_handle,
sdk_wallet_steward,
context=[],
name="",
version="",
reqId=12345678):
_wh, did = sdk_wallet_steward
# create json
raw_json = {
'operation': {
TXN_TYPE: SET_CONTEXT,
META: {
CONTEXT_NAME: name,
CONTEXT_VERSION: version,
RS_TYPE: CONTEXT_TYPE
},
DATA: context
},
"identifier": did,
"reqId": reqId,
"protocolVersion": CURRENT_PROTOCOL_VERSION,
}
set_context_txn_json = json.dumps(raw_json)
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
set_context_txn_json)
rep = sdk_get_and_check_replies(looper, [req])
return rep
def sdk_write_context(looper,
sdk_pool_handle,
sdk_wallet_steward,
context=[],
name="",
version=""):
_wh, did = sdk_wallet_steward
# create json
raw_json = {
'operation': {
TXN_TYPE: SET_CONTEXT,
META: {
CONTEXT_NAME: name,
CONTEXT_VERSION: version,
RS_TYPE: CONTEXT_TYPE
},
DATA: context
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": CURRENT_PROTOCOL_VERSION,
}
set_context_txn_json = json.dumps(raw_json)
return json.dumps({'id': did + ':' + MARKER_CONTEXT + ':' + name + ':' + version}), \
sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, set_context_txn_json))[1]
def test_send_get_context_as_client(looper, sdk_pool_handle, nodeSet,
sdk_wallet_client, sdk_wallet_trustee,
send_context):
_, did = sdk_wallet_trustee
raw_json = {
'operation': {
TXN_TYPE: GET_CONTEXT,
'dest': did,
META: {
CONTEXT_NAME: TEST_CONTEXT_NAME,
CONTEXT_VERSION: TEST_CONTEXT_VERSION,
RS_TYPE: CONTEXT_TYPE
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
get_context_txn_json = json.dumps(raw_json)
rep = sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client,
get_context_txn_json)
])
assert rep[0][1]['result']['seqNo']
assert rep[0][1]['result'][DATA][META][RS_TYPE] == CONTEXT_TYPE
assert rep[0][1]['result'][DATA][META][CONTEXT_NAME] == TEST_CONTEXT_NAME
assert rep[0][1]['result'][DATA][META][
CONTEXT_VERSION] == TEST_CONTEXT_VERSION
assert rep[0][1]['result'][DATA][DATA] == W3C_BASE_CONTEXT
def test_send_get_context_fails_with_invalid_version(looper, sdk_pool_handle,
nodeSet,
sdk_wallet_trustee,
send_context):
_, did = sdk_wallet_trustee
raw_json = {
'operation': {
TXN_TYPE: GET_CONTEXT,
'dest': did,
META: {
CONTEXT_NAME: TEST_CONTEXT_NAME,
CONTEXT_VERSION: 2.0,
RS_TYPE: CONTEXT_TYPE
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
get_context_txn_json = json.dumps(raw_json)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee,
get_context_txn_json)
])
assert "validation error [GetContextField]: expected types 'str', got 'float' (version=2.0)" in str(
e.value)
def test_send_get_context_fails_with_incorrect_version(looper, sdk_pool_handle,
nodeSet,
sdk_wallet_trustee,
send_context):
_, did = sdk_wallet_trustee
raw_json = {
'operation': {
TXN_TYPE: GET_CONTEXT,
'dest': did,
META: {
CONTEXT_NAME: TEST_CONTEXT_NAME,
CONTEXT_VERSION: '2.0',
RS_TYPE: CONTEXT_TYPE
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
get_context_txn_json = json.dumps(raw_json)
rep = sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee,
get_context_txn_json)
])
assert rep[0][1]['result']['seqNo'] is None
def sdk_write_context(looper, sdk_pool_handle, sdk_wallet_steward, context_array=[], name="", version=""):
_wh, did = sdk_wallet_steward
'''_, context_json = looper.loop.run_until_complete(
issuer_create_context(
did, name,
version, json.dumps(context_array)
))
'''
# create json
SET_CONTEXT = "200"
raw_json = {
'operation': {
'type': SET_CONTEXT,
'data': {
'name': name,
'version': version,
'context_array': context_array
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
set_context_txn_json = json.dumps(raw_json)
return json.dumps({'id': did + ':7:' + name + ':' + version}), \
sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, set_context_txn_json))[1]
def test_send_get_context_fails_with_invalid_dest(looper, sdk_pool_handle,
nodeSet, sdk_wallet_trustee,
send_context):
_, did = sdk_wallet_trustee
raw_json = {
'operation': {
TXN_TYPE: GET_CONTEXT,
'dest': "wrong_did",
META: {
CONTEXT_NAME: TEST_CONTEXT_NAME,
CONTEXT_VERSION: TEST_CONTEXT_VERSION,
RS_TYPE: CONTEXT_TYPE
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
get_context_txn_json = json.dumps(raw_json)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee,
get_context_txn_json)
])
assert "validation error [ClientGetContextOperation]: should not contain the following chars [\'_\'] (" \
"dest=wrong_did)" in str(e.value)
def test_auth_rule_after_get_auth_rule_as_is_using_sdk(
looper, sdk_pool_handle, sdk_wallet_trustee
):
# get all auth rules
auth_rules_resp = sdk_send_and_check_get_auth_rule_request(
looper, sdk_pool_handle, sdk_wallet_trustee
)
auth_rules = auth_rules_resp[0][1][RESULT][DATA]
for rule in auth_rules:
# prepare action key
dict_key = dict(rule)
dict_key.pop(CONSTRAINT)
# prepare AUTH_RULE request
req_json = build_auth_rule_request_json(
looper, sdk_wallet_trustee[1], **rule
)
# send AUTH_RULE txn
req = sdk_sign_and_submit_req(sdk_pool_handle,
sdk_wallet_trustee,
req_json)
sdk_get_and_check_replies(looper, [req])
# send GET_AUTH_RULE
get_response = sdk_send_and_check_get_auth_rule_request(
looper, sdk_pool_handle, sdk_wallet_trustee, **dict_key)
# check response
result = get_response[0][1]["result"][DATA]
assert len(result) == 1
_check_key(dict_key, result[0])
assert rule[CONSTRAINT] == result[0][CONSTRAINT]
assert get_response[0][1]["result"][STATE_PROOF]
def test_state_proof_returned_for_get_revoc_reg_entry(looper,
nodeSetWithOneNodeResponding,
sdk_wallet_steward,
sdk_pool_handle,
sdk_wallet_client,
send_revoc_reg_entry):
revoc_reg_def = send_revoc_reg_entry[0]
revoc_reg_entry_data = send_revoc_reg_entry[1][0]['operation']
timestamp = int(time.time())
req = looper.loop.run_until_complete(build_get_revoc_reg_request(
sdk_wallet_client[1], get_revoc_reg_def_id(sdk_wallet_steward[1], revoc_reg_def[0]), timestamp))
rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, req)])
result = rep[0][1]['result']
expected_data = revoc_reg_entry_data
data = result.get(DATA)
del expected_data['type']
del data['seqNo']
del data['txnTime']
assert DATA in result
assert data
assert data == expected_data
assert result[TXN_TIME]
check_valid_proof(result)
def test_send_get_schema_as_client(
looper, sdk_pool_handle, nodeSet, sdk_wallet_client, send_schema):
_, did = sdk_wallet_client
request = looper.loop.run_until_complete(build_get_schema_request(did, send_schema))
rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, request)])
assert rep[0][1]['result']['seqNo']
def test_taa_acceptance_valid_on_uncommitted(
validate_taa_acceptance_func_api,
txnPoolNodeSet, looper, sdk_wallet_trustee, sdk_pool_handle,
add_taa_acceptance
):
text, version = gen_random_txn_author_agreement()
old_pp_seq_no = txnPoolNodeSet[0].master_replica.last_ordered_3pc[1]
with delay_rules([n.nodeIbStasher for n in txnPoolNodeSet], cDelay()):
req = looper.loop.run_until_complete(build_txn_author_agreement_request(sdk_wallet_trustee[1],
text, version,
ratification_ts=get_utc_epoch() - 600))
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, req)
def check():
assert old_pp_seq_no + 1 == txnPoolNodeSet[0].master_replica._consensus_data.preprepared[-1].pp_seq_no
looper.run(eventually(check))
request_json = add_taa_acceptance(
taa_text=text,
taa_version=version,
taa_a_time=get_utc_epoch() // SEC_PER_DAY * SEC_PER_DAY
)
request_dict = dict(**json.loads(request_json))
validate_taa_acceptance_func_api(request_dict)
def test_send_nym_with_fees(helpers, looper, nodeSetWithIntegratedTokenPlugin,
sdk_wallet_trustee, sdk_wallet_steward,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
req = helpers.request.nym_new(sdk_wallet=sdk_wallet_trustee)
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
utxos = [{
"source": utxo_from_addr_and_seq_no(address_main, init_seq_no),
AMOUNT: amount
}]
req = Request(**json.loads(req))
req = add_fees_request_with_address(helpers,
fees_set,
req,
address_main,
utxos=utxos)
token_len = len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1])
helpers.sdk.send_and_check_request_objects([req],
wallet=sdk_wallet_trustee)
assert token_len == len(
nodeSetWithIntegratedTokenPlugin[0].ledgers[-1]) - 1
assert get_last_token_txn(
nodeSetWithIntegratedTokenPlugin)[1]['txn']['data']['fees'] == NYM_FEE
request = looper.loop.run_until_complete(
build_get_nym_request(sdk_wallet_trustee[1], req.operation['dest']))
read_rep = sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)
])
reply = json.loads(read_rep[0][1]['result'][DATA])
assert req.operation['dest'] == reply['dest']
assert req.operation['verkey'] == reply['verkey']
def test_send_claim_def_with_fees(helpers,
looper,
nodeSetWithIntegratedTokenPlugin,
sdk_wallet_trustee,
sdk_pool_handle,
schema_json,
fees_set, address_main, mint_tokens):
req = helpers.request.claim_def(schema_json, sdk_wallet=sdk_wallet_trustee)
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
utxos = [{"source": utxo_from_addr_and_seq_no(address_main, init_seq_no),
AMOUNT: amount}]
req = Request(**json.loads(req))
req = add_fees_request_with_address(
helpers,
fees_set,
req,
address_main,
utxos=utxos
)
token_len = len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1])
write_rep = helpers.sdk.send_and_check_request_objects([req], wallet=sdk_wallet_trustee)
assert token_len == len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1]) - 1
assert get_last_token_txn(nodeSetWithIntegratedTokenPlugin)[1]['txn']['data']['fees'] == CLAIM_DEF_FEE
added_claim_def_id = write_rep[0][1]['result'][TXN_METADATA][TXN_METADATA_ID]
request = looper.loop.run_until_complete(build_get_cred_def_request(sdk_wallet_trustee[1], added_claim_def_id))
read_rep = sdk_get_and_check_replies(looper,
[sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
assert req.operation[DATA] == read_rep[0][1]['result'][DATA]
def check_get_delta(looper,
sdk_wallet_client,
sdk_wallet_steward,
revoc_reg_def,
timestamp_fr,
timestamp_to,
sdk_pool_handle,
revoc_reg_entry_data,
check_data=True):
req = looper.loop.run_until_complete(
build_get_revoc_reg_delta_request(
sdk_wallet_client[1],
get_revoc_reg_def_id(sdk_wallet_steward[1], revoc_reg_def[0]),
timestamp_fr, timestamp_to))
rep = sdk_get_and_check_replies(
looper,
[sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, req)])
if check_data:
result = rep[0][1]['result']
expected_data = revoc_reg_entry_data
data = result.get(DATA)['value']['accum_to']
del data['seqNo']
del data['txnTime']
if 'type' in expected_data:
del expected_data['type']
assert DATA in result
assert data
assert data == expected_data
assert result[TXN_TIME]
check_valid_proof(result)
def test_send_get_schema_fails_with_invalid_version(
looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, send_schema):
_, did = sdk_wallet_trustee
request = looper.loop.run_until_complete(build_get_schema_request(did, send_schema))
request = modify_field(request, '2.0', OPERATION, DATA, VERSION)
rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
assert rep[0][1]['result']['seqNo'] is None
def sdk_send_txn_author_agreement(looper, sdk_pool_handle, sdk_wallet, version: str,
text: Optional[str] = None,
ratified: Optional[int] = None,
retired: Optional[int] = None):
req = looper.loop.run_until_complete(build_txn_author_agreement_request(sdk_wallet[1], text, version,
ratified, retired))
rep = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet, req)
return sdk_get_and_check_replies(looper, [rep])[0]
def sdk_send_claim_def(looper, sdk_pool_handle, sdk_wallet, tag, schema_json):
wallet_handle, identifier = sdk_wallet
_, definition_json = looper.loop.run_until_complete(issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, tag, "CL", json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
reply = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet, request)])
return reply
def test_send_get_claim_def_succeeds(looper, sdk_pool_handle, nodeSet,
sdk_wallet_trustee, added_claim_def_id):
_, did = sdk_wallet_trustee
request = looper.loop.run_until_complete(
build_get_cred_def_request(did, added_claim_def_id))
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)
])
def sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
pool_config_data):
_, did = sdk_wallet_trustee
req = looper.loop.run_until_complete(
build_pool_config_request(did, pool_config_data['writes'],
pool_config_data['force']))
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, req)
return req
def sdk_send_and_check_req_json(
looper, sdk_pool_handle, sdk_wallet, req_json, no_wait=False
):
req = sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet, req_json)
if no_wait:
return req
resp = sdk_get_and_check_replies(looper, [req])
return resp
