aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rwxr-xr-xtests/block_weight/block_weight.py5
-rw-r--r--tests/core_tests/bulletproofs.h2
-rw-r--r--tests/core_tests/chaingen.h23
-rw-r--r--tests/core_tests/multisig.h2
-rw-r--r--tests/core_tests/rct.h2
-rw-r--r--tests/core_tests/wallet_tools.cpp2
-rw-r--r--tests/difficulty/difficulty.cpp5
-rwxr-xr-xtests/functional_tests/blockchain.py14
-rw-r--r--tests/hash-target.cpp3
-rw-r--r--tests/hash/main.cpp4
-rw-r--r--tests/libwallet_api_tests/main.cpp3
-rw-r--r--tests/trezor/daemon.cpp8
-rw-r--r--tests/trezor/trezor_tests.cpp89
-rw-r--r--tests/trezor/trezor_tests.h2
-rw-r--r--tests/unit_tests/blockchain_db.cpp4
-rw-r--r--tests/unit_tests/long_term_block_weight.cpp17
-rw-r--r--tests/unit_tests/ringct.cpp120
-rw-r--r--tests/unit_tests/serialization.cpp79
18 files changed, 192 insertions, 192 deletions
diff --git a/tests/block_weight/block_weight.py b/tests/block_weight/block_weight.py
index ba533c53c..b23da3d77 100755
--- a/tests/block_weight/block_weight.py
+++ b/tests/block_weight/block_weight.py
@@ -9,7 +9,6 @@ import math
MEDIAN_WINDOW_SMALL = 100 # number of recent blocks for median computation
MEDIAN_WINDOW_BIG = 5000
-MULTIPLIER_SMALL = 1.4 # multipliers for determining weights
MULTIPLIER_BIG = 50.0
MEDIAN_THRESHOLD = 300*1000 # initial value for median (scaled kB -> B)
lcg_seed = 0
@@ -24,9 +23,9 @@ def get_median(vec):
#temp = vec
temp = sorted(vec)
if len(temp) % 2 == 1:
- return temp[len(temp)/2]
+ return temp[len(temp)//2]
else:
- return int((temp[len(temp)/2]+temp[len(temp)/2-1])/2)
+ return int((temp[len(temp)//2]+temp[len(temp)//2-1])//2)
def LCG():
global lcg_seed
diff --git a/tests/core_tests/bulletproofs.h b/tests/core_tests/bulletproofs.h
index efc751df7..f9768a316 100644
--- a/tests/core_tests/bulletproofs.h
+++ b/tests/core_tests/bulletproofs.h
@@ -97,7 +97,7 @@ template<>
struct get_test_options<gen_bp_tx_validation_base> {
const std::pair<uint8_t, uint64_t> hard_forks[4] = {std::make_pair(1, 0), std::make_pair(2, 1), std::make_pair(10, 73), std::make_pair(0, 0)};
const cryptonote::test_options test_options = {
- hard_forks
+ hard_forks, 0
};
};
diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h
index f2bcb7787..797d1207b 100644
--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@@ -643,7 +643,15 @@ public:
log_event("cryptonote::block");
cryptonote::block_verification_context bvc = AUTO_VAL_INIT(bvc);
- m_c.handle_incoming_block(t_serializable_object_to_blob(b), &b, bvc);
+ cryptonote::blobdata bd = t_serializable_object_to_blob(b);
+ std::vector<cryptonote::block> pblocks;
+ if (m_c.prepare_handle_incoming_blocks(std::vector<cryptonote::block_complete_entry>(1, {bd, {}}), pblocks))
+ {
+ m_c.handle_incoming_block(bd, &b, bvc);
+ m_c.cleanup_handle_incoming_blocks();
+ }
+ else
+ bvc.m_verifivation_failed = true;
bool r = check_block_verification_context(bvc, m_ev_index, b, m_validator);
CHECK_AND_NO_ASSERT_MES(r, false, "block verification context check failed");
return r;
@@ -666,7 +674,14 @@ public:
log_event("serialized_block");
cryptonote::block_verification_context bvc = AUTO_VAL_INIT(bvc);
- m_c.handle_incoming_block(sr_block.data, NULL, bvc);
+ std::vector<cryptonote::block> pblocks;
+ if (m_c.prepare_handle_incoming_blocks(std::vector<cryptonote::block_complete_entry>(1, {sr_block.data, {}}), pblocks))
+ {
+ m_c.handle_incoming_block(sr_block.data, NULL, bvc);
+ m_c.cleanup_handle_incoming_blocks();
+ }
+ else
+ bvc.m_verifivation_failed = true;
cryptonote::block blk;
std::stringstream ss;
@@ -748,7 +763,7 @@ template<typename t_test_class>
struct get_test_options {
const std::pair<uint8_t, uint64_t> hard_forks[2];
const cryptonote::test_options test_options = {
- hard_forks
+ hard_forks, 0
};
get_test_options():hard_forks{std::make_pair((uint8_t)1, (uint64_t)0), std::make_pair((uint8_t)0, (uint64_t)0)}{}
};
@@ -776,7 +791,7 @@ inline bool do_replay_events_get_core(std::vector<test_event_entry>& events, cry
// Hardforks can be specified in events.
v_hardforks_t hardforks;
- cryptonote::test_options test_options_tmp{};
+ cryptonote::test_options test_options_tmp{nullptr, 0};
const cryptonote::test_options * test_options_ = &gto.test_options;
if (extract_hard_forks(events, hardforks)){
hardforks.push_back(std::make_pair((uint8_t)0, (uint64_t)0)); // terminator
diff --git a/tests/core_tests/multisig.h b/tests/core_tests/multisig.h
index 1e8226d26..10fe6ffe8 100644
--- a/tests/core_tests/multisig.h
+++ b/tests/core_tests/multisig.h
@@ -84,7 +84,7 @@ template<>
struct get_test_options<gen_multisig_tx_validation_base> {
const std::pair<uint8_t, uint64_t> hard_forks[3] = {std::make_pair(1, 0), std::make_pair(4, 1), std::make_pair(0, 0)};
const cryptonote::test_options test_options = {
- hard_forks
+ hard_forks, 0
};
};
diff --git a/tests/core_tests/rct.h b/tests/core_tests/rct.h
index 72460d98e..00a2bd88c 100644
--- a/tests/core_tests/rct.h
+++ b/tests/core_tests/rct.h
@@ -83,7 +83,7 @@ template<>
struct get_test_options<gen_rct_tx_validation_base> {
const std::pair<uint8_t, uint64_t> hard_forks[4] = {std::make_pair(1, 0), std::make_pair(2, 1), std::make_pair(4, 65), std::make_pair(0, 0)};
const cryptonote::test_options test_options = {
- hard_forks
+ hard_forks, 0
};
};
diff --git a/tests/core_tests/wallet_tools.cpp b/tests/core_tests/wallet_tools.cpp
index 616774d18..d9cee34c1 100644
--- a/tests/core_tests/wallet_tools.cpp
+++ b/tests/core_tests/wallet_tools.cpp
@@ -135,7 +135,7 @@ bool wallet_tools::fill_tx_sources(tools::wallet2 * wallet, std::vector<cryptono
}
}
- MINFO("Selected " << i << " from tx: " << dump_keys(td.m_txid.data)
+ MDEBUG("Selected " << i << " from tx: " << dump_keys(td.m_txid.data)
<< " ki: " << dump_keys(td.m_key_image.data)
<< " amnt: " << td.amount()
<< " rct: " << td.is_rct()
diff --git a/tests/difficulty/difficulty.cpp b/tests/difficulty/difficulty.cpp
index 9985b8710..11ce0bd73 100644
--- a/tests/difficulty/difficulty.cpp
+++ b/tests/difficulty/difficulty.cpp
@@ -36,6 +36,7 @@
#include <algorithm>
#include <stdexcept>
+#include "misc_log_ex.h"
#include "cryptonote_config.h"
#include "cryptonote_basic/difficulty.h"
@@ -82,6 +83,8 @@ static int test_wide_difficulty(const char *filename)
}
int main(int argc, char *argv[]) {
+ TRY_ENTRY();
+
if (argc < 2) {
cerr << "Wrong arguments" << endl;
return 1;
@@ -136,4 +139,6 @@ int main(int argc, char *argv[]) {
data.clear(fstream::badbit);
}
return 0;
+
+ CATCH_ENTRY_L0("main", 1);
}
diff --git a/tests/functional_tests/blockchain.py b/tests/functional_tests/blockchain.py
index 3957200d8..56164600d 100755
--- a/tests/functional_tests/blockchain.py
+++ b/tests/functional_tests/blockchain.py
@@ -61,8 +61,8 @@ class BlockchainTest():
prev_block = res_info.top_block_hash
res_height = daemon.get_height()
assert res_height.height == height
- assert int(res_info.wide_cumulative_difficulty) == (res_info.cumulative_difficulty_top64 << 64) + res_info.cumulative_difficulty
- cumulative_difficulty = int(res_info.wide_cumulative_difficulty)
+ assert int(res_info.wide_cumulative_difficulty, 16) == (res_info.cumulative_difficulty_top64 << 64) + res_info.cumulative_difficulty
+ cumulative_difficulty = int(res_info.wide_cumulative_difficulty, 16)
# we should not see a block at height
ok = False
@@ -91,11 +91,11 @@ class BlockchainTest():
assert block_header.orphan_status == False
assert block_header.depth == blocks - n - 1
assert block_header.prev_hash == prev_block, prev_block
- assert int(block_header.wide_difficulty) == (block_header.difficulty_top64 << 64) + block_header.difficulty
- assert int(block_header.wide_cumulative_difficulty) == (block_header.cumulative_difficulty_top64 << 64) + block_header.cumulative_difficulty
+ assert int(block_header.wide_difficulty, 16) == (block_header.difficulty_top64 << 64) + block_header.difficulty
+ assert int(block_header.wide_cumulative_difficulty, 16) == (block_header.cumulative_difficulty_top64 << 64) + block_header.cumulative_difficulty
assert block_header.reward >= 600000000000 # tail emission
- cumulative_difficulty += int(block_header.wide_difficulty)
- assert cumulative_difficulty == int(block_header.wide_cumulative_difficulty)
+ cumulative_difficulty += int(block_header.wide_difficulty, 16)
+ assert cumulative_difficulty == int(block_header.wide_cumulative_difficulty, 16)
assert block_header.block_size > 0
assert block_header.block_weight >= block_header.block_size
assert block_header.long_term_weight > 0
@@ -123,7 +123,7 @@ class BlockchainTest():
assert res_getblocktemplate.expected_reward >= 600000000000
assert len(res_getblocktemplate.blocktemplate_blob) > 0
assert len(res_getblocktemplate.blockhashing_blob) > 0
- assert int(res_getblocktemplate.wide_difficulty) == (res_getblocktemplate.difficulty_top64 << 64) + res_getblocktemplate.difficulty
+ assert int(res_getblocktemplate.wide_difficulty, 16) == (res_getblocktemplate.difficulty_top64 << 64) + res_getblocktemplate.difficulty
# diff etc should be the same
assert res_getblocktemplate.prev_hash == res_info.top_block_hash
diff --git a/tests/hash-target.cpp b/tests/hash-target.cpp
index 12acc5a67..1e988c302 100644
--- a/tests/hash-target.cpp
+++ b/tests/hash-target.cpp
@@ -32,6 +32,7 @@
#include <cstdlib>
#include <cstring>
#include <limits>
+#include "misc_log_ex.h"
#include "crypto/hash.h"
#include "cryptonote_basic/difficulty.h"
@@ -39,6 +40,7 @@ using namespace std;
using cryptonote::check_hash;
int main(int argc, char *argv[]) {
+ TRY_ENTRY();
crypto::hash h;
for (cryptonote::difficulty_type diff = 1;; diff += 1 + (diff >> 8)) {
for (uint16_t b = 0; b < 256; b++) {
@@ -83,4 +85,5 @@ int main(int argc, char *argv[]) {
}
}
return 0;
+ CATCH_ENTRY_L0("main", 1);
}
diff --git a/tests/hash/main.cpp b/tests/hash/main.cpp
index adf1bd9c4..d62098a60 100644
--- a/tests/hash/main.cpp
+++ b/tests/hash/main.cpp
@@ -35,6 +35,7 @@
#include <string>
#include <cfenv>
+#include "misc_log_ex.h"
#include "warnings.h"
#include "crypto/hash.h"
#include "crypto/variant2_int_sqrt.h"
@@ -89,6 +90,8 @@ int test_variant2_int_sqrt();
int test_variant2_int_sqrt_ref();
int main(int argc, char *argv[]) {
+ TRY_ENTRY();
+
hash_f *f;
hash_func *hf;
fstream input;
@@ -183,6 +186,7 @@ int main(int argc, char *argv[]) {
}
}
return error ? 1 : 0;
+ CATCH_ENTRY_L0("main", 1);
}
#if defined(__x86_64__) || (defined(_MSC_VER) && defined(_WIN64))
diff --git a/tests/libwallet_api_tests/main.cpp b/tests/libwallet_api_tests/main.cpp
index 02faae50d..c34da04b7 100644
--- a/tests/libwallet_api_tests/main.cpp
+++ b/tests/libwallet_api_tests/main.cpp
@@ -1139,6 +1139,8 @@ TEST_F(WalletManagerMainnetTest, RecoverAndRefreshWalletMainNetAsync)
int main(int argc, char** argv)
{
+ TRY_ENTRY();
+
tools::on_startup();
// we can override default values for "TESTNET_DAEMON_ADDRESS" and "WALLETS_ROOT_DIR"
@@ -1173,4 +1175,5 @@ int main(int argc, char** argv)
::testing::InitGoogleTest(&argc, argv);
Monero::WalletManagerFactory::setLogLevel(Monero::WalletManagerFactory::LogLevel_Max);
return RUN_ALL_TESTS();
+ CATCH_ENTRY_L0("main", 1);
}
diff --git a/tests/trezor/daemon.cpp b/tests/trezor/daemon.cpp
index 5e987793a..41af93f3f 100644
--- a/tests/trezor/daemon.cpp
+++ b/tests/trezor/daemon.cpp
@@ -101,6 +101,9 @@ void mock_daemon::load_params(boost::program_options::variables_map const & vm)
mock_daemon::~mock_daemon()
{
+ if(m_http_client.is_connected())
+ m_http_client.disconnect();
+
if (!m_terminated)
{
try
@@ -134,11 +137,14 @@ void mock_daemon::init()
if(m_http_client.is_connected())
m_http_client.disconnect();
- CHECK_AND_ASSERT_THROW_MES(m_http_client.set_server(rpc_addr(), boost::none), "RPC client init fail");
+ CHECK_AND_ASSERT_THROW_MES(m_http_client.set_server(rpc_addr(), boost::none, epee::net_utils::ssl_support_t::e_ssl_support_disabled), "RPC client init fail");
}
void mock_daemon::deinit()
{
+ if(m_http_client.is_connected())
+ m_http_client.disconnect();
+
try
{
m_rpc_server.deinit();
diff --git a/tests/trezor/trezor_tests.cpp b/tests/trezor/trezor_tests.cpp
index 8d5540328..a867a4047 100644
--- a/tests/trezor/trezor_tests.cpp
+++ b/tests/trezor/trezor_tests.cpp
@@ -60,13 +60,14 @@ namespace
#define HW_TREZOR_NAME "Trezor"
#define TREZOR_ACCOUNT_ORDERING &m_miner_account, &m_alice_account, &m_bob_account, &m_eve_account
-#define TREZOR_COMMON_TEST_CASE(genclass, CORE, BASE) \
+#define TREZOR_COMMON_TEST_CASE(genclass, CORE, BASE) do { \
rollback_chain(CORE, BASE.head_block()); \
{ \
genclass ctest; \
BASE.fork(ctest); \
GENERATE_AND_PLAY_INSTANCE(genclass, ctest, *(CORE)); \
- }
+ } \
+} while(0)
#define TREZOR_SETUP_CHAIN(NAME) do { \
++tests_count; \
@@ -83,6 +84,11 @@ static device_trezor_test *ensure_trezor_test_device();
static void rollback_chain(cryptonote::core * core, const cryptonote::block & head);
static void setup_chain(cryptonote::core * core, gen_trezor_base & trezor_base, std::string chain_path, bool fix_chain, const po::variables_map & vm_core);
+static long get_env_long(const char * flag_name, boost::optional<long> def = boost::none){
+ const char *env_data = getenv(flag_name);
+ return env_data ? atol(env_data) : (def ? def.get() : 0);
+}
+
int main(int argc, char* argv[])
{
TRY_ENTRY();
@@ -127,12 +133,13 @@ int main(int argc, char* argv[])
const bool heavy_tests = command_line::get_arg(vm, arg_heavy_tests);
const bool fix_chain = command_line::get_arg(vm, arg_fix_chain);
- hw::register_device(HW_TREZOR_NAME, ensure_trezor_test_device());
- // hw::trezor::register_all(); // We use our shim instead.
+ hw::register_device(HW_TREZOR_NAME, ensure_trezor_test_device()); // shim device for call tracking
// Bootstrapping common chain & accounts
- const uint8_t initial_hf = 9;
- const uint8_t max_hf = 10;
+ const uint8_t initial_hf = (uint8_t)get_env_long("TEST_MIN_HF", 11);
+ const uint8_t max_hf = (uint8_t)get_env_long("TEST_MAX_HF", 11);
+ MINFO("Test versions " << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")");
+ MINFO("Testing hardforks [" << (int)initial_hf << ", " << (int)max_hf << "]");
cryptonote::core core_obj(nullptr);
cryptonote::core * const core = &core_obj;
@@ -150,16 +157,20 @@ int main(int argc, char* argv[])
mock_daemon::default_options(vm_core);
// Transaction tests
- for(uint8_t hf=initial_hf; hf <= max_hf; ++hf)
+ for(uint8_t hf=initial_hf; hf <= max_hf + 1; ++hf)
{
- MDEBUG("Transaction tests for HF " << (int)hf);
- if (hf > initial_hf)
+ if (hf > initial_hf || hf > max_hf)
{
daemon->stop_and_deinit();
daemon = nullptr;
trezor_base.daemon(nullptr);
+ if (hf > max_hf)
+ {
+ break;
+ }
}
+ MDEBUG("Transaction tests for HF " << (int)hf);
trezor_base.set_hard_fork(hf);
TREZOR_SETUP_CHAIN(std::string("HF") + std::to_string((int)hf));
@@ -196,7 +207,6 @@ int main(int argc, char* argv[])
TREZOR_COMMON_TEST_CASE(gen_trezor_many_utxo, core, trezor_base);
}
- daemon->stop();
core->deinit();
el::Level level = (failed_tests.empty() ? el::Level::Info : el::Level::Error);
MLOG(level, "\nREPORT:");
@@ -225,6 +235,7 @@ static void rollback_chain(cryptonote::core * core, const cryptonote::block & he
crypto::hash head_hash = get_block_hash(head), cur_hash{};
uint64_t height = get_block_height(head), cur_height=0;
+ MDEBUG("Rollbacking to " << height << " to hash " << head_hash);
do {
core->get_blockchain_top(cur_height, cur_hash);
@@ -293,7 +304,7 @@ static bool init_core_replay_events(std::vector<test_event_entry>& events, crypt
// Hardforks can be specified in events.
v_hardforks_t hardforks;
- cryptonote::test_options test_options_tmp{};
+ cryptonote::test_options test_options_tmp{nullptr, 0};
const cryptonote::test_options * test_options_ = &gto.test_options;
if (extract_hard_forks(events, hardforks)){
hardforks.push_back(std::make_pair((uint8_t)0, (uint64_t)0)); // terminator
@@ -593,7 +604,7 @@ gen_trezor_base::gen_trezor_base(){
gen_trezor_base::gen_trezor_base(const gen_trezor_base &other):
m_generator(other.m_generator), m_bt(other.m_bt), m_miner_account(other.m_miner_account),
m_bob_account(other.m_bob_account), m_alice_account(other.m_alice_account), m_eve_account(other.m_eve_account),
- m_hard_forks(other.m_hard_forks), m_trezor(other.m_trezor), m_rct_config(other.m_rct_config),
+ m_hard_forks(other.m_hard_forks), m_trezor(other.m_trezor), m_rct_config(other.m_rct_config), m_top_hard_fork(other.m_top_hard_fork),
m_heavy_tests(other.m_heavy_tests), m_test_get_tx_key(other.m_test_get_tx_key), m_live_refresh_enabled(other.m_live_refresh_enabled),
m_network_type(other.m_network_type), m_daemon(other.m_daemon)
{
@@ -625,6 +636,7 @@ void gen_trezor_base::fork(gen_trezor_base & other)
other.m_events = m_events;
other.m_head = m_head;
other.m_hard_forks = m_hard_forks;
+ other.m_top_hard_fork = m_top_hard_fork;
other.m_trezor_path = m_trezor_path;
other.m_heavy_tests = m_heavy_tests;
other.m_rct_config = m_rct_config;
@@ -806,8 +818,6 @@ bool gen_trezor_base::generate(std::vector<test_event_entry>& events)
// RCT transactions, wallets have to be used
wallet_tools::process_transactions(m_wl_alice.get(), events, blk_5r, m_bt);
wallet_tools::process_transactions(m_wl_bob.get(), events, blk_5r, m_bt);
- MDEBUG("Available funds on Alice: " << get_available_funds(m_wl_alice.get()));
- MDEBUG("Available funds on Bob: " << get_available_funds(m_wl_bob.get()));
// Send Alice -> Bob, manually constructed. Simple TX test, precondition.
cryptonote::transaction tx_1;
@@ -827,7 +837,12 @@ bool gen_trezor_base::generate(std::vector<test_event_entry>& events)
CHECK_AND_ASSERT_THROW_MES(resx, "tx_1 semantics failed");
CHECK_AND_ASSERT_THROW_MES(resy, "tx_1 non-semantics failed");
- REWIND_BLOCKS_HF(events, blk_6r, blk_6, m_miner_account, CUR_HF);
+ REWIND_BLOCKS_N_HF(events, blk_6r, blk_6, m_miner_account, 10, CUR_HF);
+ wallet_tools::process_transactions(m_wl_alice.get(), events, blk_6, m_bt);
+ wallet_tools::process_transactions(m_wl_bob.get(), events, blk_6, m_bt);
+ MDEBUG("Available funds on Alice: " << get_available_funds(m_wl_alice.get()));
+ MDEBUG("Available funds on Bob: " << get_available_funds(m_wl_bob.get()));
+
m_head = blk_6r;
m_events = events;
return true;
@@ -889,15 +904,44 @@ void gen_trezor_base::load(std::vector<test_event_entry>& events)
MDEBUG("Available funds on Bob: " << get_available_funds(m_wl_bob.get()));
}
+void gen_trezor_base::rewind_blocks(std::vector<test_event_entry>& events, size_t rewind_n, uint8_t hf)
+{
+ auto & generator = m_generator; // macro shortcut
+ REWIND_BLOCKS_N_HF(events, blk_new, m_head, m_miner_account, rewind_n, hf);
+ m_head = blk_new;
+ m_events = events;
+ MDEBUG("Blocks rewound: " << rewind_n << ", #blocks: " << num_blocks(events) << ", #events: " << events.size());
+
+ wallet_tools::process_transactions(m_wl_alice.get(), events, m_head, m_bt);
+ wallet_tools::process_transactions(m_wl_bob.get(), events, m_head, m_bt);
+}
+
void gen_trezor_base::fix_hf(std::vector<test_event_entry>& events)
{
// If current test requires higher hard-fork, move it up
const auto current_hf = m_hard_forks.back().first;
- if (m_rct_config.bp_version == 2 && current_hf < 10){
+
+ if (current_hf > m_top_hard_fork)
+ {
+ throw std::runtime_error("Generated chain hardfork is higher than desired maximum");
+ }
+
+ if (m_rct_config.bp_version == 2 && m_top_hard_fork < 10)
+ {
+ throw std::runtime_error("Desired maximum is too low for BPv2");
+ }
+
+ if (current_hf < m_top_hard_fork)
+ {
auto hardfork_height = num_blocks(events);
- ADD_HARDFORK(m_hard_forks, 10, hardfork_height);
+ ADD_HARDFORK(m_hard_forks, m_top_hard_fork, hardfork_height);
add_top_hfork(events, m_hard_forks);
- MDEBUG("Hardfork height: " << hardfork_height);
+ MDEBUG("Hardfork added at height: " << hardfork_height << ", from " << (int)current_hf << " to " << (int)m_top_hard_fork);
+
+ if (current_hf < 10)
+ { // buffer blocks, add 10 to apply v10 rules
+ rewind_blocks(events, 10, m_top_hard_fork);
+ }
}
}
@@ -934,10 +978,9 @@ void gen_trezor_base::add_transactions_to_events(
{
// If current test requires higher hard-fork, move it up
const auto current_hf = m_hard_forks.back().first;
- const uint8_t tx_hf = m_rct_config.bp_version == 2 ? 10 : 9;
- if (tx_hf > current_hf){
- throw std::runtime_error("Too late for HF change");
- }
+ const uint8_t tx_hf = m_top_hard_fork;
+ CHECK_AND_ASSERT_THROW_MES(tx_hf <= current_hf, "Too late for HF change: " << (int)tx_hf << " current: " << (int)current_hf);
+ CHECK_AND_ASSERT_THROW_MES(m_rct_config.bp_version < 2 || tx_hf >= 10, "HF too low for BPv2: " << (int)tx_hf);
std::list<cryptonote::transaction> tx_list;
for(const auto & tx : txs)
@@ -1808,7 +1851,7 @@ bool wallet_api_tests::generate(std::vector<test_event_entry>& events)
CHECK_AND_ASSERT_THROW_MES(w->init(daemon()->rpc_addr(), 0), "Wallet init fail");
CHECK_AND_ASSERT_THROW_MES(w->refresh(), "Refresh fail");
uint64_t balance = w->balance(0);
- MINFO("Balance: " << balance);
+ MDEBUG("Balance: " << balance);
CHECK_AND_ASSERT_THROW_MES(w->status() == Monero::PendingTransaction::Status_Ok, "Status nok");
auto addr = get_address(m_eve_account);
diff --git a/tests/trezor/trezor_tests.h b/tests/trezor/trezor_tests.h
index bed49fec4..46eb5e6a5 100644
--- a/tests/trezor/trezor_tests.h
+++ b/tests/trezor/trezor_tests.h
@@ -84,6 +84,8 @@ public:
virtual void mine_and_test(std::vector<test_event_entry>& events);
+ virtual void rewind_blocks(std::vector<test_event_entry>& events, size_t rewind_n, uint8_t hf);
+
virtual void set_hard_fork(uint8_t hf);
crypto::hash head_hash() const { return get_block_hash(m_head); }
diff --git a/tests/unit_tests/blockchain_db.cpp b/tests/unit_tests/blockchain_db.cpp
index 4fbc21ddc..f302d7946 100644
--- a/tests/unit_tests/blockchain_db.cpp
+++ b/tests/unit_tests/blockchain_db.cpp
@@ -271,6 +271,8 @@ TYPED_TEST(BlockchainDBTest, AddBlock)
this->get_filenames();
this->init_hard_fork();
+ db_wtxn_guard guard(this->m_db);
+
// adding a block with no parent in the blockchain should throw.
// note: this shouldn't be possible, but is a good (and cheap) failsafe.
//
@@ -317,6 +319,8 @@ TYPED_TEST(BlockchainDBTest, RetrieveBlockData)
this->get_filenames();
this->init_hard_fork();
+ db_wtxn_guard guard(this->m_db);
+
ASSERT_NO_THROW(this->m_db->add_block(this->m_blocks[0], t_sizes[0], t_sizes[0], t_diffs[0], t_coins[0], this->m_txs[0]));
ASSERT_EQ(t_sizes[0], this->m_db->get_block_weight(0));
diff --git a/tests/unit_tests/long_term_block_weight.cpp b/tests/unit_tests/long_term_block_weight.cpp
index bf1368618..b7713c63a 100644
--- a/tests/unit_tests/long_term_block_weight.cpp
+++ b/tests/unit_tests/long_term_block_weight.cpp
@@ -198,9 +198,10 @@ TEST(long_term_block_weight, multi_pop)
const uint64_t effective_median = bc->get_current_cumulative_block_weight_median();
const uint64_t effective_limit = bc->get_current_cumulative_block_weight_limit();
- for (uint64_t h = 0; h < 4; ++h)
+ const uint64_t num_pop = 4;
+ for (uint64_t h = 0; h < num_pop; ++h)
{
- size_t w = h < TEST_LONG_TERM_BLOCK_WEIGHT_WINDOW ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 : bc->get_current_cumulative_block_weight_limit();
+ size_t w = bc->get_current_cumulative_block_weight_limit();
uint64_t ltw = bc->get_next_long_term_block_weight(w);
bc->get_db().add_block(std::make_pair(cryptonote::block(), ""), w, ltw, h, h, {});
ASSERT_TRUE(bc->update_next_cumulative_weight_limit());
@@ -208,10 +209,8 @@ TEST(long_term_block_weight, multi_pop)
cryptonote::block b;
std::vector<cryptonote::transaction> txs;
- bc->get_db().pop_block(b, txs);
- bc->get_db().pop_block(b, txs);
- bc->get_db().pop_block(b, txs);
- bc->get_db().pop_block(b, txs);
+ for (uint64_t h = 0; h < num_pop; ++h)
+ bc->get_db().pop_block(b, txs);
ASSERT_TRUE(bc->update_next_cumulative_weight_limit());
ASSERT_EQ(effective_median, bc->get_current_cumulative_block_weight_median());
@@ -294,9 +293,11 @@ TEST(long_term_block_weight, pop_invariant_random)
{
PREFIX(10);
- for (uint64_t h = 1; h < TEST_LONG_TERM_BLOCK_WEIGHT_WINDOW - 10; ++h)
+ for (uint64_t h = 1; h < 2 * TEST_LONG_TERM_BLOCK_WEIGHT_WINDOW - 10; ++h)
{
- size_t w = bc->get_db().height() < TEST_LONG_TERM_BLOCK_WEIGHT_WINDOW ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 : bc->get_current_cumulative_block_weight_limit();
+ lcg_seed = bc->get_db().height();
+ uint32_t r = lcg();
+ size_t w = bc->get_db().height() < TEST_LONG_TERM_BLOCK_WEIGHT_WINDOW ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 : (r % bc->get_current_cumulative_block_weight_limit());
uint64_t ltw = bc->get_next_long_term_block_weight(w);
bc->get_db().add_block(std::make_pair(cryptonote::block(), ""), w, ltw, h, h, {});
ASSERT_TRUE(bc->update_next_cumulative_weight_limit());
diff --git a/tests/unit_tests/ringct.cpp b/tests/unit_tests/ringct.cpp
index e239154cf..4d51ec434 100644
--- a/tests/unit_tests/ringct.cpp
+++ b/tests/unit_tests/ringct.cpp
@@ -143,13 +143,16 @@ TEST(ringct, range_proofs)
//ct range proofs
ctkeyV sc, pc;
ctkey sctmp, pctmp;
- //add fake input 5000
- tie(sctmp, pctmp) = ctskpkGen(6000);
+ std::vector<uint64_t> inamounts;
+ //add fake input 6000
+ inamounts.push_back(6000);
+ tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
- tie(sctmp, pctmp) = ctskpkGen(7000);
+ inamounts.push_back(7000);
+ tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
vector<xmr_amount >amounts;
@@ -173,14 +176,20 @@ TEST(ringct, range_proofs)
const rct::RCTConfig rct_config { RangeProofBorromean, 0 };
- //compute rct data with mixin 500
- rctSig s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default"));
+ //compute rct data with mixin 3 - should fail since full type with > 1 input
+ bool ok = false;
+ try { genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default")); }
+ catch(...) { ok = true; }
+ ASSERT_TRUE(ok);
+
+ //compute rct data with mixin 3
+ rctSig s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config, hw::get_device("default"));
//verify rct data
- ASSERT_TRUE(verRct(s));
+ ASSERT_TRUE(verRctSimple(s));
//decode received amount
- decodeRct(s, amount_keys[1], 1, mask, hw::get_device("default"));
+ decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
// Ring CT with failing MG sig part should not verify!
// Since sum of inputs != outputs
@@ -190,14 +199,14 @@ TEST(ringct, range_proofs)
destinations[1] = Pk;
- //compute rct data with mixin 500
- s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default"));
+ //compute rct data with mixin 3
+ s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config, hw::get_device("default"));
//verify rct data
- ASSERT_FALSE(verRct(s));
+ ASSERT_FALSE(verRctSimple(s));
//decode received amount
- decodeRct(s, amount_keys[1], 1, mask, hw::get_device("default"));
+ decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
}
TEST(ringct, range_proofs_with_fee)
@@ -206,13 +215,16 @@ TEST(ringct, range_proofs_with_fee)
//ct range proofs
ctkeyV sc, pc;
ctkey sctmp, pctmp;
- //add fake input 5000
- tie(sctmp, pctmp) = ctskpkGen(6001);
+ std::vector<uint64_t> inamounts;
+ //add fake input 6001
+ inamounts.push_back(6001);
+ tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
- tie(sctmp, pctmp) = ctskpkGen(7000);
+ inamounts.push_back(7000);
+ tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
vector<xmr_amount >amounts;
@@ -227,10 +239,6 @@ TEST(ringct, range_proofs_with_fee)
skpkGen(Sk, Pk);
destinations.push_back(Pk);
- //add txn fee for 1
- //has no corresponding destination..
- amounts.push_back(1);
-
//add output for 12500
amounts.push_back(12500);
amount_keys.push_back(hash_to_scalar(zero()));
@@ -239,14 +247,14 @@ TEST(ringct, range_proofs_with_fee)
const rct::RCTConfig rct_config { RangeProofBorromean, 0 };
- //compute rct data with mixin 500
- rctSig s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default"));
+ //compute rct data with mixin 3
+ rctSig s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 1, 3, rct_config, hw::get_device("default"));
//verify rct data
- ASSERT_TRUE(verRct(s));
+ ASSERT_TRUE(verRctSimple(s));
//decode received amount
- decodeRct(s, amount_keys[1], 1, mask, hw::get_device("default"));
+ decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
// Ring CT with failing MG sig part should not verify!
// Since sum of inputs != outputs
@@ -256,14 +264,14 @@ TEST(ringct, range_proofs_with_fee)
destinations[1] = Pk;
- //compute rct data with mixin 500
- s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default"));
+ //compute rct data with mixin 3
+ s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 500, 3, rct_config, hw::get_device("default"));
//verify rct data
- ASSERT_FALSE(verRct(s));
+ ASSERT_FALSE(verRctSimple(s));
//decode received amount
- decodeRct(s, amount_keys[1], 1, mask, hw::get_device("default"));
+ decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
}
TEST(ringct, simple)
@@ -538,10 +546,10 @@ TEST(ringct, range_proofs_accept_zero_out_middle_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
}
-TEST(ringct, range_proofs_accept_zero_in_first)
+TEST(ringct, range_proofs_accept_zero)
{
- const uint64_t inputs[] = {0, 5000};
- const uint64_t outputs[] = {5000};
+ const uint64_t inputs[] = {0};
+ const uint64_t outputs[] = {0};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
}
@@ -552,13 +560,6 @@ TEST(ringct, range_proofs_accept_zero_in_first_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
}
-TEST(ringct, range_proofs_accept_zero_in_last)
-{
- const uint64_t inputs[] = {5000, 0};
- const uint64_t outputs[] = {5000};
- EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
-}
-
TEST(ringct, range_proofs_accept_zero_in_last_simple)
{
const uint64_t inputs[] = {5000, 0};
@@ -566,13 +567,6 @@ TEST(ringct, range_proofs_accept_zero_in_last_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
}
-TEST(ringct, range_proofs_accept_zero_in_middle)
-{
- const uint64_t inputs[] = {2500, 0, 2500};
- const uint64_t outputs[] = {5000};
- EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
-}
-
TEST(ringct, range_proofs_accept_zero_in_middle_simple)
{
const uint64_t inputs[] = {2500, 0, 2500};
@@ -762,13 +756,6 @@ TEST(ringct, range_proofs_accept_1_to_N_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false,true));
}
-TEST(ringct, range_proofs_accept_N_to_1)
-{
- const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
- const uint64_t outputs[] = {5000};
- EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
-}
-
TEST(ringct, range_proofs_accept_N_to_1_simple)
{
const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
@@ -776,13 +763,6 @@ TEST(ringct, range_proofs_accept_N_to_1_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
}
-TEST(ringct, range_proofs_accept_N_to_N)
-{
- const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
- const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
- EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
-}
-
TEST(ringct, range_proofs_accept_N_to_N_simple)
{
const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
@@ -790,20 +770,6 @@ TEST(ringct, range_proofs_accept_N_to_N_simple)
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
}
-TEST(ringct, range_proofs_accept_very_long)
-{
- const size_t N=12;
- uint64_t inputs[N];
- uint64_t outputs[N];
- for (size_t n = 0; n < N; ++n) {
- inputs[n] = n;
- outputs[n] = n;
- }
- std::random_shuffle(inputs, inputs + N);
- std::random_shuffle(outputs, outputs + N);
- EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
-}
-
TEST(ringct, range_proofs_accept_very_long_simple)
{
const size_t N=12;
@@ -861,7 +827,7 @@ TEST(ringct, prooveRange_is_non_deterministic)
TEST(ringct, fee_0_valid)
{
- const uint64_t inputs[] = {1000, 1000};
+ const uint64_t inputs[] = {2000};
const uint64_t outputs[] = {2000, 0};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
}
@@ -875,7 +841,7 @@ TEST(ringct, fee_0_valid_simple)
TEST(ringct, fee_non_0_valid)
{
- const uint64_t inputs[] = {1000, 1000};
+ const uint64_t inputs[] = {2000};
const uint64_t outputs[] = {1900, 100};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
}
@@ -917,7 +883,7 @@ TEST(ringct, fee_non_0_invalid_lower_simple)
TEST(ringct, fee_burn_valid_one_out)
{
- const uint64_t inputs[] = {1000, 1000};
+ const uint64_t inputs[] = {2000};
const uint64_t outputs[] = {0, 2000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
}
@@ -931,7 +897,7 @@ TEST(ringct, fee_burn_valid_one_out_simple)
TEST(ringct, fee_burn_valid_zero_out)
{
- const uint64_t inputs[] = {1000, 1000};
+ const uint64_t inputs[] = {2000};
const uint64_t outputs[] = {2000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
}
@@ -945,7 +911,7 @@ TEST(ringct, fee_burn_valid_zero_out_simple)
static rctSig make_sig()
{
- static const uint64_t inputs[] = {1000, 1000};
+ static const uint64_t inputs[] = {2000};
static const uint64_t outputs[] = {1000, 1000};
static rct::rctSig sig = make_sample_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, true);
return sig;
@@ -1044,7 +1010,7 @@ TEST(ringct, reject_gen_simple_ver_non_simple)
TEST(ringct, reject_gen_non_simple_ver_simple)
{
- const uint64_t inputs[] = {1000, 1000};
+ const uint64_t inputs[] = {2000};
const uint64_t outputs[] = {1000, 1000};
rct::rctSig sig = make_sample_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, true);
ASSERT_FALSE(rct::verRctSimple(sig));
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index 27b14ffff..23f028464 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -477,7 +477,7 @@ TEST(Serialization, serializes_ringct_types)
rct::ecdhTuple ecdh0, ecdh1;
rct::boroSig boro0, boro1;
rct::mgSig mg0, mg1;
- rct::rangeSig rg0, rg1;
+ rct::Bulletproof bp0, bp1;
rct::rctSig s0, s1;
cryptonote::transaction tx0, tx1;
@@ -566,12 +566,15 @@ TEST(Serialization, serializes_ringct_types)
ASSERT_TRUE(!memcmp(&boro0, &boro1, sizeof(boro0)));
// create a full rct signature to use its innards
+ vector<uint64_t> inamounts;
rct::ctkeyV sc, pc;
rct::ctkey sctmp, pctmp;
- tie(sctmp, pctmp) = rct::ctskpkGen(6000);
+ inamounts.push_back(6000);
+ tie(sctmp, pctmp) = rct::ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
- tie(sctmp, pctmp) = rct::ctskpkGen(7000);
+ inamounts.push_back(7000);
+ tie(sctmp, pctmp) = rct::ctskpkGen(inamounts.back());
sc.push_back(sctmp);
pc.push_back(pctmp);
vector<uint64_t> amounts;
@@ -588,9 +591,9 @@ TEST(Serialization, serializes_ringct_types)
amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
rct::skpkGen(Sk, Pk);
destinations.push_back(Pk);
- //compute rct data with mixin 500
+ //compute rct data with mixin 3
const rct::RCTConfig rct_config{ rct::RangeProofPaddedBulletproof, 0 };
- s0 = rct::genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default"));
+ s0 = rct::genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config, hw::get_device("default"));
mg0 = s0.p.MGs[0];
ASSERT_TRUE(serialization::dump_binary(mg0, blob));
@@ -605,66 +608,12 @@ TEST(Serialization, serializes_ringct_types)
// mixRing and II are not serialized, they are meant to be reconstructed
ASSERT_TRUE(mg1.II.empty());
- rg0 = s0.p.rangeSigs.front();
- ASSERT_TRUE(serialization::dump_binary(rg0, blob));
- ASSERT_TRUE(serialization::parse_binary(blob, rg1));
- ASSERT_TRUE(!memcmp(&rg0, &rg1, sizeof(rg0)));
-
-#if 0
- ASSERT_TRUE(serialization::dump_binary(s0, blob));
- ASSERT_TRUE(serialization::parse_binary(blob, s1));
- ASSERT_TRUE(s0.type == s1.type);
- ASSERT_TRUE(s0.p.rangeSigs.size() == s1.p.rangeSigs.size());
- for (size_t n = 0; n < s0.p.rangeSigs.size(); ++n)
- {
- ASSERT_TRUE(!memcmp(&s0.p.rangeSigs[n], &s1.p.rangeSigs[n], sizeof(s0.p.rangeSigs[n])));
- }
- ASSERT_TRUE(s0.p.MGs.size() == s1.p.MGs.size());
- ASSERT_TRUE(s0.p.MGs[0].ss.size() == s1.p.MGs[0].ss.size());
- for (size_t n = 0; n < s0.p.MGs[0].ss.size(); ++n)
- {
- ASSERT_TRUE(s0.p.MGs[0].ss[n] == s1.p.MGs[0].ss[n]);
- }
- ASSERT_TRUE(s0.p.MGs[0].cc == s1.p.MGs[0].cc);
- // mixRing and II are not serialized, they are meant to be reconstructed
- ASSERT_TRUE(s1.p.MGs[0].II.empty());
-
- // mixRing and II are not serialized, they are meant to be reconstructed
- ASSERT_TRUE(s1.mixRing.size() == 0);
-
- ASSERT_TRUE(s0.ecdhInfo.size() == s1.ecdhInfo.size());
- for (size_t n = 0; n < s0.ecdhInfo.size(); ++n)
- {
- ASSERT_TRUE(!memcmp(&s0.ecdhInfo[n], &s1.ecdhInfo[n], sizeof(s0.ecdhInfo[n])));
- }
- ASSERT_TRUE(s0.outPk.size() == s1.outPk.size());
- for (size_t n = 0; n < s0.outPk.size(); ++n)
- {
- // serialization only does the mask
- ASSERT_TRUE(!memcmp(&s0.outPk[n].mask, &s1.outPk[n].mask, sizeof(s0.outPk[n].mask)));
- }
-#endif
-
- tx0.set_null();
- tx0.version = 2;
- cryptonote::txin_to_key txin_to_key1{};
- txin_to_key1.amount = 100;
- txin_to_key1.key_offsets.resize(4);
- cryptonote::txin_to_key txin_to_key2{};
- txin_to_key2.amount = 200;
- txin_to_key2.key_offsets.resize(4);
- tx0.vin.push_back(txin_to_key1);
- tx0.vin.push_back(txin_to_key2);
- tx0.vout.push_back(cryptonote::tx_out());
- tx0.vout.push_back(cryptonote::tx_out());
- tx0.rct_signatures = s0;
- ASSERT_EQ(tx0.rct_signatures.p.rangeSigs.size(), 2);
- ASSERT_TRUE(serialization::dump_binary(tx0, blob));
- ASSERT_TRUE(serialization::parse_binary(blob, tx1));
- ASSERT_EQ(tx1.rct_signatures.p.rangeSigs.size(), 2);
- std::string blob2;
- ASSERT_TRUE(serialization::dump_binary(tx1, blob2));
- ASSERT_TRUE(blob == blob2);
+ ASSERT_FALSE(s0.p.bulletproofs.empty());
+ bp0 = s0.p.bulletproofs.front();
+ ASSERT_TRUE(serialization::dump_binary(bp0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, bp1));
+ bp1.V = bp0.V; // this is not saved, as it is reconstructed from other tx data
+ ASSERT_EQ(bp0, bp1);
}
TEST(Serialization, portability_wallet)
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 15:40:02 +0000