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