tiamak/salvium
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix unit-tests

Browse Source
This commit is contained in:
akildemir
2025-03-31 10:49:39 +03:00
parent 0418bfee30
commit 0f97ec9ea7
35 changed files with 639 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit_tests/serialization.cpp
+279 -254
View File
@@ -135,6 +135,33 @@ namespace example_namespace
}
}
// copied from wallet2::decrypt
std::string decrypt(const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated)
{
const size_t prefix_size = sizeof(chacha_iv) + (authenticated ? sizeof(crypto::signature) : 0);
if(ciphertext.size() < prefix_size)
return {};
crypto::chacha_key key;
crypto::generate_chacha_key(&skey, sizeof(skey), key, 1);
const crypto::chacha_iv &iv = *(const crypto::chacha_iv*)&ciphertext[0];
if (authenticated)
{
crypto::hash hash;
crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
crypto::public_key pkey;
crypto::secret_key_to_public_key(skey, pkey);
const crypto::signature &signature = *(const crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
if(!crypto::check_signature(hash, pkey, signature))
return {};
}
std::unique_ptr<char[]> buffer{new char[ciphertext.size() - prefix_size]};
auto wiper = epee::misc_utils::create_scope_leave_handler([&]() { memwipe(buffer.get(), ciphertext.size() - prefix_size); });
crypto::chacha20(ciphertext.data() + sizeof(iv), ciphertext.size() - prefix_size, key, iv, buffer.get());
return std::string(buffer.get(), ciphertext.size() - prefix_size);
};
TEST(Serialization, BinaryArchiveInts) {
uint64_t x = 0xff00000000, x1;
@@ -328,7 +355,7 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
// Empty tx
tx.set_null();
ASSERT_TRUE(serialization::dump_binary(tx, blob));
ASSERT_EQ(5, blob.size()); // 5 bytes + 0 bytes extra + 0 bytes signatures
ASSERT_EQ(6, blob.size()); // 6 bytes + 0 bytes extra + 0 bytes signatures
ASSERT_TRUE(serialization::parse_binary(blob, tx1));
ASSERT_EQ(tx, tx1);
ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures));
@@ -339,7 +366,7 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
tx.set_null();
tx.vin.push_back(txin_gen1);
ASSERT_TRUE(serialization::dump_binary(tx, blob));
ASSERT_EQ(7, blob.size()); // 5 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures
ASSERT_EQ(8, blob.size()); // 6 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures
ASSERT_TRUE(serialization::parse_binary(blob, tx1));
ASSERT_EQ(tx, tx1);
ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures));
@@ -348,7 +375,7 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
tx.signatures.resize(1);
tx.invalidate_hashes();
ASSERT_TRUE(serialization::dump_binary(tx, blob));
ASSERT_EQ(7, blob.size()); // 5 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures
ASSERT_EQ(8, blob.size()); // 5 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures
ASSERT_TRUE(serialization::parse_binary(blob, tx1));
ASSERT_EQ(tx, tx1);
ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures));
@@ -375,7 +402,7 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
tx.signatures.resize(0);
tx.invalidate_hashes();
ASSERT_TRUE(serialization::dump_binary(tx, blob));
ASSERT_EQ(9, blob.size()); // 5 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures
ASSERT_EQ(10, blob.size()); // 6 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures
ASSERT_TRUE(serialization::parse_binary(blob, tx1));
ASSERT_EQ(tx, tx1);
ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures));
@@ -389,7 +416,7 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
tx.signatures.resize(2);
tx.invalidate_hashes();
ASSERT_TRUE(serialization::dump_binary(tx, blob));
ASSERT_EQ(9, blob.size()); // 5 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures
ASSERT_EQ(10, blob.size()); // 6 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures
ASSERT_TRUE(serialization::parse_binary(blob, tx1));
ASSERT_EQ(tx, tx1);
ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures));
@@ -606,7 +633,7 @@ TEST(Serialization, serializes_ringct_types)
rct::skpkGen(Sk, Pk);
destinations.push_back(Pk);
//compute rct data with mixin 3
const rct::RCTConfig rct_config{ rct::RangeProofPaddedBulletproof, 2 };
const rct::RCTConfig rct_config{ rct::RangeProofPaddedBulletproof, 4 };
cryptonote::transaction_type tx_type = cryptonote::transaction_type::TRANSFER;
std::string in_asset_type = "SAL";
std::vector<std::string> destination_asset_types;
@@ -616,29 +643,33 @@ TEST(Serialization, serializes_ringct_types)
rct::salvium_data_t salvium_data;
s0 = rct::genRctSimple(rct::zero(), sc, pc, destinations, tx_type, in_asset_type, destination_asset_types, inamounts, amounts, amount_keys, 0, 3, rct_config, hw::get_device("default"), salvium_data);
ASSERT_FALSE(s0.p.MGs.empty());
ASSERT_TRUE(s0.p.CLSAGs.empty());
mg0 = s0.p.MGs[0];
ASSERT_TRUE(serialization::dump_binary(mg0, blob));
ASSERT_TRUE(serialization::parse_binary(blob, mg1));
ASSERT_TRUE(mg0.ss.size() == mg1.ss.size());
for (size_t n = 0; n < mg0.ss.size(); ++n)
{
ASSERT_TRUE(mg0.ss[n] == mg1.ss[n]);
}
ASSERT_TRUE(mg0.cc == mg1.cc);
// NOTE: Salvium doesn't have MLSAG support
// mixRing and II are not serialized, they are meant to be reconstructed
ASSERT_TRUE(mg1.II.empty());
// ASSERT_FALSE(s0.p.MGs.empty());
// ASSERT_TRUE(s0.p.CLSAGs.empty());
// mg0 = s0.p.MGs[0];
// ASSERT_TRUE(serialization::dump_binary(mg0, blob));
// ASSERT_TRUE(serialization::parse_binary(blob, mg1));
// ASSERT_TRUE(mg0.ss.size() == mg1.ss.size());
// for (size_t n = 0; n < mg0.ss.size(); ++n)
// {
// ASSERT_TRUE(mg0.ss[n] == mg1.ss[n]);
// }
// ASSERT_TRUE(mg0.cc == mg1.cc);
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);
// // mixRing and II are not serialized, they are meant to be reconstructed
// ASSERT_TRUE(mg1.II.empty());
const rct::RCTConfig rct_config_clsag{ rct::RangeProofPaddedBulletproof, 3 };
// NOTE: Salvium uses bulletproofs_plus
// 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);
const rct::RCTConfig rct_config_clsag{ rct::RangeProofPaddedBulletproof, 4 };
s0 = rct::genRctSimple(rct::zero(), sc, pc, destinations, tx_type, in_asset_type, destination_asset_types, inamounts, amounts, amount_keys, 0, 3, rct_config_clsag, hw::get_device("default"), salvium_data);
ASSERT_FALSE(s0.p.CLSAGs.empty());
@@ -660,8 +691,8 @@ TEST(Serialization, portability_wallet)
{
const cryptonote::network_type nettype = cryptonote::TESTNET;
tools::wallet2 w(nettype);
const boost::filesystem::path wallet_file = unit_test::data_dir / "wallet_9svHk1";
string password = "test";
const boost::filesystem::path wallet_file = unit_test::data_dir / "wallet_SaLvTyL";
string password = "";
bool r = false;
try
{
@@ -669,7 +700,9 @@ TEST(Serialization, portability_wallet)
r = true;
}
catch (const exception& e)
{}
{
std::cout << "Error loading wallet: " << e.what() << std::endl;
}
ASSERT_TRUE(r);
/*
fields of tools::wallet2 to be checked:
@@ -687,54 +720,55 @@ TEST(Serialization, portability_wallet)
std::vector<tools::wallet2::address_book_row> m_address_book
*/
// blockchain
ASSERT_TRUE(w.m_blockchain.size() == 1);
ASSERT_TRUE(epee::string_tools::pod_to_hex(w.m_blockchain[0]) == "48ca7cd3c8de5b6a4d53d2861fbdaedca141553559f9be9520068053cda8430b");
ASSERT_EQ(w.m_blockchain.size(), 788);
ASSERT_EQ(epee::string_tools::pod_to_hex(w.m_blockchain[787]), "011141071acd1d4c5ddad37255d7c9e96757f6f53f79365113725157e1f9d5ac");
// transfers (TODO)
ASSERT_TRUE(w.m_transfers.size() == 3);
ASSERT_EQ(w.m_transfers.size(), 3);
// account public address
ASSERT_TRUE(epee::string_tools::pod_to_hex(w.m_account_public_address.m_view_public_key) == "e47d4b6df6ab7339539148c2a03ad3e2f3434e5ab2046848e1f21369a3937cad");
ASSERT_TRUE(epee::string_tools::pod_to_hex(w.m_account_public_address.m_spend_public_key) == "13daa2af00ad26a372d317195de0bdd716f7a05d33bc4d7aff1664b6ee93c060");
ASSERT_EQ(epee::string_tools::pod_to_hex(w.m_account_public_address.m_view_public_key), "80bde378b389ec10ef2830777a01603541716a6bc3e849751d291cb825aae947");
ASSERT_EQ(epee::string_tools::pod_to_hex(w.m_account_public_address.m_spend_public_key), "450a31016163e3f0e40a0b024a5d5d399bc8ef9a44d3820fe604292e84983991");
// key images
ASSERT_TRUE(w.m_key_images.size() == 3);
ASSERT_EQ(w.m_key_images.size(), 3);
{
crypto::key_image ki[3];
epee::string_tools::hex_to_pod("c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8", ki[0]);
epee::string_tools::hex_to_pod("d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0", ki[1]);
epee::string_tools::hex_to_pod("6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76", ki[2]);
epee::string_tools::hex_to_pod("f91d1661f9f82aa93d2e4b374fe953d73b7e6ede27d2601e0a73a3a9da613e5e", ki[0]);
epee::string_tools::hex_to_pod("d1a2da6d49f9045702f825960257dc6ab7d8ed6cb1cb21d9f182c6308548e888", ki[1]);
epee::string_tools::hex_to_pod("151002549667b12b9fe22d3c59e25430866f2b9ce681ce6c70227e3704c4ac3f", ki[2]);
ASSERT_EQ_MAP(0, w.m_key_images, ki[0]);
ASSERT_EQ_MAP(1, w.m_key_images, ki[1]);
ASSERT_EQ_MAP(2, w.m_key_images, ki[2]);
}
// unconfirmed txs
ASSERT_TRUE(w.m_unconfirmed_txs.size() == 0);
ASSERT_EQ(w.m_unconfirmed_txs.size(), 0);
// payments
ASSERT_TRUE(w.m_payments.size() == 2);
ASSERT_EQ(w.m_payments.size(), 2);
{
auto pd0 = w.m_payments.begin();
auto pd1 = pd0;
++pd1;
ASSERT_TRUE(epee::string_tools::pod_to_hex(pd0->first) == "0000000000000000000000000000000000000000000000000000000000000000");
ASSERT_TRUE(epee::string_tools::pod_to_hex(pd1->first) == "0000000000000000000000000000000000000000000000000000000000000000");
ASSERT_EQ(epee::string_tools::pod_to_hex(pd0->first), "0000000000000000000000000000000000000000000000000000000000000000");
ASSERT_EQ(epee::string_tools::pod_to_hex(pd1->first), "0000000000000000000000000000000000000000000000000000000000000000");
if (epee::string_tools::pod_to_hex(pd0->second.m_tx_hash) == "ec34c9bb12b99af33d49691384eee5bed9171498ff04e59516505f35d1fc5efc")
swap(pd0, pd1);
ASSERT_TRUE(epee::string_tools::pod_to_hex(pd0->second.m_tx_hash) == "15024343b38e77a1a9860dfed29921fa17e833fec837191a6b04fa7cb9605b8e");
ASSERT_TRUE(epee::string_tools::pod_to_hex(pd1->second.m_tx_hash) == "ec34c9bb12b99af33d49691384eee5bed9171498ff04e59516505f35d1fc5efc");
ASSERT_TRUE(pd0->second.m_amount == 13400845012231);
ASSERT_TRUE(pd1->second.m_amount == 1200000000000);
ASSERT_TRUE(pd0->second.m_block_height == 818424);
ASSERT_TRUE(pd1->second.m_block_height == 818522);
ASSERT_TRUE(pd0->second.m_unlock_time == 818484);
ASSERT_TRUE(pd1->second.m_unlock_time == 0);
ASSERT_TRUE(pd0->second.m_timestamp == 1483263366);
ASSERT_TRUE(pd1->second.m_timestamp == 1483272963);
ASSERT_EQ(epee::string_tools::pod_to_hex(pd0->second.m_tx_hash), "733674c4f446d73620c6300b8376c88903f29795e3fb808d43aeee0dc99a1a9e");
ASSERT_EQ(epee::string_tools::pod_to_hex(pd1->second.m_tx_hash), "857cbe184830d93a93c4a164fe492124152e0b21b3c04e8f4145ac83611c47ee");
ASSERT_EQ(pd0->second.m_amount, 1000000000);
ASSERT_EQ(pd0->second.m_block_height, 771);
ASSERT_EQ(pd0->second.m_unlock_time, 0);
ASSERT_EQ(pd0->second.m_timestamp, 1742816322);
ASSERT_EQ(pd1->second.m_block_height, 773);
ASSERT_EQ(pd1->second.m_unlock_time, 60);
ASSERT_EQ(pd1->second.m_amount, 12373394220);
ASSERT_EQ(pd1->second.m_timestamp, 1742819016);
}
// tx keys
ASSERT_TRUE(w.m_tx_keys.size() == 2);
ASSERT_EQ(w.m_tx_keys.size(), 1);
{
const std::vector<std::pair<std::string, std::string>> txid_txkey =
{
{"b9aac8c020ab33859e0c0b6331f46a8780d349e7ac17b067116e2d87bf48daad", "bf3614c6de1d06c09add5d92a5265d8c76af706f7bc6ac830d6b0d109aa87701"},
{"6e7013684d35820f66c6679197ded9329bfe0e495effa47e7b25258799858dba", "e556884246df5a787def6732c6ea38f1e092fa13e5ea98f732b99c07a6332003"},
{"29d01fde215589faf866153b538851420c0bf5e3479b58981598ac375c92f45e", "87d5a0d94d9a3a7e5c7dcffe22a5db7716c657351a0895f32b25656106dad103"},
};
for (size_t i = 0; i < txid_txkey.size(); ++i)
{
@@ -746,40 +780,41 @@ TEST(Serialization, portability_wallet)
}
}
// confirmed txs
ASSERT_TRUE(w.m_confirmed_txs.size() == 1);
ASSERT_EQ(w.m_confirmed_txs.size(), 1);
// tx notes
ASSERT_TRUE(w.m_tx_notes.size() == 2);
ASSERT_EQ(w.m_tx_notes.size(), 2);
{
crypto::hash h[2];
epee::string_tools::hex_to_pod("15024343b38e77a1a9860dfed29921fa17e833fec837191a6b04fa7cb9605b8e", h[0]);
epee::string_tools::hex_to_pod("6e7013684d35820f66c6679197ded9329bfe0e495effa47e7b25258799858dba", h[1]);
ASSERT_EQ_MAP("sample note", w.m_tx_notes, h[0]);
ASSERT_EQ_MAP("sample note 2", w.m_tx_notes, h[1]);
epee::string_tools::hex_to_pod("857cbe184830d93a93c4a164fe492124152e0b21b3c04e8f4145ac83611c47ee", h[0]);
epee::string_tools::hex_to_pod("29d01fde215589faf866153b538851420c0bf5e3479b58981598ac375c92f45e", h[1]);
ASSERT_EQ_MAP("miner reward", w.m_tx_notes, h[0]);
ASSERT_EQ_MAP("outgoing tx", w.m_tx_notes, h[1]);
}
// unconfirmed payments
ASSERT_TRUE(w.m_unconfirmed_payments.size() == 0);
ASSERT_EQ(w.m_unconfirmed_payments.size(), 0);
// pub keys
ASSERT_TRUE(w.m_pub_keys.size() == 3);
ASSERT_EQ(w.m_pub_keys.size(), 3);
{
crypto::public_key pubkey[3];
epee::string_tools::hex_to_pod("33f75f264574cb3a9ea5b24220a5312e183d36dc321c9091dfbb720922a4f7b0", pubkey[0]);
epee::string_tools::hex_to_pod("5066ff2ce9861b1d131cf16eeaa01264933a49f28242b97b153e922ec7b4b3cb", pubkey[1]);
epee::string_tools::hex_to_pod("0d8467e16e73d16510452b78823e082e05ee3a63788d40de577cf31eb555f0c8", pubkey[2]);
epee::string_tools::hex_to_pod("b7f55351c1d1ce9f2389d6f5dcc094f34e9244dd129c0c8e6415accd096a612a", pubkey[0]);
epee::string_tools::hex_to_pod("7e27f85c752652b894b9dded8df67b6b8b945a6539dbedc93c03ed0a8a9c346c", pubkey[1]);
epee::string_tools::hex_to_pod("f7c37687c942ec9896631cfc6f4f28625f64ba1d0d955363c2abfc03846e70ca", pubkey[2]);
ASSERT_EQ_MAP(0, w.m_pub_keys, pubkey[0]);
ASSERT_EQ_MAP(1, w.m_pub_keys, pubkey[1]);
ASSERT_EQ_MAP(2, w.m_pub_keys, pubkey[2]);
}
// address book
ASSERT_TRUE(w.m_address_book.size() == 1);
ASSERT_EQ(w.m_address_book.size(), 1);
{
auto address_book_row = w.m_address_book.begin();
ASSERT_TRUE(epee::string_tools::pod_to_hex(address_book_row->m_address.m_spend_public_key) == "9bc53a6ff7b0831c9470f71b6b972dbe5ad1e8606f72682868b1dda64e119fb3");
ASSERT_TRUE(epee::string_tools::pod_to_hex(address_book_row->m_address.m_view_public_key) == "49fece1ef97dc0c0f7a5e2106e75e96edd910f7e86b56e1e308cd0cf734df191");
ASSERT_TRUE(address_book_row->m_description == "testnet wallet 9y52S6");
ASSERT_EQ(epee::string_tools::pod_to_hex(address_book_row->m_address.m_spend_public_key), "450a31016163e3f0e40a0b024a5d5d399bc8ef9a44d3820fe604292e84983991");
ASSERT_EQ(epee::string_tools::pod_to_hex(address_book_row->m_address.m_view_public_key), "80bde378b389ec10ef2830777a01603541716a6bc3e849751d291cb825aae947");
ASSERT_TRUE(address_book_row->m_description == "testnet wallet 5");
}
}
#define OUTPUT_EXPORT_FILE_MAGIC "Monero output export\003"
#define OUTPUT_EXPORT_FILE_MAGIC "Salvium output export\004"
TEST(Serialization, portability_outputs)
{
// read file
@@ -789,56 +824,40 @@ TEST(Serialization, portability_outputs)
ASSERT_TRUE(r);
const size_t magiclen = strlen(OUTPUT_EXPORT_FILE_MAGIC);
ASSERT_FALSE(data.size() < magiclen || memcmp(data.data(), OUTPUT_EXPORT_FILE_MAGIC, magiclen));
// decrypt (copied from wallet2::decrypt)
auto decrypt = [] (const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated) -> string
{
const size_t prefix_size = sizeof(chacha_iv) + (authenticated ? sizeof(crypto::signature) : 0);
if(ciphertext.size() < prefix_size)
return {};
crypto::chacha_key key;
crypto::generate_chacha_key(&skey, sizeof(skey), key, 1);
const crypto::chacha_iv &iv = *(const crypto::chacha_iv*)&ciphertext[0];
std::string plaintext;
plaintext.resize(ciphertext.size() - prefix_size);
if (authenticated)
{
crypto::hash hash;
crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
crypto::public_key pkey;
crypto::secret_key_to_public_key(skey, pkey);
const crypto::signature &signature = *(const crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
if(!crypto::check_signature(hash, pkey, signature))
return {};
}
crypto::chacha8(ciphertext.data() + sizeof(iv), ciphertext.size() - prefix_size, key, iv, &plaintext[0]);
return plaintext;
};
// decrypt
crypto::secret_key view_secret_key;
epee::string_tools::hex_to_pod("339673bb1187e2f73ba7841ab6841c5553f96e9f13f8fe6612e69318db4e9d0a", view_secret_key);
epee::string_tools::hex_to_pod("b8e51dc4df86d489e71b678bd9df13fced3b790048ca85c1fa19e512b15a6d04", view_secret_key);
bool authenticated = true;
data = decrypt(std::string(data, magiclen), view_secret_key, authenticated);
ASSERT_FALSE(data.empty());
// check public view/spend keys
const size_t headerlen = 2 * sizeof(crypto::public_key);
ASSERT_FALSE(data.size() < headerlen);
const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[0];
const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[sizeof(crypto::public_key)];
ASSERT_TRUE(epee::string_tools::pod_to_hex(public_spend_key) == "13daa2af00ad26a372d317195de0bdd716f7a05d33bc4d7aff1664b6ee93c060");
ASSERT_TRUE(epee::string_tools::pod_to_hex(public_view_key) == "e47d4b6df6ab7339539148c2a03ad3e2f3434e5ab2046848e1f21369a3937cad");
ASSERT_EQ(epee::string_tools::pod_to_hex(public_spend_key), "450a31016163e3f0e40a0b024a5d5d399bc8ef9a44d3820fe604292e84983991");
ASSERT_EQ(epee::string_tools::pod_to_hex(public_view_key), "80bde378b389ec10ef2830777a01603541716a6bc3e849751d291cb825aae947");
// import outputs
r = false;
std::vector<tools::wallet2::transfer_details> outputs;
std::tuple<uint64_t, uint64_t, std::vector<tools::wallet2::exported_transfer_details>> new_outputs;
try
{
std::istringstream iss(std::string(data, headerlen));
boost::archive::portable_binary_iarchive ar(iss);
ar >> outputs;
r = true;
std::string body(data, headerlen);
binary_archive<false> ar{epee::strspan<std::uint8_t>(body)};
if (::serialization::serialize(ar, new_outputs))
if (::serialization::check_stream_state(ar))
r = true;
}
catch (const std::exception &e)
{
std::cout << "Error importing outputs: " << e.what() << std::endl;
}
catch (...)
{}
ASSERT_TRUE(r);
/*
fields of tools::wallet2::transfer_details to be checked:
fields of tools::wallet2::exported_transfer_details to be checked:
uint64_t m_block_height
cryptonote::transaction_prefix m_tx // TODO
crypto::hash m_txid
@@ -853,81 +872,77 @@ TEST(Serialization, portability_outputs)
bool m_key_image_known
size_t m_pk_index
*/
const auto outputs = std::get<2>(new_outputs);
ASSERT_TRUE(outputs.size() == 3);
auto& td0 = outputs[0];
auto& td1 = outputs[1];
auto& td2 = outputs[2];
ASSERT_TRUE(td0.m_block_height == 818424);
ASSERT_TRUE(td1.m_block_height == 818522);
ASSERT_TRUE(td2.m_block_height == 818522);
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_txid) == "15024343b38e77a1a9860dfed29921fa17e833fec837191a6b04fa7cb9605b8e");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_txid) == "ec34c9bb12b99af33d49691384eee5bed9171498ff04e59516505f35d1fc5efc");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_txid) == "6e7013684d35820f66c6679197ded9329bfe0e495effa47e7b25258799858dba");
ASSERT_TRUE(td0.m_internal_output_index == 0);
ASSERT_TRUE(td1.m_internal_output_index == 0);
ASSERT_TRUE(td2.m_internal_output_index == 1);
ASSERT_TRUE(td0.m_global_output_index == 19642);
ASSERT_TRUE(td1.m_global_output_index == 19757);
ASSERT_TRUE(td2.m_global_output_index == 19760);
ASSERT_TRUE (td0.m_spent);
ASSERT_FALSE(td1.m_spent);
ASSERT_FALSE(td2.m_spent);
ASSERT_TRUE(td0.m_spent_height == 0);
ASSERT_TRUE(td1.m_spent_height == 0);
ASSERT_TRUE(td2.m_spent_height == 0);
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_key_image) == "c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_key_image) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_key_image) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_mask) == "0100000000000000000000000000000000000000000000000000000000000000");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_mask) == "d3997a7b27fa199a377643b88cbd3f20f447496746dabe92d288730ecaeda007");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
ASSERT_TRUE(td0.m_amount == 13400845012231);
ASSERT_TRUE(td1.m_amount == 1200000000000);
ASSERT_TRUE(td2.m_amount == 11066009260865);
ASSERT_TRUE(td0.m_rct);
ASSERT_TRUE(td1.m_rct);
ASSERT_TRUE(td2.m_rct);
ASSERT_TRUE(td0.m_key_image_known);
ASSERT_TRUE(td1.m_key_image_known);
ASSERT_TRUE(td2.m_key_image_known);
ASSERT_TRUE(td0.m_pk_index == 0);
ASSERT_TRUE(td1.m_pk_index == 0);
ASSERT_TRUE(td2.m_pk_index == 0);
ASSERT_EQ(td0.m_internal_output_index, 1);
ASSERT_EQ(td1.m_internal_output_index, 0);
ASSERT_EQ(td2.m_internal_output_index, 0);
ASSERT_EQ(td0.m_global_output_index, 775);
ASSERT_EQ(td1.m_global_output_index, 777);
ASSERT_EQ(td2.m_global_output_index, 790);
ASSERT_EQ(epee::string_tools::pod_to_hex(td0.m_pubkey), "b7f55351c1d1ce9f2389d6f5dcc094f34e9244dd129c0c8e6415accd096a612a");
ASSERT_EQ(epee::string_tools::pod_to_hex(td1.m_pubkey), "7e27f85c752652b894b9dded8df67b6b8b945a6539dbedc93c03ed0a8a9c346c");
ASSERT_EQ(epee::string_tools::pod_to_hex(td2.m_pubkey), "f7c37687c942ec9896631cfc6f4f28625f64ba1d0d955363c2abfc03846e70ca");
ASSERT_EQ(epee::string_tools::pod_to_hex(td0.m_tx_pubkey), "875e4f85fdf604d1f5531a5789b53662088f67686dc3d078e264c94ecba8d57b");
ASSERT_EQ(epee::string_tools::pod_to_hex(td1.m_tx_pubkey), "ece1f956db0c5d41bf23e448bd36c4d8749d1b11190f810cd5bd8f27d51e52e7");
ASSERT_EQ(epee::string_tools::pod_to_hex(td2.m_tx_pubkey), "63361169176f57185a1435a426a93a1936c78c117271b852e3b8fdb58d5a7d7a");
ASSERT_EQ(td0.m_amount, 1000000000);
ASSERT_EQ(td1.m_amount, 12373394220);
ASSERT_EQ(td2.m_amount, 499051520);
ASSERT_TRUE(td0.m_flags.m_rct);
ASSERT_TRUE(td1.m_flags.m_rct);
ASSERT_TRUE(td2.m_flags.m_rct);
ASSERT_TRUE(td0.m_flags.m_key_image_known);
ASSERT_TRUE(td1.m_flags.m_key_image_known);
ASSERT_TRUE(td2.m_flags.m_key_image_known);
ASSERT_TRUE (td0.m_flags.m_spent);
ASSERT_FALSE(td1.m_flags.m_spent);
ASSERT_FALSE(td2.m_flags.m_spent);
ASSERT_EQ(td0.m_subaddr_index_major, 0);
ASSERT_EQ(td1.m_subaddr_index_major, 0);
ASSERT_EQ(td2.m_subaddr_index_major, 0);
ASSERT_EQ(td0.m_subaddr_index_minor, 0);
ASSERT_EQ(td1.m_subaddr_index_minor, 0);
ASSERT_EQ(td2.m_subaddr_index_minor, 0);
}
struct unsigned_tx_set
{
std::vector<tools::wallet2::tx_construction_data> txes;
tools::wallet2::transfer_container transfers;
};
template <class Archive>
inline void serialize(Archive &a, unsigned_tx_set &x, const boost::serialization::version_type ver)
{
a & x.txes;
a & x.transfers;
}
#define UNSIGNED_TX_PREFIX "Monero unsigned tx set\003"
#define UNSIGNED_TX_PREFIX "Salvium unsigned tx set\005"
TEST(Serialization, portability_unsigned_tx)
{
const boost::filesystem::path filename = unit_test::data_dir / "unsigned_monero_tx";
const boost::filesystem::path filename = unit_test::data_dir / "unsigned_salvium_tx";
std::string s;
const cryptonote::network_type nettype = cryptonote::TESTNET;
bool r = epee::file_io_utils::load_file_to_string(filename.string(), s);
ASSERT_TRUE(r);
const size_t magiclen = strlen(UNSIGNED_TX_PREFIX);
ASSERT_FALSE(strncmp(s.c_str(), UNSIGNED_TX_PREFIX, magiclen));
unsigned_tx_set exported_txs;
s = s.substr(magiclen);
// decrypt
crypto::secret_key view_secret_key;
epee::string_tools::hex_to_pod("b8e51dc4df86d489e71b678bd9df13fced3b790048ca85c1fa19e512b15a6d04", view_secret_key);
bool authenticated = true;
s = decrypt(s, view_secret_key, authenticated);
ASSERT_FALSE(s.empty());
r = false;
tools::wallet2::unsigned_tx_set exported_txs;
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> exported_txs;
r = true;
binary_archive<false> ar{epee::strspan<std::uint8_t>(s)};
r = ::serialization::serialize(ar, exported_txs);
}
catch (const std::exception &e)
{
std::cout << "Error importing unsigned tx: " << e.what() << std::endl;
}
catch (...)
{}
ASSERT_TRUE(r);
/*
fields of tools::wallet2::unsigned_tx_set to be checked:
@@ -964,97 +979,94 @@ TEST(Serialization, portability_unsigned_tx)
ASSERT_TRUE(tcd.sources.size() == 1);
auto& tse = tcd.sources[0];
// tcd.sources[0].outputs
ASSERT_TRUE(tse.outputs.size() == 5);
ASSERT_TRUE(tse.outputs.size() == 16);
auto& out0 = tse.outputs[0];
auto& out1 = tse.outputs[1];
auto& out2 = tse.outputs[2];
auto& out3 = tse.outputs[3];
auto& out4 = tse.outputs[4];
ASSERT_TRUE(out0.first == 6295);
ASSERT_TRUE(out1.first == 14302);
ASSERT_TRUE(out2.first == 17598);
ASSERT_TRUE(out3.first == 18671);
ASSERT_TRUE(out4.first == 19760);
ASSERT_TRUE(epee::string_tools::pod_to_hex(out0.second) == "e7272cb589954ddeedd20de9411ed57265f154d41f33cec9ff69e5d642e09814096490b0ac85308342acf436cc0270d53abef9dc04c6202f2459e879bfd40ce6");
ASSERT_TRUE(epee::string_tools::pod_to_hex(out1.second) == "c3a9f49d1fe75939cc3feb39871ce0a7366c2879a63faa1a5cf34e65723b120a272ff0c7d84ab8b6ee3528d196450b0e28b3fed276bc2597a2b5b17afb9354ab");
ASSERT_TRUE(epee::string_tools::pod_to_hex(out2.second) == "176e239c8c39000c2275e2f63ed7d55c55e0843524091522bbd3d3b869044969021fad70fc1244115449d4754829ae7c47346342ee5d52a2cdd47dfc351d0ab0");
ASSERT_TRUE(epee::string_tools::pod_to_hex(out3.second) == "ef12d7946302fb064f2ba9df1a73d72233ac74664ed3b370580fa3bdc377542ad93f64898bd95851d6efe0d7bf2dbbea9b7c6b3c57e2c807e7b17d55b4622259");
ASSERT_TRUE(epee::string_tools::pod_to_hex(out4.second) == "0d8467e16e73d16510452b78823e082e05ee3a63788d40de577cf31eb555f0c8525096cbc88d00a841eed66f3cdb6f0a018e6ce9fb9433ed61afba15cbbebd04");
auto& out1 = tse.outputs[8];
auto& out2 = tse.outputs[15];
ASSERT_TRUE(out0.first == 182);
ASSERT_TRUE(out1.first == 679);
ASSERT_TRUE(out2.first == 790);
ASSERT_EQ(epee::string_tools::pod_to_hex(out0.second), "9abac9a9758f3ce2b34a013f1cb0b36d2b63d1aec75faedcaa9d93c48693445c3a0938152a55a15950354fc3415003b9b0d402e29c4fb2ddc35d9e0436c17ebe");
ASSERT_EQ(epee::string_tools::pod_to_hex(out1.second), "9f02bb13c1a60e8e44345be3cf96326bf560d2b22172b61bd7440aa3f6a96ce4fd87a9d0da769857bb18b4260564c6bf4c3a5d3a3aa0b220b793bd7760bd7e17");
ASSERT_EQ(epee::string_tools::pod_to_hex(out2.second), "f7c37687c942ec9896631cfc6f4f28625f64ba1d0d955363c2abfc03846e70caf0837c1242a48cab9e1dd5c3525579e932e9bca221bfa27e803e01d92ca0a2dc");
// tcd.sources[0].{real_output, real_out_tx_key, real_output_in_tx_index, amount, rct, mask}
ASSERT_TRUE(tse.real_output == 4);
ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.real_out_tx_key) == "4d86c7ba1c285fe4bc1cd7b54ba894fa89fa02fc6b0bbeea67d53251acd14a05");
ASSERT_TRUE(tse.real_output_in_tx_index == 1);
ASSERT_TRUE(tse.amount == 11066009260865);
ASSERT_TRUE(tse.real_output == 15);
ASSERT_EQ(epee::string_tools::pod_to_hex(tse.real_out_tx_key), "63361169176f57185a1435a426a93a1936c78c117271b852e3b8fdb58d5a7d7a");
ASSERT_TRUE(tse.real_output_in_tx_index == 0);
ASSERT_TRUE(tse.amount == 499051520);
ASSERT_TRUE(tse.rct);
ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
ASSERT_EQ(epee::string_tools::pod_to_hex(tse.mask), "d1d971dcd00b7f766d330d7c29bf8f50885c1792de6c83696caf535027dcb905");
// tcd.change_dts
ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
ASSERT_TRUE(tcd.change_dts.amount == 198103040);
ASSERT_EQ(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr), "SaLvTyLBwuJ1EPjNJ86Ezv1PDo5bLAbFcSobs9LU9it88nHNsd7XTtWMBxLNAgERE7Lz5CxyhYfeRK2TZs5AGpW7XoTZT3TAioR37");
// tcd.splitted_dsts
ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
auto& splitted_dst0 = tcd.splitted_dsts[0];
auto& splitted_dst1 = tcd.splitted_dsts[1];
ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
ASSERT_TRUE(splitted_dst0.amount == 198103040);
ASSERT_TRUE(splitted_dst1.amount == 300000000);
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "SaLvTyLBwuJ1EPjNJ86Ezv1PDo5bLAbFcSobs9LU9it88nHNsd7XTtWMBxLNAgERE7Lz5CxyhYfeRK2TZs5AGpW7XoTZT3TAioR37");
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "SaLvTyLQAH4U9sgB7vT5Na9X5UrHsf5Fp6eFpkQQ1wQyg7gRyKoiXCQ4HA8Fmg6xqdhtDWcWmrbfyTcGNPRJokqiJpkMsVpicdK1R");
// tcd.selected_transfers
ASSERT_TRUE(tcd.selected_transfers.size() == 1);
ASSERT_TRUE(tcd.selected_transfers.front() == 2);
// tcd.extra
ASSERT_TRUE(tcd.extra.size() == 68);
ASSERT_TRUE(tcd.extra.size() == 44);
// tcd.{unlock_time, use_rct}
ASSERT_TRUE(tcd.unlock_time == 0);
ASSERT_TRUE(tcd.use_rct);
// tcd.dests
ASSERT_TRUE(tcd.dests.size() == 1);
auto& dest = tcd.dests[0];
ASSERT_TRUE(dest.amount == 1400000000000);
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
ASSERT_TRUE(dest.amount == 300000000);
ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "SaLvTyLQAH4U9sgB7vT5Na9X5UrHsf5Fp6eFpkQQ1wQyg7gRyKoiXCQ4HA8Fmg6xqdhtDWcWmrbfyTcGNPRJokqiJpkMsVpicdK1R");
// transfers
ASSERT_TRUE(exported_txs.transfers.size() == 3);
auto& td0 = exported_txs.transfers[0];
auto& td1 = exported_txs.transfers[1];
auto& td2 = exported_txs.transfers[2];
ASSERT_TRUE(td0.m_block_height == 818424);
ASSERT_TRUE(td1.m_block_height == 818522);
ASSERT_TRUE(td2.m_block_height == 818522);
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_txid) == "15024343b38e77a1a9860dfed29921fa17e833fec837191a6b04fa7cb9605b8e");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_txid) == "ec34c9bb12b99af33d49691384eee5bed9171498ff04e59516505f35d1fc5efc");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_txid) == "6e7013684d35820f66c6679197ded9329bfe0e495effa47e7b25258799858dba");
ASSERT_TRUE(td0.m_internal_output_index == 0);
ASSERT_TRUE(td1.m_internal_output_index == 0);
ASSERT_TRUE(td2.m_internal_output_index == 1);
ASSERT_TRUE(td0.m_global_output_index == 19642);
ASSERT_TRUE(td1.m_global_output_index == 19757);
ASSERT_TRUE(td2.m_global_output_index == 19760);
ASSERT_TRUE (td0.m_spent);
ASSERT_FALSE(td1.m_spent);
ASSERT_FALSE(td2.m_spent);
ASSERT_TRUE(td0.m_spent_height == 0);
ASSERT_TRUE(td1.m_spent_height == 0);
ASSERT_TRUE(td2.m_spent_height == 0);
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_key_image) == "c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_key_image) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_key_image) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_mask) == "0100000000000000000000000000000000000000000000000000000000000000");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_mask) == "d3997a7b27fa199a377643b88cbd3f20f447496746dabe92d288730ecaeda007");
ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
ASSERT_TRUE(td0.m_amount == 13400845012231);
ASSERT_TRUE(td1.m_amount == 1200000000000);
ASSERT_TRUE(td2.m_amount == 11066009260865);
ASSERT_TRUE(td0.m_rct);
ASSERT_TRUE(td1.m_rct);
ASSERT_TRUE(td2.m_rct);
ASSERT_TRUE(td0.m_key_image_known);
ASSERT_TRUE(td1.m_key_image_known);
ASSERT_TRUE(td2.m_key_image_known);
ASSERT_TRUE(td0.m_pk_index == 0);
ASSERT_TRUE(td1.m_pk_index == 0);
ASSERT_TRUE(td2.m_pk_index == 0);
const auto exported_transfers = std::get<2>(exported_txs.new_transfers);
ASSERT_EQ(exported_transfers.size(), 0);
// TODO: serialization of the transfers_details doesn't seem to be supported in newer versions.
// auto& td0 = exported_transfers[0];
// auto& td1 = exported_transfers[1];
// auto& td2 = exported_transfers[2];
// std::cout << "td0.m_pubkey: " << epee::string_tools::pod_to_hex(td0.m_pubkey) << std::endl;
// std::cout << "td1.m_pubkey: " << epee::string_tools::pod_to_hex(td1.m_pubkey) << std::endl;
// std::cout << "td2.m_pubkey: " << epee::string_tools::pod_to_hex(td2.m_pubkey) << std::endl;
// std::cout << "td0.m_tx_pubkey: " << epee::string_tools::pod_to_hex(td0.m_tx_pubkey) << std::endl;
// std::cout << "td1.m_tx_pubkey: " << epee::string_tools::pod_to_hex(td1.m_tx_pubkey) << std::endl;
// std::cout << "td2.m_tx_pubkey: " << epee::string_tools::pod_to_hex(td2.m_tx_pubkey) << std::endl;
// ASSERT_TRUE(td0.m_internal_output_index == 0);
// ASSERT_TRUE(td1.m_internal_output_index == 0);
// ASSERT_TRUE(td2.m_internal_output_index == 1);
// ASSERT_TRUE(td0.m_global_output_index == 19642);
// ASSERT_TRUE(td1.m_global_output_index == 19757);
// ASSERT_TRUE(td2.m_global_output_index == 19760);
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_pubkey) == "c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8");
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_pubkey) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_pubkey) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_tx_pubkey) == "0100000000000000000000000000000000000000000000000000000000000000");
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_tx_pubkey) == "d3997a7b27fa199a377643b88cbd3f20f447496746dabe92d288730ecaeda007");
// ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_tx_pubkey) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
// ASSERT_TRUE(td0.m_amount == 13400845012231);
// ASSERT_TRUE(td1.m_amount == 1200000000000);
// ASSERT_TRUE(td2.m_amount == 11066009260865);
// ASSERT_TRUE(td0.m_flags.m_rct);
// ASSERT_TRUE(td1.m_flags.m_rct);
// ASSERT_TRUE(td2.m_flags.m_rct);
// ASSERT_TRUE(td0.m_flags.m_key_image_known);
// ASSERT_TRUE(td1.m_flags.m_key_image_known);
// ASSERT_TRUE(td2.m_flags.m_key_image_known);
// ASSERT_TRUE (td0.m_flags.m_spent);
// ASSERT_FALSE(td1.m_flags.m_spent);
// ASSERT_FALSE(td2.m_flags.m_spent);
}
#define SIGNED_TX_PREFIX "Monero signed tx set\003"
// TODO: wallet2::sign_tx() needs fixing
#define SIGNED_TX_PREFIX "Salvium signed tx set\005"
/*
TEST(Serialization, portability_signed_tx)
{
const boost::filesystem::path filename = unit_test::data_dir / "signed_monero_tx";
@@ -1066,34 +1078,43 @@ TEST(Serialization, portability_signed_tx)
ASSERT_FALSE(strncmp(s.c_str(), SIGNED_TX_PREFIX, magiclen));
tools::wallet2::signed_tx_set exported_txs;
s = s.substr(magiclen);
// decrypt
crypto::secret_key view_secret_key;
epee::string_tools::hex_to_pod("b8e51dc4df86d489e71b678bd9df13fced3b790048ca85c1fa19e512b15a6d04", view_secret_key);
bool authenticated = true;
s = decrypt(s, view_secret_key, authenticated);
ASSERT_FALSE(s.empty());
r = false;
tools::wallet2::signed_tx_set exported_txs;
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> exported_txs;
r = true;
binary_archive<false> ar{epee::strspan<std::uint8_t>(s)};
r = ::serialization::serialize(ar, exported_txs);
}
catch (const std::exception &e)
{
std::cout << "Error importing signed tx: " << e.what() << std::endl;
}
catch (...)
{}
ASSERT_TRUE(r);
/*
fields of tools::wallet2::signed_tx_set to be checked:
std::vector<pending_tx> ptx
std::vector<crypto::key_image> key_images
// fields of tools::wallet2::signed_tx_set to be checked:
// std::vector<pending_tx> ptx
// std::vector<crypto::key_image> key_images
// fields of tools::walllet2::pending_tx to be checked:
// cryptonote::transaction tx // TODO
// uint64_t dust
// uint64_t fee
// bool dust_added_to_fee
// cryptonote::tx_destination_entry change_dts
// std::list<size_t> selected_transfers
// std::string key_images
// crypto::secret_key tx_key
// std::vector<cryptonote::tx_destination_entry> dests
// tx_construction_data construction_data
fields of tools::walllet2::pending_tx to be checked:
cryptonote::transaction tx // TODO
uint64_t dust
uint64_t fee
bool dust_added_to_fee
cryptonote::tx_destination_entry change_dts
std::list<size_t> selected_transfers
std::string key_images
crypto::secret_key tx_key
std::vector<cryptonote::tx_destination_entry> dests
tx_construction_data construction_data
*/
// ptx
ASSERT_TRUE(exported_txs.ptx.size() == 1);
auto& ptx = exported_txs.ptx[0];
@@ -1175,6 +1196,7 @@ TEST(Serialization, portability_signed_tx)
ASSERT_TRUE(epee::string_tools::pod_to_hex(ki1) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
ASSERT_TRUE(epee::string_tools::pod_to_hex(ki2) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
}
*/
TEST(Serialization, difficulty_type)
{
@@ -1199,6 +1221,8 @@ TEST(Serialization, difficulty_type)
ASSERT_EQ(v_original, v_unserialized);
}
// TODO: seems like this is an outdated method of doing json serialization
/*
TEST(Serialization, adl_free_function)
{
std::stringstream ss;
@@ -1210,3 +1234,4 @@ TEST(Serialization, adl_free_function)
const std::string expected = "{\"custom_fieldname\": " + std::to_string(msg.size()) + '"' + epee::string_tools::buff_to_hex_nodelimer(msg) + "\"}";
EXPECT_EQ(expected, ss.str());
}
*/