//------------------------------------------------------------------------------------------------------------------------------ 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 checkpoints::check_block(uint64_t height, const crypto::hash& h) const { auto it = m_points.find(height); if(it == m_points.end()) return true; if(it->second == h) { LOG_PRINT_GREEN("CHECKPOINT PASSED FOR HEIGHT " << height << " " << h, LOG_LEVEL_0); return true; }else { LOG_ERROR("CHECKPOINT FAILED FOR HEIGHT " << height << ". EXPECTED HASH: " << it->second << ", FETCHED HASH: " << h); return false; } }
//------------------------------------------------------------------------------------------------------------------------------ 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 wallet_rpc_server::on_maketelepod(const wallet_rpc::COMMAND_RPC_MAKETELEPOD::request& req, wallet_rpc::COMMAND_RPC_MAKETELEPOD::response& res, epee::json_rpc::error& er, connection_context& cntx) { //check available balance if (m_wallet.unlocked_balance() <= req.amount) { res.status = "INSUFFICIENT_COINS"; return true; } currency::account_base acc; acc.generate(); std::vector<currency::tx_destination_entry> dsts(1); dsts.back().amount = req.amount; dsts.back().addr = acc.get_keys().m_account_address; currency::transaction tx = AUTO_VAL_INIT(tx); try { std::vector<uint8_t> extra; m_wallet.transfer(dsts, 0, 0, DEFAULT_FEE, extra, tx); } catch (const std::runtime_error& er) { LOG_ERROR("Failed to send transaction: " << er.what()); res.status = "INTERNAL_ERROR"; return true; } res.tpd.basement_tx_id_hex = string_tools::pod_to_hex(currency::get_transaction_hash(tx)); std::string buff = epee::serialization::store_t_to_binary(acc); res.tpd.account_keys_hex = string_tools::buff_to_hex_nodelimer(buff); res.status = "OK"; LOG_PRINT_GREEN("TELEPOD ISSUED [" << currency::print_money(req.amount) << "BBR, base_tx_id: ]" << currency::get_transaction_hash(tx), LOG_LEVEL_0); return true; }
void daemon_backend::main_worker(const po::variables_map& vm) { view::daemon_status_info dsi = AUTO_VAL_INIT(dsi); dsi.difficulty = "---"; m_pview->update_daemon_status(dsi); //initialize objects LOG_PRINT_L0("Initializing p2p server..."); dsi.text_state = "Initializing p2p server"; m_pview->update_daemon_status(dsi); bool res = m_p2psrv.init(vm); CHECK_AND_ASSERT_MES(res, void(), "Failed to initialize p2p server."); LOG_PRINT_L0("P2p server initialized OK on port: " << m_p2psrv.get_this_peer_port()); //LOG_PRINT_L0("Starting UPnP"); //upnp_helper.run_port_mapping_loop(p2psrv.get_this_peer_port(), p2psrv.get_this_peer_port(), 20*60*1000); LOG_PRINT_L0("Initializing currency protocol..."); dsi.text_state = "Initializing currency protocol"; m_pview->update_daemon_status(dsi); res = m_cprotocol.init(vm); CHECK_AND_ASSERT_MES(res, void(), "Failed to initialize currency protocol."); LOG_PRINT_L0("Currency protocol initialized OK"); LOG_PRINT_L0("Initializing core rpc server..."); dsi.text_state = "Initializing core rpc server"; m_pview->update_daemon_status(dsi); res = m_rpc_server.init(vm); CHECK_AND_ASSERT_MES(res, void(), "Failed to initialize core rpc server."); LOG_PRINT_GREEN("Core rpc server initialized OK on port: " << m_rpc_server.get_binded_port(), LOG_LEVEL_0); //initialize core here LOG_PRINT_L0("Initializing core..."); dsi.text_state = "Initializing core"; m_pview->update_daemon_status(dsi); res = m_ccore.init(vm); CHECK_AND_ASSERT_MES(res, void(), "Failed to initialize core"); LOG_PRINT_L0("Core initialized OK"); LOG_PRINT_L0("Starting core rpc server..."); dsi.text_state = "Starting core rpc server"; m_pview->update_daemon_status(dsi); res = m_rpc_server.run(2, false); CHECK_AND_ASSERT_MES(res, void(), "Failed to initialize core rpc server."); LOG_PRINT_L0("Core rpc server started ok"); LOG_PRINT_L0("Starting p2p net loop..."); dsi.text_state = "Starting network loop"; m_pview->update_daemon_status(dsi); m_p2psrv.run(false); LOG_PRINT_L0("p2p net loop stopped"); //go to monitoring view loop loop(); dsi.daemon_network_state = 3; CRITICAL_REGION_BEGIN(m_wallet_lock); if(m_wallet->get_wallet_path().size()) { LOG_PRINT_L0("Storing wallet data..."); dsi.text_state = "Storing wallet data..."; m_pview->update_daemon_status(dsi); m_wallet->store(); } CRITICAL_REGION_END(); LOG_PRINT_L0("Stopping core p2p server..."); dsi.text_state = "Stopping p2p network server"; m_pview->update_daemon_status(dsi); m_p2psrv.send_stop_signal(); m_p2psrv.timed_wait_server_stop(10); //stop components LOG_PRINT_L0("Stopping core rpc server..."); dsi.text_state = "Stopping rpc network server"; m_pview->update_daemon_status(dsi); m_rpc_server.send_stop_signal(); m_rpc_server.timed_wait_server_stop(5000); //deinitialize components LOG_PRINT_L0("Deinitializing core..."); dsi.text_state = "Deinitializing core"; m_pview->update_daemon_status(dsi); m_ccore.deinit(); LOG_PRINT_L0("Deinitializing rpc server ..."); dsi.text_state = "Deinitializing rpc server"; m_pview->update_daemon_status(dsi); m_rpc_server.deinit(); LOG_PRINT_L0("Deinitializing currency_protocol..."); dsi.text_state = "Deinitializing currency_protocol"; m_pview->update_daemon_status(dsi); m_cprotocol.deinit(); LOG_PRINT_L0("Deinitializing p2p..."); dsi.text_state = "Deinitializing p2p"; m_pview->update_daemon_status(dsi); m_p2psrv.deinit(); m_ccore.set_currency_protocol(NULL); m_cprotocol.set_p2p_endpoint(NULL); LOG_PRINT("Node stopped.", LOG_LEVEL_0); dsi.text_state = "Node stopped"; m_pview->update_daemon_status(dsi); m_pview->on_backend_stopped(); }
bool simpleminer::run() { std::string pool_session_id; simpleminer::job_details_native job = AUTO_VAL_INIT(job); uint64_t last_job_ticks = 0; while(true) { //----------------- last_job_ticks = epee::misc_utils::get_tick_count(); if(!m_http_client.is_connected()) { LOG_PRINT_L0("Connecting " << m_pool_ip << ":" << m_pool_port << "...."); if(!m_http_client.connect(m_pool_ip, m_pool_port, 20000)) { LOG_PRINT_L0("Failed to connect " << m_pool_ip << ":" << m_pool_port << ", sleep...."); epee::misc_utils::sleep_no_w(1000); continue; } //DO AUTH LOG_PRINT_L0("Connected " << m_pool_ip << ":" << m_pool_port << " OK"); COMMAND_RPC_LOGIN::request req = AUTO_VAL_INIT(req); req.login = m_login; req.pass = m_pass; req.agent = "simpleminer/0.1"; COMMAND_RPC_LOGIN::response resp = AUTO_VAL_INIT(resp); if(!epee::net_utils::invoke_http_json_rpc<mining::COMMAND_RPC_LOGIN>("/", req, resp, m_http_client)) { LOG_PRINT_L0("Failed to invoke login " << m_pool_ip << ":" << m_pool_port << ", disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); continue; } if(resp.status != "OK" || resp.id.empty()) { LOG_PRINT_L0("Failed to login " << m_pool_ip << ":" << m_pool_port << ", disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); continue; } pool_session_id = resp.id; //78 if (resp.job.blob.empty() && resp.job.target.empty() && resp.job.job_id.empty()) { LOG_PRINT_L0("Job didn't change"); continue; } else if(!text_job_details_to_native_job_details(resp.job, job)) { LOG_PRINT_L0("Failed to text_job_details_to_native_job_details(), disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); continue; } last_job_ticks = epee::misc_utils::get_tick_count(); } while(epee::misc_utils::get_tick_count() - last_job_ticks < 20000) { //uint32_t c = (*((uint32_t*)&job.blob.data()[39])); ++(*((uint32_t*)&job.blob.data()[39])); crypto::hash h = cryptonote::null_hash; crypto::cn_slow_hash(job.blob.data(), job.blob.size(), h); if( ((uint32_t*)&h)[7] < job.target ) { //found! COMMAND_RPC_SUBMITSHARE::request submit_request = AUTO_VAL_INIT(submit_request); COMMAND_RPC_SUBMITSHARE::response submit_response = AUTO_VAL_INIT(submit_response); submit_request.id = pool_session_id; submit_request.job_id = job.job_id; submit_request.nonce = epee::string_tools::pod_to_hex((*((uint32_t*)&job.blob.data()[39]))); submit_request.result = epee::string_tools::pod_to_hex(h); LOG_PRINT_L0("Share found: nonce=" << submit_request.nonce << " for job=" << job.job_id << ", submitting..."); if(!epee::net_utils::invoke_http_json_rpc<mining::COMMAND_RPC_SUBMITSHARE>("/", submit_request, submit_response, m_http_client)) { LOG_PRINT_L0("Failed to submit share! disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); break; } if(submit_response.status != "OK") { LOG_PRINT_L0("Failed to submit share! (submitted share rejected) disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); break; } LOG_PRINT_GREEN("Share submitted successfully!", LOG_LEVEL_0); break; } } //get next job COMMAND_RPC_GETJOB::request getjob_request = AUTO_VAL_INIT(getjob_request); COMMAND_RPC_GETJOB::response getjob_response = AUTO_VAL_INIT(getjob_response); getjob_request.id = pool_session_id; LOG_PRINT_L0("Getting next job..."); if(!epee::net_utils::invoke_http_json_rpc<mining::COMMAND_RPC_GETJOB>("/", getjob_request, getjob_response, m_http_client)) { LOG_PRINT_L0("Can't get new job! Disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); continue; } if (getjob_response.blob.empty() && getjob_response.target.empty() && getjob_response.job_id.empty()) { LOG_PRINT_L0("Job didn't change"); continue; } else if(!text_job_details_to_native_job_details(getjob_response, job)) { LOG_PRINT_L0("Failed to text_job_details_to_native_job_details(), disconnect and sleep...."); m_http_client.disconnect(); epee::misc_utils::sleep_no_w(1000); continue; } last_job_ticks = epee::misc_utils::get_tick_count(); } return true; }