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 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))