Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity

renamed api response codes to more general way, fixed loggin

Browse source
This commit is contained in:
cryptozoidberg 2020-05-07 23:26:41 +02:00
parent dc1b1d5cfe
commit c39bd62748
No known key found for this signature in database
GPG key ID: 22DEB97A54C6FDEC
17 changed files with 177 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/common/error_codes.h Normal file
View file

@ -0,0 +1,38 @@
// Copyright (c) 2014-2018 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
#define API_RETURN_CODE_OK BASIC_RESPONSE_STATUS_OK
#define API_RETURN_CODE_FAIL BASIC_RESPONSE_STATUS_FAILED
#define API_RETURN_CODE_NOT_FOUND BASIC_RESPONSE_STATUS_NOT_FOUND
#define API_RETURN_CODE_ACCESS_DENIED "ACCESS_DENIED"
#define API_RETURN_CODE_INTERNAL_ERROR "INTERNAL_ERROR"
#define API_RETURN_CODE_NOT_ENOUGH_MONEY "NOT_ENOUGH_MONEY"
#define API_RETURN_CODE_INTERNAL_ERROR_QUE_FULL "INTERNAL_ERROR_QUE_FULL"
#define API_RETURN_CODE_BAD_ARG "BAD_ARG"
#define API_RETURN_CODE_BAD_ARG_EMPTY_DESTINATIONS "BAD_ARG_EMPTY_DESTINATIONS"
#define API_RETURN_CODE_BAD_ARG_WRONG_FEE "BAD_ARG_WRONG_FEE"
#define API_RETURN_CODE_BAD_ARG_INVALID_ADDRESS "BAD_ARG_INVALID_ADDRESS"
#define API_RETURN_CODE_BAD_ARG_WRONG_AMOUNT "BAD_ARG_WRONG_AMOUNT"
#define API_RETURN_CODE_BAD_ARG_WRONG_PAYMENT_ID "BAD_ARG_WRONG_PAYMENT_ID"
#define API_RETURN_CODE_WRONG_PASSWORD "WRONG_PASSWORD"
#define API_RETURN_CODE_WALLET_WRONG_ID "WALLET_WRONG_ID"
#define API_RETURN_CODE_WALLET_WATCH_ONLY_NOT_SUPPORTED "WALLET_WATCH_ONLY_NOT_SUPPORTED"
#define API_RETURN_CODE_FILE_NOT_FOUND "FILE_NOT_FOUND"
#define API_RETURN_CODE_ALREADY_EXISTS "ALREADY_EXISTS"
#define API_RETURN_CODE_CANCELED "CANCELED"
#define API_RETURN_CODE_FILE_RESTORED "FILE_RESTORED"
#define API_RETURN_CODE_TRUE "TRUE"
#define API_RETURN_CODE_FALSE "FALSE"
#define API_RETURN_CODE_CORE_BUSY "CORE_BUSY"
#define API_RETURN_CODE_OVERFLOW "OVERFLOW"
#define API_RETURN_CODE_BUSY "BUSY"
#define API_RETURN_CODE_INVALID_FILE "INVALID_FILE"
#define API_RETURN_CODE_WRONG_SEED "WRONG_SEED"
#define API_RETURN_CODE_GENESIS_MISMATCH "GENESIS_MISMATCH"
#define API_RETURN_CODE_DISCONNECTED "DISCONNECTED"

2
src/connectivity_tool/conn_tool.cpp
View file

@ -854,7 +854,7 @@ bool handle_update_maintainers_info(po::variables_map& vm)
std::cout << "ERROR: failed to invoke request" << ENDL;
return false;
}
if(res.status != CORE_RPC_STATUS_OK)
if(res.status != API_RETURN_CODE_OK)
{
std::cout << "ERROR: failed to update maintainers info: " << res.status << ENDL;
return false;

2
src/currency_core/alias_helper.h
View file

@ -37,7 +37,7 @@ namespace tools
if (!cb(req_alias_info, alias_info))
return false;
if (alias_info.status != CORE_RPC_STATUS_OK || !alias_info.alias_details.address.size())
if (alias_info.status != API_RETURN_CODE_OK || !alias_info.alias_details.address.size())
return false;
addr_str_local = alias_info.alias_details.address;

4
src/currency_core/blockchain_storage.cpp
View file

@ -5613,12 +5613,12 @@ bool blockchain_storage::scan_pos(const COMMAND_RPC_SCAN_POS::request& sp, COMMA
LOG_PRINT_GREEN("Found kernel: amount=" << print_money(sp.pos_entries[i].amount) << ", key_image" << sp.pos_entries[i].keyimage, LOG_LEVEL_0);
rsp.index = i;
rsp.block_timestamp = ts;
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
return true;
}
}
}
rsp.status = CORE_RPC_STATUS_NOT_FOUND;
rsp.status = API_RETURN_CODE_NOT_FOUND;
return false;
}
//------------------------------------------------------------------

146
src/rpc/core_rpc_server.cpp
View file

@ -72,13 +72,13 @@ namespace currency
return true;
}
#define check_core_ready() check_core_ready_(LOCAL_FUNCTION_DEF__)
#define CHECK_CORE_READY() if(!check_core_ready()){res.status = CORE_RPC_STATUS_BUSY;return true;}
#define CHECK_CORE_READY() if(!check_core_ready()){res.status = API_RETURN_CODE_BUSY;return true;}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res, connection_context& cntx)
{
CHECK_CORE_READY();
res.height = m_core.get_current_blockchain_size();
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -256,7 +256,7 @@ namespace currency
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -267,14 +267,21 @@ namespace currency
if (req.block_ids.back() != m_core.get_blockchain_storage().get_block_id_by_height(0))
{
//genesis mismatch, return specific
res.status = CORE_RPC_STATUS_GENESIS_MISMATCH;
res.status = API_RETURN_CODE_GENESIS_MISMATCH;
return true;
}
if (req.minimum_height >= m_core.get_blockchain_storage().get_current_blockchain_size())
{
//wrong minimum_height
res.status = API_RETURN_CODE_BAD_ARG;
return true;
}
blockchain_storage::blocks_direct_container bs;
if(!m_core.get_blockchain_storage().find_blockchain_supplement(req.block_ids, bs, res.current_height, res.start_height, COMMAND_RPC_GET_BLOCKS_FAST_MAX_COUNT, req.minimum_height))
{
res.status = CORE_RPC_STATUS_FAILED;
res.status = API_RETURN_CODE_FAIL;
return false;
}
@ -285,7 +292,7 @@ namespace currency
res.blocks.back().txs_ptr = std::move(b.second);
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -296,14 +303,21 @@ namespace currency
if (req.block_ids.back() != m_core.get_blockchain_storage().get_block_id_by_height(0))
{
//genesis mismatch, return specific
res.status = CORE_RPC_STATUS_GENESIS_MISMATCH;
res.status = API_RETURN_CODE_GENESIS_MISMATCH;
return true;
}
if (req.minimum_height >= m_core.get_blockchain_storage().get_current_blockchain_size())
{
//wrong minimum_height
res.status = API_RETURN_CODE_BAD_ARG;
return true;
}
std::list<std::pair<block, std::list<transaction> > > bs;
if(!m_core.get_blockchain_storage().find_blockchain_supplement(req.block_ids, bs, res.current_height, res.start_height, COMMAND_RPC_GET_BLOCKS_FAST_MAX_COUNT, req.minimum_height))
{
res.status = CORE_RPC_STATUS_FAILED;
res.status = API_RETURN_CODE_FAIL;
return false;
}
@ -317,7 +331,7 @@ namespace currency
}
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -330,7 +344,7 @@ namespace currency
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
std::stringstream ss;
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount outs_for_amount;
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry out_entry;
@ -346,7 +360,7 @@ namespace currency
});
std::string s = ss.str();
LOG_PRINT_L2("COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS: " << ENDL << s);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -359,7 +373,7 @@ namespace currency
res.status = "Failed";
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
LOG_PRINT_L2("COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES: [" << res.o_indexes.size() << "]");
return true;
}
@ -372,7 +386,7 @@ namespace currency
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -393,7 +407,7 @@ namespace currency
{
res.txs.push_back(t_serializable_object_to_blob(tx));
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -407,7 +421,7 @@ namespace currency
bool core_rpc_server::on_check_keyimages(const COMMAND_RPC_CHECK_KEYIMAGES::request& req, COMMAND_RPC_CHECK_KEYIMAGES::response& res, connection_context& cntx)
{
m_core.get_blockchain_storage().check_keyimages(req.images, res.images_stat);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -450,14 +464,14 @@ namespace currency
res.missed_tx.push_back(string_tools::pod_to_hex(miss_tx));
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_offers_ex(const COMMAND_RPC_GET_OFFERS_EX::request& req, COMMAND_RPC_GET_OFFERS_EX::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
{
m_of.get_offers_ex(req.filter, res.offers, res.total_offers, m_core.get_blockchain_storage().get_core_runtime_config().get_core_time());
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -465,13 +479,13 @@ namespace currency
{
if (!m_p2p.get_connections_count())
{
res.status = CORE_RPC_STATUS_DISCONNECTED;
res.status = API_RETURN_CODE_DISCONNECTED;
return true;
}
res.pos_mining_allowed = m_core.get_blockchain_storage().is_pos_allowed();
if (!res.pos_mining_allowed)
{
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
return true;
}
@ -480,21 +494,21 @@ namespace currency
//TODO: need atomic operation with build_stake_modifier()
res.starter_timestamp = m_core.get_blockchain_storage().get_last_timestamps_check_window_median();
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_current_core_tx_expiration_median(const COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MEDIAN::request& req, COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MEDIAN::response& res, connection_context& cntx)
{
res.expiration_median = m_core.get_blockchain_storage().get_tx_expiration_median();
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_rpc_get_blocks_details(const COMMAND_RPC_GET_BLOCKS_DETAILS::request& req, COMMAND_RPC_GET_BLOCKS_DETAILS::response& res, connection_context& cntx)
{
m_core.get_blockchain_storage().get_main_blocks_rpc_details(req.height_start, req.count, req.ignore_transactions, res.blocks);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -517,7 +531,7 @@ namespace currency
}
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -528,25 +542,25 @@ namespace currency
return false;
m_core.get_blockchain_storage().search_by_id(id, res.types_found);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_out_info(const COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES_BY_AMOUNT::request& req, COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES_BY_AMOUNT::response& res, connection_context& cntx)
{
if (!m_core.get_blockchain_storage().get_global_index_details(req, res))
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
else
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_multisig_info(const COMMAND_RPC_GET_MULTISIG_INFO::request& req, COMMAND_RPC_GET_MULTISIG_INFO::response& res, connection_context& cntx)
{
if (!m_core.get_blockchain_storage().get_multisig_id_details(req, res))
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
else
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -560,7 +574,7 @@ namespace currency
{
m_core.get_tx_pool().get_transactions_details(req.ids, res.txs);
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -574,14 +588,14 @@ namespace currency
{
m_core.get_tx_pool().get_transactions_brief_details(req.ids, res.txs);
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_all_pool_tx_list(const COMMAND_RPC_GET_ALL_POOL_TX_LIST::request& req, COMMAND_RPC_GET_ALL_POOL_TX_LIST::response& res, connection_context& cntx)
{
m_core.get_tx_pool().get_all_transactions_list(res.ids);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -593,7 +607,7 @@ namespace currency
{
res.aliases_que.push_back(alias_info_to_rpc_alias_info(a));
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -605,7 +619,7 @@ namespace currency
error_resp.message = "the requested block has not been found";
return false;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -617,14 +631,14 @@ namespace currency
error_resp.message = "the requested block has not been found";
return false;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_alt_blocks_details(const COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::request& req, COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::response& res, connection_context& cntx)
{
m_core.get_blockchain_storage().get_alt_blocks_rpc_details(req.offset, req.count, res.blocks);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -643,7 +657,7 @@ namespace currency
if (!m_p2p.get_payload_object().get_synchronized_connections_count())
{
LOG_PRINT_L0("[on_send_raw_tx]: Failed to send, daemon not connected to net");
res.status = CORE_RPC_STATUS_DISCONNECTED;
res.status = API_RETURN_CODE_DISCONNECTED;
return true;
}
@ -675,7 +689,7 @@ namespace currency
r.txs.push_back(tx_blob);
m_core.get_protocol()->relay_transactions(r, fake_context);
//TODO: make sure that tx has reached other nodes here, probably wait to receive reflections from other nodes
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -699,7 +713,7 @@ namespace currency
currency_connection_context fake_context = AUTO_VAL_INIT(fake_context);
bool call_res = m_core.get_protocol()->relay_transactions(r, fake_context);
if (call_res)
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return call_res;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -718,7 +732,7 @@ namespace currency
res.status = "Failed, mining not started";
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -730,7 +744,7 @@ namespace currency
res.status = "Failed, mining not stopped";
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -738,7 +752,7 @@ namespace currency
{
CHECK_CORE_READY();
res.count = m_core.get_current_blockchain_size();
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -839,7 +853,7 @@ namespace currency
//calculate epoch seed
res.seed = currency::ethash_epoch_to_seed(currency::ethash_height_to_epoch(res.height));
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
@ -1004,7 +1018,7 @@ namespace currency
error_resp.message = "Internal error: can't produce valid response.";
return false;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1045,7 +1059,7 @@ namespace currency
error_resp.message = "Internal error: can't produce valid response.";
return false;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1072,7 +1086,7 @@ namespace currency
error_resp.message = "Internal error: can't produce valid response.";
return false;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1092,7 +1106,7 @@ namespace currency
}
if(!m_core.get_blockchain_storage().get_alias_info(req.alias, aib))
{
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
return true;
}
res.alias_details.address = currency::get_account_address_as_str(aib.m_address);
@ -1100,7 +1114,7 @@ namespace currency
if (aib.m_view_key.size())
res.alias_details.tracking_key = string_tools::pod_to_hex(aib.m_view_key.back());
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1121,7 +1135,7 @@ namespace currency
return true;
});
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
@ -1140,7 +1154,7 @@ namespace currency
alias_info_to_rpc_alias_info(alias, ai, res.aliases.back());
}, req.offset, req.count);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
@ -1205,7 +1219,7 @@ namespace currency
{
if(!check_core_ready())
{
res.status = CORE_RPC_STATUS_BUSY;
res.status = API_RETURN_CODE_BUSY;
return true;
}
@ -1224,7 +1238,7 @@ namespace currency
}
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1232,7 +1246,7 @@ namespace currency
{
if(!check_core_ready())
{
res.status = CORE_RPC_STATUS_BUSY;
res.status = API_RETURN_CODE_BUSY;
return true;
}
@ -1257,9 +1271,9 @@ namespace currency
res.reward = get_alias_coast_from_fee(req.alias, std::max(default_tx_fee, current_median_fee));
if (res.reward)
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
else
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1268,9 +1282,9 @@ namespace currency
bool r = m_core.get_blockchain_storage().get_est_height_from_date(req.timestamp, res.h);
if (r)
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
else
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1279,7 +1293,7 @@ namespace currency
account_public_address addr = AUTO_VAL_INIT(addr);
if (!get_account_address_from_str(addr, req))
{
res.status = CORE_RPC_STATUS_FAILED;
res.status = API_RETURN_CODE_FAIL;
return true;
}
//res.alias = m_core.get_blockchain_storage().get_alias_by_address(addr);
@ -1289,20 +1303,20 @@ namespace currency
req2.alias = m_core.get_blockchain_storage().get_alias_by_address(addr);
if (!req2.alias.size())
{
res.status = CORE_RPC_STATUS_NOT_FOUND;
res.status = API_RETURN_CODE_NOT_FOUND;
return true;
}
bool r = this->on_get_alias_details(req2, res2, error_resp, cntx);
if (!r || res2.status != CORE_RPC_STATUS_OK)
if (!r || res2.status != API_RETURN_CODE_OK)
{
res.status = CORE_RPC_STATUS_FAILED;
res.status = API_RETURN_CODE_FAIL;
return true;
}
res.alias_info.details = res2.alias_details;
res.alias_info.alias = req2.alias;
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1310,7 +1324,7 @@ namespace currency
{
if(!check_core_ready())
{
res.status = CORE_RPC_STATUS_BUSY;
res.status = API_RETURN_CODE_BUSY;
return true;
}
block b = AUTO_VAL_INIT(b);
@ -1328,7 +1342,7 @@ namespace currency
LOG_ERROR("Submited block not accepted");
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
@ -1336,19 +1350,19 @@ namespace currency
{
if (!check_core_ready())
{
res.status = CORE_RPC_STATUS_BUSY;
res.status = API_RETURN_CODE_BUSY;
return true;
}
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_reset_transaction_pool(const COMMAND_RPC_RESET_TX_POOL::request& req, COMMAND_RPC_RESET_TX_POOL::response& res, connection_context& cntx)
{
m_core.get_tx_pool().purge_transactions();
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}
}

8
src/rpc/core_rpc_server_commands_defs.h
View file

@ -15,16 +15,10 @@
#include "storages/portable_storage_base.h"
#include "currency_core/offers_service_basics.h"
#include "currency_core/basic_api_response_codes.h"
#include "common/error_codes.h"
namespace currency
{
//-----------------------------------------------
#define CORE_RPC_STATUS_OK BASIC_RESPONSE_STATUS_OK
#define CORE_RPC_STATUS_BUSY BASIC_RESPONSE_STATUS_BUSY
#define CORE_RPC_STATUS_NOT_FOUND BASIC_RESPONSE_STATUS_NOT_FOUND
#define CORE_RPC_STATUS_FAILED BASIC_RESPONSE_STATUS_FAILED
#define CORE_RPC_STATUS_GENESIS_MISMATCH "GENESIS_MISMATCH"
#define CORE_RPC_STATUS_DISCONNECTED "DISCONNECTED"
struct alias_rpc_details_base
{

4
src/simplewallet/simplewallet.cpp
View file

@ -60,11 +60,11 @@ namespace
std::string err;
if (ok)
{
if (status == CORE_RPC_STATUS_BUSY)
if (status == API_RETURN_CODE_BUSY)
{
err = "daemon is busy. Please try later";
}
else if (status != CORE_RPC_STATUS_OK)
else if (status != API_RETURN_CODE_OK)
{
err = status;
}

2
src/wallet/core_default_rpc_proxy.cpp
View file

@ -42,7 +42,7 @@ namespace tools
currency::COMMAND_RPC_GET_BLOCKS_FAST::response res = AUTO_VAL_INIT(res);
bool r = call_COMMAND_RPC_GET_BLOCKS_FAST(req, res);
rsp.status = res.status;
if (rsp.status == CORE_RPC_STATUS_OK)
if (rsp.status == API_RETURN_CODE_OK)
{
rsp.current_height = res.current_height;
rsp.start_height = res.start_height;

4
src/wallet/plain_wallet_api.cpp
View file

@ -319,7 +319,7 @@ namespace plain_wallet
{
CRITICAL_REGION_LOCAL(gjobs_lock);
gjobs[job_id] = res;
LOG_PRINT_L0("[ASYNC_CALL]: Finished(result put), job id: " << job_id);
LOG_PRINT_L2("[ASYNC_CALL]: Finished(result put), job id: " << job_id);
}
@ -396,7 +396,7 @@ namespace plain_wallet
std::thread t([async_callback]() {async_callback(); });
t.detach();
LOG_PRINT_L0("[ASYNC_CALL]: started " << method_name << ", job id: " << job_id);
LOG_PRINT_L2("[ASYNC_CALL]: started " << method_name << ", job id: " << job_id);
return std::string("{ \"job_id\": ") + std::to_string(job_id) + "}";
}

32
src/wallet/view_iface.h
View file

@ -20,6 +20,7 @@ DISABLE_VS_WARNINGS(4503)
#include "wallet/wallet_public_structs_defs.h"
#include "currency_core/offers_services_helpers.h"
#include "currency_core/basic_api_response_codes.h"
#include "common/error_codes.h"
POP_VS_WARNINGS
//#endif
@ -764,37 +765,6 @@ public:
END_KV_SERIALIZE_MAP()
};
#define API_RETURN_CODE_OK BASIC_RESPONSE_STATUS_OK
#define API_RETURN_CODE_FAIL BASIC_RESPONSE_STATUS_FAILED
#define API_RETURN_CODE_NOT_FOUND BASIC_RESPONSE_STATUS_NOT_FOUND
#define API_RETURN_CODE_ACCESS_DENIED "ACCESS_DENIED"
#define API_RETURN_CODE_INTERNAL_ERROR "INTERNAL_ERROR"
#define API_RETURN_CODE_NOT_ENOUGH_MONEY "NOT_ENOUGH_MONEY"
#define API_RETURN_CODE_INTERNAL_ERROR_QUE_FULL "INTERNAL_ERROR_QUE_FULL"
#define API_RETURN_CODE_BAD_ARG "BAD_ARG"
#define API_RETURN_CODE_BAD_ARG_EMPTY_DESTINATIONS "BAD_ARG_EMPTY_DESTINATIONS"
#define API_RETURN_CODE_BAD_ARG_WRONG_FEE "BAD_ARG_WRONG_FEE"
#define API_RETURN_CODE_BAD_ARG_INVALID_ADDRESS "BAD_ARG_INVALID_ADDRESS"
#define API_RETURN_CODE_BAD_ARG_WRONG_AMOUNT "BAD_ARG_WRONG_AMOUNT"
#define API_RETURN_CODE_BAD_ARG_WRONG_PAYMENT_ID "BAD_ARG_WRONG_PAYMENT_ID"
#define API_RETURN_CODE_WRONG_PASSWORD "WRONG_PASSWORD"
#define API_RETURN_CODE_WALLET_WRONG_ID "WALLET_WRONG_ID"
#define API_RETURN_CODE_WALLET_WATCH_ONLY_NOT_SUPPORTED "WALLET_WATCH_ONLY_NOT_SUPPORTED"
#define API_RETURN_CODE_FILE_NOT_FOUND "FILE_NOT_FOUND"
#define API_RETURN_CODE_ALREADY_EXISTS "ALREADY_EXISTS"
#define API_RETURN_CODE_CANCELED "CANCELED"
#define API_RETURN_CODE_FILE_RESTORED "FILE_RESTORED"
#define API_RETURN_CODE_TRUE "TRUE"
#define API_RETURN_CODE_FALSE "FALSE"
#define API_RETURN_CODE_CORE_BUSY "CORE_BUSY"
#define API_RETURN_CODE_OVERFLOW "OVERFLOW"
#define API_RETURN_CODE_BUSY "BUSY"
#define API_RETURN_CODE_INVALID_FILE "INVALID_FILE"
#define API_RETURN_CODE_WRONG_SEED "WRONG_SEED"
#define API_MAX_ALIASES_COUNT 10000
struct i_view

54
src/wallet/wallet2.cpp
View file

@ -323,8 +323,8 @@ void wallet2::process_new_transaction(const currency::transaction& tx, uint64_t
req.txid = get_transaction_hash(tx);
bool r = m_core_proxy->call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(req, res);
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "get_o_indexes.bin");
THROW_IF_TRUE_WALLET_EX(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_o_indexes.bin");
THROW_IF_TRUE_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_out_indices_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.status == API_RETURN_CODE_BUSY, error::daemon_busy, "get_o_indexes.bin");
THROW_IF_TRUE_WALLET_EX(res.status != API_RETURN_CODE_OK, error::get_out_indices_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.o_indexes.size() != tx.vout.size(), error::wallet_internal_error,
"transactions outputs size=" + std::to_string(tx.vout.size()) +
" not match with COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES response size=" + std::to_string(res.o_indexes.size()));
@ -507,7 +507,7 @@ void wallet2::resend_unconfirmed()
bool r = m_core_proxy->call_COMMAND_RPC_FORCE_RELAY_RAW_TXS(req, res);
WLT_CHECK_AND_ASSERT_MES(r, void(), "wrong result at call_COMMAND_RPC_FORCE_RELAY_RAW_TXS");
WLT_CHECK_AND_ASSERT_MES(res.status == CORE_RPC_STATUS_OK, void(), "wrong result at call_COMMAND_RPC_FORCE_RELAY_RAW_TXS: status != OK, status=" << res.status);
WLT_CHECK_AND_ASSERT_MES(res.status == API_RETURN_CODE_OK, void(), "wrong result at call_COMMAND_RPC_FORCE_RELAY_RAW_TXS: status != OK, status=" << res.status);
WLT_LOG_GREEN("Relayed " << req.txs_as_hex.size() << " txs", LOG_LEVEL_0);
}
@ -1146,7 +1146,7 @@ uint64_t wallet2::get_wallet_minimum_height()
req.timestamp = m_account.get_createtime();
bool r = m_core_proxy->call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(req, res);
THROW_IF_FALSE_WALLET_EX(r, error::no_connection_to_daemon, "call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE");
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(res.status == CORE_RPC_STATUS_OK, "FAILED TO CALL COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE");
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(res.status == API_RETURN_CODE_OK, "FAILED TO CALL COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE");
m_minimum_height = res.h;
return res.h;
}
@ -1163,7 +1163,7 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
if (!r)
throw error::no_connection_to_daemon(LOCATION_STR, "getblocks.bin");
WLT_LOG_L0("COMMAND_RPC_GET_BLOCKS_DIRECT: " << epee::serialization::store_t_to_json(req));
if (res.status == CORE_RPC_STATUS_GENESIS_MISMATCH)
if (res.status == API_RETURN_CODE_GENESIS_MISMATCH)
{
WLT_LOG_MAGENTA("Reseting genesis block...", LOG_LEVEL_0);
COMMAND_RPC_GET_BLOCKS_DETAILS::request gbd_req = AUTO_VAL_INIT(gbd_req);
@ -1173,7 +1173,7 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
gbd_req.ignore_transactions = true;
r = m_core_proxy->call_COMMAND_RPC_GET_BLOCKS_DETAILS(gbd_req, gbd_res);
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "get_blocks_details");
THROW_IF_TRUE_WALLET_EX(gbd_res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, gbd_res.status);
THROW_IF_TRUE_WALLET_EX(gbd_res.status != API_RETURN_CODE_OK, error::get_blocks_error, gbd_res.status);
THROW_IF_TRUE_WALLET_EX(gbd_res.blocks.size() == 0, error::get_blocks_error, gbd_res.status);
crypto::hash new_genesis_id = null_hash;
r = string_tools::parse_tpod_from_hex_string(gbd_res.blocks.back().id, new_genesis_id);
@ -1186,13 +1186,13 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
bool r = m_core_proxy->call_COMMAND_RPC_GET_BLOCKS_DIRECT(req, res);
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "getblocks.bin");
}
if (res.status == CORE_RPC_STATUS_BUSY)
if (res.status == API_RETURN_CODE_BUSY)
{
WLT_LOG_L1("Core is busy, pull cancelled");
stop = true;
return;
}
THROW_IF_TRUE_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.status != API_RETURN_CODE_OK, error::get_blocks_error, res.status);
THROW_IF_TRUE_WALLET_EX(get_blockchain_current_size() && get_blockchain_current_size() <= res.start_height && res.start_height != m_minimum_height, error::wallet_internal_error,
"wrong daemon response: m_start_height=" + std::to_string(res.start_height) +
" not less than local blockchain size=" + std::to_string(get_blockchain_current_size()));
@ -1345,8 +1345,8 @@ void wallet2::update_current_tx_limit()
currency::COMMAND_RPC_GET_INFO::response res = AUTO_VAL_INIT(res);
bool r = m_core_proxy->call_COMMAND_RPC_GET_INFO(req, res);
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "getinfo");
THROW_IF_TRUE_WALLET_EX(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getinfo");
THROW_IF_TRUE_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.status == API_RETURN_CODE_BUSY, error::daemon_busy, "getinfo");
THROW_IF_TRUE_WALLET_EX(res.status != API_RETURN_CODE_OK, error::get_blocks_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.current_blocks_median < CURRENCY_BLOCK_GRANTED_FULL_REWARD_ZONE, error::get_blocks_error, "bad median size");
m_upper_transaction_size_limit = res.current_blocks_median - CURRENCY_COINBASE_BLOB_RESERVED_SIZE;
}
@ -1368,7 +1368,7 @@ bool wallet2::has_related_alias_entry_unconfirmed(const currency::transaction& t
currency::COMMAND_RPC_GET_ALIAS_DETAILS::response res = AUTO_VAL_INIT(res);
req.alias = tei.m_alias.m_alias;
m_core_proxy->call_COMMAND_RPC_GET_ALIAS_DETAILS(req, res);
if (res.status != CORE_RPC_STATUS_OK)
if (res.status != API_RETURN_CODE_OK)
return false;
if (local_adr == res.alias_details.address)
return true;
@ -1383,11 +1383,11 @@ void wallet2::scan_tx_pool(bool& has_related_alias_in_unconfirmed)
currency::COMMAND_RPC_GET_TX_POOL::request req = AUTO_VAL_INIT(req);
currency::COMMAND_RPC_GET_TX_POOL::response res = AUTO_VAL_INIT(res);
bool r = m_core_proxy->call_COMMAND_RPC_GET_TX_POOL(req, res);
if (res.status == CORE_RPC_STATUS_BUSY)
if (res.status == API_RETURN_CODE_BUSY)
throw error::daemon_busy(LOCATION_STR, "get_tx_pool");
if (!r)
throw error::no_connection_to_daemon(LOCATION_STR, "get_tx_pool");
THROW_IF_TRUE_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, res.status);
THROW_IF_TRUE_WALLET_EX(res.status != API_RETURN_CODE_OK, error::get_blocks_error, res.status);
//- @#@ ----- debug
@ -2817,14 +2817,14 @@ bool wallet2::fill_mining_context(mining_context& ctx)
currency::COMMAND_RPC_GET_POS_MINING_DETAILS::request pos_details_req = AUTO_VAL_INIT(pos_details_req);
currency::COMMAND_RPC_GET_POS_MINING_DETAILS::response pos_details_resp = AUTO_VAL_INIT(pos_details_resp);
ctx.rsp.status = CORE_RPC_STATUS_NOT_FOUND;
ctx.rsp.status = API_RETURN_CODE_NOT_FOUND;
m_core_proxy->call_COMMAND_RPC_GET_POS_MINING_DETAILS(pos_details_req, pos_details_resp);
if (pos_details_resp.status != CORE_RPC_STATUS_OK)
if (pos_details_resp.status != API_RETURN_CODE_OK)
return false;
ctx.basic_diff.assign(pos_details_resp.pos_basic_difficulty);
ctx.sm = pos_details_resp.sm;
ctx.rsp.last_block_hash = pos_details_resp.last_block_hash;
ctx.rsp.status = CORE_RPC_STATUS_OK;
ctx.rsp.status = API_RETURN_CODE_OK;
ctx.rsp.is_pos_allowed = pos_details_resp.pos_mining_allowed;
ctx.rsp.starter_timestamp = pos_details_resp.starter_timestamp;
return true;
@ -2862,7 +2862,7 @@ bool wallet2::try_mint_pos(const currency::account_public_address& miner_address
return true;
}, m_core_runtime_config);
if (ctx.rsp.status == CORE_RPC_STATUS_OK)
if (ctx.rsp.status == API_RETURN_CODE_OK)
{
build_minted_block(ctx.sp, ctx.rsp, miner_address);
}
@ -2918,7 +2918,7 @@ bool wallet2::build_minted_block(const currency::COMMAND_RPC_SCAN_POS::request&
WLT_LOG_GREEN("Packing inputs: " << pack_tx.vin.size() << " inputs consolidated in tx " << get_transaction_hash(pack_tx), LOG_LEVEL_0);
}
m_core_proxy->call_COMMAND_RPC_GETBLOCKTEMPLATE(tmpl_req, tmpl_rsp);
WLT_CHECK_AND_ASSERT_MES(tmpl_rsp.status == CORE_RPC_STATUS_OK, false, "Failed to create block template after kernel hash found!");
WLT_CHECK_AND_ASSERT_MES(tmpl_rsp.status == API_RETURN_CODE_OK, false, "Failed to create block template after kernel hash found!");
currency::block b = AUTO_VAL_INIT(b);
currency::blobdata block_blob;
@ -2967,7 +2967,7 @@ bool wallet2::build_minted_block(const currency::COMMAND_RPC_SCAN_POS::request&
subm_req.explicit_txs.push_back(hexemizer{ tmpl_req.explicit_transaction });
m_core_proxy->call_COMMAND_RPC_SUBMITBLOCK2(subm_req, subm_rsp);
if (subm_rsp.status != CORE_RPC_STATUS_OK)
if (subm_rsp.status != API_RETURN_CODE_OK)
{
WLT_LOG_ERROR("Constructed block is not accepted by core, status: " << subm_rsp.status);
return false;
@ -3609,8 +3609,8 @@ bool wallet2::prepare_tx_sources(size_t fake_outputs_count, std::vector<currency
bool r = m_core_proxy->call_COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS(req, daemon_resp);
THROW_IF_FALSE_WALLET_EX(r, error::no_connection_to_daemon, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(daemon_resp.status != CORE_RPC_STATUS_BUSY, error::daemon_busy, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(daemon_resp.status == CORE_RPC_STATUS_OK, error::get_random_outs_error, daemon_resp.status);
THROW_IF_FALSE_WALLET_EX(daemon_resp.status != API_RETURN_CODE_BUSY, error::daemon_busy, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(daemon_resp.status == API_RETURN_CODE_OK, error::get_random_outs_error, daemon_resp.status);
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(daemon_resp.outs.size() == selected_indicies.size(),
"daemon returned wrong response for getrandom_outs.bin, wrong amounts count = " << daemon_resp.outs.size() << ", expected: " << selected_indicies.size());
@ -3719,9 +3719,9 @@ void wallet2::send_transaction_to_network(const transaction& tx)
COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
bool r = m_core_proxy->call_COMMAND_RPC_SEND_RAW_TX(req, daemon_send_resp);
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == CORE_RPC_STATUS_DISCONNECTED, error::wallet_internal_error, "Transfer attempt while daemon offline");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status != CORE_RPC_STATUS_OK, error::tx_rejected, tx, daemon_send_resp.status);
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == API_RETURN_CODE_BUSY, error::daemon_busy, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == API_RETURN_CODE_DISCONNECTED, error::wallet_internal_error, "Transfer attempt while daemon offline");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status != API_RETURN_CODE_OK, error::tx_rejected, tx, daemon_send_resp.status);
WLT_LOG_L2("transaction " << get_transaction_hash(tx) << " generated ok and sent to daemon:" << ENDL << currency::obj_to_json_str(tx));
}
@ -4160,7 +4160,7 @@ uint64_t wallet2::get_tx_expiration_median() const
currency::COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MEDIAN::response res = AUTO_VAL_INIT(res);
m_core_proxy->call_COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MEDIAN(req, res);
if (res.status != CORE_RPC_STATUS_OK)
if (res.status != API_RETURN_CODE_OK)
{
WLT_LOG_ERROR("COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MEDIAN failed, status: " << res.status);
return 0;
@ -4549,8 +4549,8 @@ void wallet2::sweep_below(size_t fake_outs_count, const currency::account_public
r = m_core_proxy->call_COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS(req, rpc_get_random_outs_resp);
THROW_IF_FALSE_WALLET_EX(r, error::no_connection_to_daemon, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(rpc_get_random_outs_resp.status != CORE_RPC_STATUS_BUSY, error::daemon_busy, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(rpc_get_random_outs_resp.status == CORE_RPC_STATUS_OK, error::get_random_outs_error, rpc_get_random_outs_resp.status);
THROW_IF_FALSE_WALLET_EX(rpc_get_random_outs_resp.status != API_RETURN_CODE_BUSY, error::daemon_busy, "getrandom_outs.bin");
THROW_IF_FALSE_WALLET_EX(rpc_get_random_outs_resp.status == API_RETURN_CODE_OK, error::get_random_outs_error, rpc_get_random_outs_resp.status);
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(rpc_get_random_outs_resp.outs.size() == selected_transfers.size(),
"daemon returned wrong number of amounts for getrandom_outs.bin: " << rpc_get_random_outs_resp.outs.size() << ", requested: " << selected_transfers.size());

8
src/wallet/wallet2.h
View file

@ -1095,7 +1095,7 @@ namespace tools
idle_condition_cb_t idle_condition_cb,
const currency::core_runtime_config &runtime_config)
{
cxt.rsp.status = CORE_RPC_STATUS_NOT_FOUND;
cxt.rsp.status = API_RETURN_CODE_NOT_FOUND;
uint64_t timstamp_start = runtime_config.get_core_time();
uint64_t timstamp_last_idle_call = runtime_config.get_core_time();
cxt.rsp.iterations_processed = 0;
@ -1134,7 +1134,7 @@ namespace tools
if (!idle_condition_cb())
{
LOG_PRINT_L0("Detected new block, minting interrupted");
cxt.rsp.status = CORE_RPC_STATUS_NOT_FOUND;
cxt.rsp.status = API_RETURN_CODE_NOT_FOUND;
return false;
}
timstamp_last_idle_call = runtime_config.get_core_time();
@ -1178,7 +1178,7 @@ namespace tools
LOG_LEVEL_0);
cxt.rsp.index = i;
cxt.rsp.block_timestamp = ts;
cxt.rsp.status = CORE_RPC_STATUS_OK;
cxt.rsp.status = API_RETURN_CODE_OK;
return true;
}
@ -1187,7 +1187,7 @@ namespace tools
}
}
cxt.rsp.status = CORE_RPC_STATUS_NOT_FOUND;
cxt.rsp.status = API_RETURN_CODE_NOT_FOUND;
return false;
}

10
src/wallet/wallets_manager.cpp
View file

@ -992,7 +992,7 @@ std::string wallets_manager::get_aliases(view::alias_set& al_set)
currency::COMMAND_RPC_GET_ALL_ALIASES::response aliases = AUTO_VAL_INIT(aliases);
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALL_ALIASES(aliases) && aliases.status == CORE_RPC_STATUS_OK)
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALL_ALIASES(aliases) && aliases.status == API_RETURN_CODE_OK)
{
al_set.aliases = aliases.aliases;
return API_RETURN_CODE_OK;
@ -1066,7 +1066,7 @@ std::string wallets_manager::request_alias_registration(const currency::alias_rp
currency::COMMAND_RPC_GET_ALIAS_DETAILS::request req = AUTO_VAL_INIT(req);
req.alias = ai.m_alias;
currency::COMMAND_RPC_GET_ALIAS_DETAILS::response rsp = AUTO_VAL_INIT(rsp);
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALIAS_DETAILS(req, rsp) && rsp.status == CORE_RPC_STATUS_NOT_FOUND)
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALIAS_DETAILS(req, rsp) && rsp.status == API_RETURN_CODE_NOT_FOUND)
{
GET_WALLET_BY_ID(wallet_id, w);
try
@ -1105,7 +1105,7 @@ std::string wallets_manager::request_alias_update(const currency::alias_rpc_deta
currency::COMMAND_RPC_GET_ALIAS_DETAILS::request req;
req.alias = ai.m_alias;
currency::COMMAND_RPC_GET_ALIAS_DETAILS::response rsp = AUTO_VAL_INIT(rsp);
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALIAS_DETAILS(req, rsp) && rsp.status == CORE_RPC_STATUS_OK)
if (m_rpc_proxy->call_COMMAND_RPC_GET_ALIAS_DETAILS(req, rsp) && rsp.status == API_RETURN_CODE_OK)
{
GET_WALLET_BY_ID(wallet_id, w);
try
@ -1749,7 +1749,7 @@ void wallets_manager::wallet_vs_options::worker_func()
pos_minin_interval.do_call([this](){
tools::wallet2::mining_context ctx = AUTO_VAL_INIT(ctx);
LOG_PRINT_L1(get_log_prefix() + " Starting PoS mint iteration");
if (!w->get()->fill_mining_context(ctx) || ctx.rsp.status != CORE_RPC_STATUS_OK)
if (!w->get()->fill_mining_context(ctx) || ctx.rsp.status != API_RETURN_CODE_OK)
{
LOG_PRINT_L1(get_log_prefix() + " cannot obtain PoS mining context, skip iteration");
return true;
@ -1763,7 +1763,7 @@ void wallets_manager::wallet_vs_options::worker_func()
return *plast_daemon_network_state == currency::COMMAND_RPC_GET_INFO::daemon_network_state_online && *plast_daemon_height == last_wallet_synch_height;
}, core_conf);
if (ctx.rsp.status == CORE_RPC_STATUS_OK)
if (ctx.rsp.status == API_RETURN_CODE_OK)
{
w->get()->build_minted_block(ctx.sp, ctx.rsp);
}

2
tests/core_tests/chaingen.cpp
View file

@ -386,7 +386,7 @@ bool test_generator::build_wallets(const blockchain_vector& blocks,
{
auto it = m_txs_outs.find(rqt.txid);
CHECK_AND_ASSERT_MES(it != m_txs_outs.end(), false, "tx " << rqt.txid << " was not found in tx global outout indexes");
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
rsp.o_indexes = it->second;
return true;
}

2
tests/core_tests/chaingen_helpers.h
View file

@ -144,7 +144,7 @@ inline bool mine_next_pos_block_in_playtime_with_wallet(tools::wallet2& w, const
std::atomic<bool> stop(false);
w.scan_pos(ctx, stop, [&w](){size_t blocks_fetched; w.refresh(blocks_fetched); return blocks_fetched == 0; }, w.get_core_runtime_config());
if (ctx.rsp.status != CORE_RPC_STATUS_OK)
if (ctx.rsp.status != API_RETURN_CODE_OK)
return false;
return w.build_minted_block(ctx.sp, ctx.rsp, miner_address);

6
tests/core_tests/multisig_wallet_tests.cpp
View file

@ -92,9 +92,9 @@ void transfer_multisig(tools::wallet2& w,
COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
bool r = w.get_core_proxy()->call_COMMAND_RPC_SEND_RAW_TX(req, daemon_send_resp);
THROW_IF_TRUE_WALLET_EX(!r, tools::error::no_connection_to_daemon, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, tools::error::daemon_busy, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == CORE_RPC_STATUS_DISCONNECTED, tools::error::wallet_internal_error, "Transfer attempt while daemon offline");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status != CORE_RPC_STATUS_OK, tools::error::tx_rejected, tx, daemon_send_resp.status);
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == API_RETURN_CODE_BUSY, tools::error::daemon_busy, "sendrawtransaction");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status == API_RETURN_CODE_DISCONNECTED, tools::error::wallet_internal_error, "Transfer attempt while daemon offline");
THROW_IF_TRUE_WALLET_EX(daemon_send_resp.status != API_RETURN_CODE_OK, tools::error::tx_rejected, tx, daemon_send_resp.status);
}
}

14
tests/core_tests/wallet_test_core_proxy.cpp
View file

@ -49,7 +49,7 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(cons
{
auto it = m_txs_outs.find(rqt.txid);
CHECK_AND_ASSERT_MES(it != m_txs_outs.end(), false, "tx " << rqt.txid << " was not found in tx global outout indexes");
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
rsp.o_indexes = it->second;
return true;
}
@ -75,7 +75,7 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::CO
}
rsp.current_height = m_blocks.size();
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
if (!m_first_call)
{
m_first_call = true;
@ -101,7 +101,7 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::
currency::COMMAND_RPC_GET_BLOCKS_FAST::response res = AUTO_VAL_INIT(res);
bool r = this->call_COMMAND_RPC_GET_BLOCKS_FAST(req, res);
rsp.status = res.status;
if (rsp.status == CORE_RPC_STATUS_OK)
if (rsp.status == API_RETURN_CODE_OK)
{
rsp.current_height = res.current_height;
rsp.start_height = res.start_height;
@ -114,7 +114,7 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp)
{
rsp.h = 0;
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
return true;
}
@ -126,13 +126,13 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_INFO(const currency::COMMAND_R
bool wallet_test_core_proxy::call_COMMAND_RPC_SEND_RAW_TX(const currency::COMMAND_RPC_SEND_RAW_TX::request& rqt, currency::COMMAND_RPC_SEND_RAW_TX::response& rsp)
{
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
return true;
}
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_TX_POOL(const currency::COMMAND_RPC_GET_TX_POOL::request& rqt, currency::COMMAND_RPC_GET_TX_POOL::response& rsp)
{
rsp.status = CORE_RPC_STATUS_OK;
rsp.status = API_RETURN_CODE_OK;
rsp.txs = m_unconfirmed_txs;
return true;
}
@ -148,7 +148,7 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_CURRENT_CORE_TX_EXPIRATION_MED
}
res.expiration_median = epee::misc_utils::median(tiemstamps);
res.status = CORE_RPC_STATUS_OK;
res.status = API_RETURN_CODE_OK;
return true;
}