def test_revert_works_for_fees_before_catch_up_on_all_nodes( looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle, sdk_wallet_trustee, fees_set, address_main, mint_tokens): node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin] with delay_rules(node_set, cDelay()): request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(check_state, n, True, retryWait=0.2, timeout=15)) sdk_send_signed_requests(sdk_pool_handle, [json.dumps(request.as_dict)]) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(check_state, n, False, retryWait=0.2, timeout=15)) for n in nodeSetWithIntegratedTokenPlugin: n.start_catchup() for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(lambda: assertExp(n.mode == Mode.participating))) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(check_state, n, True, retryWait=0.2, timeout=15)) ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)
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 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 add_new_node(helpers, looper, node_set, sdk_wallet, current_amount, seq_no, fees_set, sdk_pool_handle, tdir, tconf, allPluginsPath, address, do_post_node_creation, node_class): new_did, verkey = helpers.wallet.create_did(sdk_wallet=sdk_wallet) req = helpers.request.nym(sdk_wallet=sdk_wallet, alias="new_steward", role=STEWARD_STRING, dest=new_did, verkey=verkey) utxos = [{ADDRESS: address, AMOUNT: current_amount, f.SEQ_NO.nm: seq_no}] req = add_fees_request_with_address(helpers, fees_set, req, address, utxos=utxos) current_amount, seq_no, _ = send_and_check_nym_with_fees(helpers, fees_set, seq_no, looper, addresses, current_amount, nym_with_fees=req) new_steward_wallet_handle = sdk_wallet[0], new_did new_node = sdk_add_new_node(looper, sdk_pool_handle, new_steward_wallet_handle, 'Epsilon', tdir, tconf, allPluginsPath=allPluginsPath, do_post_node_creation=do_post_node_creation, nodeClass=node_class) node_set.append(new_node) looper.run(checkNodesConnected(node_set)) waitNodeDataEquality(looper, new_node, *node_set[:-1])
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_valid_fees_invalid_payload(helpers, fees_set, mint_tokens, address_main, sdk_wallet_client): """ The fee part of the txn is valid but the payload fails dynamic validation (unauthorised request) """ req = helpers.request.nym(sdk_wallet=sdk_wallet_client) req = add_fees_request_with_address(helpers, fees_set, req, address_main) with pytest.raises(RequestRejectedException): helpers.sdk.send_and_check_request_objects([req], sdk_wallet_client)
def test_fees_extra_field(helpers, address_main, mint_tokens, fees_set): """ The fees section has an extra field. """ request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) fees = request.fees fees.append([]) request.fees = fees with pytest.raises(RequestNackedException): helpers.sdk.send_and_check_request_objects([request])
def req_with_fees(helpers, fees_set, address_main, fees): request = helpers.request.nym() utxos = [{ "source": utxo_from_addr_and_seq_no(address_main, 1), AMOUNT: fees.get(NYM_FEES_ALIAS) }] return add_fees_request_with_address( helpers, fees_set, request, address_main, utxos=utxos, )
def test_valid_fees_invalid_payload_sig(helpers, fees_set, address_main, mint_tokens): """ The fee part of the txn is valid but the payload has invalid signature """ request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) sig = getattr(request, f.SIG.nm) # Reverse the signature of NYM txn sender, making it invalid sig = sig[::-1] setattr(request, f.SIG.nm, sig) with pytest.raises(RequestNackedException): helpers.sdk.send_and_check_request_objects([request])
def test_fees_insufficient_sig(helpers, fees_set, address_main, mint_tokens): """ The fee amount is correct but signature over the fee is incorrect. """ request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) fees = getattr(request, FEES) # set only one signature instead of two fees[2] = [] setattr(request, FEES, fees) with pytest.raises(RequestNackedException): helpers.sdk.send_and_check_request_objects([request])
def test_fees_incorrect_sig(helpers, fees_set, address_main, mint_tokens): """ The fee amount is correct but signature over the fee is incorrect. """ request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) fees = getattr(request, FEES) # reverse the signatures to make them incorrect fees[2] = [sig[::-1] for sig in fees[2]] setattr(request, FEES, fees) with pytest.raises(RequestNackedException): helpers.sdk.send_and_check_request_objects([request])
def test_revert_batches_with_fees_unset_fees_without_fee( looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle, sdk_wallet_trustee, sdk_wallet_steward, fees_set, address_main, mint_tokens): node_set = nodeSetWithIntegratedTokenPlugin reverted_node = node_set[-1] head_hash_before = get_head_hash_for_pool([reverted_node], TOKEN_LEDGER_ID) uncommitted_size_before = get_uncommitted_txns_count_for_pool( [reverted_node], TOKEN_LEDGER_ID) with delay_rules(reverted_node.nodeIbStasher, cDelay()): request_check_health = helpers.request.nym() request_check_health = add_fees_request_with_address( helpers, fees_set, request_check_health, address_main) r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, helpers.request._steward_wallet, request_check_health) looper.runFor(waits.expectedPrePrepareTime(len(node_set))) """ We send only 1 txn with fees, and expects, that we have only 1 uncommitted txn for token_ledger """ assert get_uncommitted_txns_count_for_pool( [reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1 sdk_get_and_check_replies(looper, [r]) assert get_uncommitted_txns_count_for_pool( [reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1 """ Unset fees, for sending txn without fees """ helpers.node.reset_fees() sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward) """ We sent a NYM txn without fees and expects, that count of uncommitted txns wasn`t changed """ assert get_uncommitted_txns_count_for_pool( [reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1 """ Initiate reverting procedure by calling start_catchup """ reverted_node.master_replica.revert_unordered_batches() head_hash_after = get_head_hash_for_pool([reverted_node], TOKEN_LEDGER_ID) uncommitted_size_after = get_uncommitted_txns_count_for_pool( [reverted_node], TOKEN_LEDGER_ID) assert head_hash_before == head_hash_after assert uncommitted_size_before == uncommitted_size_after
def send_nym_with_fees(helpers, address, change_address, fees_set, adjust_fees=0): (did, verkey) = helpers.wallet.create_did() request = helpers.request.nym(dest=did, verkey=verkey) request = add_fees_request_with_address(helpers, fees_set, request, address, change_address=change_address, adjust_fees=adjust_fees) helpers.sdk.send_and_check_request_objects([request]) return did
def test_revert_works_for_fees_after_view_change( looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle, sdk_wallet_trustee, fees_set, address_main, mint_tokens): node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin] with delay_rules(node_set, cDelay()): request = helpers.request.nym() request = add_fees_request_with_address(helpers, fees_set, request, address_main) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(check_state, n, True, retryWait=0.2, timeout=15)) committed_hash_before = get_committed_hash_for_pool( nodeSetWithIntegratedTokenPlugin, DOMAIN_LEDGER_ID) r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, helpers.request._steward_wallet, request) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(check_state, n, False, retryWait=0.2, timeout=15)) ensure_view_change(looper, nodeSetWithIntegratedTokenPlugin) for n in nodeSetWithIntegratedTokenPlugin: looper.run( eventually(lambda: assertExp(n.mode == Mode.participating))) looper.run( eventually(check_not_in_view_change, nodeSetWithIntegratedTokenPlugin)) committed_hash_after = get_committed_hash_for_pool( nodeSetWithIntegratedTokenPlugin, DOMAIN_LEDGER_ID) assert committed_hash_before == committed_hash_after ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)
def _send_request(looper, helpers, fees, wallets_count, address, owner, sdk_wallet_trustee, sdk_wallet_trustees, sdk_wallet_stewards, sdk_wallet_clients, sdk_wallet_trust_anchors): print(wallets_count) wallets = sdk_wallet_trustees[:wallets_count.get(TRUSTEE, 0)] + \ sdk_wallet_stewards[:wallets_count.get(STEWARD, 0)] + \ sdk_wallet_clients[:wallets_count.get(IDENTITY_OWNER, 0)] + \ sdk_wallet_trust_anchors[:wallets_count.get(TRUST_ANCHOR, 0)] # prepare owner parameter if owner == TRUSTEE: sender_wallet = sdk_wallet_trustees[0] elif owner == STEWARD: sender_wallet = sdk_wallet_stewards[0] elif owner == IDENTITY_OWNER: sender_wallet = sdk_wallet_clients[0] elif owner == TRUST_ANCHOR: sender_wallet = sdk_wallet_trust_anchors[0] else: sender_wallet = wallets[0] target_dest = sdk_wallet_trustee[1] if owner == "-1" else sender_wallet[1] # prepare data data = SecretBox().encrypt(json.dumps({'name': 'Jaime'}).encode()).hex() # create request request = add_attribute(looper, sender_wallet, None, target_dest, enc=data) request = sdk_json_to_request_object(json.loads(request)) request.signature = None request.signatures = None # add fees request = add_fees_request_with_address(helpers, fees, request, address) # sign request request = sdk_multi_sign_request_objects(looper, wallets, [request]) return helpers.sdk.sdk_send_and_check(request)