コード例 #1
0
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, getBlockHash(boost::get<CryptoNote::BlockTemplate>(events[1]))));
    //CHECK_TEST_CONDITION(get_block_reward(0) == get_balance(alice, events, chain, mtx));

    // check height
    std::vector<BlockTemplate> blocks;
    auto rawBlocks = c.getBlocks(0, 10000);
    blocks.resize(rawBlocks.size());
    for (size_t i = 0; i < rawBlocks.size(); ++i) {
      CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
    }

    CHECK_TEST_CONDITION(blocks.size() == 1);
    //CHECK_TEST_CONDITION(outs.size() == blocks.size());
    CHECK_TEST_CONDITION(c.getBlockchainTransactionCount() == 1);
    //CHECK_TEST_CONDITION(blocks.back() == boost::get<CryptoNote::BlockTemplate>(events[0]));

    return true;
}
コード例 #2
0
//-----------------------------------------------------------------------------------------------------
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::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 10000);
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  CHECK_EQ(7 + 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<BlockTemplate>(events[25 + 2 * m_currency->minedMoneyUnlockWindow()])); // blk_7

  auto alt_blocks = c.getAlternativeBlocks();
  CHECK_EQ(2, c.getAlternativeBlockCount());

  // Some blocks that were in main chain are in alt chain now
  for (const auto& b : alt_blocks) {
    CHECK_TEST_CONDITION(
        !(m_chain_1.end() == std::find_if(m_chain_1.cbegin(), m_chain_1.cend(),
                                          [&b](const CryptoNote::BlockTemplate& arg) -> bool { return b == arg; })));
  }

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx));
  CHECK_EQ(MK_COINS(3), 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(16), get_balance(m_recipient_account_4, chain, mtx));

  auto tx_pool = c.getPoolTransactions();
  CHECK_EQ(1, tx_pool.size());
  CHECK_TEST_CONDITION(!(tx_pool.front() == m_tx_pool.front()));

  std::vector<size_t> tx_outs;
  uint64_t transfered;
  lookup_acc_outs(m_recipient_account_2.getAccountKeys(), tx_pool.front(), tx_outs, transfered);
  CHECK_EQ(MK_COINS(7), transfered);

  return true;
}
コード例 #3
0
ファイル: RingSignature.cpp プロジェクト: sea51930/bytecoin
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::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 2 * static_cast<uint32_t>(m_test_size) + m_currency->minedMoneyUnlockWindow());
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(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;
}
コード例 #4
0
//-----------------------------------------------------------------------------------------------------
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<AccountBase>(events[2]);
  m_recipient_account_2 = boost::get<AccountBase>(events[3]);
  m_recipient_account_3 = boost::get<AccountBase>(events[4]);
  m_recipient_account_4 = boost::get<AccountBase>(events[5]);

  std::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 10000);
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  CHECK_EQ(6 + 2 * m_currency->minedMoneyUnlockWindow(), blocks.size());
  auto blk_4 = CryptoNote::fromBinaryArray<BlockTemplate>(
      boost::get<RawBlock>(events[21 + 2 * m_currency->minedMoneyUnlockWindow()]).block);
  CHECK_TEST_CONDITION(getBlockHash(blocks.back()) == getBlockHash(blk_4)); // blk_4

  CHECK_EQ(2, c.getAlternativeBlockCount());

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(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));

  auto tx_pool = c.getPoolTransactions();
  CHECK_EQ(1, tx_pool.size());

  std::vector<size_t> tx_outs;
  uint64_t transfered;
  lookup_acc_outs(m_recipient_account_4.getAccountKeys(), tx_pool.front(),
                  getTransactionPublicKeyFromExtra(tx_pool.front().extra), tx_outs, transfered);
  CHECK_EQ(MK_COINS(13), transfered);

  m_chain_1.swap(blocks);
  m_tx_pool.swap(tx_pool);

  return true;
}
コード例 #5
0
bool gen_upgrade::checkBlockRewardIsZero(CryptoNote::Core& c, size_t evIndex, const std::vector<test_event_entry>& events) {
  DEFINE_TESTS_ERROR_CONTEXT("gen_upgrade::checkBlockRewardIsZero");

  BlockTemplate blk = boost::get<BlockTemplate>(events[evIndex - 1]);
  uint64_t blockReward = getSummaryOutsAmount(blk.baseTransaction);
  CHECK_EQ(blockReward, 0);

  CHECK_EQ(m_coinsInCirculationAfterUpgrade - m_currency->minimumFee(), c.getTotalGeneratedAmount());

  return true;
}
コード例 #6
0
bool gen_upgrade::checkBlockTemplateVersion(CryptoNote::Core& c, uint8_t expectedMajorVersion, uint8_t expectedMinorVersion) {
  DEFINE_TESTS_ERROR_CONTEXT("gen_upgrade::checkBlockTemplateVersion");

  AccountBase account;
  account.generate();

  BlockTemplate b;
  Difficulty difficulty;
  uint32_t height;
  CHECK_TEST_CONDITION(c.getBlockTemplate(b, account.getAccountKeys().address, BinaryArray(), difficulty, height));
  CHECK_EQ(static_cast<int>(b.majorVersion), static_cast<int>(expectedMajorVersion));
  CHECK_EQ(static_cast<int>(b.minorVersion), static_cast<int>(expectedMinorVersion));

  return true;
}
コード例 #7
0
ファイル: RingSignature.cpp プロジェクト: sea51930/bytecoin
bool gen_ring_signature_2::check_balances_2(CryptoNote::Core& c, size_t ev_index,
                                            const std::vector<test_event_entry>& events) {
  DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_2");

  std::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 100 + 2 * m_currency->minedMoneyUnlockWindow());
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(0, get_balance(m_bob_account, chain, mtx));
  CHECK_EQ(MK_COINS(244) - m_currency->minimumFee(), get_balance(m_alice_account, chain, mtx));

  return true;
}
コード例 #8
0
bool gen_upgrade::rememberCoinsInCirculationAfterUpgrade(CryptoNote::Core& c, size_t /*evIndex*/, const std::vector<test_event_entry>& /*events*/) {
  m_coinsInCirculationAfterUpgrade = c.getTotalGeneratedAmount();
  return true;
}