def test_send_same_nyms_only_first_gets_written(looper, do, sdk_pool_handle,
sdk_wallet_steward):
wh, _ = sdk_wallet_steward
seed = randomString(32)
did, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 1
_, did1 = sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_steward,
dest=did,
verkey=verkey)
seed = randomString(32)
_, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 2
with pytest.raises(RequestRejectedException) as e:
_, did2 = sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_steward,
dest=did,
verkey=verkey)
e.match('is neither Trustee nor owner of')
def test_steward_suspension_by_another_trustee(looper, sdk_pool_handle,
sdk_wallet_trustee,
sdk_wallet_handle, with_verkey):
new_trustee_did, new_trustee_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
new_steward_did, new_steward_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
"""Adding new steward"""
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
'newSteward',
STEWARD_STRING,
verkey=new_steward_verkey,
dest=new_steward_did)
"""Adding new trustee"""
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
'newTrustee',
TRUSTEE_STRING,
verkey=new_trustee_verkey,
dest=new_trustee_did)
"""Blacklisting new steward by new trustee"""
op = {'type': '1', 'dest': new_steward_did, 'role': None}
if with_verkey:
op['verkey'] = new_steward_verkey
req = sdk_sign_and_submit_op(looper, sdk_pool_handle,
(sdk_wallet_handle, new_trustee_did), op)
if with_verkey:
with pytest.raises(RequestRejectedException):
sdk_get_and_check_replies(looper, [req])
else:
sdk_get_and_check_replies(looper, [req])
def test_new_DID_cannot_update_another_DID(looper,
sdk_pool_handle,
sdk_wallet_trustee,
sdk_wallet_handle):
"""Create trustee"""
trustee_did, trustee_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
"""Add trustee to ledger"""
sdk_add_new_nym(looper, sdk_pool_handle,
sdk_wallet_trustee, 'newTrustee', TRUSTEE_STRING, verkey=trustee_verkey, dest=trustee_did)
"""new DID (no role)"""
new_no_role_did, new_no_role_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
"""Adding new DID (no role) to ledger"""
sdk_add_new_nym(looper, sdk_pool_handle,
sdk_wallet_trustee,
'noRole',
verkey=new_no_role_verkey, dest=new_no_role_did)
"""Nym transaction to update Trustee DID that makes no change to verkey or role"""
op = {'type': '1',
'dest': trustee_did
}
"""Submitting the transaction fails"""
with pytest.raises(RequestRejectedException):
req = sdk_sign_and_submit_op(looper, sdk_pool_handle, sdk_wallet_trustee, op)
sdk_get_and_check_replies(looper, [req])
def test_send_same_nyms_only_first_gets_written(looper, sdk_pool_handle,
sdk_wallet):
wh, _ = sdk_wallet
seed = randomString(32)
did, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 1
_, did1 = sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet,
dest=did,
verkey=verkey)
seed = randomString(32)
_, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 2
with pytest.raises(RequestRejectedException) as e:
_, did2 = sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet,
dest=did,
verkey=verkey)
e.match('can not touch verkey field since only the owner can modify it')
def test_network_monitor_suspension_by_itself(looper, sdk_pool_handle,
sdk_wallet_steward,
sdk_wallet_handle, with_verkey):
new_network_monitor_did, new_network_monitor_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_steward[0], "{}"))
"""Adding NETWORK_MONITOR role by steward"""
op = {
'type': '1',
'dest': new_network_monitor_did,
'role': NETWORK_MONITOR,
'verkey': new_network_monitor_verkey
}
req = sdk_sign_and_submit_op(looper, sdk_pool_handle,
(sdk_wallet_handle, sdk_wallet_steward[1]),
op)
sdk_get_and_check_replies(looper, [req])
"""Blacklisting network_monitor by itself"""
op = {'type': '1', 'dest': new_network_monitor_did, 'role': None}
if with_verkey:
op['verkey'] = new_network_monitor_verkey
req = sdk_sign_and_submit_op(looper, sdk_pool_handle,
(sdk_wallet_handle, new_network_monitor_did),
op)
with pytest.raises(RequestRejectedException):
sdk_get_and_check_replies(looper, [req])
def nym_txn_data(looper, sdk_wallet_client):
seed = randomString(32)
wh, _ = sdk_wallet_client
sender_did, sender_verkey = \
looper.loop.run_until_complete(create_and_store_my_did(wh, json.dumps({'seed': seed})))
return wh, randomString(5), sender_did, sender_verkey
def _add_did(role, did_name, with_verkey=True):
nonlocal data
data['seeds'][did_name] = did_name + '0' * (32 - len(did_name))
t_sgnr = DidSigner(seed=data['seeds'][did_name].encode())
verkey = t_sgnr.full_verkey if with_verkey else None
data['txns'].append(
Member.nym_txn(nym=t_sgnr.identifier,
verkey=verkey,
role=role.value,
name=did_name,
creator=trustee.did)
)
if verkey:
(sdk_did, sdk_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(
trustee.wallet_handle,
json.dumps({'seed': data['seeds'][did_name]}))
)
return DID(
did=t_sgnr.identifier, role=role, verkey=verkey,
creator=trustee, wallet_handle=trustee.wallet_handle
)
def op(looper, sdk_wallet_stewards):
wh, did = sdk_wallet_stewards[0]
seed = randomString(32)
new_did, new_verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
op = {'type': '1', 'dest': new_did, 'verkey': new_verkey, 'role': None}
return op
def nym_full_vk(looper, tconf, nodeSet, sdk_pool_handle, sdk_wallet_trustee):
wh, tr_did = sdk_wallet_trustee
(new_did, new_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': randomString(32)})))
assert not new_verkey.startswith("~")
nwh, nd = add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee, dest=new_did, verkey=new_verkey)
return nwh, nd, new_verkey
def sdk_trustees(looper, sdk_wallet_handle, trustee_data):
trustees = []
for _, trustee_seed in trustee_data:
did_future = create_and_store_my_did(sdk_wallet_handle, json.dumps({"seed": trustee_seed}))
did, _ = looper.loop.run_until_complete(did_future)
trustees.append(did)
return trustees
def trustees(libsovtoken, wallet, looper, idr_cache):
trustees = []
for i in range(3):
did_future = create_and_store_my_did(wallet, "{}")
did, vk = looper.loop.run_until_complete(did_future)
trustees.append(did)
idr_cache.users[did] = "0"
return trustees
def test_send_same_nyms_only_first_gets_written(
looper, do, sdk_pool_handle, sdk_wallet_steward):
wh, _ = sdk_wallet_steward
seed = randomString(32)
did, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 1
_, did1 = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, dest=did, verkey=verkey)
seed = randomString(32)
_, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
# request 2
with pytest.raises(RequestRejectedException) as e:
_, did2 = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, dest=did, verkey=verkey)
e.match('is neither Trustee nor owner of')
def test_network_monitor_suspension_by_another_steward(looper, sdk_pool_handle,
sdk_wallet_steward,
sdk_wallet_trustee,
sdk_wallet_handle,
with_verkey):
new_steward_did, new_steward_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
new_network_monitor_did, new_network_monitor_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_steward[0], "{}"))
"""Adding new steward"""
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
'newSteward',
STEWARD_STRING,
verkey=new_steward_verkey,
dest=new_steward_did)
"""Adding NETWORK_MONITOR role by first steward"""
op = {
'type': '1',
'dest': new_network_monitor_did,
'role': NETWORK_MONITOR,
'verkey': new_network_monitor_verkey
}
req = sdk_sign_and_submit_op(looper, sdk_pool_handle,
(sdk_wallet_handle, new_steward_did), op)
sdk_get_and_check_replies(looper, [req])
"""Check that get_validator_info command works for NETWORK_MONITOR role"""
sdk_get_validator_info(looper,
(sdk_wallet_handle, new_network_monitor_did),
sdk_pool_handle)
"""Blacklisting network_monitor by new steward"""
op = {'type': '1', 'dest': new_network_monitor_did, 'role': None}
if with_verkey:
op['verkey'] = new_network_monitor_verkey
req = sdk_sign_and_submit_op(looper, sdk_pool_handle,
(sdk_wallet_handle, new_steward_did), op)
if with_verkey:
with pytest.raises(RequestRejectedException):
sdk_get_and_check_replies(looper, [req])
else:
sdk_get_and_check_replies(looper, [req])
with pytest.raises(RequestRejectedException):
sdk_get_validator_info(
looper, (sdk_wallet_handle, new_network_monitor_did),
sdk_pool_handle)
def sdk_stewards(looper, sdk_wallet_handle, poolTxnData):
stewards = []
pool_txn_stewards_data = get_data_for_role(poolTxnData, STEWARD)
for _, steward_seed in pool_txn_stewards_data:
did_future = create_and_store_my_did(sdk_wallet_handle, json.dumps({"seed": steward_seed}))
did, _ = looper.loop.run_until_complete(did_future)
stewards.append(did)
return stewards
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 sdk_wallet_stewards(looper, sdk_wallet_handle, poolTxnStewardNames, poolTxnData):
stewards = []
for name in poolTxnStewardNames:
seed = poolTxnData["seeds"][name]
(steward_did, steward_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': seed})))
stewards.append((sdk_wallet_handle, steward_did))
yield stewards
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 sdk_wallet_stewards(looper, sdk_wallet_handle, poolTxnStewardNames, poolTxnData):
stewards = []
for name in poolTxnStewardNames:
seed = poolTxnData["seeds"][name]
(steward_did, steward_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': seed})))
stewards.append((sdk_wallet_handle, steward_did))
yield stewards
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 create_did(self, seed=None, sdk_wallet=None):
""" Create and store a did in a sdk_wallet. """
if not seed:
seed = randomString(32)
sdk_wallet = sdk_wallet or self._client_wallet
wallet_handle, _ = sdk_wallet
config = json.dumps({seed: seed})
future = did.create_and_store_my_did(wallet_handle, config)
return self._looper.loop.run_until_complete(future)
def testSendAttribFailsForNotExistingDest(
looper, sdk_pool_handle, sdk_wallet_trustee):
wh, _ = sdk_wallet_trustee
seed = randomString(32)
did, _ = looper.loop.run_until_complete(create_and_store_my_did(
wh, json.dumps({'seed': seed})))
parameters = json.dumps({'name': 'Alice'})
with pytest.raises(RequestRejectedException) as e:
sdk_add_attribute_and_check(looper, sdk_pool_handle, sdk_wallet_trustee,
parameters, dest=did)
e.match('dest should be added before adding attribute for it')
def test_steward_cannot_create_endorsers_after_demote(looper, sdk_pool_handle,
sdk_wallet_trustee,
sdk_wallet_handle):
new_steward_did, new_steward_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
new_ta_did, new_ta_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
new_ta_2_did, new_ta_2_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
"""Adding new steward"""
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
'newSteward',
STEWARD_STRING,
verkey=new_steward_verkey,
dest=new_steward_did)
"""Adding new TA"""
sdk_add_new_nym(looper,
sdk_pool_handle, (sdk_wallet_handle, new_steward_did),
'newSteward',
ENDORSER_STRING,
verkey=new_ta_verkey,
dest=new_ta_did)
"""Blacklisting new steward by trustee"""
op = {'type': '1', 'dest': new_steward_did, 'role': None}
req = sdk_sign_and_submit_op(looper, sdk_pool_handle, sdk_wallet_trustee,
op)
sdk_get_and_check_replies(looper, [req])
"""Try to add new TA by previous demoted steward"""
with pytest.raises(RequestRejectedException):
sdk_add_new_nym(looper,
sdk_pool_handle, (sdk_wallet_handle, new_steward_did),
'newSteward',
ENDORSER_STRING,
verkey=new_ta_2_verkey,
dest=new_ta_2_did)
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 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_node_txn_promote_by_endorser(txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_trustee, looper,
sdk_wallet_handle):
validators_before = get_pool_validator_count(txnPoolNodeSet)
new_end_did, new_end_verkey = looper.loop.run_until_complete(
did.create_and_store_my_did(sdk_wallet_trustee[0], "{}"))
# Step 1. Demote node using default auth rule
demote_node(looper, sdk_wallet_trustee, sdk_pool_handle,
txnPoolNodeSet[-1])
# Check, that node was demoted
assert validators_before - get_pool_validator_count(
txnPoolNodeSet[:-1]) == 1
# Step 2. Add new Endorser
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
'newEndorser',
ENDORSER_STRING,
verkey=new_end_verkey,
dest=new_end_did)
new_constraint = AuthConstraint(ENDORSER, 1)
# Step 3. Change auth rule, to allowing endorser promote node back
sdk_send_and_check_auth_rule_request(looper,
sdk_pool_handle,
sdk_wallet_trustee,
auth_action=EDIT_PREFIX,
auth_type=promote_action.txn_type,
field=promote_action.field,
new_value=promote_action.new_value,
old_value=promote_action.old_value,
constraint=new_constraint.as_dict)
# Step 4. Promote node back, using new Endorser
promote_node(looper, (sdk_wallet_handle, new_end_did), sdk_pool_handle,
txnPoolNodeSet[-1])
# Check, that all other nodes return previous demoted node back
assert validators_before == get_pool_validator_count(txnPoolNodeSet[:-1])
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 create_new_did(looper, sdk_pool_handle, creator, role, skipverkey=False):
op = {
'type': NYM,
'role': role.value
}
new_did_verkey = None
if skipverkey:
new_did, _ = createHalfKeyIdentifierAndAbbrevVerkey()
op.update({'dest': new_did})
else:
new_did, new_did_verkey = looper.loop.run_until_complete(
create_and_store_my_did(creator.wallet_handle, "{}"))
op.update({'dest': new_did, 'verkey': new_did_verkey})
req = sdk_sign_and_submit_op(looper, sdk_pool_handle, creator.wallet_did, op)
sdk_get_and_check_replies(looper, [req])
return DIDWallet(did=new_did, role=role, verkey=new_did_verkey,
creator=creator, wallet_handle=creator.wallet_handle)
def trust_anchor_did_verkey(looper, sdk_wallet_client):
wh, _ = sdk_wallet_client
named_did, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': TRUST_ANCHOR_SEED})))
return named_did, verkey
def sdk_wallet_steward(looper, sdk_wallet_handle, sdk_steward_seed):
(steward_did, steward_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_steward_seed})))
return sdk_wallet_handle, steward_did
def trust_anchor_did_verkey(looper, sdk_wallet_client):
wh, _ = sdk_wallet_client
named_did, verkey = looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': TRUST_ANCHOR_SEED})))
return named_did, verkey
def sdk_wallet_trustee(looper, sdk_wallet_handle, sdk_trustee_seed):
(trustee_did, trustee_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_trustee_seed})))
return sdk_wallet_handle, trustee_did
def sdk_wallet_steward(looper, sdk_wallet_handle, sdk_steward_seed):
(steward_did, steward_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_steward_seed})))
return sdk_wallet_handle, steward_did
def sdk_wallet_trustee(looper, sdk_wallet_handle, sdk_trustee_seed):
(trustee_did, trustee_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_trustee_seed})))
return sdk_wallet_handle, trustee_did
def sdk_wallet_client2(looper, sdk_wallet_handle, sdk_client_seed2):
(client_did, _) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_client_seed2})))
return sdk_wallet_handle, client_did
def sdk_wallet_client2(looper, sdk_wallet_handle, sdk_client_seed2):
(client_did, _) = looper.loop.run_until_complete(
create_and_store_my_did(sdk_wallet_handle,
json.dumps({'seed': sdk_client_seed2})))
return sdk_wallet_handle, client_did
def create_verkey_did(looper, wh):
seed = randomString(32)
return looper.loop.run_until_complete(
create_and_store_my_did(wh, json.dumps({'seed': seed})))
