From 54f7429cf62ba9c8e32cf6b2a841215b1eb5b7a0 Mon Sep 17 00:00:00 2001 From: moneromooo-monero Date: Tue, 14 Jun 2016 17:15:49 +0100 Subject: [PATCH] ringct: allow no outputs, and add tests for this and fees --- src/ringct/rctSigs.cpp | 2 - tests/unit_tests/ringct.cpp | 106 +++++++++++++++++++++++++----------- 2 files changed, 75 insertions(+), 33 deletions(-) diff --git a/src/ringct/rctSigs.cpp b/src/ringct/rctSigs.cpp index a07dbaab3..7b83ca0e2 100644 --- a/src/ringct/rctSigs.cpp +++ b/src/ringct/rctSigs.cpp @@ -471,7 +471,6 @@ namespace rct { // Note: For txn fees, the last index in the amounts vector should contain that // Thus the amounts vector will be "one" longer than the destinations vectort rctSig genRct(const ctkeyV & inSk, const keyV & destinations, const vector amounts, const ctkeyM &mixRing, unsigned int index) { - CHECK_AND_ASSERT_THROW_MES(amounts.size() > 0, "Amounts must not be empty"); CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations"); CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing"); for (size_t n = 0; n < mixRing.size(); ++n) { @@ -536,7 +535,6 @@ namespace rct { // uses the attached ecdh info to find the amounts represented by each output commitment // must know the destination private key to find the correct amount, else will return a random number bool verRct(const rctSig & rv) { - CHECK_AND_ASSERT_THROW_MES(rv.rangeSigs.size() > 0, "Empty rv.rangeSigs"); CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.rangeSigs.size(), "Mismatched sizes of rv.outPk and rv.rangeSigs"); size_t i = 0; diff --git a/tests/unit_tests/ringct.cpp b/tests/unit_tests/ringct.cpp index ba9d3ecc4..c85f7ce48 100644 --- a/tests/unit_tests/ringct.cpp +++ b/tests/unit_tests/ringct.cpp @@ -275,7 +275,7 @@ TEST(ringct, range_proofs_with_fee) } static bool range_proof_test(bool expected_valid, - int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[]) + int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee) { ctkeyV sc, pc; ctkey sctmp, pctmp; @@ -292,7 +292,8 @@ static bool range_proof_test(bool expected_valid, for (int n = 0; n < n_outputs; ++n) { amounts.push_back(output_amounts[n]); skpkGen(Sk, Pk); - destinations.push_back(Pk); + if (n < n_outputs - 1 || !last_is_fee) + destinations.push_back(Pk); } //compute rct data @@ -319,189 +320,189 @@ TEST(ringct, range_proofs_reject_empty_outs) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_empty_ins) { const uint64_t inputs[] = {}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_all_empty) { const uint64_t inputs[] = {}; const uint64_t outputs[] = {}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } -TEST(ringct, range_proofs_reject_zero_empty) +TEST(ringct, range_proofs_accept_zero_empty) { const uint64_t inputs[] = {0}; const uint64_t outputs[] = {}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_empty_zero) { const uint64_t inputs[] = {}; const uint64_t outputs[] = {0}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_zero_zero) { const uint64_t inputs[] = {0}; const uint64_t outputs[] = {0}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_zero_out_first) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {0, 5000}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_zero_out_last) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {5000, 0}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_zero_out_middle) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {2500, 0, 2500}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_zero_in_first) { const uint64_t inputs[] = {0, 5000}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } 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)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } 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)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_single_lower) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {1}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_single_higher) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {5001}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_single_out_negative) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {(uint64_t)-1000ll}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_out_negative_first) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {(uint64_t)-1000ll, 6000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_out_negative_last) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {6000, (uint64_t)-1000ll}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_out_negative_middle) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_single_in_negative) { const uint64_t inputs[] = {(uint64_t)-1000ll}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_in_negative_first) { const uint64_t inputs[] = {(uint64_t)-1000ll, 6000}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_in_negative_last) { const uint64_t inputs[] = {6000, (uint64_t)-1000ll}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_in_negative_middle) { const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_reject_higher_list) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000}; - EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_1_to_1) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {5000}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_1_to_N) { const uint64_t inputs[] = {5000}; const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000}; - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } 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)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } 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)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, range_proofs_accept_very_long) @@ -515,7 +516,7 @@ TEST(ringct, range_proofs_accept_very_long) } std::random_shuffle(inputs, inputs + N); std::random_shuffle(outputs, outputs + N); - EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false)); } TEST(ringct, HPow2) @@ -579,3 +580,46 @@ TEST(ringct, prooveRange_is_non_deterministic) ASSERT_TRUE(memcmp(C[0].bytes, C[1].bytes, sizeof(C[0].bytes))); ASSERT_TRUE(memcmp(mask[0].bytes, mask[1].bytes, sizeof(mask[0].bytes))); } + +TEST(ringct, fee_0_valid) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {2000, 0}; + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} + +TEST(ringct, fee_non_0_valid) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {1900, 100}; + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} + +TEST(ringct, fee_non_0_invalid_higher) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {1990, 100}; + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} + +TEST(ringct, fee_non_0_invalid_lower) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {1000, 100}; + EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} + +TEST(ringct, fee_burn_valid_one_out) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {0, 2000}; + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} + +TEST(ringct, fee_burn_valid_zero_out) +{ + const uint64_t inputs[] = {1000, 1000}; + const uint64_t outputs[] = {2000}; + EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true)); +} +