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; }