src compiles and links

src/seraphis_mocks/jamtis_mock_keys.cpp

@@ -53,8 +53,10 @@ namespace jamtis
 namespace mocks
 {
 //-------------------------------------------------------------------------------------------------------------------
-void make_jamtis_mock_keys(jamtis_mock_keys &keys_out)
+void make_jamtis_mock_keys(const JamtisOnetimeAddressFormat onetime_address_format,
+    jamtis_mock_keys &keys_out)
 {
+    keys_out.onetime_address_format = onetime_address_format;
     keys_out.s_m  = rct::rct2sk(rct::skGen());
     keys_out.s_vb = rct::rct2sk(rct::skGen());
     make_jamtis_provespend_key(keys_out.s_m, keys_out.k_ps);
@@ -64,7 +66,10 @@ void make_jamtis_mock_keys(jamtis_mock_keys &keys_out)
     make_jamtis_filterassist_key(keys_out.s_vb, keys_out.d_fa);
     make_jamtis_generateaddress_secret(keys_out.s_vb, keys_out.s_ga);
     make_jamtis_ciphertag_secret(keys_out.s_ga, keys_out.s_ct);
-    make_seraphis_spendkey(keys_out.k_gi, keys_out.k_ps, keys_out.K_s_base);
+    if (onetime_address_format == JamtisOnetimeAddressFormat::SERAPHIS)
+        make_seraphis_spendkey(keys_out.k_gi, keys_out.k_ps, keys_out.K_s_base);
+    else // RINGCTv2 onetime address format
+        make_rct_spendkey(keys_out.k_gi, keys_out.k_ps, keys_out.K_s_base);
     make_jamtis_exchangebase_pubkey(keys_out.d_ur, keys_out.D_base);
     make_jamtis_identifyreceived_pubkey(keys_out.d_ir, keys_out.D_base, keys_out.D_ir);
     make_jamtis_filterassist_pubkey(keys_out.d_fa, keys_out.D_base, keys_out.D_fa);
@@ -74,7 +79,8 @@ void make_address_for_user(const jamtis_mock_keys &user_keys,
     const address_index_t &j,
     JamtisDestinationV1 &user_address_out)
 {
-    make_jamtis_destination_v1(user_keys.K_s_base,
+    make_jamtis_destination_v1(user_keys.onetime_address_format,
+        user_keys.K_s_base,
         user_keys.D_fa,
         user_keys.D_ir,
         user_keys.D_base,

src/seraphis_mocks/jamtis_mock_keys.h

@@ -62,29 +62,31 @@ namespace mocks
 ///
 struct jamtis_mock_keys
 {
-    crypto::secret_key s_m;           //master
-    crypto::secret_key s_vb;          //view-balance
-    crypto::secret_key k_ps;          //prove-spend
-    crypto::secret_key k_gi;          //generate-image
-    crypto::x25519_secret_key d_ur;   //unlock-received
-    crypto::x25519_secret_key d_ir;   //identify-received
-    crypto::x25519_secret_key d_fa;   //filter-assist
-    crypto::secret_key s_ga;          //generate-address
-    crypto::secret_key s_ct;          //cipher-tag
-    rct::key K_s_base;                //jamtis spend base        = k_gi X + k_ps U
-    crypto::x25519_pubkey D_base;     //exchange-base pubkey     = d_ur xG
-    crypto::x25519_pubkey D_ir;       //identify-received pubkey = d_ir D_base
-    crypto::x25519_pubkey D_fa;       //filter-assist pubkey     = d_fa D_base
+    JamtisOnetimeAddressFormat onetime_address_format;  //onetime address format
+    crypto::secret_key s_m;                             //master
+    crypto::secret_key s_vb;                            //view-balance
+    crypto::secret_key k_ps;                            //prove-spend
+    crypto::secret_key k_gi;                            //generate-image
+    crypto::x25519_secret_key d_ur;                     //unlock-received
+    crypto::x25519_secret_key d_ir;                     //identify-received
+    crypto::x25519_secret_key d_fa;                     //filter-assist
+    crypto::secret_key s_ga;                            //generate-address
+    crypto::secret_key s_ct;                            //cipher-tag
+    rct::key K_s_base;                                  //jamtis spend base        = k_gi X + k_ps U
+    crypto::x25519_pubkey D_base;                       //exchange-base pubkey     = d_ur xG
+    crypto::x25519_pubkey D_ir;                         //identify-received pubkey = d_ir D_base
+    crypto::x25519_pubkey D_fa;                         //filter-assist pubkey     = d_fa D_base
 };
 
 /// make a set of mock jamtis keys (for mock-ups/unit testing)
-void make_jamtis_mock_keys(jamtis_mock_keys &keys_out);
-/// make a jamtis-seraphis address for the given privkeys and address index
-void make_sp_address_for_user(const jamtis_mock_keys &user_keys,
+void make_jamtis_mock_keys(const JamtisOnetimeAddressFormat onetime_address_format,
+    jamtis_mock_keys &keys_out);
+/// make a jamtis address for the given privkeys and address index
+void make_address_for_user(const jamtis_mock_keys &user_keys,
     const address_index_t &j,
     JamtisDestinationV1 &user_address_out);
-/// make a random jamtis-seraphis address for the given privkeys
-void make_random_sp_address_for_user(const jamtis_mock_keys &user_keys,
+/// make a random jamtis address for the given privkeys
+void make_random_address_for_user(const jamtis_mock_keys &user_keys,
     JamtisDestinationV1 &user_address_out);
 
 } //namespace mocks

src/seraphis_mocks/mock_send_receive.cpp

@@ -264,7 +264,7 @@ void construct_tx_for_mock_ledger_v1(const legacy_mock_keys &local_user_legacy_k
             max_inputs,
             std::move(normal_payment_proposals),
             std::move(selfsend_payment_proposals),
-            local_user_sp_keys.k_vb,
+            local_user_sp_keys.s_vb,
             legacy_contextual_inputs,
             sp_contextual_inputs,
             normal_payment_proposals,
@@ -288,7 +288,7 @@ void construct_tx_for_mock_ledger_v1(const legacy_mock_keys &local_user_legacy_k
     const tx_version_t tx_version{tx_version_from(SpTxSquashedV1::SemanticRulesVersion::MOCK)};
 
     rct::key tx_proposal_prefix;
-    get_tx_proposal_prefix_v1(tx_proposal, tx_version, local_user_sp_keys.k_vb, tx_proposal_prefix);
+    get_tx_proposal_prefix_v1(tx_proposal, tx_version, local_user_sp_keys.s_vb, tx_proposal_prefix);
 
     // 6. get ledger mappings for the input membership proofs
     // note: do this after making the tx proposal to demo that inputs don't have to be on-chain when proposing a tx
@@ -322,8 +322,8 @@ void construct_tx_for_mock_ledger_v1(const legacy_mock_keys &local_user_legacy_k
         std::move(legacy_ring_signature_preps),
         std::move(sp_membership_proof_preps),
         local_user_legacy_keys.k_s,
-        local_user_sp_keys.k_m,
-        local_user_sp_keys.k_vb,
+        local_user_sp_keys.s_m,
+        local_user_sp_keys.s_vb,
         hw::get_device("default"),
         tx_out);
 }
@@ -571,7 +571,8 @@ void refresh_user_enote_store_PV(const jamtis::mocks::jamtis_mock_keys &user_key
     scanning::ScanContextLedgerSimple scan_context_ledger{enote_finding_context_ledger};
     ChunkConsumerMockSpIntermediate chunk_consumer{
             user_keys.K_s_base,
-            user_keys.d_vr,
+            user_keys.d_ur,
+            user_keys.d_ir,
             user_keys.d_fa,
             user_keys.s_ga,
             user_enote_store_inout
@@ -592,7 +593,7 @@ void refresh_user_enote_store(const jamtis::mocks::jamtis_mock_keys &user_keys,
     const EnoteFindingContextLedgerMockSp enote_finding_context_ledger{ledger_context, user_keys.d_fa};
     scanning::ScanContextNonLedgerSimple scan_context_unconfirmed{enote_finding_context_unconfirmed};
     scanning::ScanContextLedgerSimple scan_context_ledger{enote_finding_context_ledger};
-    ChunkConsumerMockSp chunk_consumer{user_keys.K_s_base, user_keys.k_vb, user_enote_store_inout};
+    ChunkConsumerMockSp chunk_consumer{user_keys.K_s_base, user_keys.s_vb, user_enote_store_inout};
 
     sp::refresh_enote_store(refresh_config,
         scan_context_unconfirmed,

src/seraphis_mocks/scan_chunk_consumer_mocks.cpp

@@ -273,12 +273,14 @@ void ChunkConsumerMockLegacy::consume_onchain_chunk(const scanning::LedgerChunk
 // Seraphis Intermediate
 //-------------------------------------------------------------------------------------------------------------------
 ChunkConsumerMockSpIntermediate::ChunkConsumerMockSpIntermediate(const rct::key &jamtis_spend_pubkey,
-    const crypto::x25519_secret_key &d_view_received,
+    const crypto::x25519_secret_key &d_unlock_received,
+    const crypto::x25519_secret_key &d_identify_received,
     const crypto::x25519_secret_key &d_filter_assist,
     const crypto::secret_key &s_generate_address,
     SpEnoteStorePaymentValidator &enote_store) :
         m_jamtis_spend_pubkey{jamtis_spend_pubkey},
-        m_d_view_received{d_view_received},
+        m_d_unlock_received{d_unlock_received},
+        m_d_identify_received{d_identify_received},
         m_d_filter_assist{d_filter_assist},
         m_s_generate_address{s_generate_address},
         m_enote_store{enote_store}
@@ -315,7 +317,8 @@ void ChunkConsumerMockSpIntermediate::consume_nonledger_chunk(const SpEnoteOrigi
     std::unordered_map<rct::key, SpContextualIntermediateEnoteRecordV1> found_enote_records;
 
     scanning::process_chunk_intermediate_sp(m_jamtis_spend_pubkey,
-        m_d_view_received,
+        m_d_unlock_received,
+        m_d_identify_received,
         m_d_filter_assist,
         m_s_generate_address,
         *m_cipher_context,
@@ -340,7 +343,8 @@ void ChunkConsumerMockSpIntermediate::consume_onchain_chunk(const scanning::Ledg
     std::unordered_map<rct::key, SpContextualIntermediateEnoteRecordV1> found_enote_records;
 
     scanning::process_chunk_intermediate_sp(m_jamtis_spend_pubkey,
-        m_d_view_received,
+        m_d_unlock_received,
+        m_d_identify_received,
         m_d_filter_assist,
         m_s_generate_address,
         *m_cipher_context,
@@ -359,15 +363,17 @@ void ChunkConsumerMockSpIntermediate::consume_onchain_chunk(const scanning::Ledg
 // Seraphis
 //-------------------------------------------------------------------------------------------------------------------
 ChunkConsumerMockSp::ChunkConsumerMockSp(const rct::key &jamtis_spend_pubkey,
-    const crypto::secret_key &k_view_balance,
+    const crypto::secret_key &s_view_balance,
     SpEnoteStore &enote_store) :
         m_jamtis_spend_pubkey{jamtis_spend_pubkey},
-        m_k_view_balance{k_view_balance},
+        m_s_view_balance{s_view_balance},
         m_enote_store{enote_store}
 {
-    jamtis::make_jamtis_viewreceived_key(m_k_view_balance, m_d_view_received);
-    jamtis::make_jamtis_filterassist_key(m_d_view_received, m_d_filter_assist);
-    jamtis::make_jamtis_generateaddress_secret(m_d_view_received, m_s_generate_address);
+    jamtis::make_jamtis_generateimage_key(m_s_view_balance, m_k_generate_image);
+    jamtis::make_jamtis_unlockreceived_key(m_s_view_balance, m_d_unlock_received);
+    jamtis::make_jamtis_identifyreceived_key(m_s_view_balance, m_d_identify_received);
+    jamtis::make_jamtis_filterassist_key(m_s_view_balance, m_d_filter_assist);
+    jamtis::make_jamtis_generateaddress_secret(m_s_view_balance, m_s_generate_address);
     jamtis::make_jamtis_ciphertag_secret(m_s_generate_address, m_s_cipher_tag);
 
     m_cipher_context = std::make_unique<jamtis::jamtis_address_tag_cipher_context>(m_s_cipher_tag);
@@ -402,8 +408,10 @@ void ChunkConsumerMockSp::consume_nonledger_chunk(const SpEnoteOriginStatus nonl
     std::unordered_map<crypto::key_image, SpEnoteSpentContextV1> legacy_key_images_in_sp_selfsends;
 
     scanning::process_chunk_full_sp(m_jamtis_spend_pubkey,
-        m_k_view_balance,
-        m_d_view_received,
+        m_s_view_balance,
+        m_k_generate_image,
+        m_d_unlock_received,
+        m_d_identify_received,
         m_d_filter_assist,
         m_s_generate_address,
         *m_cipher_context,
@@ -447,8 +455,10 @@ void ChunkConsumerMockSp::consume_onchain_chunk(const scanning::LedgerChunk &chu
     std::unordered_map<crypto::key_image, SpEnoteSpentContextV1> legacy_key_images_in_sp_selfsends;
 
     scanning::process_chunk_full_sp(m_jamtis_spend_pubkey,
-        m_k_view_balance,
-        m_d_view_received,
+        m_s_view_balance,
+        m_k_generate_image,
+        m_d_unlock_received,
+        m_d_identify_received,
         m_d_filter_assist,
         m_s_generate_address,
         *m_cipher_context,

src/seraphis_mocks/scan_chunk_consumer_mocks.h

@@ -159,7 +159,8 @@ class ChunkConsumerMockSpIntermediate final : public scanning::ChunkConsumer
 //constructors
     /// normal constructor
     ChunkConsumerMockSpIntermediate(const rct::key &jamtis_spend_pubkey,
-        const crypto::x25519_secret_key &d_view_received,
+        const crypto::x25519_secret_key &d_unlock_received,
+        const crypto::x25519_secret_key &d_identify_received,
         const crypto::x25519_secret_key &d_filter_assist,
         const crypto::secret_key &s_generate_address,
         SpEnoteStorePaymentValidator &enote_store);
@@ -189,7 +190,8 @@ class ChunkConsumerMockSpIntermediate final : public scanning::ChunkConsumer
 //member variables
 private:
     const rct::key &m_jamtis_spend_pubkey;
-    const crypto::x25519_secret_key &m_d_view_received;
+    const crypto::x25519_secret_key &m_d_unlock_received;
+    const crypto::x25519_secret_key &m_d_identify_received;
     const crypto::x25519_secret_key &m_d_filter_assist;
     const crypto::secret_key &m_s_generate_address;
     SpEnoteStorePaymentValidator &m_enote_store;
@@ -204,7 +206,7 @@ class ChunkConsumerMockSp final : public scanning::ChunkConsumer
 //constructors
     /// normal constructor
     ChunkConsumerMockSp(const rct::key &jamtis_spend_pubkey,
-        const crypto::secret_key &k_view_balance,
+        const crypto::secret_key &s_view_balance,
         SpEnoteStore &enote_store);
 
 //overloaded operators
@@ -232,10 +234,12 @@ class ChunkConsumerMockSp final : public scanning::ChunkConsumer
 //member variables
 private:
     const rct::key &m_jamtis_spend_pubkey;
-    const crypto::secret_key &m_k_view_balance;
+    const crypto::secret_key &m_s_view_balance;
     SpEnoteStore &m_enote_store;
 
-    crypto::x25519_secret_key m_d_view_received;
+    crypto::secret_key m_k_generate_image;
+    crypto::x25519_secret_key m_d_unlock_received;
+    crypto::x25519_secret_key m_d_identify_received;
     crypto::x25519_secret_key m_d_filter_assist;
     crypto::secret_key m_s_generate_address;
     crypto::secret_key m_s_cipher_tag;