diff --git a/tests/block_weight/block_weight.cpp b/tests/block_weight/block_weight.cpp index 17a5707..fe16b43 100644 --- a/tests/block_weight/block_weight.cpp +++ b/tests/block_weight/block_weight.cpp @@ -65,11 +65,12 @@ public: , const cryptonote::difficulty_type& cumulative_difficulty , const uint64_t& coins_generated , uint64_t num_rct_outs - , oracle::asset_type_counts& cum_rct_by_asset_type + , oracle::asset_type_counts_v2& cum_rct_by_asset_type , const crypto::hash& blk_hash , uint64_t slippage_total , uint64_t yield_total , uint64_t audit_total + , uint64_t token_total , const cryptonote::network_type nettype , cryptonote::yield_block_info& ybi , cryptonote::audit_block_info& abi diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp index f70d992..ae03d7a 100644 --- a/tests/core_tests/chaingen.cpp +++ b/tests/core_tests/chaingen.cpp @@ -87,11 +87,12 @@ namespace const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated, uint64_t num_rct_outs, - oracle::asset_type_counts& cum_rct_by_asset_type, + oracle::asset_type_counts_v2& cum_rct_by_asset_type, const crypto::hash& blk_hash, uint64_t slippage_total, uint64_t yield_total, uint64_t audit_total, + uint64_t token_total, const cryptonote::network_type nettype, cryptonote::yield_block_info& ybi, cryptonote::audit_block_info& abi @@ -178,10 +179,10 @@ static std::unique_ptr init_blockchain(const std: const block *blk = &boost::get(ev); auto blk_hash = get_block_hash(*blk); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::yield_block_info ybi; cryptonote::audit_block_info abi; - bdb->add_block(*blk, 1, 1, 1, 0, 0, num_rct_outs_by_asset_type, blk_hash, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + bdb->add_block(*blk, 1, 1, 1, 0, 0, num_rct_outs_by_asset_type, blk_hash, 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); } bool r = bap->blockchain.init(bdb, nettype, true, test_options, 2, nullptr); diff --git a/tests/data/txs/bpp_tx_e89415.bin b/tests/data/txs/bpp_tx_e89415.bin new file mode 100644 index 0000000..38f5963 Binary files /dev/null and b/tests/data/txs/bpp_tx_e89415.bin differ diff --git a/tests/data/unsigned_monero_tx b/tests/data/unsigned_monero_tx new file mode 100644 index 0000000..4e644bc Binary files /dev/null and b/tests/data/unsigned_monero_tx differ diff --git a/tests/data/wallet_9svHk1 b/tests/data/wallet_9svHk1 new file mode 100644 index 0000000..a49b6b5 Binary files /dev/null and b/tests/data/wallet_9svHk1 differ diff --git a/tests/data/wallet_9svHk1.keys b/tests/data/wallet_9svHk1.keys new file mode 100644 index 0000000..945283f Binary files /dev/null and b/tests/data/wallet_9svHk1.keys differ diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt index 93abe52..f4a0fc0 100644 --- a/tests/unit_tests/CMakeLists.txt +++ b/tests/unit_tests/CMakeLists.txt @@ -42,7 +42,9 @@ set(unit_tests_sources carrot_impl.cpp carrot_legacy.cpp carrot_mock_helpers.cpp + carrot_return_index.cpp carrot_sparc.cpp + carrot_return_index.cpp carrot_transcript_fixed.cpp carrot_tx_proof.cpp chacha.cpp diff --git a/tests/unit_tests/carrot_impl.cpp b/tests/unit_tests/carrot_impl.cpp index 504f87e..b61ceca 100644 --- a/tests/unit_tests/carrot_impl.cpp +++ b/tests/unit_tests/carrot_impl.cpp @@ -165,6 +165,7 @@ static void subtest_multi_account_transfer_over_transaction(const unittest_trans {{0, 0}, AddressDeriveType::Carrot}, {}, {}, + "SAL1", tx_proposal); // make unsigned transaction diff --git a/tests/unit_tests/carrot_return_index.cpp b/tests/unit_tests/carrot_return_index.cpp new file mode 100644 index 0000000..4a496bf --- /dev/null +++ b/tests/unit_tests/carrot_return_index.cpp @@ -0,0 +1,172 @@ +// Copyright (c) 2025, The Salvium Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, are +// permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, this list +// of conditions and the following disclaimer in the documentation and/or other +// materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its contributors may be +// used to endorse or promote products derived from this software without specific +// prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF +// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "gtest/gtest.h" + +#include "carrot_core/account_secrets.h" +#include "carrot_core/address_utils.h" +#include "carrot_core/enote_utils.h" +#include "carrot_core/output_set_finalization.h" +#include "carrot_core/payment_proposal.h" +#include "carrot_core/scan.h" +#include "crypto/crypto.h" +#include "crypto/generators.h" +#include "ringct/rctOps.h" + +#include "carrot_mock_helpers.h" + +using namespace carrot; + +// Alice sends once to Bob, Bob makes NUM_RETURNS return payments with random amounts, +TEST(carrot_return_index, payment_channel_multiple_returns) +{ + constexpr size_t NUM_RETURNS = 10; + + // accounts + carrot::carrot_and_legacy_account alice, bob; + alice.generate(); + bob.generate(); + + // origin tx (Alice to Bob) + const crypto::key_image origin_tx_first_key_image = rct::rct2ki(rct::pkGen()); + const input_context_t input_context = make_carrot_input_context(origin_tx_first_key_image); + + // Alice's change output onetime address (K_change) + const crypto::public_key K_change = rct::rct2pk(rct::pkGen()); + + // Bob's received output onetime address (Ko) + const crypto::public_key Ko = rct::rct2pk(rct::pkGen()); + + // Alice derives k_return_base + crypto::secret_key k_return_base; + alice.s_view_balance_dev.make_internal_return_privkey(input_context, Ko, k_return_base); + + // K_return_base = k_return_base * G + crypto::public_key K_return_base; + crypto::secret_key_to_public_key(k_return_base, K_return_base); + + // s_sr from origin TX (shared between Alice and Bob) + unsigned char s_sender_receiver_unctx[32]; + crypto::rand(32, s_sender_receiver_unctx); + + // Structure to hold Bob's return TX data (what would be on-chain) + struct ReturnTxData { + crypto::public_key K_r; // return address + crypto::public_key onetime_address; // Ko for this return TX + mx25519_pubkey enote_ephemeral_pubkey; // D_e + encrypted_amount_t amount_enc; // encrypted amount + crypto::key_image tx_first_key_image; // for input context + }; + std::vector return_txs(NUM_RETURNS); + + rct::xmr_amount bob_total_sent = 0; + + // Bob returns NUM_RETURNS payments + for (uint64_t idx = 0; idx < NUM_RETURNS; ++idx) + { + // Random amount + rct::xmr_amount amount = crypto::rand() & 0xFFFFFFFF; + bob_total_sent += amount; + + crypto::secret_key k_idx; + make_sparc_return_index(s_sender_receiver_unctx, input_context, Ko, idx, k_idx); + + // Bob: K_return_final = K_return_base + k_idx * T + rct::key k_idx_T; + rct::scalarmultKey(k_idx_T, rct::pk2rct(crypto::get_T()), rct::sk2rct(k_idx)); + rct::key K_return_final = rct::addKeys(rct::pk2rct(K_return_base), k_idx_T); + + // Bob: K_r = K_return_final + K_change + return_txs[idx].K_r = rct::rct2pk(rct::addKeys(K_return_final, rct::pk2rct(K_change))); + + // Bob: return TX enote + return_txs[idx].tx_first_key_image = rct::rct2ki(rct::pkGen()); + return_txs[idx].onetime_address = rct::rct2pk(rct::pkGen()); + + // D_e + crypto::secret_key d_e; + crypto::rand(32, to_bytes(d_e)); + sc_reduce32(to_bytes(d_e)); + make_carrot_enote_ephemeral_pubkey_cryptonote(d_e, return_txs[idx].enote_ephemeral_pubkey); + + const input_context_t return_input_context = make_carrot_input_context(return_txs[idx].tx_first_key_image); + mx25519_pubkey shared_secret_unctx; + crypto::hash shared_secret; + make_carrot_uncontextualized_shared_key_sender(d_e, K_return_base, shared_secret_unctx); + make_carrot_sender_receiver_secret(shared_secret_unctx.data, return_txs[idx].enote_ephemeral_pubkey, return_input_context, shared_secret); + + // Bob encrypts the amount + return_txs[idx].amount_enc = encrypt_carrot_amount(amount, shared_secret, return_txs[idx].onetime_address); + } + + // Verify all K_r values are unique + for (size_t i = 0; i < NUM_RETURNS; ++i) + { + for (size_t j = i + 1; j < NUM_RETURNS; ++j) + { + EXPECT_NE(return_txs[i].K_r, return_txs[j].K_r) + << "K_r for return " << i << " and " << j << " should differ"; + } + } + + // Alice receives and decrypts all return payments + rct::xmr_amount alice_total_received = 0; + + for (uint64_t idx = 0; idx < NUM_RETURNS; ++idx) + { + const auto &rtx = return_txs[idx]; + + // k_idx for this return index + crypto::secret_key alice_k_idx; + make_sparc_return_index(s_sender_receiver_unctx, input_context, Ko, idx, alice_k_idx); + + // Alice: K_return = k_return * G + k_idx * T + rct::key alice_K_return_rct; + rct::addKeys2(alice_K_return_rct, rct::sk2rct(k_return_base), rct::sk2rct(alice_k_idx), rct::pk2rct(crypto::get_T())); + + // Alice computes K_r = K_return + K_change + crypto::public_key alice_K_r = rct::rct2pk(rct::addKeys(alice_K_return_rct, rct::pk2rct(K_change))); + + // Verify Alice's K_r matches what's on-chain (Bob's) + ASSERT_EQ(alice_K_r, rtx.K_r) << "K_r mismatch for idx " << idx; + + // Alice derives shared secret using k_return_base + const input_context_t return_input_context = make_carrot_input_context(rtx.tx_first_key_image); + mx25519_pubkey shared_secret_unctx; + crypto::hash shared_secret; + make_carrot_uncontextualized_shared_key_receiver(k_return_base, rtx.enote_ephemeral_pubkey, shared_secret_unctx); + make_carrot_sender_receiver_secret(shared_secret_unctx.data, rtx.enote_ephemeral_pubkey, return_input_context, shared_secret); + + // Alice decrypts the amount + rct::xmr_amount decrypted_amount = decrypt_carrot_amount(rtx.amount_enc, shared_secret, rtx.onetime_address); + + alice_total_received += decrypted_amount; + } + + // Final verification: Alice's total matches Bob's total + EXPECT_EQ(alice_total_received, bob_total_sent); +} diff --git a/tests/unit_tests/carrot_sparc.cpp b/tests/unit_tests/carrot_sparc.cpp index 993f30f..cf4f539 100644 --- a/tests/unit_tests/carrot_sparc.cpp +++ b/tests/unit_tests/carrot_sparc.cpp @@ -109,15 +109,16 @@ std::tuple, crypto::public_key> make_origin_ crypto::secret_key k_return; alice.s_view_balance_dev.make_internal_return_privkey(input_context, enote_proposal_out.enote.onetime_address, k_return); - // compute K_return = k_return * G - crypto::public_key return_pub; - crypto::secret_key_to_public_key(k_return, return_pub); - encrypted_return_pubkey_t K_return; - static_assert(sizeof(K_return.bytes) == sizeof(return_pub.data), "Size mismatch"); - memcpy(K_return.bytes, return_pub.data, sizeof(encrypted_return_pubkey_t)); + // compute k_idx + crypto::secret_key k_idx; + //make_sparc_return_index(input_context, enote_proposal_out.enote.onetime_address, 0, k_idx); + + // compute SPARC K_return = k_return * G + crypto::public_key K_return; + secret_key_to_public_key(k_return, K_return); - // compute K_o = K_change + K_return - crypto::public_key K_o = rct::rct2pk(rct::addKeys(rct::pk2rct(return_pub), rct::pk2rct(enote_proposal_change.enote.onetime_address))); + // compute K_r = K_change + K_return + crypto::public_key K_r = rct::rct2pk(rct::addKeys(rct::pk2rct(K_return), rct::pk2rct(enote_proposal_change.enote.onetime_address))); // calculate the shared secret mx25519_pubkey shared_secret_unctx; @@ -133,16 +134,21 @@ std::tuple, crypto::public_key> make_origin_ make_sparc_return_pubkey_encryption_mask(shared_secret_unctx.data, input_context, enote_proposal_out.enote.onetime_address, m_return); // compute return_enc - enote_proposal_out.enote.return_enc = K_return ^ m_return; + encrypted_return_pubkey_t return_pub; + static_assert(sizeof(K_return.data) == sizeof(return_pub.bytes), "Size mismatch"); + memcpy(return_pub.bytes, K_return.data, sizeof(encrypted_return_pubkey_t)); + enote_proposal_out.enote.return_enc = return_pub ^ m_return; // Return the enotes and the public return key std::vector tx_enotes{enote_proposal_change, enote_proposal_out}; - return {tx_enotes, K_o}; + return {tx_enotes, K_r}; } //---------------------------------------------------------------------------------------------------------------------- -std::tuple, crypto::public_key> make_return_tx( +std::tuple, crypto::public_key, rct::xmr_amount> make_return_tx( carrot::carrot_and_legacy_account &bob, - std::vector &origin_tx_outputs + std::vector &origin_tx_outputs, + const uint64_t idx, + const uint64_t amount ) { // [0] enote is change, [1] enote bob received const auto change_output = origin_tx_outputs[0].enote; @@ -199,23 +205,43 @@ std::tuple, crypto::public_key> make_return_ ); // Create a TX fee that needs to be deducted from the returned amount - const rct::xmr_amount txnFee = recovered_amount >> 4; - const rct::xmr_amount amount_return = recovered_amount - txnFee; + const rct::xmr_amount txnFee = amount >> 4; + const rct::xmr_amount amount_return = amount - txnFee; // compute m_return encrypted_return_pubkey_t m_return; make_sparc_return_pubkey_encryption_mask(origin_tx_shared_secret_unctx.data, input_context, received_output.onetime_address, m_return); // compute K_return from return_enc - encrypted_return_pubkey_t K_return; - K_return = received_output.return_enc ^ m_return; - crypto::public_key return_pub; - static_assert(sizeof(K_return.bytes) == sizeof(return_pub.data), "Size mismatch"); - memcpy(return_pub.data, K_return.bytes, sizeof(encrypted_return_pubkey_t)); - + encrypted_return_pubkey_t K_return_encrypted; + K_return_encrypted = received_output.return_enc ^ m_return; + crypto::public_key K_return_base; + static_assert(sizeof(K_return_encrypted.bytes) == sizeof(K_return_base.data), "Size mismatch"); + memcpy(K_return_base.data, K_return_encrypted.bytes, sizeof(encrypted_return_pubkey_t)); + /* + // k_idx + crypto::secret_key k_idx; + make_sparc_return_index(input_context, received_output.onetime_address, idx, k_idx); + + // k_idx_origin for idx=0 + crypto::secret_key k_idx_origin; + make_sparc_return_index(input_context, received_output.onetime_address, 0, k_idx_origin); + + // k_idx_diff = k_idx - k_idx_origin + crypto::secret_key k_idx_diff; + sc_sub(to_bytes(k_idx_diff), to_bytes(k_idx), to_bytes(k_idx_origin)); + + // K_return: K_return = K_return_base + k_idx_diff * T + rct::key K_return_adjusted = rct::addKeys( + rct::pk2rct(K_return_base), + rct::scalarmultKey(rct::pk2rct(crypto::get_T()), rct::sk2rct(k_idx_diff)) + ); + crypto::public_key return_pub = rct::rct2pk(K_return_adjusted); + */ + // Make a destination address for the return CarrotDestinationV1 return_destination; - make_carrot_main_address_v1(change_output.onetime_address, return_pub, return_destination); + make_carrot_main_address_v1(change_output.onetime_address, K_return_base, return_destination); // Create the return proposal, using the return address and the amount const CarrotPaymentProposalV1 proposal_return = CarrotPaymentProposalV1{ @@ -226,15 +252,17 @@ std::tuple, crypto::public_key> make_return_ RCTOutputEnoteProposal enote_proposal_return; encrypted_payment_id_t encrypted_payment_id_return; - get_output_proposal_return_v1( + get_output_proposal_paymentchannel_v1( proposal_return, tx_return_first_key_image, nullptr, // s_view_balance_dev + received_output.onetime_address, + idx, enote_proposal_return, encrypted_payment_id_return ); std::vector tx_enotes{enote_proposal_return}; - return {tx_enotes, enote_proposal_return.enote.onetime_address}; + return {tx_enotes, enote_proposal_return.enote.onetime_address, txnFee}; } //---------------------------------------------------------------------------------------------------------------------- TEST(carrot_sparc, main_address_return_payment_normal_scan_completeness) @@ -242,127 +270,157 @@ TEST(carrot_sparc, main_address_return_payment_normal_scan_completeness) // these will generate a new format carrot address. carrot::carrot_and_legacy_account alice, bob; alice.generate(); + alice.generate_subaddress_map({1,1}); bob.generate(); + bob.generate_subaddress_map({1,1}); // make origin tx Alice -> Bob CarrotDestinationV1 bob_address = bob.cryptonote_address(); auto [origin_tx_outputs, origin_return_pubkey] = make_origin_tx(alice, bob_address); - // make return tx Bob -> Alice - auto [return_tx_outputs, return_pubkey] = make_return_tx(bob, origin_tx_outputs); - const auto return_output = return_tx_outputs[0].enote; + std::vector amounts; + rct::xmr_amount expected_total = 0; + for (size_t i=0; i<100; ++i) { + amounts.push_back(rct::randXmrAmount(TREASURY_SAL1_MINT_AMOUNT)); + expected_total += amounts.back(); + } - // 1. Alice checks the "hashmap" for a known return_address - ASSERT_EQ(origin_return_pubkey, return_pubkey); + rct::xmr_amount received_total = 0, fee_total = 0; + for (size_t idx=0; idx Alice + auto [return_tx_outputs, return_pubkey, txnFee] = make_return_tx(bob, origin_tx_outputs, idx, amount); + const auto return_output = return_tx_outputs[0].enote; - // Alice should now have access to the origin TX, including the "change" and "output" enotes - const auto change_output = origin_tx_outputs[0].enote; - const auto sent_output = origin_tx_outputs[1].enote; + // 1. Alice checks the "hashmap" for a known return_address + //ASSERT_EQ(origin_return_pubkey, return_pubkey); - // 2. compute k_return' - const input_context_t input_context = make_carrot_input_context(sent_output.tx_first_key_image); - crypto::secret_key k_return; - alice.s_view_balance_dev.make_internal_return_privkey(input_context, sent_output.onetime_address, k_return); + // Alice should now have access to the origin TX, including the "change" and "output" enotes + const auto change_output = origin_tx_outputs[0].enote; + const auto sent_output = origin_tx_outputs[1].enote; + + // 2. compute k_return' + const input_context_t input_context = make_carrot_input_context(sent_output.tx_first_key_image); + crypto::secret_key k_return; + alice.s_view_balance_dev.make_internal_return_privkey(input_context, sent_output.onetime_address, k_return); + + // 6. recover the shared secret(s_sr) of return tx + // s_sr = k_return * D_e + const input_context_t input_context_return = make_carrot_input_context(return_output.tx_first_key_image); + mx25519_pubkey shared_secret_return_unctx; + crypto::hash shared_secret_return; + make_carrot_uncontextualized_shared_key_receiver(k_return, return_output.enote_ephemeral_pubkey, shared_secret_return_unctx); + + // 3. compute k_idx' + crypto::secret_key k_idx; + make_sparc_return_index(shared_secret_return_unctx.data, input_context_return, sent_output.onetime_address, idx, k_idx); + + // 4. compute SPARC K_return' = k_return' * G + k_idx' * T + rct::key K_return; + rct::addKeys2(K_return, + rct::sk2rct(k_return), + rct::sk2rct(k_idx), + rct::pk2rct(crypto::get_T())); + + // 5. compute K_r' = K_change + K_return' + crypto::public_key K_r_verify = rct::rct2pk(rct::addKeys(K_return, rct::pk2rct(change_output.onetime_address))); + ASSERT_EQ(K_r_verify, return_pubkey); + + // 7. recompute the shared secret : s^ctx_sr = H_32(s_sr, D_e, input_context) + make_carrot_sender_receiver_secret(shared_secret_return_unctx.data, + return_output.enote_ephemeral_pubkey, + input_context_return, + shared_secret_return); + + // 8. recompute the view_tag and make sure it is correct + EXPECT_TRUE(test_carrot_view_tag(shared_secret_return_unctx.data, input_context_return, K_r_verify, return_output.view_tag)); - // 3. compute K_return' = k_return * G - crypto::public_key K_return; - crypto::secret_key_to_public_key(k_return, K_return); + // 9. compute the amount encryption mask and recover the amount + rct::xmr_amount recovered_amount_return = decrypt_carrot_amount(return_output.amount_enc, shared_secret_return, return_output.onetime_address); - // 4. compute K_o' = K_return' + K_change - crypto::public_key K_o_verify = rct::rct2pk(rct::addKeys(rct::pk2rct(K_return), rct::pk2rct(change_output.onetime_address))); - ASSERT_EQ(K_o_verify, return_pubkey); + // 10. compute k_a' = H_n(s^ctx_sr, a', K^j_s', enote_type') + crypto::secret_key recovered_amount_blinding_factor_return; + make_carrot_amount_blinding_factor(shared_secret_return, + recovered_amount_return, + change_output.onetime_address, + CarrotEnoteType::PAYMENT, + recovered_amount_blinding_factor_return); - // 5. recover the shared secret(s_sr) of return tx - // s_sr = k_return * D_e - const input_context_t input_context_return = make_carrot_input_context(return_output.tx_first_key_image); - mx25519_pubkey shared_secret_return_unctx; - crypto::hash shared_secret_return; - make_carrot_uncontextualized_shared_key_receiver(k_return, return_output.enote_ephemeral_pubkey, shared_secret_return_unctx); - // s^ctx_sr = H_32(s_sr, D_e, input_context) - make_carrot_sender_receiver_secret(shared_secret_return_unctx.data, - return_output.enote_ephemeral_pubkey, - input_context_return, - shared_secret_return); + // 11. compute C_a' = k_a' G + a' H + rct::key recovered_amount_commitment_return = rct::commit(recovered_amount_return, rct::sk2rct(recovered_amount_blinding_factor_return)); - // 6. verify the view_tag - EXPECT_TRUE(test_carrot_view_tag(shared_secret_return_unctx.data, input_context_return, return_output.onetime_address, return_output.view_tag)); - - // 8. compute the amount encryption mask and recover the amount - rct::xmr_amount recovered_amount_return = decrypt_carrot_amount(return_output.amount_enc, shared_secret_return, return_output.onetime_address); + // 12. verify the commitment + ASSERT_EQ(return_output.amount_commitment, recovered_amount_commitment_return); - // 10. compute k_a' = H_n(s^ctx_sr, a', K^j_s', enote_type') - crypto::secret_key recovered_amount_blinding_factor_return; - make_carrot_amount_blinding_factor(shared_secret_return, - recovered_amount_return, - change_output.onetime_address, - CarrotEnoteType::PAYMENT, - recovered_amount_blinding_factor_return); - - // 11. compute C_a' = k_a' G + a' H - rct::key recovered_amount_commitment_return = rct::commit(recovered_amount_return, rct::sk2rct(recovered_amount_blinding_factor_return)); - - // 12. verify the commitment - ASSERT_EQ(return_output.amount_commitment, recovered_amount_commitment_return); - - // 13. compute m_pid and pid_enc - not implemented/tested since not supported in SPARC - /* - if (return_output.encrypted_payment_id) + // 13. compute m_pid and pid_enc - not implemented/tested since not supported in SPARC + /* + if (return_output.encrypted_payment_id) nominal_payment_id_out = decrypt_legacy_payment_id(*encrypted_payment_id, s_sender_receiver, onetime_address); - else + else nominal_payment_id_out = null_payment_id; - encrypted_payment_id_out =encrypt_legacy_payment_id(proposal.destination.payment_id, s_sender_receiver, output_enote_out.enote.onetime_address); - */ + encrypted_payment_id_out =encrypt_legacy_payment_id(proposal.destination.payment_id, s_sender_receiver, output_enote_out.enote.onetime_address); + */ - // 15. compute m_anchor and anchor' - janus_anchor_t recovered_anchor_return = decrypt_carrot_anchor(return_output.anchor_enc, shared_secret_return, return_output.onetime_address); + // 15. compute m_anchor and anchor' + janus_anchor_t recovered_anchor_return = decrypt_carrot_anchor(return_output.anchor_enc, shared_secret_return, return_output.onetime_address); - // 17. compute d_e' - crypto::secret_key recovered_ephemeral_privkey_return; - make_carrot_enote_ephemeral_privkey(recovered_anchor_return, input_context_return, change_output.onetime_address, null_payment_id, recovered_ephemeral_privkey_return); + // 17. compute d_e' + crypto::secret_key recovered_ephemeral_privkey_return; + make_carrot_enote_ephemeral_privkey(recovered_anchor_return, input_context_return, change_output.onetime_address, null_payment_id, recovered_ephemeral_privkey_return); - // 18. compute D_e' - mx25519_pubkey recovered_ephemeral_pubkey_return; - make_carrot_enote_ephemeral_pubkey(recovered_ephemeral_privkey_return, change_output.onetime_address, false, recovered_ephemeral_pubkey_return); + // 18. compute D_e' + mx25519_pubkey recovered_ephemeral_pubkey_return; + make_carrot_enote_ephemeral_pubkey(recovered_ephemeral_privkey_return, change_output.onetime_address, false, recovered_ephemeral_pubkey_return); - // 19. verify the enote ephemeral pubkey - ASSERT_EQ(recovered_ephemeral_pubkey_return, return_output.enote_ephemeral_pubkey); + // 19. verify the enote ephemeral pubkey + ASSERT_EQ(recovered_ephemeral_pubkey_return, return_output.enote_ephemeral_pubkey); - // Scan the change output - crypto::secret_key recovered_sender_extension_g_change; - crypto::secret_key recovered_sender_extension_t_change; - crypto::public_key recovered_address_spend_pubkey_change; - rct::xmr_amount recovered_amount_change; - crypto::secret_key recovered_amount_blinding_factor_change; - CarrotEnoteType recovered_enote_type_change; - janus_anchor_t recovered_internal_message_out_change; - crypto::public_key return_address_out; - bool is_return_out; - const bool scan_success_change = try_scan_carrot_enote_internal_receiver(change_output, - alice, - recovered_sender_extension_g_change, - recovered_sender_extension_t_change, - recovered_address_spend_pubkey_change, - recovered_amount_change, - recovered_amount_blinding_factor_change, - recovered_enote_type_change, - recovered_internal_message_out_change, - return_address_out, - is_return_out); - ASSERT_TRUE(scan_success_change); + // Scan the change output + crypto::secret_key recovered_sender_extension_g_change; + crypto::secret_key recovered_sender_extension_t_change; + crypto::public_key recovered_address_spend_pubkey_change; + rct::xmr_amount recovered_amount_change; + crypto::secret_key recovered_amount_blinding_factor_change; + CarrotEnoteType recovered_enote_type_change; + janus_anchor_t recovered_internal_message_out_change; + crypto::public_key return_address_out; + bool is_return_out; + const bool scan_success_change = try_scan_carrot_enote_internal_receiver(change_output, + alice, + recovered_sender_extension_g_change, + recovered_sender_extension_t_change, + recovered_address_spend_pubkey_change, + recovered_amount_change, + recovered_amount_blinding_factor_change, + recovered_enote_type_change, + recovered_internal_message_out_change, + return_address_out, + is_return_out); + ASSERT_TRUE(scan_success_change); - // check spendability of the change output - EXPECT_TRUE(alice.can_open_fcmp_onetime_address(alice.get_keys().m_carrot_account_address.m_spend_public_key, - recovered_sender_extension_g_change, - recovered_sender_extension_t_change, - change_output.onetime_address)); + // check spendability of the change output + EXPECT_TRUE(alice.can_open_fcmp_onetime_address(alice.get_keys().m_carrot_account_address.m_spend_public_key, + recovered_sender_extension_g_change, + recovered_sender_extension_t_change, + change_output.onetime_address)); - // check spendability of the return_payment - crypto::secret_key sum_g; - sc_add(to_bytes(sum_g), to_bytes(recovered_sender_extension_g_change), to_bytes(k_return)); - ASSERT_TRUE(alice.can_open_fcmp_onetime_address(alice.get_keys().m_carrot_account_address.m_spend_public_key, - sum_g, - recovered_sender_extension_t_change, - return_output.onetime_address)); + // check spendability of the return_payment + crypto::secret_key sum_g, sum_t; + sc_add(to_bytes(sum_g), to_bytes(recovered_sender_extension_g_change), to_bytes(k_return)); + sc_add(to_bytes(sum_t), to_bytes(recovered_sender_extension_t_change), to_bytes(k_idx)); + ASSERT_TRUE(alice.can_open_fcmp_onetime_address(alice.get_keys().m_carrot_account_address.m_spend_public_key, + sum_g, + sum_t, + return_output.onetime_address)); + + received_total += recovered_amount_return; + fee_total += txnFee; + std::cout << "Amount[" << idx << "] received " << recovered_amount_return << ", fee " << txnFee << " from total " << amount << std::endl; + } + + // Verify we received all the expected amounts + ASSERT_EQ(expected_total, received_total + fee_total); } //---------------------------------------------------------------------------------------------------------------------- TEST(carrot_sparc, get_spend_authority_proof_completeness) diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp index c19960f..5b5d75b 100644 --- a/tests/unit_tests/hardfork.cpp +++ b/tests/unit_tests/hardfork.cpp @@ -53,11 +53,12 @@ public: , const cryptonote::difficulty_type& cumulative_difficulty , const uint64_t& coins_generated , uint64_t num_rct_outs - , oracle::asset_type_counts& cum_rct_by_asset_type + , oracle::asset_type_counts_v2& cum_rct_by_asset_type , const crypto::hash& blk_hash , uint64_t slippage_total , uint64_t yield_total , uint64_t audit_total + , uint64_t token_total , const cryptonote::network_type nettype , cryptonote::yield_block_info& ybi , cryptonote::audit_block_info& abi @@ -104,7 +105,7 @@ TEST(major, Only) { TestDB db; HardFork hf(db, 1, 0, 0, 0, 1, 0); // no voting - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -117,27 +118,27 @@ TEST(major, Only) ASSERT_FALSE(hf.add(mkblock(0, 2), 0)); ASSERT_FALSE(hf.add(mkblock(2, 2), 0)); ASSERT_TRUE(hf.add(mkblock(1, 2), 0)); - db.add_block(mkblock(1, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(1, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); // block height 1, only version 1 is accepted ASSERT_FALSE(hf.add(mkblock(0, 2), 1)); ASSERT_FALSE(hf.add(mkblock(2, 2), 1)); ASSERT_TRUE(hf.add(mkblock(1, 2), 1)); - db.add_block(mkblock(1, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(1, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); // block height 2, only version 2 is accepted ASSERT_FALSE(hf.add(mkblock(0, 2), 2)); ASSERT_FALSE(hf.add(mkblock(1, 2), 2)); ASSERT_FALSE(hf.add(mkblock(3, 2), 2)); ASSERT_TRUE(hf.add(mkblock(2, 2), 2)); - db.add_block(mkblock(2, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(2, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); } TEST(empty_hardforks, Success) { TestDB db; HardFork hf(db); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -147,7 +148,7 @@ TEST(empty_hardforks, Success) ASSERT_TRUE(hf.get_state(time(NULL) + 3600*24*400) == HardFork::Ready); for (uint64_t h = 0; h <= 10; ++h) { - db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } ASSERT_EQ(hf.get(0), 1); @@ -173,7 +174,7 @@ TEST(check_for_height, Success) { TestDB db; HardFork hf(db, 1, 0, 0, 0, 1, 0); // no voting - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -184,14 +185,14 @@ TEST(check_for_height, Success) for (uint64_t h = 0; h <= 4; ++h) { ASSERT_TRUE(hf.check_for_height(mkblock(1, 1), h)); ASSERT_FALSE(hf.check_for_height(mkblock(2, 2), h)); // block version is too high - db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } for (uint64_t h = 5; h <= 10; ++h) { ASSERT_FALSE(hf.check_for_height(mkblock(1, 1), h)); // block version is too low ASSERT_TRUE(hf.check_for_height(mkblock(2, 2), h)); - db.add_block(mkblock(hf, h, 2), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 2), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } } @@ -200,7 +201,7 @@ TEST(get, next_version) { TestDB db; HardFork hf(db); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -211,19 +212,19 @@ TEST(get, next_version) for (uint64_t h = 0; h <= 4; ++h) { ASSERT_EQ(2, hf.get_next_version()); - db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } for (uint64_t h = 5; h <= 9; ++h) { ASSERT_EQ(4, hf.get_next_version()); - db.add_block(mkblock(hf, h, 2), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 2), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } for (uint64_t h = 10; h <= 15; ++h) { ASSERT_EQ(4, hf.get_next_version()); - db.add_block(mkblock(hf, h, 4), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 4), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } } @@ -232,7 +233,7 @@ TEST(states, Success) { TestDB db; HardFork hf(db); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; ASSERT_TRUE(hf.add_fork(1, 0, 0)); ASSERT_TRUE(hf.add_fork(2, BLOCKS_PER_YEAR, SECONDS_PER_YEAR)); @@ -256,7 +257,7 @@ TEST(steps_asap, Success) { TestDB db; HardFork hf(db, 1,0,1,1,1); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -268,7 +269,7 @@ TEST(steps_asap, Success) hf.init(); for (uint64_t h = 0; h < 10; ++h) { - db.add_block(mkblock(hf, h, 9), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, 9), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } @@ -288,7 +289,7 @@ TEST(steps_1, Success) { TestDB db; HardFork hf(db, 1,0,1,1,1); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -298,7 +299,7 @@ TEST(steps_1, Success) hf.init(); for (uint64_t h = 0 ; h < 10; ++h) { - db.add_block(mkblock(hf, h, h+1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, h+1), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } @@ -312,7 +313,7 @@ TEST(reorganize, Same) for (int history = 1; history <= 12; ++history) { TestDB db; HardFork hf(db, 1, 0, 1, 1, history, 100); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -326,7 +327,7 @@ TEST(reorganize, Same) // index 0 1 2 3 4 5 6 7 8 9 static const uint8_t block_versions[] = { 1, 1, 4, 4, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 }; for (uint64_t h = 0; h < 20; ++h) { - db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } @@ -344,7 +345,7 @@ TEST(reorganize, Changed) { TestDB db; HardFork hf(db, 1, 0, 1, 1, 4, 100); - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -360,7 +361,7 @@ TEST(reorganize, Changed) static const uint8_t block_versions[] = { 1, 1, 4, 4, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 }; static const uint8_t expected_versions[] = { 1, 1, 1, 1, 1, 1, 4, 4, 7, 7, 9, 9, 9, 9, 9, 9 }; for (uint64_t h = 0; h < 16; ++h) { - db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE (hf.add(db.get_block_from_height(h), h)); } @@ -380,7 +381,7 @@ TEST(reorganize, Changed) ASSERT_EQ(db.height(), 3); hf.reorganize_from_block_height(2); for (uint64_t h = 3; h < 16; ++h) { - db.add_block(mkblock(hf, h, block_versions_new[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, block_versions_new[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); bool ret = hf.add(db.get_block_from_height(h), h); ASSERT_EQ (ret, h < 15); } @@ -393,7 +394,7 @@ TEST(reorganize, Changed) TEST(voting, threshold) { - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; for (int threshold = 87; threshold <= 88; ++threshold) { @@ -407,7 +408,7 @@ TEST(voting, threshold) for (uint64_t h = 0; h <= 8; ++h) { uint8_t v = 1 + !!(h % 8); - db.add_block(mkblock(hf, h, v), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, v), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); bool ret = hf.add(db.get_block_from_height(h), h); if (h >= 8 && threshold == 87) { // for threshold 87, we reach the treshold at height 7, so from height 8, hard fork to version 2, but 8 tries to add 1 @@ -425,7 +426,7 @@ TEST(voting, threshold) TEST(voting, different_thresholds) { - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; for (int threshold = 87; threshold <= 88; ++threshold) { @@ -444,7 +445,7 @@ TEST(voting, different_thresholds) static const uint8_t expected_versions[] = { 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4 }; for (uint64_t h = 0; h < sizeof(block_versions) / sizeof(block_versions[0]); ++h) { - db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); bool ret = hf.add(db.get_block_from_height(h), h); ASSERT_EQ(ret, true); } @@ -458,7 +459,7 @@ TEST(voting, info) { TestDB db; HardFork hf(db, 1, 0, 1, 1, 4, 50); // window size 4, default threshold 50% - oracle::asset_type_counts num_rct_outs_by_asset_type; + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; cryptonote::audit_block_info abi; cryptonote::yield_block_info ybi; @@ -500,7 +501,7 @@ TEST(voting, info) ASSERT_EQ(expected_thresholds[h], threshold); ASSERT_EQ(4, voting); - db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); + db.add_block(mkblock(hf, h, block_versions[h]), 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); ASSERT_TRUE(hf.add(db.get_block_from_height(h), h)); } } @@ -563,10 +564,10 @@ TEST(reorganize, changed) #define ADD(v, h, a) \ do { \ cryptonote::block b = mkblock(hf, h, v); \ - oracle::asset_type_counts num_rct_outs_by_asset_type; \ + oracle::asset_type_counts_v2 num_rct_outs_by_asset_type; \ cryptonote::audit_block_info abi; \ cryptonote::yield_block_info ybi; \ - db.add_block(b, 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); \ + db.add_block(b, 0, 0, 0, 0, 0, num_rct_outs_by_asset_type, crypto::hash(), 0, 0, 0, 0, cryptonote::FAKECHAIN, ybi, abi); \ ASSERT_##a(hf.add(b, h)); \ } while(0) #define ADD_TRUE(v, h) ADD(v, h, TRUE) diff --git a/tests/unit_tests/long_term_block_weight.cpp b/tests/unit_tests/long_term_block_weight.cpp index a4aa94a..e09d5c2 100644 --- a/tests/unit_tests/long_term_block_weight.cpp +++ b/tests/unit_tests/long_term_block_weight.cpp @@ -57,11 +57,12 @@ public: , const cryptonote::difficulty_type& cumulative_difficulty , const uint64_t& coins_generated , uint64_t num_rct_outs - , oracle::asset_type_counts& cum_rct_by_asset_type + , oracle::asset_type_counts_v2& cum_rct_by_asset_type , const crypto::hash& blk_hash , uint64_t slippage_total , uint64_t yield_total , uint64_t audit_total + , uint64_t token_total , const cryptonote::network_type nettype , cryptonote::yield_block_info& ybi , cryptonote::audit_block_info& abi diff --git a/tests/unit_tests/protocol_tx.cpp b/tests/unit_tests/protocol_tx.cpp index 2fe0dfc..1f52af9 100644 --- a/tests/unit_tests/protocol_tx.cpp +++ b/tests/unit_tests/protocol_tx.cpp @@ -55,11 +55,12 @@ public: , const difficulty_type& cumulative_difficulty , const uint64_t& coins_generated , uint64_t num_rct_outs - , oracle::asset_type_counts& cum_rct_by_asset_type + , oracle::asset_type_counts_v2& cum_rct_by_asset_type , const crypto::hash& blk_hash , uint64_t slippage_total , uint64_t yield_total , uint64_t audit_total + , uint64_t token_total , const network_type nettype , yield_block_info& ybi , audit_block_info& abi diff --git a/tests/unit_tests/tx_construction_helpers.cpp b/tests/unit_tests/tx_construction_helpers.cpp index edfb4e7..6e0674c 100644 --- a/tests/unit_tests/tx_construction_helpers.cpp +++ b/tests/unit_tests/tx_construction_helpers.cpp @@ -415,6 +415,7 @@ cryptonote::transaction construct_carrot_pruned_transaction_fake_inputs( {{0, 0}, carrot::AddressDeriveType::PreCarrot}, {}, {}, + "SAL1", tx_proposal); cryptonote::transaction tx; diff --git a/tests/unit_tests/wallet_tx_builder.cpp b/tests/unit_tests/wallet_tx_builder.cpp index 2ee1dd8..1da8897 100644 --- a/tests/unit_tests/wallet_tx_builder.cpp +++ b/tests/unit_tests/wallet_tx_builder.cpp @@ -109,6 +109,7 @@ TEST(wallet_tx_builder, input_selection_basic) top_block_index, /*allow_carrot_external_inputs_in_normal_transfers=*/true, /*allow_pre_carrot_inputs_in_normal_transfers=*/true, + /*asset_type=*/"", selected_transfer_indices ); diff --git a/utils/python-rpc/framework/wallet.py b/utils/python-rpc/framework/wallet.py index 5179749..d78cb73 100644 --- a/utils/python-rpc/framework/wallet.py +++ b/utils/python-rpc/framework/wallet.py @@ -1136,45 +1136,3 @@ class Wallet(object): 'id': '0' } return self.rpc.send_json_rpc_request(frozen) - - class BackgroundSyncOptions(object): - def __init__(self): - self.off = 'off' - self.reuse_password = 'reuse-wallet-password' - self.custom_password = 'custom-background-password' - background_sync_options = BackgroundSyncOptions() - - def setup_background_sync(self, background_sync_type = background_sync_options.off, wallet_password = '', background_cache_password = ''): - setup_background_sync = { - 'method': 'setup_background_sync', - 'jsonrpc': '2.0', - 'params' : { - 'background_sync_type': background_sync_type, - 'wallet_password': wallet_password, - 'background_cache_password': background_cache_password, - }, - 'id': '0' - } - return self.rpc.send_json_rpc_request(setup_background_sync) - - def start_background_sync(self): - start_background_sync = { - 'method': 'start_background_sync', - 'jsonrpc': '2.0', - 'params' : {}, - 'id': '0' - } - return self.rpc.send_json_rpc_request(start_background_sync) - - def stop_background_sync(self, wallet_password = '', seed = '', seed_offset = ''): - stop_background_sync = { - 'method': 'stop_background_sync', - 'jsonrpc': '2.0', - 'params' : { - 'wallet_password': wallet_password, - 'seed': seed, - 'seed_offset': seed_offset, - }, - 'id': '0' - } - return self.rpc.send_json_rpc_request(stop_background_sync)