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