diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp index d09d1558..db2ba769 100644 --- a/tests/core_tests/chaingen_main.cpp +++ b/tests/core_tests/chaingen_main.cpp @@ -873,6 +873,7 @@ int main(int argc, char* argv[]) GENERATE_AND_PLAY(wallet_rpc_integrated_address); GENERATE_AND_PLAY(wallet_rpc_integrated_address_transfer); GENERATE_AND_PLAY(wallet_rpc_transfer); + GENERATE_AND_PLAY(wallet_rpc_exchange_suite); GENERATE_AND_PLAY(wallet_chain_switch_with_spending_the_same_ki); GENERATE_AND_PLAY(wallet_sending_to_integrated_address); diff --git a/tests/core_tests/wallet_rpc_tests.cpp b/tests/core_tests/wallet_rpc_tests.cpp index 626dfae2..4075ef1e 100644 --- a/tests/core_tests/wallet_rpc_tests.cpp +++ b/tests/core_tests/wallet_rpc_tests.cpp @@ -304,5 +304,382 @@ bool wallet_rpc_transfer::c1(currency::core& c, size_t ev_index, const std::vect CHECK_AND_ASSERT_MES(currency::count_type_in_variant_container(pche->tx.extra) == 1, false, "tx_payer: incorrect count of items"); + return true; +} + +//------------------------------------------------------------------------------ + +wallet_rpc_exchange_suite::wallet_rpc_exchange_suite() +{ + REGISTER_CALLBACK_METHOD(wallet_rpc_exchange_suite, c1); +} + +bool wallet_rpc_exchange_suite::generate(std::vector& events) const +{ + m_accounts.resize(TOTAL_ACCS_COUNT); + account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate(); + + MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, test_core_time::get_time()); + DO_CALLBACK(events, "c1"); + + return true; +} + + +struct transport +{ + tools::wallet_rpc_server& m_rpc_srv; + transport(tools::wallet_rpc_server& rpc_srv):m_rpc_srv(rpc_srv) + {} + epee::net_utils::http::http_response_info m_response; + + bool is_connected() { return true; } + template + bool connect(t_a ta, t_b tb, t_c tc) { return true; } + + template + bool invoke(const std::string uri, const std::string method_, const std::string& body, const epee::net_utils::http::http_response_info** ppresponse_info, const dummy_t& d) + { + epee::net_utils::http::http_request_info query_info; + query_info.m_URI = uri; + query_info.m_body = body; + tools::wallet_rpc_server::connection_context ctx; + bool r = m_rpc_srv.handle_http_request(query_info, m_response, ctx); + if (ppresponse_info) + *ppresponse_info = &m_response; + return r; + } +}; + +template +bool invoke_text_json_for_rpc(tools::wallet_rpc_server& srv, const std::string& method_name, const request_t& req, response_t& resp) +{ + transport tr(srv); + + bool r = epee::net_utils::invoke_http_json_rpc("/json_rpc", method_name, req, resp, tr); + return r; +} + +#include "wallet_rpc_tests_legacy_defs.h" + + +std::string gen_payment_id(tools::wallet_rpc_server& custody_wlt_rpc) +{ + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request req = AUTO_VAL_INIT(req); + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response resp = AUTO_VAL_INIT(resp); + bool r = invoke_text_json_for_rpc(custody_wlt_rpc, "make_integrated_address", req, resp); + CHECK_AND_ASSERT_MES(r, "", "failed to call"); + return resp.payment_id; +} + +std::string get_integr_addr(tools::wallet_rpc_server& custody_wlt_rpc, const std::string payment_id) +{ + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request req = AUTO_VAL_INIT(req); + req.payment_id = payment_id; + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response resp = AUTO_VAL_INIT(resp); + bool r = invoke_text_json_for_rpc(custody_wlt_rpc, "make_integrated_address", req, resp); + CHECK_AND_ASSERT_MES(r, "", "failed to call"); + return resp.integrated_address; +} + +#define TRANSFER_COMMENT "SSDVSf" +std::string transfer_(std::shared_ptr wlt, const std::string& address, uint64_t amount) +{ + tools::wallet_rpc_server custody_wlt_rpc(*wlt); + pre_hf4_api::COMMAND_RPC_TRANSFER::request tr_req = AUTO_VAL_INIT(tr_req); + tr_req.comment = TRANSFER_COMMENT; + tr_req.destinations.resize(1); + tr_req.destinations.back().address = address; + tr_req.destinations.back().amount = amount; + tr_req.fee = TX_DEFAULT_FEE; + pre_hf4_api::COMMAND_RPC_TRANSFER::response tr_resp = AUTO_VAL_INIT(tr_resp); + bool r = invoke_text_json_for_rpc(custody_wlt_rpc, "transfer", tr_req, tr_resp); + CHECK_AND_ASSERT_MES(r, "", "failed to call"); + return tr_resp.tx_hash; +} + +bool test_payment_ids_generation(tools::wallet_rpc_server& custody_wlt_rpc) +{ + //check make_integrated_address/split_integrated_address +//check auto generated payment_id + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request req = AUTO_VAL_INIT(req); + pre_hf4_api::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response resp = AUTO_VAL_INIT(resp); + bool r = invoke_text_json_for_rpc(custody_wlt_rpc, "make_integrated_address", req, resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + //custody_wlt_rpc.handle_http_request() + + pre_hf4_api::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::request req2 = AUTO_VAL_INIT(req2); + req2.integrated_address = resp.integrated_address; + pre_hf4_api::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::response resp2 = AUTO_VAL_INIT(resp2); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "split_integrated_address", req2, resp2); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + + CHECK_AND_ASSERT_MES(resp2.payment_id == resp.payment_id, false, "generated paymentids missmatched"); + + //check manually set payment_id + req.payment_id = resp.payment_id; + r = invoke_text_json_for_rpc(custody_wlt_rpc, "make_integrated_address", req, resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + //custody_wlt_rpc.handle_http_request() + req2.integrated_address = resp.integrated_address; + r = invoke_text_json_for_rpc(custody_wlt_rpc, "split_integrated_address", req2, resp2); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + + CHECK_AND_ASSERT_MES(resp2.payment_id == req.payment_id, false, "generated paymentids missmatched"); + return true; +} + +bool wallet_rpc_exchange_suite::c1(currency::core& c, size_t ev_index, const std::vector& events) +{ + + bool r = false; + account_base alice_acc, bob_acc, carol_acc, custody_acc; + alice_acc.generate(); + bob_acc.generate(); + carol_acc.generate(); + custody_acc.generate(); + + std::shared_ptr miner_wlt = init_playtime_test_wallet(events, c, MINER_ACC_IDX); + std::shared_ptr alice_wlt = init_playtime_test_wallet(events, c, alice_acc); + std::shared_ptr bob_wlt = init_playtime_test_wallet(events, c, bob_acc); + std::shared_ptr carol_wlt = init_playtime_test_wallet(events, c, carol_acc); + std::shared_ptr custody_wlt = init_playtime_test_wallet(events, c, custody_acc); + + r = mine_next_pow_blocks_in_playtime(alice_wlt->get_account().get_public_address(), c, 3); + r = mine_next_pow_blocks_in_playtime(bob_wlt->get_account().get_public_address(), c, 3); + r = mine_next_pow_blocks_in_playtime(carol_wlt->get_account().get_public_address(), c, 3); + //r = mine_next_pow_blocks_in_playtime(custody_wlt->get_account().get_public_address(), c, 3); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + + + // wallet RPC server + tools::wallet_rpc_server custody_wlt_rpc(*custody_wlt); + + r = test_payment_ids_generation(custody_wlt_rpc); + CHECK_AND_ASSERT_MES(r, false, "test_payment_ids_generation() failed "); + //====================================================================== + std::string alice_payment_id = gen_payment_id(custody_wlt_rpc); + std::string bob_payment_id = gen_payment_id(custody_wlt_rpc); + std::string carol_payment_id = gen_payment_id(custody_wlt_rpc); + + // generate payment id's for each wallet and deposit + custody_wlt->refresh(); + alice_wlt->refresh(); + bob_wlt->refresh(); + carol_wlt->refresh(); + +#define TRANSFER_AMOUNT COIN / 10 + + std::string alice_tx1 = transfer_(alice_wlt, get_integr_addr(custody_wlt_rpc, alice_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + std::string bob_tx1 = transfer_(bob_wlt, get_integr_addr(custody_wlt_rpc, bob_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + std::string bob_tx2 = transfer_(bob_wlt, get_integr_addr(custody_wlt_rpc, bob_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + std::string carol_tx1 = transfer_(carol_wlt, get_integr_addr(custody_wlt_rpc, carol_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + std::string carol_tx2 = transfer_(carol_wlt, get_integr_addr(custody_wlt_rpc, carol_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + std::string carol_tx3 = transfer_(carol_wlt, get_integr_addr(custody_wlt_rpc, carol_payment_id), TRANSFER_AMOUNT); + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, 1); + + CHECK_AND_ASSERT_MES(alice_tx1.size() + && bob_tx1.size() + && bob_tx2.size() + && carol_tx1.size() + && carol_tx2.size() + && carol_tx3.size(), + false, "One of deposit transactions wan't created" + ); + + r = mine_next_pow_blocks_in_playtime(miner_wlt->get_account().get_public_address(), c, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + + custody_wlt->refresh(); + pre_hf4_api::COMMAND_RPC_GET_RECENT_TXS_AND_INFO::request req = AUTO_VAL_INIT(req); + req.update_provision_info = true; + req.count = 10; + + pre_hf4_api::COMMAND_RPC_GET_RECENT_TXS_AND_INFO::response resp = AUTO_VAL_INIT(resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "get_recent_txs_and_info", req, resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + +#define CHECK_RESPONSE_EQUAL(condition) CHECK_AND_ASSERT_MES((condition), false, "Failed check"); + + CHECK_RESPONSE_EQUAL(resp.pi.balance == 600000000000); + CHECK_RESPONSE_EQUAL(resp.pi.unlocked_balance == 600000000000); + CHECK_RESPONSE_EQUAL(resp.pi.transfers_count == 6); + CHECK_RESPONSE_EQUAL(resp.total_transfers == 6); + CHECK_RESPONSE_EQUAL(resp.transfers.size() == 6); + CHECK_RESPONSE_EQUAL(resp.transfers[0].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[0].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[0].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[0].payment_id) == carol_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[0].tx_hash) == carol_tx3); + + CHECK_RESPONSE_EQUAL(resp.transfers[1].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[1].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[1].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[1].payment_id) == carol_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[1].tx_hash) == carol_tx2); + + CHECK_RESPONSE_EQUAL(resp.transfers[2].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[2].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[2].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[2].payment_id) == carol_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[2].tx_hash) == carol_tx1); + + CHECK_RESPONSE_EQUAL(resp.transfers[3].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[3].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[3].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[3].payment_id) == bob_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[3].tx_hash) == bob_tx2); + + CHECK_RESPONSE_EQUAL(resp.transfers[4].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[4].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[4].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[4].payment_id) == bob_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[4].tx_hash) == bob_tx1); + + CHECK_RESPONSE_EQUAL(resp.transfers[5].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[5].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[5].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[5].payment_id) == alice_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[5].tx_hash) == alice_tx1); + + + req.count = 10; + req.offset = 2; + r = invoke_text_json_for_rpc(custody_wlt_rpc, "get_recent_txs_and_info", req, resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + + CHECK_RESPONSE_EQUAL(resp.pi.balance == 600000000000); + CHECK_RESPONSE_EQUAL(resp.pi.unlocked_balance == 600000000000); + CHECK_RESPONSE_EQUAL(resp.pi.transfers_count == 6); + CHECK_RESPONSE_EQUAL(resp.total_transfers == 6); + CHECK_RESPONSE_EQUAL(resp.transfers.size() == 4); + CHECK_RESPONSE_EQUAL(resp.transfers[0].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[0].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[0].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[0].payment_id) == carol_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[0].tx_hash) == carol_tx1); + + CHECK_RESPONSE_EQUAL(resp.transfers[1].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[1].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[1].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[1].payment_id) == bob_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[1].tx_hash) == bob_tx2); + + CHECK_RESPONSE_EQUAL(resp.transfers[2].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[2].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[2].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[2].payment_id) == bob_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[2].tx_hash) == bob_tx1); + + CHECK_RESPONSE_EQUAL(resp.transfers[3].comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(resp.transfers[3].amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(resp.transfers[3].is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(resp.transfers[3].payment_id) == alice_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(resp.transfers[3].tx_hash) == alice_tx1); + + //getbalance + pre_hf4_api::COMMAND_RPC_GET_BALANCE::request gb_req = AUTO_VAL_INIT(gb_req); + pre_hf4_api::COMMAND_RPC_GET_BALANCE::response gb_resp = AUTO_VAL_INIT(gb_resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "getbalance", gb_req, gb_resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + CHECK_RESPONSE_EQUAL(gb_resp.balance == 600000000000); + CHECK_RESPONSE_EQUAL(gb_resp.unlocked_balance == 600000000000); + + //get_wallet_info + pre_hf4_api::COMMAND_RPC_GET_WALLET_INFO::request gwi_req = AUTO_VAL_INIT(gwi_req); + pre_hf4_api::COMMAND_RPC_GET_WALLET_INFO::response gwi_resp = AUTO_VAL_INIT(gwi_resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "get_wallet_info", gwi_req, gwi_resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + CHECK_RESPONSE_EQUAL(gwi_resp.current_height == 35); + CHECK_RESPONSE_EQUAL(gwi_resp.transfer_entries_count == 6); + CHECK_RESPONSE_EQUAL(gwi_resp.transfers_count == 6); + CHECK_RESPONSE_EQUAL(gwi_resp.address == custody_wlt->get_account().get_public_address_str()); + + + //search_for_transactions + pre_hf4_api::COMMAND_RPC_SEARCH_FOR_TRANSACTIONS::request st_req = AUTO_VAL_INIT(st_req); + st_req.filter_by_height = false; + st_req.in = true; + st_req.out = true; + st_req.pool = true; + st_req.tx_id = resp.transfers[1].tx_hash; //bob_tx2 + pre_hf4_api::COMMAND_RPC_SEARCH_FOR_TRANSACTIONS::response st_resp = AUTO_VAL_INIT(st_resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "search_for_transactions", st_req, st_resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + //TODO: add more cases for search transaction in pool, in and out + + + CHECK_RESPONSE_EQUAL(st_resp.in.size() == 1); + CHECK_RESPONSE_EQUAL(st_resp.in.begin()->comment == TRANSFER_COMMENT); + CHECK_RESPONSE_EQUAL(st_resp.in.begin()->amount == TRANSFER_AMOUNT); + CHECK_RESPONSE_EQUAL(st_resp.in.begin()->is_income == true); + CHECK_RESPONSE_EQUAL(epee::string_tools::buff_to_hex_nodelimer(st_resp.in.begin()->payment_id) == bob_payment_id); + CHECK_RESPONSE_EQUAL(boost::lexical_cast(st_resp.in.begin()->tx_hash) == bob_tx2); + + + //get_payments + pre_hf4_api::COMMAND_RPC_GET_PAYMENTS::request gps_req = AUTO_VAL_INIT(gps_req); + gps_req.payment_id = carol_payment_id; + pre_hf4_api::COMMAND_RPC_GET_PAYMENTS::response gps_resp = AUTO_VAL_INIT(gps_resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "get_payments", gps_req, gps_resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + + { + //sort by block_height to have deterministic order + gps_resp.payments.sort([&](const pre_hf4_api::payment_details& a, const pre_hf4_api::payment_details& b) {return a.block_height < b.block_height; }); + + CHECK_RESPONSE_EQUAL(gps_resp.payments.size() == 3); + auto it = gps_resp.payments.begin(); + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == carol_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 23); + it++; + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == carol_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 24); + it++; + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == carol_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 25); + } + + + + //get_bulk_payments + pre_hf4_api::COMMAND_RPC_GET_BULK_PAYMENTS::request gbps_req = AUTO_VAL_INIT(gbps_req); + gbps_req.payment_ids.push_back(bob_payment_id); + gbps_req.payment_ids.push_back(alice_payment_id); + pre_hf4_api::COMMAND_RPC_GET_BULK_PAYMENTS::response gbps_resp = AUTO_VAL_INIT(gbps_resp); + r = invoke_text_json_for_rpc(custody_wlt_rpc, "get_bulk_payments", gbps_req, gbps_resp); + CHECK_AND_ASSERT_MES(r, false, "failed to call"); + + { + //sort by block_height to have deterministic order + gbps_resp.payments.sort([&](const pre_hf4_api::payment_details& a, const pre_hf4_api::payment_details& b) {return a.block_height < b.block_height; }); + + CHECK_RESPONSE_EQUAL(gbps_resp.payments.size() == 3); + auto it = gbps_resp.payments.begin(); + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == alice_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 20); + it++; + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == bob_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 21); + it++; + CHECK_RESPONSE_EQUAL(it->amount == 100000000000); + CHECK_RESPONSE_EQUAL(it->payment_id == bob_payment_id); + CHECK_RESPONSE_EQUAL(it->block_height == 22); + } + return true; } diff --git a/tests/core_tests/wallet_rpc_tests.h b/tests/core_tests/wallet_rpc_tests.h index 1c0ea50c..06c41575 100644 --- a/tests/core_tests/wallet_rpc_tests.h +++ b/tests/core_tests/wallet_rpc_tests.h @@ -29,3 +29,16 @@ struct wallet_rpc_transfer : public wallet_test bool configure_core(currency::core& c, size_t ev_index, const std::vector& events); bool c1(currency::core& c, size_t ev_index, const std::vector& events); }; + +/* + Tests to make sure api for exchanges didn't change after HF4(Zarcanum) + testing api: get_recent_txs_and_info, make_integrated_address, + getbalance, get_wallet_info, get_transfer_by_txid, +*/ +struct wallet_rpc_exchange_suite : public wallet_test +{ + wallet_rpc_exchange_suite(); + bool generate(std::vector& events) const; + bool c1(currency::core& c, size_t ev_index, const std::vector& events); +}; + diff --git a/tests/core_tests/wallet_rpc_tests_legacy_defs.h b/tests/core_tests/wallet_rpc_tests_legacy_defs.h new file mode 100644 index 00000000..f4994a5a --- /dev/null +++ b/tests/core_tests/wallet_rpc_tests_legacy_defs.h @@ -0,0 +1,431 @@ +// Copyright (c) 2014-2024 Zano Project +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +namespace pre_hf4_api +{ + struct COMMAND_RPC_MAKE_INTEGRATED_ADDRESS + { + struct request + { + std::string payment_id; // hex-encoded + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payment_id) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::string integrated_address; + std::string payment_id; // hex-encoded + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(integrated_address) + KV_SERIALIZE(payment_id) + END_KV_SERIALIZE_MAP() + }; + }; + + struct COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS + { + struct request + { + std::string integrated_address; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(integrated_address) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::string standard_address; + std::string payment_id; // hex-encoded + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(standard_address) + KV_SERIALIZE(payment_id) + END_KV_SERIALIZE_MAP() + }; + }; + + struct transfer_destination + { + uint64_t amount; + std::string address; + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(amount) + KV_SERIALIZE(address) + END_KV_SERIALIZE_MAP() + }; + + struct tx_service_attachment + { + std::string service_id; //string identifying service which addressed this attachment + std::string instruction; //string identifying specific instructions for service/way to interpret data + std::string body; //any data identifying service, options etc + std::vector security; //some of commands need proof of owner + uint8_t flags; //special flags (ex: TX_SERVICE_ATTACHMENT_ENCRYPT_BODY), see below + + BEGIN_SERIALIZE() + FIELD(service_id) + FIELD(instruction) + FIELD(body) + FIELD(security) + FIELD(flags) + END_SERIALIZE() + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(service_id) + KV_SERIALIZE(instruction) + KV_SERIALIZE_BLOB_AS_HEX_STRING(body) + KV_SERIALIZE_CONTAINER_POD_AS_BLOB(security) + KV_SERIALIZE(flags) + END_KV_SERIALIZE_MAP() + }; + + struct COMMAND_RPC_TRANSFER + { + struct request + { + std::list destinations; + uint64_t fee; + uint64_t mixin; + //uint64_t unlock_time; + std::string payment_id; // hex-encoded + std::string comment; + bool push_payer; + bool hide_receiver; + std::vector service_entries; + bool service_entries_permanent; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(destinations) + KV_SERIALIZE(fee) + KV_SERIALIZE(mixin) + KV_SERIALIZE(payment_id) + KV_SERIALIZE(comment) + KV_SERIALIZE(push_payer) + KV_SERIALIZE(hide_receiver) + KV_SERIALIZE(service_entries) + KV_SERIALIZE(service_entries_permanent) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::string tx_hash; + std::string tx_unsigned_hex; // for cold-signing process + uint64_t tx_size; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(tx_hash) + KV_SERIALIZE(tx_unsigned_hex) + KV_SERIALIZE(tx_size) + END_KV_SERIALIZE_MAP() + }; + }; + + struct wallet_transfer_info_details + { + std::list rcv; + std::list spn; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(rcv) + KV_SERIALIZE(spn) + END_KV_SERIALIZE_MAP() + + }; + + struct wallet_transfer_info + { + uint64_t amount; + uint64_t timestamp; + crypto::hash tx_hash; + uint64_t height; //if height == 0 then tx is unconfirmed + uint64_t unlock_time; + uint32_t tx_blob_size; + std::string payment_id; + std::vector remote_addresses; //optional + std::vector recipients_aliases; //optional + std::string comment; + bool is_income; + bool is_service; + bool is_mixing; + bool is_mining; + uint64_t tx_type; + wallet_transfer_info_details td; + std::vector service_entries; + //not included in streaming serialization + uint64_t fee; + bool show_sender; + //std::vector contract; //not traxking this part + uint16_t extra_flags; + uint64_t transfer_internal_index; + + + //not included in kv serialization map + currency::transaction tx; + std::vector selected_indicies; + std::list marketplace_entries; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(amount) + KV_SERIALIZE_POD_AS_HEX_STRING(tx_hash) + KV_SERIALIZE(height) + KV_SERIALIZE(unlock_time) + KV_SERIALIZE(tx_blob_size) + KV_SERIALIZE_BLOB_AS_HEX_STRING(payment_id) + KV_SERIALIZE(remote_addresses) + KV_SERIALIZE(recipients_aliases) + KV_SERIALIZE(comment) + KV_SERIALIZE(is_income) + KV_SERIALIZE(timestamp) + KV_SERIALIZE(td) + KV_SERIALIZE(fee) + KV_SERIALIZE(is_service) + KV_SERIALIZE(is_mixing) + KV_SERIALIZE(is_mining) + KV_SERIALIZE(tx_type) + KV_SERIALIZE(show_sender) + //KV_SERIALIZE(contract) + KV_SERIALIZE(service_entries) + KV_SERIALIZE(transfer_internal_index) + END_KV_SERIALIZE_MAP() + }; + + struct wallet_provision_info + { + uint64_t transfers_count; + uint64_t transfer_entries_count; + uint64_t balance; + uint64_t unlocked_balance; + uint64_t curent_height; + + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(transfers_count) + KV_SERIALIZE(transfer_entries_count) + KV_SERIALIZE(balance) + KV_SERIALIZE(unlocked_balance) + KV_SERIALIZE(curent_height) + END_KV_SERIALIZE_MAP() + }; + + struct COMMAND_RPC_GET_RECENT_TXS_AND_INFO + { + struct request + { + + /* + if offset is 0, then GET_RECENT_TXS_AND_INFO return + unconfirmed transactions as the first first items of "transfers", + this unconfirmed transactions is not counted regarding "count" parameter + */ + uint64_t offset; + uint64_t count; + + /* + need_to_get_info - should backend re-calculate balance(could be relatively heavy, + and not needed when getting long tx history with multiple calls + of GET_RECENT_TXS_AND_INFO with offsets) + */ + bool update_provision_info; + bool exclude_mining_txs; + bool exclude_unconfirmed; + std::string order; // "FROM_BEGIN_TO_END" or "FROM_END_TO_BEGIN" + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(offset) + KV_SERIALIZE(count) + KV_SERIALIZE(update_provision_info) + KV_SERIALIZE(exclude_mining_txs) + KV_SERIALIZE(exclude_unconfirmed) + KV_SERIALIZE(order) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + wallet_provision_info pi; + std::vector transfers; + uint64_t total_transfers; + uint64_t last_item_index; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(pi) + KV_SERIALIZE(transfers) + KV_SERIALIZE(total_transfers) + KV_SERIALIZE(last_item_index) + END_KV_SERIALIZE_MAP() + }; + }; + + + struct COMMAND_RPC_GET_BALANCE + { + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + + struct response + { + uint64_t balance; + uint64_t unlocked_balance; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(balance) + KV_SERIALIZE(unlocked_balance) + END_KV_SERIALIZE_MAP() + }; + }; + + + struct COMMAND_RPC_GET_WALLET_INFO + { + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::string address; + std::string path; + uint64_t transfers_count; + uint64_t transfer_entries_count; + bool is_whatch_only; + std::vector utxo_distribution; + uint64_t current_height; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(address) + KV_SERIALIZE(path) + KV_SERIALIZE(transfers_count) + KV_SERIALIZE(transfer_entries_count) + KV_SERIALIZE(is_whatch_only) + KV_SERIALIZE(utxo_distribution) + KV_SERIALIZE(current_height) + END_KV_SERIALIZE_MAP() + }; + }; + + + struct COMMAND_RPC_SEARCH_FOR_TRANSACTIONS + { + struct request + { + crypto::hash tx_id; + bool in; + bool out; + //bool pending; + //bool failed; + bool pool; + bool filter_by_height; + uint64_t min_height; + uint64_t max_height; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE_POD_AS_HEX_STRING(tx_id) + KV_SERIALIZE(in) + KV_SERIALIZE(out) + //KV_SERIALIZE(pending) + //KV_SERIALIZE(failed) + KV_SERIALIZE(pool) + KV_SERIALIZE(filter_by_height) + KV_SERIALIZE(min_height) + KV_SERIALIZE(max_height) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::list in; + std::list out; + //std::list pending; + //std::list failed; + std::list pool; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(in) + KV_SERIALIZE(out) + //KV_SERIALIZE(pending) + //KV_SERIALIZE(failed) + KV_SERIALIZE(pool) + END_KV_SERIALIZE_MAP() + }; + }; + + struct payment_details + { + std::string payment_id; + std::string tx_hash; + uint64_t amount; + uint64_t block_height; + uint64_t unlock_time; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payment_id) + KV_SERIALIZE(tx_hash) + KV_SERIALIZE(amount) + KV_SERIALIZE(block_height) + KV_SERIALIZE(unlock_time) + END_KV_SERIALIZE_MAP() + }; + + struct COMMAND_RPC_GET_PAYMENTS + { + struct request + { + std::string payment_id; // hex-encoded + bool allow_locked_transactions; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payment_id) + KV_SERIALIZE(allow_locked_transactions) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::list payments; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payments) + END_KV_SERIALIZE_MAP() + }; + }; + + struct COMMAND_RPC_GET_BULK_PAYMENTS + { + struct request + { + std::vector payment_ids; + uint64_t min_block_height; + bool allow_locked_transactions; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payment_ids) + KV_SERIALIZE(min_block_height) + KV_SERIALIZE(allow_locked_transactions) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::list payments; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(payments) + END_KV_SERIALIZE_MAP() + }; + }; + +}