boost::optional<std::string> NodeRPCProxy::get_fee_quantization_mask(uint64_t &fee_quantization_mask) const
{
uint64_t height;
boost::optional<std::string> result = get_height(height);
if (result)
return result;
if (m_offline)
return boost::optional<std::string>("offline");
if (m_dynamic_base_fee_estimate_cached_height != height)
{
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::request req_t = AUTO_VAL_INIT(req_t);
cryptonote::COMMAND_RPC_GET_BASE_FEE_ESTIMATE::response resp_t = AUTO_VAL_INIT(resp_t);
m_daemon_rpc_mutex.lock();
req_t.grace_blocks = m_dynamic_base_fee_estimate_grace_blocks;
bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_fee_estimate", req_t, resp_t, m_http_client, rpc_timeout);
m_daemon_rpc_mutex.unlock();
CHECK_AND_ASSERT_MES(r, std::string("Failed to connect to daemon"), "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status != CORE_RPC_STATUS_BUSY, resp_t.status, "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status == CORE_RPC_STATUS_OK, resp_t.status, "Failed to get fee estimate");
m_dynamic_base_fee_estimate = resp_t.fee;
m_dynamic_base_fee_estimate_cached_height = height;
m_fee_quantization_mask = resp_t.quantization_mask;
}
fee_quantization_mask = m_fee_quantization_mask;
if (fee_quantization_mask == 0)
{
MERROR("Fee quantization mask is 0, forcing to 1");
fee_quantization_mask = 1;
}
return boost::optional<std::string>();
}
TEST(parse_and_validate_tx_extra, put_and_load_alias)
{
currency::transaction miner_tx = AUTO_VAL_INIT(miner_tx);
currency::account_public_address acc = AUTO_VAL_INIT(acc);
currency::alias_info alias = AUTO_VAL_INIT(alias);
force_random(alias.m_address);
force_random(alias.m_sign);
force_random(alias.m_view_key);
alias.m_alias = "sdsdsd";
alias.m_text_comment = "werwrwerw";
bool res = currency::construct_miner_tx(0, 0, 0, 0, 0, 1000, acc, acc, acc, miner_tx, currency::blobdata(), 10, 50, alias);
currency::tx_extra_info ei = AUTO_VAL_INIT(ei);
bool r = parse_and_validate_tx_extra(miner_tx, ei);
ASSERT_TRUE(r);
if(ei.m_alias.m_address.m_spend_public_key == alias.m_address.m_spend_public_key &&
ei.m_alias.m_address.m_view_public_key == alias.m_address.m_view_public_key &&
ei.m_alias.m_alias == alias.m_alias &&
ei.m_alias.m_sign == alias.m_sign &&
ei.m_alias.m_text_comment == alias.m_text_comment &&
ei.m_alias.m_view_key == alias.m_view_key)
{
return;
}else
ASSERT_TRUE(false);
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_clonetelepod(const wallet_rpc::COMMAND_RPC_CLONETELEPOD::request& req, wallet_rpc::COMMAND_RPC_CLONETELEPOD::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
currency::transaction tx2 = AUTO_VAL_INIT(tx2);
//new destination account
currency::account_base acc2 = AUTO_VAL_INIT(acc2);
acc2.generate();
if (!build_transaction_from_telepod(req.tpd, acc2.get_keys().m_account_address, tx2, res.status))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
return true;
}
//send transaction to daemon
currency::COMMAND_RPC_SEND_RAW_TX::request req_send_raw;
req_send_raw.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx2));
currency::COMMAND_RPC_SEND_RAW_TX::response rsp_send_raw;
bool r = m_wallet.get_core_proxy()->call_COMMAND_RPC_SEND_RAW_TX(req_send_raw, rsp_send_raw);
if (!r || rsp_send_raw.status != CORE_RPC_STATUS_OK)
{
LOG_ERROR("Problem with construct_tx(....), blobl size os too big: " << get_object_blobsize(tx2));
res.status = "INTERNAL_ERROR";
return true;
}
res.tpd.basement_tx_id_hex = string_tools::pod_to_hex(currency::get_transaction_hash(tx2));
std::string acc2_buff = epee::serialization::store_t_to_binary(acc2);
res.tpd.account_keys_hex = string_tools::buff_to_hex_nodelimer(acc2_buff);
res.status = "OK";
LOG_PRINT_GREEN("TELEPOD ISSUED [" << currency::print_money(currency::get_outs_money_amount(tx2)) << "BBR, base_tx_id: ]" << currency::get_transaction_hash(tx2), LOG_LEVEL_0);
return true;
}
bool communicate(const std::string url, t_request& req, t_response& rsp, const std::string& ip, const std::string& port, bool use_json, bool use_jrpc = false)
{
epee::net_utils::http::http_simple_client http_client;
bool r = http_client.connect(ip, port, 1000);
CHECK_AND_ASSERT_MES(r, false, "failed to connect");
if(use_json)
{
if(use_jrpc)
{
epee::json_rpc::request<t_request> req_t = AUTO_VAL_INIT(req_t);
req_t.jsonrpc = "2.0";
req_t.id = epee::serialization::storage_entry(10);
req_t.method = "command_example_1";
req_t.params = req;
epee::json_rpc::response<t_response, std::string> resp_t = AUTO_VAL_INIT(resp_t);
if(!epee::net_utils::invoke_http_json_remote_command2("/request_json_rpc", req_t, resp_t, http_client))
{
return false;
}
rsp = resp_t.result;
return true;
}else
return epee::net_utils::invoke_http_json_remote_command2(url, req, rsp, http_client);
}
else
return epee::net_utils::invoke_http_bin_remote_command2(url, req, rsp, http_client);
}
extern "C" uint64_t pNXT_submit_tx(currency::core *m_core,currency::simple_wallet *wallet,unsigned char *txbytes,int16_t size)
{
int i,j;
crypto::hash h;
uint64_t txid = 0;
blobdata txb,b;
transaction tx = AUTO_VAL_INIT(tx);
txin_to_key input_to_key = AUTO_VAL_INIT(input_to_key);
NOTIFY_NEW_TRANSACTIONS::request req;
currency_connection_context fake_context = AUTO_VAL_INIT(fake_context);
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
if ( m_core == 0 || wallet == 0 )
{
printf("pNXT_submit_tx missing m_core.%p or wallet.%p\n",m_core,wallet);
return(0);
}
tx.vin.clear();
tx.vout.clear();
tx.signatures.clear();
keypair txkey = keypair::generate();
add_tx_pub_key_to_extra(tx, txkey.pub);
if ( sizeof(input_to_key.k_image) != 32 )
{
printf("FATAL: expected sizeof(input_to_key.k_image) to be 32!\n");
return(0);
}
j = add_byte(&tx,&input_to_key,0,size&0xff);
j = add_byte(&tx,&input_to_key,j,(size>>8)&0xff);
for (i=0; i<size; i++)
j = add_byte(&tx,&input_to_key,j,txbytes[i]);
if ( j != 0 )
tx.vin.push_back(input_to_key);
tx.version = 0;
txb = tx_to_blob(tx);
printf("FROM submit jl777\n");
if ( !m_core->handle_incoming_tx(txb,tvc,false) )
{
LOG_PRINT_L0("[on_send_raw_tx]: Failed to process tx");
return(0);
}
if ( tvc.m_verifivation_failed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx verification failed");
return(0);
}
if( !tvc.m_should_be_relayed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx accepted, but not relayed");
return(0);
}
req.txs.push_back(txb);
m_core->get_protocol()->relay_transactions(req,fake_context);
get_transaction_hash(tx,h);
txid = calc_txid((unsigned char *)&h,sizeof(h));
return(txid);
}
bool daemon_backend::update_state_info()
{
view::daemon_status_info dsi = AUTO_VAL_INIT(dsi);
dsi.difficulty = "---";
currency::COMMAND_RPC_GET_INFO::response inf = AUTO_VAL_INIT(inf);
if(!m_rpc_proxy.get_info(inf))
{
dsi.text_state = "get_info failed";
m_pview->update_daemon_status(dsi);
LOG_ERROR("Failed to call get_info");
return false;
}
dsi.difficulty = std::to_string(inf.difficulty);
dsi.hashrate = inf.current_network_hashrate_350;
dsi.inc_connections_count = inf.incoming_connections_count;
dsi.out_connections_count = inf.outgoing_connections_count;
switch(inf.daemon_network_state)
{
case currency::COMMAND_RPC_GET_INFO::daemon_network_state_connecting: dsi.text_state = "Connecting";break;
case currency::COMMAND_RPC_GET_INFO::daemon_network_state_online: dsi.text_state = "Online";break;
case currency::COMMAND_RPC_GET_INFO::daemon_network_state_synchronizing: dsi.text_state = "Synchronizing";break;
default: dsi.text_state = "unknown";break;
}
dsi.daemon_network_state = inf.daemon_network_state;
dsi.synchronization_start_height = inf.synchronization_start_height;
dsi.max_net_seen_height = inf.max_net_seen_height;
dsi.last_build_available = std::to_string(inf.mi.ver_major)
+ "." + std::to_string(inf.mi.ver_minor)
+ "." + std::to_string(inf.mi.ver_revision)
+ "." + std::to_string(inf.mi.build_no);
if (inf.mi.mode)
{
dsi.last_build_displaymode = inf.mi.mode + 1;
}
else
{
if (inf.mi.build_no > PROJECT_VERSION_BUILD_NO)
dsi.last_build_displaymode = view::ui_last_build_displaymode::ui_lb_dm_new;
else
{
dsi.last_build_displaymode = view::ui_last_build_displaymode::ui_lb_dm_actual;
}
}
m_last_daemon_height = dsi.height = inf.height;
m_pview->update_daemon_status(dsi);
return true;
}
bool daemon_backend::get_transfer_address(const std::string& adr_str, currency::account_public_address& addr)
{
if (!adr_str.size())
return false;
std::string addr_str_local = adr_str;
if (adr_str[0] == '@')
{
//referred by alias name
if (adr_str.size() < 2)
return false;
std::string pure_alias_name = adr_str.substr(1);
CHECK_AND_ASSERT_MES(currency::validate_alias_name(pure_alias_name), false, "wrong name set in transfer command");
//currency::alias_info_base ai = AUTO_VAL_INIT(ai);
currency::COMMAND_RPC_GET_ALIAS_DETAILS::response alias_info = AUTO_VAL_INIT(alias_info);
if (!m_rpc_proxy.get_alias_info(pure_alias_name, alias_info))
return false;
if (alias_info.status != CORE_RPC_STATUS_OK)
return false;
addr_str_local = alias_info.alias_details.address;
}
if (!get_account_address_from_str(addr, addr_str_local))
{
return false;
}
return true;
}
TEST(parse_and_validate_tx_extra, fails_on_big_extra_nonce)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b(TX_EXTRA_NONCE_MAX_COUNT + 1, 0);
ASSERT_FALSE(cryptonote::construct_miner_tx(0, 0, 10000000000000, 1000, DEFAULT_FEE, acc.get_keys().m_account_address, tx, b, 1));
}
TEST(parse_and_validate_tx_extra, is_correct_extranonce_too_big)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b(260, 0);
bool r = cryptonote::construct_miner_tx(0, 0, 10000000000000, 1000, DEFAULT_FEE, acc.get_keys().m_account_address, tx, b, 1);
ASSERT_FALSE(r);
}
TEST(parse_and_validate_tx_extra, fails_on_wrong_size_in_extra_nonce)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
tx.extra.resize(20, 0);
tx.extra[0] = TX_EXTRA_NONCE;
tx.extra[1] = 255;
std::vector<cryptonote::tx_extra_field> tx_extra_fields;
ASSERT_FALSE(cryptonote::parse_tx_extra(tx.extra, tx_extra_fields));
}
TEST(parse_and_validate_tx_extra, fails_on_big_extra_nonce)
{
cryptonote::Currency currency = cryptonote::CurrencyBuilder().currency();
cryptonote::Transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b(TX_EXTRA_NONCE_MAX_COUNT + 1, 0);
ASSERT_FALSE(currency.constructMinerTx(0, 0, 10000000000000, 1000, currency.minimumFee(), acc.get_keys().m_account_address, tx, b, 1));
}
boost::optional<std::string> NodeRPCProxy::get_rpc_version(uint32_t &rpc_version) const
{
if (m_offline)
return boost::optional<std::string>("offline");
if (m_rpc_version == 0)
{
cryptonote::COMMAND_RPC_GET_VERSION::request req_t = AUTO_VAL_INIT(req_t);
cryptonote::COMMAND_RPC_GET_VERSION::response resp_t = AUTO_VAL_INIT(resp_t);
m_daemon_rpc_mutex.lock();
bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_version", req_t, resp_t, m_http_client, rpc_timeout);
m_daemon_rpc_mutex.unlock();
CHECK_AND_ASSERT_MES(r, std::string("Failed to connect to daemon"), "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status != CORE_RPC_STATUS_BUSY, resp_t.status, "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status == CORE_RPC_STATUS_OK, resp_t.status, "Failed to get daemon RPC version");
m_rpc_version = resp_t.version;
}
rpc_version = m_rpc_version;
return boost::optional<std::string>();
}
TEST(parse_and_validate_tx_extra, is_valid_tx_extra_parsed)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b = "dsdsdfsdfsf";
ASSERT_TRUE(cryptonote::construct_miner_tx(0, 0, 10000000000000, 1000, DEFAULT_FEE, acc.get_keys().m_account_address, tx, b, 1));
crypto::public_key tx_pub_key = cryptonote::get_tx_pub_key_from_extra(tx);
ASSERT_NE(tx_pub_key, cryptonote::null_pkey);
}
TEST(parse_and_validate_tx_extra, is_correct_wrong_extra_couner_too_big)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
tx.extra.resize(20, 0);
tx.extra[0] = TX_EXTRA_NONCE;
tx.extra[1] = 255;
crypto::public_key tx_pub_key;
bool r = parse_and_validate_tx_extra(tx, tx_pub_key);
ASSERT_FALSE(r);
}
bool daemon_backend::get_aliases(view::alias_set& al_set)
{
currency::COMMAND_RPC_GET_ALL_ALIASES::response aliases = AUTO_VAL_INIT(aliases);
if (m_rpc_proxy.get_aliases(aliases) && aliases.status == CORE_RPC_STATUS_OK)
{
al_set.aliases = aliases.aliases;
return true;
}
return false;
}
TEST(parse_and_validate_tx_extra, is_correct_wrong_extra_nonce_double_entry)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
tx.extra.resize(20, 0);
cryptonote::blobdata v = "asasdasd";
cryptonote::add_tx_extra_nonce(tx, v);
cryptonote::add_tx_extra_nonce(tx, v);
crypto::public_key tx_pub_key;
bool r = parse_and_validate_tx_extra(tx, tx_pub_key);
ASSERT_FALSE(r);
}
TEST(parse_and_validate_tx_extra, is_valid_tx_extra_parsed)
{
cryptonote::Currency currency = cryptonote::CurrencyBuilder().currency();
cryptonote::Transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b = "dsdsdfsdfsf";
ASSERT_TRUE(currency.constructMinerTx(0, 0, 10000000000000, 1000, currency.minimumFee(), acc.get_keys().m_account_address, tx, b, 1));
crypto::public_key tx_pub_key = cryptonote::get_tx_pub_key_from_extra(tx);
ASSERT_NE(tx_pub_key, cryptonote::null_pkey);
}
TEST(block_pack_unpack, basic_struct_packing)
{
currency::block b = AUTO_VAL_INIT(b);
currency::generate_genesis_block(b);
currency::blobdata blob = currency::t_serializable_object_to_blob(b);
currency::block b_loaded = AUTO_VAL_INIT(b_loaded);
currency::parse_and_validate_block_from_blob(blob, b_loaded);
crypto::hash original_id = get_block_hash(b);
crypto::hash loaded_id = get_block_hash(b_loaded);
ASSERT_EQ(original_id, loaded_id);
std::stringstream ss;
boost::archive::binary_oarchive a(ss);
a << b;
currency::block b_loaded_from_boost = AUTO_VAL_INIT(b_loaded_from_boost);
boost::archive::binary_iarchive a2(ss);
a2 >> b_loaded_from_boost;
crypto::hash loaded_boost_id = get_block_hash(b_loaded_from_boost);
ASSERT_EQ(original_id, loaded_boost_id);
}
TEST(parse_and_validate_tx_extra, is_correct_parse_and_validate_tx_extra)
{
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
cryptonote::account_base acc;
acc.generate();
cryptonote::blobdata b = "dsdsdfsdfsf";
bool r = cryptonote::construct_miner_tx(0, 0, 10000000000000, 1000, DEFAULT_FEE, acc.get_keys().m_account_address, tx, b, 1);
ASSERT_TRUE(r);
crypto::public_key tx_pub_key;
r = cryptonote::parse_and_validate_tx_extra(tx, tx_pub_key);
ASSERT_TRUE(r);
}
boost::optional<std::string> NodeRPCProxy::get_earliest_height(uint8_t version, uint64_t &earliest_height) const
{
if (m_offline)
return boost::optional<std::string>("offline");
if (m_earliest_height[version] == 0)
{
cryptonote::COMMAND_RPC_HARD_FORK_INFO::request req_t = AUTO_VAL_INIT(req_t);
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response resp_t = AUTO_VAL_INIT(resp_t);
m_daemon_rpc_mutex.lock();
req_t.version = version;
bool r = net_utils::invoke_http_json_rpc("/json_rpc", "hard_fork_info", req_t, resp_t, m_http_client, rpc_timeout);
m_daemon_rpc_mutex.unlock();
CHECK_AND_ASSERT_MES(r, std::string("Failed to connect to daemon"), "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status != CORE_RPC_STATUS_BUSY, resp_t.status, "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status == CORE_RPC_STATUS_OK, resp_t.status, "Failed to get hard fork status");
m_earliest_height[version] = resp_t.earliest_height;
}
earliest_height = m_earliest_height[version];
return boost::optional<std::string>();
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_telepodstatus(const wallet_rpc::COMMAND_RPC_TELEPODSTATUS::request& req, wallet_rpc::COMMAND_RPC_TELEPODSTATUS::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
currency::transaction tx2 = AUTO_VAL_INIT(tx2);
//new destination account
currency::account_base acc2 = AUTO_VAL_INIT(acc2);
acc2.generate();
if (!build_transaction_from_telepod(req.tpd, acc2.get_keys().m_account_address, tx2, res.status))
{
return true;
}
//check if transaction is spent
currency::COMMAND_RPC_CHECK_KEYIMAGES::request req_ki = AUTO_VAL_INIT(req_ki);
currency::COMMAND_RPC_CHECK_KEYIMAGES::response rsp_ki = AUTO_VAL_INIT(rsp_ki);
for (auto& i : tx2.vin)
req_ki.images.push_back(boost::get<currency::txin_to_key>(i).k_image);
if (!m_wallet.get_core_proxy()->call_COMMAND_RPC_COMMAND_RPC_CHECK_KEYIMAGES(req_ki, rsp_ki)
|| rsp_ki.status != CORE_RPC_STATUS_OK
|| rsp_ki.images_stat.size() != req_ki.images.size())
{
LOG_ERROR("Problem with call_COMMAND_RPC_COMMAND_RPC_CHECK_KEYIMAGES(....)");
res.status = "INTERNAL_ERROR";
return true;
}
for (auto s : rsp_ki.images_stat)
{
if (!s)
{
res.status = "SPENT";
return true;
}
}
res.status = "OK";
return true;
}
bool WalletManagerImpl::connected(uint32_t *version)
{
epee::json_rpc::request<cryptonote::COMMAND_RPC_GET_VERSION::request> req_t = AUTO_VAL_INIT(req_t);
epee::json_rpc::response<cryptonote::COMMAND_RPC_GET_VERSION::response, std::string> resp_t = AUTO_VAL_INIT(resp_t);
req_t.jsonrpc = "2.0";
req_t.id = epee::serialization::storage_entry(0);
req_t.method = "get_version";
if (!epee::net_utils::invoke_http_json("/json_rpc", req_t, resp_t, m_http_client))
return false;
if (version)
*version = resp_t.result.version;
return true;
}
void daemon_backend::on_money_spent2(const currency::block& b, const currency::transaction& tx, uint64_t amount, const tools::money_transfer2_details& td)
{
view::transfer_event_info tei = AUTO_VAL_INIT(tei);
tei.ti.timestamp = b.timestamp;
tei.ti.amount = currency::print_money(amount);
tei.ti.height = currency::get_block_height(b);
tei.ti.is_income = false;
tei.ti.spent = true;
tei.ti.tx_hash = string_tools::pod_to_hex(currency::get_transaction_hash(tx));
tei.balance = currency::print_money(m_wallet->balance());
tei.unlocked_balance = currency::print_money(m_wallet->unlocked_balance());
fill_transfer_details(tx, td, tei.ti.td);
m_pview->money_spent(tei);
}
bool daemon_backend::update_wallet_info()
{
CRITICAL_REGION_LOCAL(m_wallet_lock);
view::wallet_info wi = AUTO_VAL_INIT(wi);
wi.address = m_wallet->get_account().get_public_address_str();
wi.tracking_hey = string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_view_secret_key);
wi.balance = currency::print_money(m_wallet->balance());
wi.unlocked_balance = currency::print_money(m_wallet->unlocked_balance());
wi.path = m_wallet->get_wallet_path();
m_pview->update_wallet_info(wi);
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_transfer(const wallet_rpc::COMMAND_RPC_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_TRANSFER::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
std::vector<currency::tx_destination_entry> dsts;
for (auto it = req.destinations.begin(); it != req.destinations.end(); it++)
{
currency::tx_destination_entry de;
if(!m_wallet.get_transfer_address(it->address, de.addr))
{
er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
er.message = std::string("WALLET_RPC_ERROR_CODE_WRONG_ADDRESS: ") + it->address;
return false;
}
de.amount = it->amount;
dsts.push_back(de);
}
try
{
std::vector<uint8_t> extra;
crypto::hash payment_id = AUTO_VAL_INIT(payment_id);
if(currency::parse_payment_id_from_hex_str(req.payment_id_hex, payment_id))
{
currency::set_payment_id_to_tx_extra(extra, payment_id);
}
currency::transaction tx;
m_wallet.transfer(dsts, req.mixin, req.unlock_time, req.fee, extra, tx);
res.tx_hash = boost::lexical_cast<std::string>(currency::get_transaction_hash(tx));
return true;
}
catch (const tools::error::daemon_busy& e)
{
er.code = WALLET_RPC_ERROR_CODE_DAEMON_IS_BUSY;
er.message = e.what();
return false;
}
catch (const std::exception& e)
{
er.code = WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR;
er.message = e.what();
return false;
}
catch (...)
{
er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
er.message = "WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR";
return false;
}
return true;
}
boost::optional<std::string> NodeRPCProxy::get_info() const
{
if (m_offline)
return boost::optional<std::string>("offline");
const time_t now = time(NULL);
if (now >= m_get_info_time + 30) // re-cache every 30 seconds
{
cryptonote::COMMAND_RPC_GET_INFO::request req_t = AUTO_VAL_INIT(req_t);
cryptonote::COMMAND_RPC_GET_INFO::response resp_t = AUTO_VAL_INIT(resp_t);
m_daemon_rpc_mutex.lock();
bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_info", req_t, resp_t, m_http_client, rpc_timeout);
m_daemon_rpc_mutex.unlock();
CHECK_AND_ASSERT_MES(r, std::string("Failed to connect to daemon"), "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status != CORE_RPC_STATUS_BUSY, resp_t.status, "Failed to connect to daemon");
CHECK_AND_ASSERT_MES(resp_t.status == CORE_RPC_STATUS_OK, resp_t.status, "Failed to get target blockchain height");
m_height = resp_t.height;
m_target_height = resp_t.target_height;
m_block_weight_limit = resp_t.block_weight_limit ? resp_t.block_weight_limit : resp_t.block_size_limit;
m_get_info_time = now;
}
return boost::optional<std::string>();
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_withdrawtelepod(const wallet_rpc::COMMAND_RPC_WITHDRAWTELEPOD::request& req, wallet_rpc::COMMAND_RPC_WITHDRAWTELEPOD::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
currency::transaction tx2 = AUTO_VAL_INIT(tx2);
//parse destination add
currency::account_public_address acc_addr = AUTO_VAL_INIT(acc_addr);
if (!currency::get_account_address_from_str(acc_addr, req.addr))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
res.status = "BAD_ADDRESS";
return true;
}
if (!build_transaction_from_telepod(req.tpd, acc_addr, tx2, res.status))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
return true;
}
//send transaction to daemon
currency::COMMAND_RPC_SEND_RAW_TX::request req_send_raw;
req_send_raw.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx2));
currency::COMMAND_RPC_SEND_RAW_TX::response rsp_send_raw;
bool r = m_wallet.get_core_proxy()->call_COMMAND_RPC_SEND_RAW_TX(req_send_raw, rsp_send_raw);
if (!r || rsp_send_raw.status != CORE_RPC_STATUS_OK)
{
LOG_ERROR("Problem with construct_tx(....), blobl size os too big: " << get_object_blobsize(tx2));
res.status = "INTERNAL_ERROR";
return true;
}
res.status = "OK";
LOG_PRINT_GREEN("TELEPOD WITHDRAWN [" << currency::print_money(currency::get_outs_money_amount(tx2)) << "BBR, tx_id: ]" << currency::get_transaction_hash(tx2), LOG_LEVEL_0);
return true;
}
bool WalletManagerImpl::connected(uint32_t *version = NULL) const
{
epee::json_rpc::request<cryptonote::COMMAND_RPC_GET_VERSION::request> req_t = AUTO_VAL_INIT(req_t);
epee::json_rpc::response<cryptonote::COMMAND_RPC_GET_VERSION::response, std::string> resp_t = AUTO_VAL_INIT(resp_t);
req_t.jsonrpc = "2.0";
req_t.id = epee::serialization::storage_entry(0);
req_t.method = "get_version";
epee::net_utils::http::http_simple_client http_client;
bool r = epee::net_utils::invoke_http_json_remote_command2(m_daemonAddress + "/json_rpc", req_t, resp_t, http_client);
if (!r)
return false;
if (version)
*version = resp_t.result.version;
return true;
}
//-----------------------------------------------------------------------------------------------
bool core::handle_incoming_block_blob(const blobdata& block_blob, block_verification_context& bvc, bool control_miner, bool relay_block) {
if (block_blob.size() > m_currency.maxBlockBlobSize()) {
LOG_PRINT_L0("WRONG BLOCK BLOB, too big size " << block_blob.size() << ", rejected");
bvc.m_verifivation_failed = true;
return false;
}
Block b = AUTO_VAL_INIT(b);
if (!parse_and_validate_block_from_blob(block_blob, b)) {
LOG_PRINT_L0("Failed to parse and validate new block");
bvc.m_verifivation_failed = true;
return false;
}
return handle_incoming_block(b, bvc, control_miner, relay_block);
}
static tools::wallet2::transfer_container make_transfers_container(size_t N)
{
tools::wallet2::transfer_container transfers;
for (size_t n = 0; n < N; ++n)
{
transfers.push_back(AUTO_VAL_INIT(tools::wallet2::transfer_details()));
tools::wallet2::transfer_details &td = transfers.back();
td.m_block_height = 1000;
td.m_spent = false;
td.m_txid = crypto::null_hash;
td.m_txid.data[0] = n & 0xff;
td.m_txid.data[1] = (n >> 8) & 0xff;
td.m_txid.data[2] = (n >> 16) & 0xff;
td.m_txid.data[3] = (n >> 24) & 0xff;
}
return transfers;
}
