townforge/tests/db_tests/db_tests_cc.cpp

// Copyright (c) 2020, Crypto City
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "blockchain_db/blockchain_db.h"
#include "cc/cc_script.h"
#include "db_tests.h"

bool db_tests_cc_blobs(cryptonote::BlockchainDB &db)
{
  const crypto::hash hash = cc::script::get_blob_hash("test");
  size_t n_blobs;
  cryptonote::blobdata blob;

  n_blobs = 0;
  DB_TESTS_ASSERT(db.for_all_cc_blobs([&n_blobs](const crypto::hash&, uint32_t, const cryptonote::blobdata_ref&) { ++n_blobs; return true; }));
  DB_TESTS_ASSERT(n_blobs == 0);
  DB_TESTS_ASSERT(db.get_cc_blob(hash, blob) == 0);

  db.add_cc_blob("test");
  n_blobs = 0;
  DB_TESTS_ASSERT(db.for_all_cc_blobs([&n_blobs, &hash](const crypto::hash &h, uint32_t refs, const cryptonote::blobdata_ref &blob) {
    DB_TESTS_ASSERT(h == hash);
    DB_TESTS_ASSERT(refs == 1);
    DB_TESTS_ASSERT(blob == "test");
    ++n_blobs;
    return true;
  }));
  DB_TESTS_ASSERT(n_blobs == 1);
  DB_TESTS_ASSERT(db.get_cc_blob(hash, blob) == 1);
  DB_TESTS_ASSERT(blob == "test");

  db.add_cc_blob("test");
  n_blobs = 0;
  DB_TESTS_ASSERT(db.for_all_cc_blobs([&n_blobs, &hash](const crypto::hash &h, uint32_t refs, const cryptonote::blobdata_ref &blob) {
    DB_TESTS_ASSERT(h == hash);
    DB_TESTS_ASSERT(refs == 2);
    DB_TESTS_ASSERT(blob == "test");
    ++n_blobs;
    return true;
  }));
  DB_TESTS_ASSERT(n_blobs == 1);
  DB_TESTS_ASSERT(db.get_cc_blob(hash, blob) == 2);
  DB_TESTS_ASSERT(blob == "test");

  db.delete_cc_blob("test");
  n_blobs = 0;
  DB_TESTS_ASSERT(db.for_all_cc_blobs([&n_blobs, &hash](const crypto::hash &h, uint32_t refs, const cryptonote::blobdata_ref &blob) {
    DB_TESTS_ASSERT(h == hash);
    DB_TESTS_ASSERT(refs == 1);
    DB_TESTS_ASSERT(blob == "test");
    ++n_blobs;
    return true;
  }));
  DB_TESTS_ASSERT(n_blobs == 1);
  DB_TESTS_ASSERT(db.get_cc_blob(hash, blob) == 1);
  DB_TESTS_ASSERT(blob == "test");

  db.delete_cc_blob("test");
  n_blobs = 0;
  DB_TESTS_ASSERT(db.for_all_cc_blobs([&n_blobs](const crypto::hash&, uint32_t, const cryptonote::blobdata_ref&) { ++n_blobs; return true; }));
  DB_TESTS_ASSERT(n_blobs == 0);
  DB_TESTS_ASSERT(db.get_cc_blob(hash, blob) == 0);

  return true;
}

bool db_tests_cc_random_seed(cryptonote::BlockchainDB &db)
{
  db.set_cc_random_seed(crypto::null_hash);
  DB_TESTS_ASSERT(db.get_cc_random_seed() == crypto::null_hash);
  crypto::hash seed = crypto::null_hash;
  seed.data[3] = 0x42;
  db.set_cc_random_seed(seed);
  DB_TESTS_ASSERT(db.get_cc_random_seed() == seed);

  return true;
}

bool db_tests_cc_foreclosures(cryptonote::BlockchainDB &db)
{
  size_t n_mortgages = 0;
  DB_TESTS_ASSERT(db.for_all_cc_foreclosures([&n_mortgages](const cc::foreclosure_t&) {
    ++n_mortgages;
    return true;
  }));
  DB_TESTS_ASSERT(n_mortgages == 0);

  db.add_cc_foreclosure({10, 11, 12, 13});
  n_mortgages = 0;
  DB_TESTS_ASSERT(db.for_all_cc_foreclosures([&n_mortgages](const cc::foreclosure_t &foreclosure) {
    DB_TESTS_ASSERT(foreclosure.mortgage == 10);
    DB_TESTS_ASSERT(foreclosure.flag == 11);
    DB_TESTS_ASSERT(foreclosure.height == 12);
    DB_TESTS_ASSERT(foreclosure.debt_per_share == 13);
    ++n_mortgages;
    return true;
  }));
  DB_TESTS_ASSERT(n_mortgages == 1);

  db.remove_cc_foreclosure(10);
  n_mortgages = 0;
  DB_TESTS_ASSERT(db.for_all_cc_foreclosures([&n_mortgages](const cc::foreclosure_t&) {
    ++n_mortgages;
    return true;
  }));
  DB_TESTS_ASSERT(n_mortgages == 0);

  return true;
}

bool db_tests_cc_runestones(cryptonote::BlockchainDB &db)
{
  size_t n_runestones = 0;
  DB_TESTS_ASSERT(db.for_all_cc_runestones([&n_runestones](const cc::runestone_t &runestone) {
    ++n_runestones;
    return true;
  }));
  DB_TESTS_ASSERT(n_runestones == 0);

  cc::runestone_t runestone;
  runestone.flag = 10;
  runestone.x = 11;
  runestone.y = 12;
  runestone.h = 13;
  runestone.script = 14;
  runestone.message = "15";
  runestone.overrides.push_back(std::make_tuple(0, 1, "foo"));
  runestone.overrides.push_back(std::make_tuple(1, 2, "bar"));
  db.add_cc_runestone(runestone);

  n_runestones = 0;
  DB_TESTS_ASSERT(db.for_all_cc_runestones([&n_runestones](const cc::runestone_t &runestone) {
    DB_TESTS_ASSERT(runestone.flag == 10);
    DB_TESTS_ASSERT(runestone.x == 11);
    DB_TESTS_ASSERT(runestone.y == 12);
    DB_TESTS_ASSERT(runestone.h == 13);
    DB_TESTS_ASSERT(runestone.script == 14);
    DB_TESTS_ASSERT(runestone.message == "15");
    DB_TESTS_ASSERT(runestone.overrides.size() == 2);
    DB_TESTS_ASSERT(runestone.overrides[0] == std::make_tuple(0, 1, "foo"));
    DB_TESTS_ASSERT(runestone.overrides[1] == std::make_tuple(1, 2, "bar"));
    ++n_runestones;
    return true;
  }));
  DB_TESTS_ASSERT(n_runestones == 1);

  cc::runestone_t r;
  DB_TESTS_ASSERT(!db.get_cc_runestone(10, 0, 0, 0, r));
  DB_TESTS_ASSERT(db.get_cc_runestone(10, 11, 12, 13, r));
  DB_TESTS_ASSERT(r.flag == 10);
  DB_TESTS_ASSERT(r.x == 11);
  DB_TESTS_ASSERT(r.y == 12);
  DB_TESTS_ASSERT(r.h == 13);
  DB_TESTS_ASSERT(r.script == 14);
  DB_TESTS_ASSERT(r.message == "15");
  DB_TESTS_ASSERT(r.overrides.size() == 2);
  DB_TESTS_ASSERT(r.overrides[0] == std::make_tuple(0, 1, "foo"));
  DB_TESTS_ASSERT(r.overrides[1] == std::make_tuple(1, 2, "bar"));

  db.remove_cc_runestone(10, 11, 12, 13);
  n_runestones = 0;
  DB_TESTS_ASSERT(db.for_all_cc_runestones([&n_runestones](const cc::runestone_t &runestone) {
    ++n_runestones;
    return true;
  }));
  DB_TESTS_ASSERT(n_runestones == 0);

  return true;
}

bool db_tests_cc_script_variables(cryptonote::BlockchainDB &db)
{
  size_t n_script_variables = 0;
  DB_TESTS_ASSERT(db.for_all_cc_script_variables([&n_script_variables](const boost::string_ref&, uint64_t) { ++n_script_variables; return true; }));
  DB_TESTS_ASSERT(n_script_variables == 0);

  DB_TESTS_ASSERT(db.get_cc_script_variable("test") == 0);
  db.set_cc_script_variable("test", 1);
  DB_TESTS_ASSERT(db.get_cc_script_variable("test") == 1);

  n_script_variables = 0;
  DB_TESTS_ASSERT(db.for_all_cc_script_variables([&n_script_variables](const boost::string_ref &name, uint64_t value) {
    DB_TESTS_ASSERT(name == "test");
    DB_TESTS_ASSERT(value == 1);
    ++n_script_variables;
    return true;
  }));
  DB_TESTS_ASSERT(n_script_variables == 1);

  db.set_cc_script_variable("test", 0);
  DB_TESTS_ASSERT(db.get_cc_script_variable("test") == 0);

  n_script_variables = 0;
  DB_TESTS_ASSERT(db.for_all_cc_script_variables([&n_script_variables](const boost::string_ref&, uint64_t) { ++n_script_variables; return true; }));
  DB_TESTS_ASSERT(n_script_variables == 0);

  return true;
}

bool db_tests_cc_scripts(cryptonote::BlockchainDB &db)
{
  size_t n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts](const cryptonote::cc_script_data_t&){ ++n_scripts; return true; }));
  DB_TESTS_ASSERT(n_scripts == 0);
  DB_TESTS_ASSERT(db.get_num_cc_scripts() == 0);

  const uint32_t id = db.allocate_new_cc_script("name", "icon", "desc", "blob", 42, true);
  DB_TESTS_ASSERT(id != 0);
  DB_TESTS_ASSERT(db.get_num_cc_scripts() == 1);
  n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts, id](const cryptonote::cc_script_data_t &s){
    DB_TESTS_ASSERT(s.id == id);
    DB_TESTS_ASSERT(s.name == "name");
    DB_TESTS_ASSERT(s.desc == "desc");
    DB_TESTS_ASSERT(s.icon == "icon");
    DB_TESTS_ASSERT(s.blob == "blob");
    DB_TESTS_ASSERT(s.owner == 42);
    DB_TESTS_ASSERT(s.is_public == true);
    DB_TESTS_ASSERT(s.enabled == true);
    ++n_scripts;
    return true;
  }));
  DB_TESTS_ASSERT(n_scripts == 1);

  const uint32_t id2 = db.allocate_new_cc_script("name2", "icon2", "desc2", "blob2", 43, false);
  DB_TESTS_ASSERT(id2 && id2 == id + 1);
  n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts, id](const cryptonote::cc_script_data_t &s){
    DB_TESTS_ASSERT(s.id == id || s.id == id + 1);
    DB_TESTS_ASSERT(s.name == (s.id == id ? "name" : "name2"));
    DB_TESTS_ASSERT(s.desc == (s.id == id ? "desc" : "desc2"));
    DB_TESTS_ASSERT(s.icon == (s.id == id ? "icon" : "icon2"));
    DB_TESTS_ASSERT(s.blob == (s.id == id ? "blob" : "blob2"));
    DB_TESTS_ASSERT(s.owner == (s.id == id ? 42 : 43));
    DB_TESTS_ASSERT(s.is_public == (s.id == id));
    DB_TESTS_ASSERT(s.enabled);
    ++n_scripts;
    return true;
  }));
  DB_TESTS_ASSERT(n_scripts == 2);
  DB_TESTS_ASSERT(db.get_num_cc_scripts() == 2);

  cryptonote::cc_script_data_t sd;
  DB_TESTS_ASSERT(db.get_cc_script_data(id, sd));
  DB_TESTS_ASSERT(sd.id == id);
  DB_TESTS_ASSERT(sd.name == "name");
  DB_TESTS_ASSERT(db.get_cc_script_data(id2, sd));
  DB_TESTS_ASSERT(sd.id == id2);
  DB_TESTS_ASSERT(sd.name == "name2");

  db.set_cc_script_enabled(id, false);
  n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts, id](const cryptonote::cc_script_data_t &s){
    DB_TESTS_ASSERT(s.enabled == (s.id != id));
    ++n_scripts;
    return true;
  }));
  DB_TESTS_ASSERT(n_scripts == 2);

  db.set_cc_script_enabled(id, true);
  n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts, id](const cryptonote::cc_script_data_t &s){
    DB_TESTS_ASSERT(s.enabled == true);
    ++n_scripts;
    return true;
  }));
  DB_TESTS_ASSERT(n_scripts == 2);

  db.delete_cc_script(id2);
  n_scripts = 0;
  DB_TESTS_ASSERT(db.for_all_cc_scripts([&n_scripts, id](const cryptonote::cc_script_data_t &s){
    DB_TESTS_ASSERT(s.id == id);
    DB_TESTS_ASSERT(s.name == "name");
    DB_TESTS_ASSERT(s.desc == "desc");
    DB_TESTS_ASSERT(s.icon == "icon");
    DB_TESTS_ASSERT(s.blob == "blob");
    DB_TESTS_ASSERT(s.owner == 42);
    DB_TESTS_ASSERT(s.is_public == true);
    ++n_scripts;
    return true;
  }));
  DB_TESTS_ASSERT(n_scripts == 1);
  DB_TESTS_ASSERT(db.get_num_cc_scripts() == 1);

  return true;
}

bool db_tests_cc_script_effects(cryptonote::BlockchainDB &db)
{
  cc::script::script_effects_t effects;
  DB_TESTS_EXCEPTION(db.get_cc_script_effects(4, effects));

  cc::script::script_effects_t test_effects;
  test_effects.balances.push_back({3, 4, 5});
  test_effects.local_variables.push_back({"test", 6});
  db.set_cc_script_effects(4, test_effects);

  db.get_cc_script_effects(4, effects);
  DB_TESTS_ASSERT(effects.balances.size() == 1 && effects.balances[0].account == 3 && effects.balances[0].counterparty == 4 && effects.balances[0].balance_delta == 5);
  DB_TESTS_ASSERT(effects.local_variables.size() == 1 && effects.local_variables[0].name == "test" && effects.local_variables[0].value_delta == 6);

  db.set_cc_script_effects(5, test_effects);

  db.delete_cc_script_effects(4);
  DB_TESTS_EXCEPTION(db.get_cc_script_effects(4, effects));

  db.get_cc_script_effects(5, effects);
  DB_TESTS_ASSERT(effects.balances.size() == 1 && effects.balances[0].account == 3 && effects.balances[0].counterparty == 4 && effects.balances[0].balance_delta == 5);
  DB_TESTS_ASSERT(effects.local_variables.size() == 1 && effects.local_variables[0].name == "test" && effects.local_variables[0].value_delta == 6);

  db.delete_cc_script_effects(5);

  return true;
}

bool db_tests_cc_item_counts(cryptonote::BlockchainDB &db)
{
  DB_TESTS_ASSERT(db.get_cc_item_count(1) == 0);
  DB_TESTS_ASSERT(db.get_cc_item_count(2) == 0);
  db.set_cc_item_count(1, 1);
  db.set_cc_item_count(2, 2);
  DB_TESTS_ASSERT(db.get_cc_item_count(1) == 1);
  DB_TESTS_ASSERT(db.get_cc_item_count(2) == 2);
  db.set_cc_item_count(1, 0);
  db.set_cc_item_count(2, 0);
  DB_TESTS_ASSERT(db.get_cc_item_count(1) == 0);
  DB_TESTS_ASSERT(db.get_cc_item_count(2) == 0);
  return true;
}

bool db_tests_cc_invitations(cryptonote::BlockchainDB &db)
{
  crypto::public_key pkey0 = crypto::null_pkey, pkey1 = crypto::null_pkey;
  pkey0.data[0] = 8;
  pkey1.data[0] = 16;

  DB_TESTS_ASSERT(!db.has_invitation(pkey0));
  DB_TESTS_ASSERT(!db.has_invitation(pkey1));
  db.add_invitation(pkey0);
  DB_TESTS_ASSERT(db.has_invitation(pkey0));
  DB_TESTS_ASSERT(!db.has_invitation(pkey1));
  db.add_invitation(pkey1);
  DB_TESTS_ASSERT(db.has_invitation(pkey0));
  DB_TESTS_ASSERT(db.has_invitation(pkey1));
  db.remove_invitation(pkey0);
  DB_TESTS_ASSERT(!db.has_invitation(pkey0));
  DB_TESTS_ASSERT(db.has_invitation(pkey1));
  db.remove_invitation(pkey1);
  DB_TESTS_ASSERT(!db.has_invitation(pkey0));
  DB_TESTS_ASSERT(!db.has_invitation(pkey1));

  return true;
}

bool db_tests_cc_attributes(cryptonote::BlockchainDB &db)
{
  cryptonote::cc_attribute_data_t ad;
  size_t n_attributes = 0;
  DB_TESTS_ASSERT(db.for_all_cc_attributes([&n_attributes](const cryptonote::cc_attribute_data_t &ad){ ++n_attributes; return true; }));
  DB_TESTS_ASSERT(n_attributes == 0);
  DB_TESTS_ASSERT(!db.get_cc_attribute(0, ad));
  DB_TESTS_ASSERT(!db.get_cc_attribute(1, ad));
  DB_TESTS_EXCEPTION(db.delete_cc_attribute(0));
  DB_TESTS_EXCEPTION(db.delete_cc_attribute(1));

  const uint32_t id = db.allocate_new_cc_attribute("name", "desc");
  DB_TESTS_ASSERT(id == 1);
  n_attributes = 0;
  DB_TESTS_ASSERT(db.for_all_cc_attributes([&n_attributes](const cryptonote::cc_attribute_data_t &ad){
    DB_TESTS_ASSERT(ad.name == "name");
    DB_TESTS_ASSERT(ad.description == "desc");
    ++n_attributes;
    return true;
  }));
  DB_TESTS_ASSERT(n_attributes == 1);

  DB_TESTS_ASSERT(!db.get_cc_attribute(0, ad));
  DB_TESTS_ASSERT(db.get_cc_attribute(1, ad));
  DB_TESTS_ASSERT(ad.name == "name");
  DB_TESTS_ASSERT(ad.description == "desc");

  db.delete_cc_attribute(id);
  DB_TESTS_ASSERT(!db.get_cc_attribute(0, ad));
  DB_TESTS_ASSERT(!db.get_cc_attribute(1, ad));

  return true;
}

bool db_tests_cc_auctions(cryptonote::BlockchainDB &db)
{
  cc::auction_t ad;
  size_t n_auctions = 0;
  DB_TESTS_ASSERT(db.for_all_cc_auctions([&n_auctions](const cc::auction_t &auction){ ++n_auctions; return true; }));
  DB_TESTS_ASSERT(n_auctions == 0);
  DB_TESTS_ASSERT(!db.get_cc_auction_data(0, ad));
  DB_TESTS_ASSERT(!db.get_cc_auction_data(1, ad));
  DB_TESTS_EXCEPTION(db.remove_cc_auction(0));
  DB_TESTS_EXCEPTION(db.remove_cc_auction(1));

  const uint32_t id = db.allocate_cc_auction(1, cc::auction_t::type_flag, {std::make_pair(1, 1)}, 2, "a", "b", 0);
  DB_TESTS_ASSERT(id == 1);
  n_auctions = 0;
  DB_TESTS_ASSERT(db.for_all_cc_auctions([&n_auctions](const cc::auction_t &ad){
    DB_TESTS_ASSERT(ad.id == 1);
    DB_TESTS_ASSERT(ad.seller == 1);
    DB_TESTS_ASSERT(ad.type == cc::auction_t::type_flag);
    DB_TESTS_ASSERT(ad.entries.size() == 1);
    DB_TESTS_ASSERT(ad.entries[0].first == 1);
    DB_TESTS_ASSERT(ad.entries[0].second == 1);
    DB_TESTS_ASSERT(ad.title == "a");
    DB_TESTS_ASSERT(ad.description == "b");
    DB_TESTS_ASSERT(ad.bids.empty());
    ++n_auctions;
    return true;
  }));
  DB_TESTS_ASSERT(n_auctions == 1);

  DB_TESTS_ASSERT(!db.get_cc_auction_data(0, ad));
  DB_TESTS_ASSERT(db.get_cc_auction_data(1, ad));
  DB_TESTS_ASSERT(ad.id == 1);
  DB_TESTS_ASSERT(ad.seller == 1);
  DB_TESTS_ASSERT(ad.type == cc::auction_t::type_flag);
  DB_TESTS_ASSERT(ad.entries.size() == 1);
  DB_TESTS_ASSERT(ad.entries[0].first == 1);
  DB_TESTS_ASSERT(ad.entries[0].second == 1);
  DB_TESTS_ASSERT(ad.bids.empty());

  db.add_cc_auction_bid(1, 2, 200, 200);
  DB_TESTS_ASSERT(db.get_cc_auction_data(1, ad));
  DB_TESTS_ASSERT(ad.bids.size() == 1);
  DB_TESTS_ASSERT(ad.bids[0] == std::make_tuple(2, 200, 200));
  db.add_cc_auction_bid(1, 3, 400, 300);
  DB_TESTS_ASSERT(db.get_cc_auction_data(1, ad));
  DB_TESTS_ASSERT(ad.bids.size() == 2);
  DB_TESTS_ASSERT(ad.bids[0] == std::make_tuple(2, 200, 200));
  DB_TESTS_ASSERT(ad.bids[1] == std::make_tuple(3, 400, 300));

  db.set_cc_auction_ended(1, true);
  n_auctions = 0;
  DB_TESTS_ASSERT(db.for_all_cc_auctions([&n_auctions](const cc::auction_t &auction){ ++n_auctions; return true; }));
  DB_TESTS_ASSERT(n_auctions == 0);
  DB_TESTS_ASSERT(!db.get_cc_auction_data(1, ad));

  db.set_cc_auction_ended(1, false);
  DB_TESTS_ASSERT(db.get_cc_auction_data(1, ad));

  db.remove_cc_auction_bid(1, 3, 400, 300);
  db.remove_cc_auction_bid(1, 2, 200, 200);
  DB_TESTS_ASSERT(db.get_cc_auction_data(1, ad));
  DB_TESTS_ASSERT(ad.bids.empty());

  db.remove_cc_auction(1);
  DB_TESTS_ASSERT(!db.get_cc_auction_data(0, ad));
  DB_TESTS_ASSERT(!db.get_cc_auction_data(1, ad));

  return true;
}

bool db_tests_cc_hunt(cryptonote::BlockchainDB &db)
{
  uint32_t moose, bears;
  DB_TESTS_EXCEPTION(db.get_last_cc_hunt(moose, bears));
  DB_TESTS_EXCEPTION(db.remove_last_cc_hunt());
  db.add_cc_hunt(123, 456);
  db.get_last_cc_hunt(moose, bears);
  DB_TESTS_ASSERT(moose == 123);
  DB_TESTS_ASSERT(bears == 456);
  db.add_cc_hunt(555, 888);
  db.get_last_cc_hunt(moose, bears);
  DB_TESTS_ASSERT(moose == 555);
  DB_TESTS_ASSERT(bears == 888);
  db.remove_last_cc_hunt();
  db.get_last_cc_hunt(moose, bears);
  DB_TESTS_ASSERT(moose == 123);
  DB_TESTS_ASSERT(bears == 456);
  db.remove_last_cc_hunt();
  DB_TESTS_EXCEPTION(db.get_last_cc_hunt(moose, bears));
  DB_TESTS_EXCEPTION(db.remove_last_cc_hunt());
  db.add_cc_hunt(789, 111);
  db.get_last_cc_hunt(moose, bears);
  DB_TESTS_ASSERT(moose == 789);
  DB_TESTS_ASSERT(bears == 111);
  db.remove_last_cc_hunt();
  DB_TESTS_EXCEPTION(db.get_last_cc_hunt(moose, bears));

  return true;
}

bool db_tests_cc_trade_used(cryptonote::BlockchainDB &db)
{
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  db.set_cc_trade_used(8, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  db.set_cc_trade_used(8, 5);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 5);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  db.set_cc_trade_used(8, 6);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 6);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  db.set_cc_trade_used(9, 2);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 6);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 2);
  db.set_cc_trade_used(9, 1);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 6);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 1);
  db.set_cc_trade_used(8, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 1);
  db.set_cc_trade_used(9, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(0x1234567890ull) == 0);
  db.set_cc_trade_used(0x1234567890ull, 3);
  DB_TESTS_ASSERT(db.get_cc_trade_used(0x1234567890ull) == 3);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  db.set_cc_trade_used(9, 2);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 2);
  db.set_cc_trade_used(8, 3);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 3);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 2);
  db.set_cc_trade_used(8, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 2);
  db.set_cc_trade_used(9, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(8) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(9) == 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(0x1234567890ull) == 3);
  db.set_cc_trade_used(0x1234567890ull, 0);
  DB_TESTS_ASSERT(db.get_cc_trade_used(0x1234567890ull) == 0);

  return true;
}

bool db_tests_cc_used_nonces(cryptonote::BlockchainDB &db)
{
  crypto::hash h = crypto::null_hash, hq;
  h.data[0] = 4;
  std::vector<uint32_t> a, aq;
  a.push_back(2);
  a.push_back(3);

  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, &aq, &hq));
  db.add_cc_used_nonce(1, h);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(hq == h);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(aq.empty());

  unsigned seen = 0;
  db.for_all_cc_nonces_used([&seen, &h, &a](uint64_t nonce, const std::vector<uint32_t> &accounts, const crypto::hash &txid){
    seen++;
    DB_TESTS_ASSERT(accounts.empty());
    DB_TESTS_ASSERT(txid == h);
    return true;
  });
  DB_TESTS_ASSERT(seen == 1);

  db.remove_cc_used_nonce(1);
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(!db.is_cc_nonce_used(1, &aq, &hq));

  seen = 0;
  db.for_all_cc_nonces_used([&seen](uint64_t nonce, const std::vector<uint32_t> &accounts, const crypto::hash &txid){ seen++; return true; });
  DB_TESTS_ASSERT(seen == 0);

  db.add_cc_used_nonce(1, a);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(hq == crypto::null_hash);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(aq == a);

  seen = 0;
  db.for_all_cc_nonces_used([&seen, &h, &a](uint64_t nonce, const std::vector<uint32_t> &accounts, const crypto::hash &txid){
    seen++;
    DB_TESTS_ASSERT(accounts == a);
    DB_TESTS_ASSERT(txid == crypto::null_hash);
    return true;
  });
  DB_TESTS_ASSERT(seen == 1);

  db.add_cc_used_nonce(1, h);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(hq == h);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(aq == a);

  seen = 0;
  db.for_all_cc_nonces_used([&seen, &h, &a](uint64_t nonce, const std::vector<uint32_t> &accounts, const crypto::hash &txid){
    seen++;
    DB_TESTS_ASSERT(accounts == a);
    DB_TESTS_ASSERT(txid == h);
    return true;
  });
  DB_TESTS_ASSERT(seen == 1);

  db.add_cc_used_nonce(1, crypto::null_hash);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1));
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, NULL, &hq));
  DB_TESTS_ASSERT(hq == crypto::null_hash);
  DB_TESTS_ASSERT(db.is_cc_nonce_used(1, &aq, NULL));
  DB_TESTS_ASSERT(aq == a);

  seen = 0;
  db.for_all_cc_nonces_used([&seen, &h, &a](uint64_t nonce, const std::vector<uint32_t> &accounts, const crypto::hash &txid){
    seen++;
    DB_TESTS_ASSERT(accounts == a);
    DB_TESTS_ASSERT(txid == crypto::null_hash);
    return true;
  });
  DB_TESTS_ASSERT(seen == 1);

  return true;
}

bool db_tests_cc_whispers(cryptonote::BlockchainDB &db)
{
  cc::whisper_t whisper;
  whisper.city = 1;
  whisper.expiration = 1;
  whisper.id = 0x42;
  whisper.x = whisper.y = whisper.z = 1;
  whisper.rx = whisper.ry = 2;
  whisper.red = whisper.green = whisper.blue = 3;
  whisper.message = "test 0x42";

  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(0, [](const cc::whisper_t&) { DB_TESTS_ASSERT(false); return true; }));
  DB_TESTS_EXCEPTION(db.remove_cc_whisper(whisper));

  db.add_cc_whisper(whisper);
  int seen = 0;
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(0, [](const cc::whisper_t&) { DB_TESTS_ASSERT(false); return true; }));
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(1, [&seen, &whisper](const cc::whisper_t &w) { DB_TESTS_ASSERT(w == whisper); ++seen; return true; }));
  DB_TESTS_ASSERT(seen == 1);

  ++whisper.id;
  DB_TESTS_EXCEPTION(db.remove_cc_whisper(whisper));
  --whisper.id;
  db.remove_cc_whisper(whisper);

  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(0, [](const cc::whisper_t&) { DB_TESTS_ASSERT(false); return true; }));
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(1, [](const cc::whisper_t&) { DB_TESTS_ASSERT(false); return true; }));

  db.add_cc_whisper(whisper);
  ++whisper.id;
  whisper.city = 0;
  db.add_cc_whisper(whisper);
  ++whisper.id;
  ++whisper.expiration;
  whisper.city = 1;
  db.add_cc_whisper(whisper);

  // there's now 0x42 (exp 1) and 0x44 (exp 2) in 1, and 0x43 (exp 1) in 0

  seen = 0;
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(0, [&seen](const cc::whisper_t &w) { DB_TESTS_ASSERT(w.id == 0x43); ++seen; return true; }));
  DB_TESTS_ASSERT(seen == 1);
  seen = 0;
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(1, [&seen](const cc::whisper_t &w) { DB_TESTS_ASSERT(w.id == 0x42 || w.id == 0x44); ++seen; return true; }));
  DB_TESTS_ASSERT(seen == 2);

  whisper.id -= 2;
  whisper.city = 1;
  --whisper.expiration;

  db.add_block({}, 100, 100, 100, 100, 2);

  seen = 0;
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(0, [&seen](const cc::whisper_t &w) { DB_TESTS_ASSERT(false); return true; }));
  DB_TESTS_ASSERT(seen == 0);
  seen = 0;
  DB_TESTS_ASSERT(db.for_all_active_cc_whispers(1, [&seen](const cc::whisper_t &w) { DB_TESTS_ASSERT(w.id == 0x44); ++seen; return true; }));
  DB_TESTS_ASSERT(seen == 1);

  return true;
}