bool gen_double_spend_in_different_chains::check_double_spend(CryptoNote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_double_spend_in_different_chains::check_double_spend"); std::list<Block> block_list; bool r = c.get_blocks(0, 100 + 2 * m_currency.minedMoneyUnlockWindow(), block_list); CHECK_TEST_CONDITION(r); std::vector<Block> blocks(block_list.begin(), block_list.end()); CHECK_EQ(expected_blockchain_height, blocks.size()); CHECK_EQ(1, c.get_pool_transactions_count()); CHECK_EQ(1, c.get_alternative_blocks_count()); CryptoNote::AccountBase bob_account = boost::get<CryptoNote::AccountBase>(events[1]); CryptoNote::AccountBase alice_account = boost::get<CryptoNote::AccountBase>(events[2]); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(0, get_balance(bob_account, blocks, mtx)); CHECK_EQ(send_amount - m_currency.minimumFee(), get_balance(alice_account, blocks, mtx)); return true; }
bool one_block::verify_1(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) { DEFINE_TESTS_ERROR_CONTEXT("one_block::verify_1"); alice = boost::get<CryptoNote::AccountBase>(events[1]); // check balances //std::vector<const CryptoNote::Block*> chain; //map_hash2tx_t mtx; //CHECK_TEST_CONDITION(find_block_chain(events, chain, mtx, get_block_hash(boost::get<CryptoNote::Block>(events[1])))); //CHECK_TEST_CONDITION(get_block_reward(0) == get_balance(alice, events, chain, mtx)); // check height std::list<CryptoNote::Block> blocks; std::list<Crypto::PublicKey> outs; bool r = c.get_blocks(0, 100, blocks); //c.get_outs(100, outs); CHECK_TEST_CONDITION(r); CHECK_TEST_CONDITION(blocks.size() == 1); //CHECK_TEST_CONDITION(outs.size() == blocks.size()); CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 1); CHECK_TEST_CONDITION(blocks.back() == boost::get<CryptoNote::Block>(events[0])); return true; }
bool gen_block_invalid_binary_format::check_all_blocks_purged(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_block_invalid_binary_format::check_all_blocks_purged"); CHECK_EQ(1, c.get_pool_transactions_count()); CHECK_EQ(m_corrupt_blocks_begin_idx - 2, c.get_current_blockchain_height()); return true; }
//----------------------------------------------------------------------------------------------------- bool gen_simple_chain_split_1::check_split_not_switched2(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) { DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched2"); //check height CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 9); CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 9); CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<CryptoNote::Block>(events[8]))); CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 3); return true; }
bool gen_ring_signature_big::check_balances_2(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_big::check_balances_2"); std::list<Block> blocks; bool r = c.get_blocks(0, 2 * m_test_size + m_currency.minedMoneyUnlockWindow(), blocks); CHECK_TEST_CONDITION(r); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(0, get_balance(m_bob_account, chain, mtx)); CHECK_EQ(m_tx_amount, get_balance(m_alice_account, chain, mtx)); for (size_t i = 2; i < 1 + m_test_size; ++i) { const AccountBase& an_account = boost::get<AccountBase>(events[i]); uint64_t balance = m_tx_amount + m_currency.minimumFee() * i; CHECK_EQ(balance, get_balance(an_account, chain, mtx)); } std::vector<size_t> tx_outs; uint64_t transfered; lookup_acc_outs(m_alice_account.getAccountKeys(), boost::get<Transaction>(events[events.size() - 3]), getTransactionPublicKeyFromExtra(boost::get<Transaction>(events[events.size() - 3]).extra), tx_outs, transfered); CHECK_EQ(m_tx_amount, transfered); return true; }
bool gen_ring_signature_big::check_balances_1(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_big::check_balances_1"); m_bob_account = boost::get<AccountBase>(events[1]); m_alice_account = boost::get<AccountBase>(events[1 + m_test_size]); std::list<Block> blocks; bool r = c.get_blocks(0, 2 * m_test_size + m_currency.minedMoneyUnlockWindow(), blocks); CHECK_TEST_CONDITION(r); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(m_tx_amount + m_currency.minimumFee(), get_balance(m_bob_account, chain, mtx)); CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); for (size_t i = 2; i < 1 + m_test_size; ++i) { const AccountBase& an_account = boost::get<AccountBase>(events[i]); uint64_t balance = m_tx_amount + m_currency.minimumFee() * i; CHECK_EQ(balance, get_balance(an_account, chain, mtx)); } return true; }
//----------------------------------------------------------------------------------------------------- bool gen_chain_switch_1::check_split_not_switched(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_not_switched"); m_recipient_account_1 = boost::get<account_base>(events[1]); m_recipient_account_2 = boost::get<account_base>(events[2]); m_recipient_account_3 = boost::get<account_base>(events[3]); m_recipient_account_4 = boost::get<account_base>(events[4]); std::list<Block> blocks; bool r = c.get_blocks(0, 10000, blocks); CHECK_TEST_CONDITION(r); CHECK_EQ(5 + 2 * m_currency.minedMoneyUnlockWindow(), blocks.size()); CHECK_TEST_CONDITION(blocks.back() == boost::get<Block>(events[20 + 2 * m_currency.minedMoneyUnlockWindow()])); // blk_4 CHECK_EQ(2, c.get_alternative_blocks_count()); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx)); CHECK_EQ(MK_COINS(10), get_balance(m_recipient_account_2, chain, mtx)); CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx)); CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_4, chain, mtx)); std::list<Transaction> tx_pool; c.get_pool_transactions(tx_pool); CHECK_EQ(1, tx_pool.size()); std::vector<size_t> tx_outs; uint64_t transfered; lookup_acc_outs(m_recipient_account_4.get_keys(), tx_pool.front(), get_tx_pub_key_from_extra(tx_pool.front()), tx_outs, transfered); CHECK_EQ(MK_COINS(13), transfered); m_chain_1.swap(blocks); m_tx_pool.swap(tx_pool); return true; }
//----------------------------------------------------------------------------------------------------- bool gen_chain_switch_1::check_split_switched(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_switched"); std::list<Block> blocks; bool r = c.get_blocks(0, 10000, blocks); CHECK_TEST_CONDITION(r); CHECK_EQ(6 + 2 * m_currency.minedMoneyUnlockWindow(), blocks.size()); auto it = blocks.end(); --it; --it; --it; CHECK_TEST_CONDITION(std::equal(blocks.begin(), it, m_chain_1.begin())); CHECK_TEST_CONDITION(blocks.back() == boost::get<Block>(events[24 + 2 * m_currency.minedMoneyUnlockWindow()])); // blk_7 std::list<Block> alt_blocks; r = c.get_alternative_blocks(alt_blocks); CHECK_TEST_CONDITION(r); CHECK_EQ(2, c.get_alternative_blocks_count()); // Some blocks that were in main chain are in alt chain now BOOST_FOREACH(Block b, alt_blocks) { CHECK_TEST_CONDITION(m_chain_1.end() != std::find(m_chain_1.begin(), m_chain_1.end(), b)); }
bool gen_ring_signature_1::check_balances_2(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_1::check_balances_2"); std::list<Block> blocks; bool r = c.get_blocks(0, 100 + 2 * m_currency.minedMoneyUnlockWindow(), blocks); CHECK_TEST_CONDITION(r); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(MK_COINS(1), get_balance(m_bob_account, chain, mtx)); CHECK_EQ(MK_COINS(129) + 2 * rnd_11 + rnd_20 + 3 * rnd_29 - m_currency.minimumFee(), get_balance(m_alice_account, chain, mtx)); return true; }
bool gen_ring_signature_2::check_balances_1(CryptoNote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_1"); m_bob_account = boost::get<AccountBase>(events[1]); m_alice_account = boost::get<AccountBase>(events[2]); std::list<Block> blocks; bool r = c.get_blocks(0, 100 + 2 * m_currency.minedMoneyUnlockWindow(), blocks); CHECK_TEST_CONDITION(r); std::vector<CryptoNote::Block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(MK_COINS(244), get_balance(m_bob_account, chain, mtx)); CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); return true; }
bool gen_ring_signature_2::check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_1"); m_bob_account = boost::get<account_base>(events[1]); m_alice_account = boost::get<account_base>(events[2]); std::list<block> blocks; bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); CHECK_TEST_CONDITION(r); std::vector<cryptonote::block> chain; map_hash2tx_t mtx; r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); CHECK_TEST_CONDITION(r); CHECK_EQ(MK_COINS(244), get_balance(m_bob_account, chain, mtx)); CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); return true; }
bool DoubleSpendBase::check_double_spend(CryptoNote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& events) { DEFINE_TESTS_ERROR_CONTEXT("DoubleSpendBase::check_double_spend"); CHECK_EQ(m_last_valid_block, c.get_tail_id()); return true; }
bool DoubleSpendBase::mark_last_valid_block(CryptoNote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& /*events*/) { m_last_valid_block = c.get_tail_id(); return true; }
//----------------------------------------------------------------------------------------------------- bool gen_simple_chain_split_1::check_mempool_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) { DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_mempool_1"); CHECK_TEST_CONDITION(c.get_pool_transactions_count() == 3); return true; }
int import_from_file(cryptonote::core& core, const std::string& import_file_path, uint64_t block_stop=0) { // Reset stats, in case we're using newly created db, accumulating stats // from addition of genesis block. // This aligns internal db counts with importer counts. core.get_blockchain_storage().get_db().reset_stats(); boost::filesystem::path fs_import_file_path(import_file_path); boost::system::error_code ec; if (!boost::filesystem::exists(fs_import_file_path, ec)) { MFATAL("bootstrap file not found: " << fs_import_file_path); return false; } uint64_t start_height = 1, seek_height; if (opt_resume) start_height = core.get_blockchain_storage().get_current_blockchain_height(); seek_height = start_height; BootstrapFile bootstrap; std::streampos pos; // BootstrapFile bootstrap(import_file_path); uint64_t total_source_blocks = bootstrap.count_blocks(import_file_path, pos, seek_height); MINFO("bootstrap file last block number: " << total_source_blocks-1 << " (zero-based height) total blocks: " << total_source_blocks); if (total_source_blocks-1 <= start_height) { return false; } std::cout << ENDL; std::cout << "Preparing to read blocks..." << ENDL; std::cout << ENDL; std::ifstream import_file; import_file.open(import_file_path, std::ios_base::binary | std::ifstream::in); uint64_t h = 0; uint64_t num_imported = 0; if (import_file.fail()) { MFATAL("import_file.open() fail"); return false; } // 4 byte magic + (currently) 1024 byte header structures uint8_t major_version, minor_version; bootstrap.seek_to_first_chunk(import_file, major_version, minor_version); std::string str1; char buffer1[1024]; char buffer_block[BUFFER_SIZE]; block b; transaction tx; int quit = 0; uint64_t bytes_read; // Note that a new blockchain will start with block number 0 (total blocks: 1) // due to genesis block being added at initialization. if (! block_stop) { block_stop = total_source_blocks - 1; } // These are what we'll try to use, and they don't have to be a determination // from source and destination blockchains, but those are the defaults. MINFO("start block: " << start_height << " stop block: " << block_stop); bool use_batch = opt_batch && !opt_verify; MINFO("Reading blockchain from bootstrap file..."); std::cout << ENDL; std::vector<block_complete_entry> blocks; // Skip to start_height before we start adding. { bool q2 = false; import_file.seekg(pos); bytes_read = bootstrap.count_bytes(import_file, start_height-seek_height, h, q2); if (q2) { quit = 2; goto quitting; } h = start_height; } if (use_batch) { uint64_t bytes, h2; bool q2; pos = import_file.tellg(); bytes = bootstrap.count_bytes(import_file, db_batch_size, h2, q2); if (import_file.eof()) import_file.clear(); import_file.seekg(pos); core.get_blockchain_storage().get_db().batch_start(db_batch_size, bytes); } while (! quit) { uint32_t chunk_size; import_file.read(buffer1, sizeof(chunk_size)); // TODO: bootstrap.read_chunk(); if (! import_file) { std::cout << refresh_string; MINFO("End of file reached"); quit = 1; break; } bytes_read += sizeof(chunk_size); str1.assign(buffer1, sizeof(chunk_size)); if (! ::serialization::parse_binary(str1, chunk_size)) { throw std::runtime_error("Error in deserialization of chunk size"); } MDEBUG("chunk_size: " << chunk_size); if (chunk_size > BUFFER_SIZE) { MWARNING("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE); throw std::runtime_error("Aborting: chunk size exceeds buffer size"); } if (chunk_size > CHUNK_SIZE_WARNING_THRESHOLD) { MINFO("NOTE: chunk_size " << chunk_size << " > " << CHUNK_SIZE_WARNING_THRESHOLD); } else if (chunk_size == 0) { MFATAL("ERROR: chunk_size == 0"); return 2; } import_file.read(buffer_block, chunk_size); if (! import_file) { if (import_file.eof()) { std::cout << refresh_string; MINFO("End of file reached - file was truncated"); quit = 1; break; } else { MFATAL("ERROR: unexpected end of file: bytes read before error: " << import_file.gcount() << " of chunk_size " << chunk_size); return 2; } } bytes_read += chunk_size; MDEBUG("Total bytes read: " << bytes_read); if (h > block_stop) { std::cout << refresh_string << "block " << h-1 << " / " << block_stop << "\r" << std::flush; std::cout << ENDL << ENDL; MINFO("Specified block number reached - stopping. block: " << h-1 << " total blocks: " << h); quit = 1; break; } try { str1.assign(buffer_block, chunk_size); bootstrap::block_package bp; bool res; if (major_version == 0) { bootstrap::block_package_1 bp1; res = ::serialization::parse_binary(str1, bp1); if (res) { bp.block = std::move(bp1.block); bp.txs = std::move(bp1.txs); bp.block_weight = bp1.block_weight; bp.cumulative_difficulty = bp1.cumulative_difficulty; bp.coins_generated = bp1.coins_generated; } } else res = ::serialization::parse_binary(str1, bp); if (!res) throw std::runtime_error("Error in deserialization of chunk"); int display_interval = 1000; int progress_interval = 10; // NOTE: use of NUM_BLOCKS_PER_CHUNK is a placeholder in case multi-block chunks are later supported. for (int chunk_ind = 0; chunk_ind < NUM_BLOCKS_PER_CHUNK; ++chunk_ind) { ++h; if ((h-1) % display_interval == 0) { std::cout << refresh_string; MDEBUG("loading block number " << h-1); } else { MDEBUG("loading block number " << h-1); } b = bp.block; MDEBUG("block prev_id: " << b.prev_id << ENDL); if ((h-1) % progress_interval == 0) { std::cout << refresh_string << "block " << h-1 << " / " << block_stop << "\r" << std::flush; } if (opt_verify) { cryptonote::blobdata block; cryptonote::block_to_blob(bp.block, block); std::vector<cryptonote::blobdata> txs; for (const auto &tx: bp.txs) { txs.push_back(cryptonote::blobdata()); cryptonote::tx_to_blob(tx, txs.back()); } blocks.push_back({block, txs}); int ret = check_flush(core, blocks, false); if (ret) { quit = 2; // make sure we don't commit partial block data break; } } else { std::vector<std::pair<transaction, blobdata>> txs; std::vector<transaction> archived_txs; archived_txs = bp.txs; // tx number 1: coinbase tx // tx number 2 onwards: archived_txs for (const transaction &tx : archived_txs) { // add blocks with verification. // for Blockchain and blockchain_storage add_new_block(). // for add_block() method, without (much) processing. // don't add coinbase transaction to txs. // // because add_block() calls // add_transaction(blk_hash, blk.miner_tx) first, and // then a for loop for the transactions in txs. txs.push_back(std::make_pair(tx, tx_to_blob(tx))); } size_t block_weight; difficulty_type cumulative_difficulty; uint64_t coins_generated; block_weight = bp.block_weight; cumulative_difficulty = bp.cumulative_difficulty; coins_generated = bp.coins_generated; try { uint64_t long_term_block_weight = core.get_blockchain_storage().get_next_long_term_block_weight(block_weight); core.get_blockchain_storage().get_db().add_block(std::make_pair(b, block_to_blob(b)), block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs); } catch (const std::exception& e) { std::cout << refresh_string; MFATAL("Error adding block to blockchain: " << e.what()); quit = 2; // make sure we don't commit partial block data break; } if (use_batch) { if ((h-1) % db_batch_size == 0) { uint64_t bytes, h2; bool q2; std::cout << refresh_string; // zero-based height std::cout << ENDL << "[- batch commit at height " << h-1 << " -]" << ENDL; core.get_blockchain_storage().get_db().batch_stop(); pos = import_file.tellg(); bytes = bootstrap.count_bytes(import_file, db_batch_size, h2, q2); import_file.seekg(pos); core.get_blockchain_storage().get_db().batch_start(db_batch_size, bytes); std::cout << ENDL; core.get_blockchain_storage().get_db().show_stats(); } } } ++num_imported; } } catch (const std::exception& e) { std::cout << refresh_string; MFATAL("exception while reading from file, height=" << h << ": " << e.what()); return 2; } } // while quitting: import_file.close(); if (opt_verify) { int ret = check_flush(core, blocks, true); if (ret) return ret; } if (use_batch) { if (quit > 1) { // There was an error, so don't commit pending data. // Destructor will abort write txn. } else { core.get_blockchain_storage().get_db().batch_stop(); } } core.get_blockchain_storage().get_db().show_stats(); MINFO("Number of blocks imported: " << num_imported); if (h > 0) // TODO: if there was an error, the last added block is probably at zero-based height h-2 MINFO("Finished at block: " << h-1 << " total blocks: " << h); std::cout << ENDL; return 0; }
int check_flush(cryptonote::core &core, std::vector<block_complete_entry> &blocks, bool force) { if (blocks.empty()) return 0; if (!force && blocks.size() < db_batch_size) return 0; // wait till we can verify a full HOH without extra, for speed uint64_t new_height = core.get_blockchain_storage().get_db().height() + blocks.size(); if (!force && new_height % HASH_OF_HASHES_STEP) return 0; std::vector<crypto::hash> hashes; for (const auto &b: blocks) { cryptonote::block block; if (!parse_and_validate_block_from_blob(b.block, block)) { MERROR("Failed to parse block: " << epee::string_tools::pod_to_hex(get_blob_hash(b.block))); core.cleanup_handle_incoming_blocks(); return 1; } hashes.push_back(cryptonote::get_block_hash(block)); } core.prevalidate_block_hashes(core.get_blockchain_storage().get_db().height(), hashes); std::vector<block> pblocks; if (!core.prepare_handle_incoming_blocks(blocks, pblocks)) { MERROR("Failed to prepare to add blocks"); return 1; } if (!pblocks.empty() && pblocks.size() != blocks.size()) { MERROR("Unexpected parsed blocks size"); core.cleanup_handle_incoming_blocks(); return 1; } size_t blockidx = 0; for(const block_complete_entry& block_entry: blocks) { // process transactions for(auto& tx_blob: block_entry.txs) { tx_verification_context tvc = AUTO_VAL_INIT(tvc); core.handle_incoming_tx(tx_blob, tvc, true, true, false); if(tvc.m_verifivation_failed) { MERROR("transaction verification failed, tx_id = " << epee::string_tools::pod_to_hex(get_blob_hash(tx_blob))); core.cleanup_handle_incoming_blocks(); return 1; } } // process block block_verification_context bvc = boost::value_initialized<block_verification_context>(); core.handle_incoming_block(block_entry.block, pblocks.empty() ? NULL : &pblocks[blockidx++], bvc, false); // <--- process block if(bvc.m_verifivation_failed) { MERROR("Block verification failed, id = " << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block))); core.cleanup_handle_incoming_blocks(); return 1; } if(bvc.m_marked_as_orphaned) { MERROR("Block received at sync phase was marked as orphaned"); core.cleanup_handle_incoming_blocks(); return 1; } } // each download block if (!core.cleanup_handle_incoming_blocks()) return 1; blocks.clear(); return 0; }