37 #include <boost/foreach.hpp> 49 #include "gtest/gtest.h" 62 template <
class Archive>
68 ar.serialize_int(s.
a);
70 ar.serialize_int(s.
b);
72 ar.serialize_blob(s.
blob,
sizeof(s.
blob));
80 vector<boost::variant<Struct, int32_t>>
si;
126 TEST(Serialization, BinaryArchiveInts) {
134 ASSERT_EQ(
string(
"\0\0\0\0\xff\0\0\0", 8), oss.str());
136 istringstream iss(oss.str());
138 iar.serialize_int(x1);
145 TEST(Serialization, BinaryArchiveVarInts) {
153 ASSERT_EQ(
string(
"\x80\x80\x80\x80\xF0\x1F", 6), oss.str());
155 istringstream iss(oss.str());
157 iar.serialize_varint(x1);
190 TEST(Serialization, Overflow) {
191 Blob x = { 0xff00000000 };
201 vector<Blob> bigvector;
206 TEST(Serialization, serializes_vector_uint64_as_varint)
208 std::vector<uint64_t> v;
245 v.push_back(0xFFFFFFFFFFFFFFFF);
250 TEST(Serialization, serializes_vector_int64_as_fixed_int)
252 std::vector<int64_t> v;
289 v.push_back(0xFFFFFFFFFFFFFFFF);
297 std::vector<T> linearize_vector2(
const std::vector< std::vector<T> >& vec_vec)
300 BOOST_FOREACH(
const auto& vec, vec_vec)
302 res.insert(
res.end(), vec.begin(), vec.end());
308 TEST(Serialization, serializes_transacion_signatures_correctly)
328 tx.
vin.push_back(txin_gen1);
362 tx.
vin.push_back(txin_gen1);
399 tx.
vin.push_back(txin_gen1);
417 tx.
vin.push_back(txin_to_key1);
418 tx.
vin.push_back(txin_to_key1);
469 TEST(Serialization, serializes_ringct_types)
491 for (
size_t n = 0; n < keyv0.size(); ++n)
496 for (
size_t n = 0; n < keyv0.size(); ++n)
502 for (
size_t n = 0; n < keym0.size(); ++n)
503 for (
size_t i = 0; i < keym0[n].size(); ++i)
508 for (
size_t n = 0; n < keym0.size(); ++n)
511 for (
size_t i = 0; i < keym0[n].size(); ++i)
520 ASSERT_TRUE(!memcmp(&ctkey0, &ctkey1,
sizeof(ctkey0)));
522 ctkeyv0 = std::vector<rct::ctkey>(14);
523 for (
size_t n = 0; n < ctkeyv0.size(); ++n)
528 for (
size_t n = 0; n < ctkeyv0.size(); ++n)
530 ASSERT_TRUE(!memcmp(&ctkeyv0[n], &ctkeyv1[n],
sizeof(ctkeyv0[n])));
533 ctkeym0 = std::vector<rct::ctkeyV>(9);
534 for (
size_t n = 0; n < ctkeym0.size(); ++n)
536 ctkeym0[n] = std::vector<rct::ctkey>(11);
537 for (
size_t i = 0; i < ctkeym0[n].size(); ++i)
543 for (
size_t n = 0; n < ctkeym0.size(); ++n)
545 ASSERT_TRUE(ctkeym0[n].size() == ctkeym1[n].size());
546 for (
size_t i = 0; i < ctkeym0.size(); ++i)
548 ASSERT_TRUE(!memcmp(&ctkeym0[n][i], &ctkeym1[n][i],
sizeof(ctkeym0[n][i])));
559 for (
size_t n = 0; n < 64; ++n)
567 ASSERT_TRUE(!memcmp(&boro0, &boro1,
sizeof(boro0)));
570 vector<uint64_t> inamounts;
573 inamounts.push_back(6000);
577 inamounts.push_back(7000);
581 vector<uint64_t> amounts;
584 amounts.push_back(500);
589 destinations.push_back(Pk);
591 amounts.push_back(12500);
594 destinations.push_back(Pk);
597 s0 =
rct::genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config,
hw::get_device(
"default"));
603 for (
size_t n = 0; n < mg0.
ss.size(); ++n)
621 TEST(Serialization, portability_wallet)
626 string password =
"test";
630 w.
load(wallet_file.string(), password);
633 catch (
const exception& e)
679 auto pd0 = w.m_payments.begin();
694 ASSERT_TRUE(pd0->second.m_timestamp == 1529981363);
695 ASSERT_TRUE(pd1->second.m_timestamp == 1529981381);
700 const std::vector<std::pair<std::string, std::string>> txid_txkey =
702 {
"ba1deb702d98d78f589ffda136031ef355c4b27213205653f0682abc73fd2069",
"4fef24852171a1baa436975ad76f9c7fdba990fb3a817442eccf6e12d62cb200"},
703 {
"d26df736b0a0f6946d8a05596848acd531d65d57926ac64b17f0c22611f3f437",
"088732a6d90686d8999f03c8f9910c86edd6e1543e2611727a9502cbad2fa605"},
705 for (
size_t i = 0; i < txid_txkey.size(); ++i)
741 auto address_book_row = w.m_address_book.begin();
745 ASSERT_TRUE(address_book_row->m_description ==
"testnet etn wallet");
750 #define OUTPUT_EXPORT_FILE_MAGIC "Electroneum output export\003" 751 TEST(Serialization, portability_outputs)
763 const size_t prefix_size =
sizeof(chacha_iv) + (authenticated ?
sizeof(
crypto::signature) : 0);
764 if(ciphertext.size() < prefix_size)
766 crypto::chacha_key
key;
767 crypto::generate_chacha_key(&skey,
sizeof(skey),
key, 1);
768 const crypto::chacha_iv &iv = *(
const crypto::chacha_iv*)&ciphertext[0];
770 plaintext.resize(ciphertext.size() - prefix_size);
781 crypto::chacha8(ciphertext.data() +
sizeof(iv), ciphertext.size() - prefix_size,
key, iv, &plaintext[0]);
786 bool authenticated =
true;
797 std::vector<tools::wallet2::transfer_details> outputs;
800 std::istringstream iss(
std::string(data, headerlen));
825 auto& td0 = outputs[0];
826 auto& td1 = outputs[1];
827 auto& td2 = outputs[2];
834 ASSERT_EQ(td0.m_internal_output_index, 0);
835 ASSERT_EQ(td1.m_internal_output_index, 1);
836 ASSERT_EQ(td2.m_internal_output_index, 2);
838 ASSERT_EQ(td1.m_global_output_index, 11);
839 ASSERT_EQ(td2.m_global_output_index, 17);
868 std::vector<tools::wallet2::tx_construction_data>
txes;
871 template <
class Archive>
877 #define UNSIGNED_TX_PREFIX "Electroneum unsigned tx set\003" 878 TEST(Serialization, portability_unsigned_tx)
888 s = s.substr(magiclen);
892 std::istringstream iss(s);
930 auto& tcd = exported_txs.
txes[0];
933 auto& tse = tcd.sources[0];
936 auto& out0 = tse.outputs[0];
937 auto& out1 = tse.outputs[1];
938 auto& out2 = tse.outputs[2];
939 auto& out3 = tse.outputs[3];
940 auto& out4 = tse.outputs[4];
959 ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
963 auto& splitted_dst0 = tcd.splitted_dsts[0];
964 auto& splitted_dst1 = tcd.splitted_dsts[1];
965 ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
966 ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
979 auto&
dest = tcd.dests[0];
1026 #define SIGNED_TX_PREFIX "Electroneum signed tx set\003" 1027 TEST(Serialization, portability_signed_tx)
1037 s = s.substr(magiclen);
1041 std::istringstream iss(s);
1068 auto& ptx = exported_txs.
ptx[0];
1074 ASSERT_TRUE(ptx.change_dts.amount == 9631208773403);
1080 ASSERT_TRUE(ptx.key_images ==
"<6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76> ");
1084 ASSERT_TRUE(ptx.dests[0].amount == 1400000000000);
1087 auto& tcd = ptx.construction_data;
1089 auto& tse = tcd.sources[0];
1092 auto& out0 = tse.outputs[0];
1093 auto& out1 = tse.outputs[1];
1094 auto& out2 = tse.outputs[2];
1095 auto& out3 = tse.outputs[3];
1096 auto& out4 = tse.outputs[4];
1115 ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
1119 auto& splitted_dst0 = tcd.splitted_dsts[0];
1120 auto& splitted_dst1 = tcd.splitted_dsts[1];
1121 ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
1122 ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
1135 auto&
dest = tcd.dests[0];
1150 std::vector<cryptonote::difficulty_type> v_original;
1152 for(
int i = 0; i != 100; i++)
1155 if(v_original.size() > 1)
1156 v_original.back() *= v_original[v_original.size()-2];
1159 std::stringstream ss;
1163 std::vector<cryptonote::difficulty_type> v_unserialized;
1166 a2 >> v_unserialized;
rctSig genRctSimple(const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &inamounts, const vector< etn_amount > &outamounts, etn_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
std::vector< tools::wallet2::tx_construction_data > txes
std::string get_account_address_as_str(network_type nettype, bool subaddress, account_public_address const &adr)
#define ASSERT_EQ_MAP(val, map, key)
vector< boost::variant< Struct, int32_t > > si
CXA_THROW_INFO_T void(* dest)(void *))
bool try_parse(const string &blob)
tuple< ctkey, ctkey > ctskpkGen(etn_amount amount)
bool load_file_to_string(const std::string &path_to_file, std::string &target_str, size_t max_size=1000000000)
std::vector< uint64_t > key_offsets
bool parse_binary(const std::string &blob, T &v)
boost::filesystem::path data_dir
bool dump_binary(T &v, std::string &blob)
void chacha8(const void *data, size_t length, const uint8_t *key, const uint8_t *iv, char *cipher)
#define UNSIGNED_TX_PREFIX
#define END_SERIALIZE()
self-explanatory
keyM keyMInit(size_t rows, size_t cols)
#define ASSERT_FALSE(condition)
Holds cryptonote related classes and helpers.
#define ASSERT_EQ(val1, val2)
TEST(Serialization, BinaryArchiveInts)
static bool serialize(Archive &ar, Struct &s)
std::vector< txin_v > vin
crypto::public_key m_spend_public_key
for dealing with variants
void serialize_varint(T &v)
crypto::public_key m_view_public_key
void serialize(Archive &a, unsigned_tx_set &x, const boost::serialization::version_type ver)
device & get_device(const std::string &device_descriptor)
std::vector< ctkey > ctkeyV
unsigned __int64 uint64_t
#define BEGIN_SERIALIZE_OBJECT()
begins the environment of the DSL for described the serialization of an object
void hash_to_scalar(key &hash, const void *data, const std::size_t l)
void cn_fast_hash(const void *data, size_t length, char *hash)
std::vector< std::vector< crypto::signature > > signatures
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
void decrypt(const void *ciphertext, size_t length, const uint8_t *key, const uint8_t *iv, char *plaintext, size_t *plaintext_len)
... wouldn't a class be better?
boost::multiprecision::uint128_t difficulty_type
void * memcpy(void *a, const void *b, size_t c)
#define ASSERT_TRUE(condition)
crypto::key_image k_image
void skpkGen(key &sk, key &pk)
tools::wallet2::transfer_container transfers
bool operator==(const Blob &rhs) const
bool secret_key_to_public_key(const secret_key &sec, public_key &pub)
#define OUTPUT_EXPORT_FILE_MAGIC
std::vector< ctkeyV > ctkeyM
#define FIELD(f)
tags the field with the variable name and then serializes it
std::vector< Bulletproof > bulletproofs
a archive using the JSON standard
bool check_signature(const hash &prefix_hash, const public_key &pub, const signature &sig)
VARIANT_TAG(binary_archive, Struct, 0xe0)