439 lines
18 KiB
C++
439 lines
18 KiB
C++
#include <boost/uuid/uuid.hpp>
|
|
#include <boost/uuid/uuid_io.hpp>
|
|
#include <boost/uuid/random_generator.hpp>
|
|
#include <unordered_map>
|
|
|
|
#include "include_base_utils.h"
|
|
using namespace epee;
|
|
#include "wallet/wallet2.h"
|
|
|
|
#include "transactions_flow_test.h"
|
|
#include "stake_tx.h"
|
|
|
|
using namespace cryptonote;
|
|
|
|
// fixed-difficulty should be at least 7.
|
|
|
|
|
|
bool stop_mining(epee::net_utils::http::http_simple_client& http_client){
|
|
COMMAND_RPC_STOP_MINING::request stop_mine_req = AUTO_VAL_INIT(stop_mine_req);
|
|
COMMAND_RPC_STOP_MINING::response stop_mine_rsp = AUTO_VAL_INIT(stop_mine_rsp);
|
|
bool r = net_utils::invoke_http_json("/stop_mining", stop_mine_req, stop_mine_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to stop mining");
|
|
return true;
|
|
}
|
|
|
|
bool stake_transaction_test(std::string& working_folder,
|
|
std::string wallet_name,
|
|
std::string& daemon_addr_a,
|
|
uint64_t amount_to_stake) {
|
|
LOG_PRINT_L0("-----------------------STARTING STAKE TRANSACTION TEST-----------------------");
|
|
tools::wallet2 w1(network_type::TESTNET);
|
|
w1.inactivity_lock_timeout(0);
|
|
w1.ask_password(tools::wallet2::AskPasswordType::AskPasswordNever);
|
|
w1.setup_background_mining(tools::wallet2::BackgroundMiningSetupType::BackgroundMiningNo); // disable background mining
|
|
if(wallet_name.empty())
|
|
wallet_name = generate_random_wallet_name();
|
|
|
|
try
|
|
{
|
|
w1.generate(working_folder + "/" + wallet_name, "");
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
LOG_ERROR("failed to generate wallet: " << e.what());
|
|
return false;
|
|
}
|
|
|
|
w1.init(daemon_addr_a);
|
|
|
|
epee::net_utils::http::http_simple_client http_client;
|
|
bool r = http_client.set_server(daemon_addr_a, boost::none);
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to connect to daemon");
|
|
|
|
// stop mining just in case
|
|
stop_mining(http_client);
|
|
|
|
// get current height
|
|
COMMAND_RPC_GET_HEIGHT::request height_req = AUTO_VAL_INIT(height_req);
|
|
COMMAND_RPC_GET_HEIGHT::response height_rsp = AUTO_VAL_INIT(height_rsp);
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
|
|
|
|
// pop blocks to make sure of the start height
|
|
COMMAND_RPC_POP_BLOCKS::request pop_blocks_req = AUTO_VAL_INIT(pop_blocks_req);
|
|
COMMAND_RPC_POP_BLOCKS::response pop_blocks_rsp = AUTO_VAL_INIT(pop_blocks_rsp);
|
|
pop_blocks_req.nblocks = height_rsp.height - 1; //keep at least one block
|
|
r = net_utils::invoke_http_json("/pop_blocks", pop_blocks_req, pop_blocks_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to pop blocks");
|
|
|
|
// flush tx pool to make sure of the start state
|
|
COMMAND_RPC_FLUSH_TRANSACTION_POOL::request flush_req = AUTO_VAL_INIT(flush_req);
|
|
COMMAND_RPC_FLUSH_TRANSACTION_POOL::response flush_rsp = AUTO_VAL_INIT(flush_rsp);
|
|
r = net_utils::invoke_http_json_rpc("/json_rpc", "flush_txpool", flush_req, flush_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to flush tx pool");
|
|
|
|
w1.rescan_blockchain(true, true, false);
|
|
MGINFO_GREEN("Using wallets: " << ENDL
|
|
<< "Source: " << w1.get_account().get_public_address_str(TESTNET) << ENDL << "Path: " << working_folder + "/" + wallet_name << ENDL);
|
|
|
|
//lets make some money
|
|
COMMAND_RPC_START_MINING::request start_mining_req = AUTO_VAL_INIT(start_mining_req);
|
|
COMMAND_RPC_START_MINING::response start_mining_rsp = AUTO_VAL_INIT(start_mining_rsp);
|
|
start_mining_req.miner_address = w1.get_account().get_public_address_str(TESTNET);
|
|
start_mining_req.threads_count = 1;
|
|
r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
|
|
CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
|
|
|
|
// mine until we reach to block 710
|
|
height_rsp.height = 1;
|
|
while (height_rsp.height < 710)
|
|
{
|
|
misc_utils::sleep_no_w(1000); // The difficulty should be high enough to stop mining before reaching block 800.”
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon 1");
|
|
}
|
|
|
|
// stop mining
|
|
stop_mining(http_client);
|
|
|
|
// refresh wallet
|
|
uint64_t blocks_fetched = 0;
|
|
bool received_money;
|
|
w1.refresh(true, 0, blocks_fetched, received_money);
|
|
|
|
MGINFO_GREEN("balance: " << w1.balance(0, "SAL", false));
|
|
|
|
// create and submit CN SAL stake transaction ~ block 710
|
|
std::vector<cryptonote::tx_destination_entry> dsts;
|
|
cryptonote::tx_destination_entry de;
|
|
de.addr = w1.get_account().get_keys().m_account_address;
|
|
de.amount = amount_to_stake;
|
|
de.is_subaddress = false;
|
|
dsts.push_back(de);
|
|
try
|
|
{
|
|
std::vector<tools::wallet2::pending_tx> ptx;
|
|
ptx = w1.create_transactions_2(dsts, "SAL", "SAL", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
|
|
for (auto &p: ptx)
|
|
w1.commit_tx(p);
|
|
}
|
|
catch (const std::exception&)
|
|
{
|
|
LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height << "with SAL");
|
|
return false;
|
|
}
|
|
|
|
// lets make some money
|
|
r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
|
|
CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
|
|
|
|
// mine until we reach to block 1010
|
|
while (height_rsp.height < 1010) // difficulty should be high enough to stop mining before reaching block 1080
|
|
{
|
|
misc_utils::sleep_no_w(1000);
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
|
|
}
|
|
|
|
// stop mining if not stopped already
|
|
stop_mining(http_client);
|
|
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
|
|
// Check the height to ensure we are receiving yield payments before the Carrot hard fork at block 1100
|
|
if (!r)
|
|
{
|
|
LOG_ERROR("failed to get height from daemon");
|
|
return false;
|
|
}
|
|
if (height_rsp.height > 1080)
|
|
{
|
|
LOG_PRINT_L0("----!! The current height (" << height_rsp.height << ") exceeds the acceptable range for this test. Please restart the node with an increased fixed difficulty. !!----");
|
|
}
|
|
|
|
|
|
// refresh wallet
|
|
blocks_fetched = 0;
|
|
received_money = false;
|
|
bool ok = false;
|
|
if(!w1.refresh(true, blocks_fetched, received_money, ok))
|
|
{
|
|
LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
|
|
return false;
|
|
}
|
|
|
|
// check if we have received yield from CN SAL stake transaction ~1010
|
|
tools::wallet2::transfer_container incoming_transfers;
|
|
// scan payments
|
|
w1.get_transfers(incoming_transfers);
|
|
CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
|
|
bool found = false;
|
|
for (const auto& p: incoming_transfers)
|
|
{
|
|
if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
|
|
{
|
|
if (p.m_amount > amount_to_stake)
|
|
{
|
|
LOG_PRINT_L0("found yield from CN SAL stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("invalid yield amount from CN SAL stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
return false;
|
|
}
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
CHECK_AND_ASSERT_MES(found, false, "failed to find yield from CN SAL stake transaction");
|
|
|
|
//create and submit CN SAL1 stake transaction
|
|
dsts.clear();
|
|
de.addr = w1.get_account().get_keys().m_account_address;
|
|
de.amount = amount_to_stake;
|
|
de.is_subaddress = false;
|
|
dsts.push_back(de);
|
|
try
|
|
{
|
|
std::vector<tools::wallet2::pending_tx> ptx;
|
|
ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
|
|
for (auto &p: ptx)
|
|
w1.commit_tx(p);
|
|
}
|
|
catch (const std::exception&)
|
|
{
|
|
LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height << "with SAL1");
|
|
return false;
|
|
}
|
|
|
|
// lets make some money
|
|
r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
|
|
CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
|
|
|
|
// mine until we reach to block 1091
|
|
while (height_rsp.height < 1091)
|
|
{
|
|
misc_utils::sleep_no_w(100);
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(1));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
|
|
}
|
|
|
|
// stop mining if not stopped already
|
|
stop_mining(http_client);
|
|
|
|
// refresh wallet
|
|
blocks_fetched = 0;
|
|
received_money = false;
|
|
ok = false;
|
|
if(!w1.refresh(true, blocks_fetched, received_money, ok))
|
|
{
|
|
LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
|
|
return false;
|
|
}
|
|
|
|
// check if we have received yield from CN SAL stake transaction
|
|
incoming_transfers.clear();
|
|
// scan payments
|
|
w1.get_transfers(incoming_transfers);
|
|
CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
|
|
found = false;
|
|
for (const auto& p: incoming_transfers)
|
|
{
|
|
if (p.m_block_height < 1010) continue; // skip payments from the first stake transaction
|
|
if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
|
|
{
|
|
if (p.m_amount > amount_to_stake)
|
|
{
|
|
LOG_PRINT_L0("found yield from CN SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("invalid yield amount from CN SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
return false;
|
|
}
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
CHECK_AND_ASSERT_MES(found, false, "failed to find yield from CN SAL1 stake transaction");
|
|
|
|
// pop blocks to make sure of the start height
|
|
pop_blocks_req = AUTO_VAL_INIT(pop_blocks_req);
|
|
pop_blocks_req.nblocks = height_rsp.height - 1090; //keep at least 1090 blocks
|
|
r = net_utils::invoke_http_json("/pop_blocks", pop_blocks_req, pop_blocks_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to pop blocks");
|
|
|
|
// flush tx pool to make sure of the start state
|
|
r = net_utils::invoke_http_json_rpc("/json_rpc", "flush_txpool", flush_req, flush_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to flush tx pool");
|
|
|
|
// rescan blockchain to ensure wallet is in sync after popping blocks
|
|
w1.rescan_blockchain(true, true, false);
|
|
MGINFO_GREEN("Using wallets: " << ENDL
|
|
<< "Source: " << w1.get_account().get_public_address_str(TESTNET) << ENDL << "Path: " << working_folder + "/" + wallet_name << ENDL);
|
|
|
|
// Create and stake CN SAL1 stake transaction and get yield after the Carrot hard fork at block 1100 ~ block 1090
|
|
dsts.clear();
|
|
de.addr = w1.get_account().get_keys().m_account_address;
|
|
de.amount = amount_to_stake;
|
|
de.is_subaddress = false;
|
|
dsts.push_back(de);
|
|
try
|
|
{
|
|
std::vector<tools::wallet2::pending_tx> ptx;
|
|
ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
|
|
for (auto &p: ptx)
|
|
w1.commit_tx(p);
|
|
}
|
|
catch (const std::exception&)
|
|
{
|
|
LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height << "with SAL1");
|
|
return false;
|
|
}
|
|
|
|
/// lets make some money
|
|
r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
|
|
CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
|
|
|
|
// mine until we reach to block 1100
|
|
while (height_rsp.height < 1100)
|
|
{
|
|
misc_utils::sleep_no_w(1000);
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
|
|
}
|
|
|
|
// stop mining if not stopped already
|
|
stop_mining(http_client);
|
|
|
|
// Carrot will not be able to connect to the network until the node is restarted
|
|
LOG_PRINT_L0("---------------------- PLEASE RESTART THE NODE NOW ----------------------");
|
|
misc_utils::sleep_no_w(1000); // wait for the log to be printed
|
|
LOG_PRINT_L2("Press any key to continue once the node is back online");
|
|
std::string input;
|
|
std::cin >> input;
|
|
|
|
// restart the http client connection
|
|
r = http_client.set_server(daemon_addr_a, boost::none);
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to connect to daemon");
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "Daemon is not yet back online");
|
|
|
|
LOG_PRINT_L0("Daemon is back online, continuing tests");
|
|
LOG_PRINT_L2("Carrot has been enabled.");
|
|
|
|
// restart the wallet connection
|
|
w1.init(daemon_addr_a);
|
|
|
|
// Create and stake Carrot SAL1 stake transaction ~ block 1100
|
|
dsts.clear();
|
|
de.addr = w1.get_account().get_keys().m_carrot_main_address;
|
|
de.amount = amount_to_stake;
|
|
de.is_subaddress = false;
|
|
dsts.push_back(de);
|
|
try
|
|
{
|
|
std::vector<tools::wallet2::pending_tx> ptx;
|
|
ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
|
|
for (auto &p: ptx)
|
|
w1.commit_tx(p);
|
|
}
|
|
catch (const std::exception&)
|
|
{
|
|
LOG_ERROR("failed to create/commit Carrot stake transaction at height: " << height_rsp.height << " with SAL1");
|
|
return false;
|
|
}
|
|
|
|
// lets make some money
|
|
start_mining_req.miner_address = w1.get_account().get_carrot_public_address_str(TESTNET);
|
|
start_mining_req.threads_count = 1;
|
|
r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
|
|
CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
|
|
|
|
// mine until we reach to block 1300
|
|
while (height_rsp.height < 1300)
|
|
{
|
|
misc_utils::sleep_no_w(1000);
|
|
r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
|
|
CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
|
|
}
|
|
|
|
// stop mining
|
|
stop_mining(http_client);
|
|
|
|
// refresh wallet
|
|
blocks_fetched = 0;
|
|
received_money = false;
|
|
ok = false;
|
|
if(!w1.refresh(true, blocks_fetched, received_money, ok))
|
|
{
|
|
LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
|
|
return false;
|
|
}
|
|
|
|
// check if we have received yield from Carrot SAL1 stake transaction
|
|
incoming_transfers.clear();
|
|
// scan payments
|
|
w1.get_transfers(incoming_transfers);
|
|
CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
|
|
found = false;
|
|
for (const auto& p: incoming_transfers)
|
|
{
|
|
if (p.m_block_height > 1112 || p.m_block_height < 1090) continue; // Skip payments originating from CryptoNote stake transactions
|
|
if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
|
|
{
|
|
if (p.m_amount > amount_to_stake)
|
|
{
|
|
LOG_PRINT_L0("found yield from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
LOG_PRINT_L2("Stake was made before the Carrot hard fork and yield received after Carrot hard fork");
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("invalid yield amount from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
return false;
|
|
}
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
CHECK_AND_ASSERT_MES(found, false, "failed to find yield from Carrot SAL1 stake transaction");
|
|
|
|
|
|
// check if we have received yield from Carrot SAL1 stake transaction
|
|
incoming_transfers.clear();
|
|
// scan payments
|
|
w1.get_transfers(incoming_transfers);
|
|
CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
|
|
found = false;
|
|
for (const auto& p: incoming_transfers)
|
|
{
|
|
if (p.m_block_height <= 1112) continue; // // Skip payments originating from CryptoNote stake transactions
|
|
if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
|
|
{
|
|
if (p.m_amount > amount_to_stake)
|
|
{
|
|
LOG_PRINT_L0("found yield from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
LOG_PRINT_L0("All yields from stake transactions have been successfully found!");
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR("invalid yield amount from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
|
|
return false;
|
|
}
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
CHECK_AND_ASSERT_MES(found, false, "failed to find yield from Carrot SAL1 stake transaction");
|
|
LOG_PRINT_L2("All yields from stake transactions have been successfully found!");
|
|
LOG_PRINT_L0("-----------------------STAKE TRANSACTION TEST PASSED-----------------------");
|
|
|
|
return true;
|
|
}
|