Merge pull request #961

887db9f blockchain: testnet heights for v3, v4, and v5 (moneromooo-monero)
f24ab58 ringct: remove unused code (moneromooo-monero)
b38452b ringct: pass structure by const ref, not value (moneromooo-monero)
fd11271 ringct: use memcpy/memset instead of handwritten loop where appropriate (moneromooo-monero)
5d38206 ringct: remove spurious copies (moneromooo-monero)
16732a8 rct: faster Cryptonote/rct conversions (moneromooo-monero)
fbd7c35 wallet: fix some "may be used uninitialized" warnings (moneromooo-monero)
4a41dd4 wallet: do not generate 0 change (moneromooo-monero)
a0925e6 core: use full rct signatures if just one input (moneromooo-monero)
94fd881 rct: early out on failure on verRange (moneromooo-monero)
45349b6 wallet: do not ask for duplicate histograms (moneromooo-monero)
b951bc8 wallet: transfer_selected_rct now also selects fake outs (moneromooo-monero)
4f887de increase minimum mixin to 4 on hard fork 5 (moneromooo-monero)
0815c72 core: allow v1 txes after HF 5 when sweeping unmixable outputs (moneromooo-monero)
f782d45 tests: hard fork list must end with a 0 (moneromooo-monero)
074e602 ringct: use Cryptonote serialization to hash non prunable data (moneromooo-monero)
c3b3260 New "Halfway RingCT" outputs for coinbase transactions (moneromooo-monero)
6f526cd rct: log why verification fails (moneromooo-monero)
d4b8991 rct: serialize txnFee as varint (moneromooo-monero)
d4b62a1 rct amount key modified as per luigi1111's recommendations (moneromooo-monero)
93f5c62 rct: rework v2 txes into prunable and non prunable data (moneromooo-monero)
d93746b rct: rework the verification preparation process (moneromooo-monero)
3ab2ab3 rct: change the simple flag to a type (moneromooo-monero)
c5be4b0 rct: avoid the need for the last II element (Shen Noether)
a47ceee wallet: do not store signatures in the wallet cache (moneromooo-monero)
0263dd2 core: add some locking around pool use (moneromooo-monero)
2c9d951 wallet2: factor m_spent changes (moneromooo-monero)
1303cda wallet: always use new algorithm for RPC transfers (moneromooo-monero)
b337aea rct: do not serialize senderPk - it is not used anymore (moneromooo-monero)
e5a9a47 core_tests: fix a couple pre-rct tests using rct (moneromooo-monero)
230fca2 wallet: use the prefered rct case only when enough rct outs exist (moneromooo-monero)
c27194a wallet: do not try to use rct txes a few blocks before the fork (moneromooo-monero)
1bf0698 tx_pool: log why a transaction was rejected for version checks (moneromooo-monero)
37bdf6e change fork settings to allow pre-rct txes for one more fork cycle (moneromooo-monero)
cc85cc6 simplewallet: better check_tx_key feedback (moneromooo-monero)
9b70856 rct: make the amount key derivable by a third party with the tx key (moneromooo-monero)
cf33e1a rct: do not serialize public keys in outPk (moneromooo-monero)
83ab315 wallet2_api: zero amounts are now allowed with rct (moneromooo-monero)
096ac06 wallet2_api: update on_money_{received,spent} prototypes for rct changes (moneromooo-monero)
3cb2ede rpc: send global indices along with blocks/transacions on refresh (moneromooo-monero)
414b424 core: always use the new simple rct variant (moneromooo-monero)
ce5de8b tests: add tests for wallet output selection (moneromooo-monero)
84c82cd wallet: better tx input selection (moneromooo-monero)
1e21651 rct: use the already defined H where possible (moneromooo-monero)
07d353d wallet: handle 0 change properly (moneromooo-monero)
e81a2b2 port get_tx_key/check_tx_key to rct (moneromooo-monero)
e06faef tests: add basic tests for simple rct api (moneromooo-monero)
a4d4d61 integrate simple rct api (moneromooo-monero)
1e8d37e serialization: add override for serializing bool (moneromooo-monero)
dbb5f2d ringct: optimization/cleanup of hash functions (Shen Noether)
4fd01f2 ringct: "simple" ringct variant (Shen Noether)
37c895e wallet: rct specific output selection (moneromooo-monero)
1181c57 wallet: make sweep_all work with rct txes too (moneromooo-monero)
c2ec6d3 mixable transactions must be rct for v3 (moneromooo-monero)
1017a75 wallet: factor transfer_rct code with transfer code (moneromooo-monero)
f5465d8 Condition v2 txes on v3 hard fork (moneromooo-monero)
59a66e2 move the rct commitments to the output_amounts database (moneromooo-monero)
6d0e471 rct: add the tx prefix hash into the MLSAG (moneromooo-monero)
35dce5c ringct: fix size unit mismatch calling keccak (moneromooo-monero)
20e50ec ringct: do not serialize what can be reconstructed (moneromooo-monero)
106e3dc Add rct core tests (moneromooo-monero)
ada5275 Use the supplied hard fork version in validate_miner_transaction (moneromooo-monero)
acbe06d wallet: update spent status when an accepted tx disappears (moneromooo-monero)
089df4a wallet: reset output spent status on blockchain reorg (moneromooo-monero)
73d59f1 ringct: catch errors from ge_frombytes_vartime (moneromooo-monero)
161551e tests: test for ringct rctSig data sizes (moneromooo-monero)
359f469 ringct: add missing size check for ecdhInfo (moneromooo-monero)
229968e ringct: change asserts to return false for boolean functions (moneromooo-monero)
dc4aad7 add rct to the protocol (moneromooo-monero)
211d1db db_lmdb: update reset for recent db changes (moneromooo-monero)
dee42d6 ringct: add functions to commit to an amount (moneromooo-monero)
cc7f449 make rct tx serialization work (moneromooo-monero)
e70e8a6 crypto: error out where appropriate (moneromooo-monero)
54f7429 ringct: allow no outputs, and add tests for this and fees (moneromooo-monero)
e99904a ringct: make fee optional (moneromooo-monero)
f8c04ad ringct: txn fee stuff (Shen Noether)
66f9626 ringct: new {gen,decode}Rct APIs for convenience (moneromooo-monero)
789b2e2 ringct: add more convenience functions (moneromooo-monero)
9856443 core: link against libringct (moneromooo-monero)
4258dab core: new /getrandom_rctouts.bin binary RPC call (moneromooo-monero)
c3a2e14 ringct: add convenience functions to bridge ringct and cryptonote (moneromooo-monero)
eb56d0f blockchain_db: add functions for adding/removing/getting rct commitments (moneromooo-monero)
82072e7 ringct: restore verRange check in debug mode (moneromooo-monero)
63856ca ringct: add check for destinations/amount size being equal (moneromooo-monero)
e816a09 ringct: fix off by 1 in mixin usage (moneromooo-monero)
09c5ea4 ringct: simplify random key generation (moneromooo-monero)
53cdf4d tests: new ringct test for checking H2 values (Shen Noether)
56f6549 ringct: cosmetic fixes (Shen Noether)
55ff136 ringct: changes to hashToPointSimple to calcualte H2 values (Shen Noether)
63733b1 ringct: compare keys with bitwise equality, not crypto ops (Shen Noether)
98f4c6f ringct: fix size argument to cn_fast_hash (Shen Noether)
720ac85 tests: zero inputs/outputs are in fact supposed to be accepted (moneromooo-monero)
84948ea ringct: add a test for prooveRange being non deterministic (moneromooo-monero)
09fb9f4 Fix sc_0 to skGen in ProveRange (Shen Noether)
d37c1db ringct: add a few consts where appropriate (moneromooo-monero)
700248f tests: more ringct range proof tests (moneromooo-monero)
d02f999 rct: add serialization machinery to rct types (moneromooo-monero)
0ff8305 serialization: declare do_serialize specializations before use (moneromooo-monero)
8b135e7 Added note on generating H2 (Shen Noether)
4d639d9 Fixed missing last index H2 (Shen Noether)
9e82b69 remove original Cryptonote blockchain_storage blockchain format (moneromooo-monero)
86b4426 ringct: lock access to the PRNG (moneromooo-monero)
4d7f073 ringct: add simple input validation (moneromooo-monero)
57779ab tests: add some more ringct building block tests (moneromooo-monero)
b656001 ringct: add convenience operators to key (moneromooo-monero)
2d6303f tests: add Shen Noether's basic ringct tests (moneromooo-monero)
9b1afe5 ringct: import of Shen Noether's ring confidential transactions (moneromooo-monero)

1 files changed, 198 insertions, 0 deletions

diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index b110a41ab..40209f6ed 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -36,6 +36,7 @@
 #include <boost/foreach.hpp>
 #include "cryptonote_core/cryptonote_basic.h"
 #include "cryptonote_core/cryptonote_basic_impl.h"
+#include "ringct/rctSigs.h"
 #include "serialization/serialization.h"
 #include "serialization/binary_archive.h"
 #include "serialization/json_archive.h"
@@ -442,3 +443,200 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
   blob.resize(blob.size() + sizeof(crypto::signature) / 2);
   ASSERT_FALSE(serialization::parse_binary(blob, tx1));
 }
+
+TEST(Serialization, serializes_ringct_types)
+{
+  string blob;
+  rct::key key0, key1;
+  rct::keyV keyv0, keyv1;
+  rct::keyM keym0, keym1;
+  rct::ctkey ctkey0, ctkey1;
+  rct::ctkeyV ctkeyv0, ctkeyv1;
+  rct::ctkeyM ctkeym0, ctkeym1;
+  rct::ecdhTuple ecdh0, ecdh1;
+  rct::asnlSig asnl0, asnl1;
+  rct::mgSig mg0, mg1;
+  rct::rangeSig rg0, rg1;
+  rct::rctSig s0, s1;
+  cryptonote::transaction tx0, tx1;
+
+  key0 = rct::skGen();
+  ASSERT_TRUE(serialization::dump_binary(key0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, key1));
+  ASSERT_TRUE(key0 == key1);
+
+  keyv0 = rct::skvGen(30);
+  for (size_t n = 0; n < keyv0.size(); ++n)
+    keyv0[n] = rct::skGen();
+  ASSERT_TRUE(serialization::dump_binary(keyv0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, keyv1));
+  ASSERT_TRUE(keyv0.size() == keyv1.size());
+  for (size_t n = 0; n < keyv0.size(); ++n)
+  {
+    ASSERT_TRUE(keyv0[n] == keyv1[n]);
+  }
+
+  keym0 = rct::keyMInit(9, 12);
+  for (size_t n = 0; n < keym0.size(); ++n)
+    for (size_t i = 0; i < keym0[n].size(); ++i)
+      keym0[n][i] = rct::skGen();
+  ASSERT_TRUE(serialization::dump_binary(keym0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, keym1));
+  ASSERT_TRUE(keym0.size() == keym1.size());
+  for (size_t n = 0; n < keym0.size(); ++n)
+  {
+    ASSERT_TRUE(keym0[n].size() == keym1[n].size());
+    for (size_t i = 0; i < keym0[n].size(); ++i)
+    {
+      ASSERT_TRUE(keym0[n][i] == keym1[n][i]);
+    }
+  }
+
+  rct::skpkGen(ctkey0.dest, ctkey0.mask);
+  ASSERT_TRUE(serialization::dump_binary(ctkey0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, ctkey1));
+  ASSERT_TRUE(!memcmp(&ctkey0, &ctkey1, sizeof(ctkey0)));
+
+  ctkeyv0 = std::vector<rct::ctkey>(14);
+  for (size_t n = 0; n < ctkeyv0.size(); ++n)
+    rct::skpkGen(ctkeyv0[n].dest, ctkeyv0[n].mask);
+  ASSERT_TRUE(serialization::dump_binary(ctkeyv0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, ctkeyv1));
+  ASSERT_TRUE(ctkeyv0.size() == ctkeyv1.size());
+  for (size_t n = 0; n < ctkeyv0.size(); ++n)
+  {
+    ASSERT_TRUE(!memcmp(&ctkeyv0[n], &ctkeyv1[n], sizeof(ctkeyv0[n])));
+  }
+
+  ctkeym0 = std::vector<rct::ctkeyV>(9);
+  for (size_t n = 0; n < ctkeym0.size(); ++n)
+  {
+    ctkeym0[n] = std::vector<rct::ctkey>(11);
+    for (size_t i = 0; i < ctkeym0[n].size(); ++i)
+      rct::skpkGen(ctkeym0[n][i].dest, ctkeym0[n][i].mask);
+  }
+  ASSERT_TRUE(serialization::dump_binary(ctkeym0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, ctkeym1));
+  ASSERT_TRUE(ctkeym0.size() == ctkeym1.size());
+  for (size_t n = 0; n < ctkeym0.size(); ++n)
+  {
+    ASSERT_TRUE(ctkeym0[n].size() == ctkeym1[n].size());
+    for (size_t i = 0; i < ctkeym0.size(); ++i)
+    {
+      ASSERT_TRUE(!memcmp(&ctkeym0[n][i], &ctkeym1[n][i], sizeof(ctkeym0[n][i])));
+    }
+  }
+
+  ecdh0.mask = rct::skGen();
+  ecdh0.amount = rct::skGen();
+  ecdh0.senderPk = rct::skGen();
+  ASSERT_TRUE(serialization::dump_binary(ecdh0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, ecdh1));
+  ASSERT_TRUE(!memcmp(&ecdh0.mask, &ecdh1.mask, sizeof(ecdh0.mask)));
+  ASSERT_TRUE(!memcmp(&ecdh0.amount, &ecdh1.amount, sizeof(ecdh0.amount)));
+  // senderPk is not serialized
+
+  for (size_t n = 0; n < 64; ++n)
+  {
+    asnl0.L1[n] = rct::skGen();
+    asnl0.s2[n] = rct::skGen();
+  }
+  asnl0.s = rct::skGen();
+  ASSERT_TRUE(serialization::dump_binary(asnl0, blob));
+  ASSERT_TRUE(serialization::parse_binary(blob, asnl1));
+  ASSERT_TRUE(!memcmp(&asnl0, &asnl1, sizeof(asnl0)));
+
+  // create a full rct signature to use its innards
+  rct::ctkeyV sc, pc;
+  rct::ctkey sctmp, pctmp;
+  tie(sctmp, pctmp) = rct::ctskpkGen(6000);
+  sc.push_back(sctmp);
+  pc.push_back(pctmp);
+  tie(sctmp, pctmp) = rct::ctskpkGen(7000);
+  sc.push_back(sctmp);
+  pc.push_back(pctmp);
+  vector<uint64_t> amounts;
+  rct::keyV amount_keys;
+  //add output 500
+  amounts.push_back(500);
+  rct::keyV destinations;
+  rct::key Sk, Pk;
+  rct::skpkGen(Sk, Pk);
+  destinations.push_back(Pk);
+  //add output for 12500
+  amounts.push_back(12500);
+  amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+  rct::skpkGen(Sk, Pk);
+  destinations.push_back(Pk);
+  //compute rct data with mixin 500
+  s0 = rct::genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+  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);
+
+  // 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)));
+
+  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)));
+  }
+
+  tx0.set_null();
+  tx0.version = 2;
+  cryptonote::txin_to_key txin_to_key1;
+  txin_to_key1.key_offsets.resize(2);
+  cryptonote::txin_to_key txin_to_key2;
+  txin_to_key2.key_offsets.resize(2);
+  tx0.vin.push_back(txin_to_key1);
+  tx0.vin.push_back(txin_to_key2);
+  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);
+}