def test_create_did_without_endorser_payment(looper, nodeSetWithIntegratedTokenPlugin, nym_txn_data, sdk_pool_handle,
fees_set, address_main, mint_tokens, changed_auth_rule,
sdk_wallet_trustee, helpers):
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee)
wh, alias, sender_did, sender_verkey = nym_txn_data
req = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE))
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
)
rep = helpers.sdk.send_and_check_request_objects([req], wallet=(wh, sender_did))
details = get_nym_details(nodeSetWithIntegratedTokenPlugin[0].states[1], sender_did, is_committed=True)
assert details[ROLE] == NEW_ROLE
assert details[VERKEY] == sender_verkey
def test_nym_send_twice(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
for i in range(2):
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
if i == 0:
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
else:
# TODO(INDY-1069): Ugly hack to deal with old libindy which raises exception on REJECT,
# in fact it should be simple:
# assert result['op'] == REJECT
try:
json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert False
except IndyError as ex:
assert ex.error_code == ErrorCode.LedgerInvalidTransaction
def test_idr_cache_update_after_catchup(txnPoolNodeSet, looper,
sdk_pool_handle, sdk_wallet_steward,
tconf, tdir, allPluginsPath):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=True)
looper.removeProdable(node_to_disconnect)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
restarted_node = start_stopped_node(node_to_disconnect, looper, tconf,
tdir, allPluginsPath)
txnPoolNodeSet[-1] = restarted_node
waitNodeDataEquality(looper, restarted_node, *txnPoolNodeSet[:-1])
req_handler = restarted_node.get_req_handler(DOMAIN_LEDGER_ID)
root_hash = req_handler.ts_store.get_equal_or_prev(
get_txn_time(result['result']))
key = domain.make_state_path_for_nym(idr)
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def test_idr_cache_update_after_catchup(txnPoolNodeSet,
looper,
sdk_pool_handle,
sdk_wallet_steward,
tconf,
tdir,
allPluginsPath):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=True)
looper.removeProdable(node_to_disconnect)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
restarted_node = start_stopped_node(node_to_disconnect, looper,
tconf, tdir, allPluginsPath)
txnPoolNodeSet[-1] = restarted_node
waitNodeDataEquality(looper, restarted_node, *txnPoolNodeSet[:-1])
req_handler = restarted_node.getDomainReqHandler()
root_hash = req_handler.ts_store.get_equal_or_prev(get_txn_time(result['result']))
key = domain.make_state_path_for_nym(idr)
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def nym(
self,
seed=None,
alias=None,
role=None,
dest=None,
verkey=None,
sdk_wallet=None,
):
""" Builds a nym request. """
sdk_wallet_did = self._find_wallet_did(sdk_wallet)
if not dest:
(dest, new_verkey) = self._wallet.create_did(seed=seed,
sdk_wallet=sdk_wallet)
verkey = verkey or new_verkey
nym_request_future = build_nym_request(
sdk_wallet_did,
dest,
verkey,
alias,
role,
)
nym_request = self._looper.loop.run_until_complete(nym_request_future)
request = self._sdk.sdk_json_to_request_object(json.loads(nym_request))
request = self._sign_sdk(request, sdk_wallet=sdk_wallet)
return request
def test_create_did_without_endorser_sig_count_2_one_on_ledger(
looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle,
sdk_wallet_trustee):
change_auth_rule(looper,
sdk_pool_handle,
sdk_wallet_trustee,
constraint=AuthConstraint(role='*',
sig_count=2,
off_ledger_signature=True))
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias,
NEW_ROLE))
nym_request = sdk_multisign_request_object(looper, (wh, sender_did),
nym_request)
nym_request = sdk_multisign_request_object(looper, sdk_wallet_trustee,
nym_request)
request_couple = sdk_send_signed_requests(sdk_pool_handle,
[nym_request])[0]
sdk_get_and_check_replies(looper, [request_couple])
details = get_nym_details(txnPoolNodeSet[0].states[1],
sender_did,
is_committed=True)
assert details[ROLE] == NEW_ROLE
assert details[VERKEY] == sender_verkey
def test_idr_cache_update_after_catchup(txnPoolNodeSet,
looper,
sdk_pool_handle,
sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
req_handler = node_to_disconnect.getDomainReqHandler()
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=False)
looper.runFor(2)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
reconnect_node_and_ensure_connected(looper, txnPoolNodeSet, node_to_disconnect.name)
waitNodeDataEquality(looper, node_to_disconnect, *txnPoolNodeSet)
key = domain.make_state_path_for_nym(idr)
root_hash = req_handler.ts_store.get_equal_or_prev(result['result']['txnTime'])
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def test_create_did_without_endorser_fails(looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle):
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE))
request_couple = sdk_sign_and_send_prepared_request(looper, (wh, sender_did), sdk_pool_handle, nym_request)
with pytest.raises(RequestRejectedException, match='is not found in the Ledger'):
sdk_get_and_check_replies(looper, [request_couple])
def sdk_build_nym(self, identifier=None, sdk_wallet=None):
sdk_wallet = sdk_wallet or self._wallet_steward
identifier = identifier or sdk_wallet[1]
ident, verk = self._looper.loop.run_until_complete(
did.create_and_store_my_did(self._wallet_steward[0],
json.dumps({'seed': plenum_helper.random_string(32)})))
request = self._looper.loop.run_until_complete(build_nym_request(identifier, ident, verk, None, None))
return request
def test_create_did_without_endorser_empty_verkey(looper, nym_txn_data, sdk_wallet_client, sdk_pool_handle):
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(build_nym_request(sender_did, sender_did, None, alias, NEW_ROLE))
request_couple = sdk_sign_and_send_prepared_request(looper, (wh, sender_did), sdk_pool_handle, nym_request)
with pytest.raises(RequestNackedException, match='Can not find verkey for {}'.format(sender_did)):
sdk_get_and_check_replies(looper, [request_couple])
def new_client_request(role, name, looper, sdk_wallet):
wh, did = sdk_wallet
seed = randomString(32)
(named_did, named_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
nym_request = looper.loop.run_until_complete(
build_nym_request(did, named_did, named_verkey, name, role))
return sdk_sign_request_strings(looper, sdk_wallet,
[json.loads(nym_request)])[0]
def test_nym_resend(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
for i in range(2):
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
def test_create_did_without_endorser(looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle, patch_nym_validation):
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE))
request_couple = sdk_sign_and_send_prepared_request(looper, (wh, sender_did), sdk_pool_handle, nym_request)
sdk_get_and_check_replies(looper, [request_couple])
details = get_nym_details(txnPoolNodeSet[0].states[1], sender_did, is_committed=True)
assert details[ROLE] == NEW_ROLE
assert details[VERKEY] == sender_verkey
def new_client_request(role, name, looper, sdk_wallet):
wh, did = sdk_wallet
seed = randomString(32)
(named_did, named_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
nym_request = looper.loop.run_until_complete(
build_nym_request(did, named_did, named_verkey,
name, role))
return sdk_sign_request_strings(looper, sdk_wallet,
[json.loads(nym_request)])[0]
def nym_on_ledger(looper, sdk_pool_handle, sdk_wallet_client, sdk_wallet_steward, seed=None):
did_future = create_and_store_my_did(sdk_wallet_client[0], json.dumps({"seed": seed}) if seed else "{}")
did, vk = looper.loop.run_until_complete(did_future)
nym_req_future = build_nym_request(sdk_wallet_steward[1], did, vk, None, None)
nym_req = looper.loop.run_until_complete(nym_req_future)
nym_resp_future = sign_and_submit_request(sdk_pool_handle, sdk_wallet_steward[0], sdk_wallet_steward[1], nym_req)
nym_resp = looper.loop.run_until_complete(nym_resp_future)
nym = json.loads(nym_resp)
assert nym["result"]
assert nym["result"][TXN_METADATA]
assert nym["result"][TXN_METADATA][TXN_METADATA_SEQ_NO]
return nym["result"][TXN_METADATA][TXN_METADATA_SEQ_NO]
def test_nym_reply_is_valid(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
_, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_nym_txn(reply['result']['txn'])
def test_create_did_without_endorser_need_to_be(looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle,
sdk_wallet_trustee):
change_auth_rule(looper, sdk_pool_handle, sdk_wallet_trustee, constraint=AuthConstraint(role='*',
sig_count=1,
off_ledger_signature=False))
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE))
request_couple = sdk_sign_and_send_prepared_request(looper, (wh, sender_did), sdk_pool_handle, nym_request)
with pytest.raises(RequestRejectedException, match='is not found in the Ledger'):
sdk_get_and_check_replies(looper, [request_couple])
def req(request, looper, sdk_pool_handle, sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
if request.param == "ATTRIB":
raw = json.dumps({'answer': 42})
request_json = looper.loop.run_until_complete(
build_attrib_request(identifier,
identifier,
raw=raw,
xhash=None,
enc=None))
elif request.param == "SCHEMA":
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0",
json.dumps(["first", "last"])))
request_json = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
elif request.param == "RS_SCHEMA":
rs_schema = {'@id': "fakeId234e", '@type': "0od"}
request_json = build_rs_schema_request(identifier, rs_schema,
"ISO18023_Drivers_License",
"1.1")
elif request.param == "CLAIM_DEF":
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_json = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
elif request.param == "NYM":
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request_json = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request_json))
return Request(**json.loads(req_signed))
def test_nym_resend(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
for i in range(2):
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
def test_create_did_without_endorser_different_dest(looper, nym_txn_data,
sdk_wallet_client,
sdk_pool_handle,
patch_nym_validation):
wh, alias, sender_did, sender_verkey = nym_txn_data
nym_request = looper.loop.run_until_complete(
build_nym_request(sender_did, sdk_wallet_client[1], sender_verkey,
alias, NEW_ROLE))
request_couple = sdk_sign_and_send_prepared_request(
looper, (wh, sender_did), sdk_pool_handle, nym_request)
with pytest.raises(RequestNackedException,
match=CouldNotAuthenticate.reason.format(sender_did)):
sdk_get_and_check_replies(looper, [request_couple])
def nym(
self,
seed=None,
alias=None,
role=None,
dest=None,
verkey=None,
sdk_wallet=None,
taa=False,
mechanism=None,
text=None,
version=None
):
"""
Builds a nym request.
Role can be:
None => No change,
'' => Standard User,
'0' => Trustee,
'2' => Steward,
'101' => Endorser,
"""
sdk_wallet_did = self._find_wallet_did(sdk_wallet)
if not dest:
(dest, new_verkey) = self._wallet.create_did(
seed=seed,
sdk_wallet=sdk_wallet
)
verkey = new_verkey
nym_request_future = build_nym_request(
sdk_wallet_did,
dest,
verkey,
alias,
role,
)
nym_request = self._looper.loop.run_until_complete(nym_request_future)
if taa:
nym_request = self.add_transaction_author_agreement_to_request(nym_request, text, mechanism, version)
request = self._sdk.sdk_json_to_request_object(json.loads(nym_request))
request = self._sign_sdk(request, sdk_wallet=sdk_wallet)
return request
def test_get_txn_after_bls_key_rotation(looper, txnPoolNodeSet,
sdk_wallet_stewards,
sdk_wallet_trustee,
sdk_wallet_client,
sdk_pool_handle):
check_update_bls_key(node_num=0, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=1, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=2, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=3, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
# Stop receiving of commits in a circle, so all nodes will have different sets of multi signatures
with delay_rules_without_processing(txnPoolNodeSet[0].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[3].name)):
with delay_rules_without_processing(txnPoolNodeSet[1].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[0].name)):
with delay_rules_without_processing(txnPoolNodeSet[2].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[1].name)):
with delay_rules_without_processing(txnPoolNodeSet[3].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[2].name)):
did_future = create_and_store_my_did(sdk_wallet_client[0], "{}")
did, verkey = looper.loop.run_until_complete(did_future)
nym_request_future = ledger.build_nym_request(sdk_wallet_trustee[1], did, verkey, None, None)
nym_request = looper.loop.run_until_complete(nym_request_future)
nym_response_future = ledger.sign_and_submit_request(sdk_pool_handle, sdk_wallet_trustee[0], sdk_wallet_trustee[1], nym_request)
looper.loop.run_until_complete(nym_response_future)
get_txn_request_future = ledger.build_get_txn_request(sdk_wallet_client[1], "DOMAIN", 1)
get_txn_request = looper.loop.run_until_complete(get_txn_request_future)
get_txn_response_future = ledger.submit_request(sdk_pool_handle, get_txn_request)
looper.loop.run_until_complete(get_txn_response_future)
def test_endorser_required_when_multi_sig_with_off_ledger_signature(
looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle,
sdk_wallet_trustee, sdk_wallet_endorser):
change_new_did_auth_rule(looper,
sdk_pool_handle,
sdk_wallet_trustee,
constraint=AuthConstraint(
role='*',
sig_count=2,
off_ledger_signature=True))
new_did, verkey = \
looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_client[0], json.dumps({'seed': randomString(32)})))
sdk_wallet_new_client = (sdk_wallet_client[0], new_did)
nym_request = looper.loop.run_until_complete(
build_nym_request(new_did, new_did, verkey, None, IDENTITY_OWNER))
# can not send without Endorser
with pytest.raises(
RequestRejectedException,
match=
"'Endorser' field must be explicitly set for the endorsed transaction"
):
signed_req = sdk_multisign_request_object(looper,
sdk_wallet_new_client,
nym_request)
signed_req = sdk_multisign_request_object(looper, sdk_wallet_endorser,
signed_req)
request_couple = sdk_send_signed_requests(sdk_pool_handle,
[signed_req])[0]
sdk_get_and_check_replies(looper, [request_couple])
# can send with Endorser
sdk_submit_and_check_by_endorser(looper,
sdk_pool_handle,
sdk_wallet_author=sdk_wallet_new_client,
sdk_wallet_endorser=sdk_wallet_endorser,
request_json=nym_request)
details = get_nym_details(txnPoolNodeSet[0].states[1],
new_did,
is_committed=True)
assert details[ROLE] == IDENTITY_OWNER
assert details[VERKEY] == verkey
def nym(
self,
seed=None,
alias=None,
role=None,
dest=None,
verkey=None,
sdk_wallet=None,
):
"""
Builds a nym request.
Role can be:
None => No change,
'' => Standard User,
'0' => Trustee,
'2' => Steward,
'101' => Trust Anchor,
"""
sdk_wallet_did = self._find_wallet_did(sdk_wallet)
if not dest:
(dest, new_verkey) = self._wallet.create_did(seed=seed,
sdk_wallet=sdk_wallet)
verkey = verkey or new_verkey
nym_request_future = build_nym_request(
sdk_wallet_did,
dest,
verkey,
alias,
role,
)
nym_request = self._looper.loop.run_until_complete(nym_request_future)
request = self._sdk.sdk_json_to_request_object(json.loads(nym_request))
request = self._sign_sdk(request, sdk_wallet=sdk_wallet)
return request
def test_sigining_without_identifier(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_steward_seed, sdk_wallet_handle):
req = {TXN_PAYLOAD: {TXN_PAYLOAD_DATA: {"aaa": "BBB"}}}
steward_did_future = create_and_store_my_did(
sdk_wallet_handle, json.dumps({"seed": sdk_steward_seed}))
steward_did, _ = looper.loop.run_until_complete(steward_did_future)
did_future = create_and_store_my_did(sdk_wallet_handle, json.dumps({}))
did, verkey = looper.loop.run_until_complete(did_future)
nym_future = build_nym_request(steward_did, did, verkey, None, None)
nym = looper.loop.run_until_complete(nym_future)
resp_future = sign_and_submit_request(sdk_pool_handle, sdk_wallet_handle,
steward_did, nym)
resp = looper.loop.run_until_complete(resp_future)
req_future = multi_sign_request(sdk_wallet_handle, did, json.dumps(req))
req = looper.loop.run_until_complete(req_future)
req = json.loads(req)
sigs = txnPoolNodeSet[0].init_core_authenticator().authenticate(req)
assert sigs == [did]
def add_new_nym(looper, sdk_pool_handle, creators_wallet, dest, verkey=None):
wh, submitter_did = creators_wallet
nym_request = looper.loop.run_until_complete(build_nym_request(submitter_did, dest, verkey, None, None))
req = sdk_sign_and_send_prepared_request(looper, creators_wallet, sdk_pool_handle, nym_request)
sdk_get_and_check_replies(looper, [req])
return wh, dest
def nym_request(wallet, looper, trustees):
did_future = create_and_store_my_did(wallet, "{}")
did, vk = looper.loop.run_until_complete(did_future)
nym_future = build_nym_request(trustees[0], did, vk, None, None)
nym_req = looper.loop.run_until_complete(nym_future)
return nym_req
def sdk_gen_domain_request(looper, sdk_wallet):
_, did = sdk_wallet
target_did = SimpleSigner(seed=random_string(32).encode()).identifier
req = looper.loop.run_until_complete(build_nym_request(did, target_did, None, None, None))
return Request(**json.loads(req))
