Merge pull request monero-project#51 from jeffro256/fcmp++-stage-carrot-tx-proposal-overhaul

Carrot tx proposal overhaul, wallet2_basic lib, sweep fixes, and preliminary hot/cold types

Author: jeffro256

src/carrot_core/core_types.cpp

@@ -117,6 +117,11 @@ janus_anchor_t gen_janus_anchor()
     return crypto::rand<janus_anchor_t>();
 }
 //-------------------------------------------------------------------------------------------------------------------
+encrypted_amount_t gen_encrypted_amount()
+{
+    return crypto::rand<encrypted_amount_t>();
+}
+//-------------------------------------------------------------------------------------------------------------------
 payment_id_t gen_payment_id()
 {
     while (true)

src/carrot_core/core_types.h

@@ -129,6 +129,8 @@ static inline bool operator!=(const view_tag_t &a, const view_tag_t &b) { return
 
 /// generate a random janus anchor
 janus_anchor_t gen_janus_anchor();
+/// generate a random encrypted amount
+encrypted_amount_t gen_encrypted_amount();
 /// generate a random (non-null) payment ID
 payment_id_t gen_payment_id();
 /// generate a random encrypted payment ID

src/carrot_core/device.h

@@ -180,4 +180,17 @@ struct generate_address_secret_device
     virtual ~generate_address_secret_device() = default;
 };
 
+struct generate_image_key_device
+{
+    /**
+     * brief: generate_image_scalar_mult_hash_to_point - 
+     *   [carrot] L_partial = k_gi Hp(K_o)
+     *   [legacy] L_partial = k_s Hp(K_o)
+     * param: onetime_address - K_o
+     * return: L_partial
+     */
+    virtual crypto::ec_point generate_image_scalar_mult_hash_to_point(
+        const crypto::public_key &onetime_address) const = 0;
+};
+
 } //namespace carrot

src/carrot_core/device_ram_borrowed.cpp

@@ -94,4 +94,15 @@ void generate_address_secret_ram_borrowed_device::make_index_extension_generator
     make_carrot_index_extension_generator(m_s_generate_address, major_index, minor_index, address_generator_out);
 }
 //-------------------------------------------------------------------------------------------------------------------
+crypto::ec_point generate_image_key_ram_borrowed_device::generate_image_scalar_mult_hash_to_point(
+    const crypto::public_key &onetime_address) const
+{
+    // I = Hp(K_o)
+    crypto::ec_point key_image_generator;
+    crypto::derive_key_image_generator(onetime_address, key_image_generator);
+
+    // L_partial = k_gi I
+    return rct::rct2pt(rct::scalarmultKey(rct::pt2rct(key_image_generator), rct::sk2rct(m_k_generate_image)));
+}
+//-------------------------------------------------------------------------------------------------------------------
 } //namespace carrot

src/carrot_core/device_ram_borrowed.h

@@ -96,4 +96,16 @@ class generate_address_secret_ram_borrowed_device: public generate_address_secre
     const crypto::secret_key &m_s_generate_address;
 };
 
+class generate_image_key_ram_borrowed_device: public generate_image_key_device
+{
+public:
+    generate_image_key_ram_borrowed_device(const crypto::secret_key &k_generate_image):
+        m_k_generate_image(k_generate_image) {}
+
+    crypto::ec_point generate_image_scalar_mult_hash_to_point(const crypto::public_key &onetime_address) const override;
+
+protected:
+    const crypto::secret_key &m_k_generate_image;
+};
+
 } //namespace carrot

src/carrot_core/exceptions.h

@@ -60,6 +60,7 @@ CARROT_DEFINE_SIMPLE_ERROR_TYPE(crypto_function_failed,    carrot_runtime_error)
 CARROT_DEFINE_SIMPLE_ERROR_TYPE(not_enough_money,          carrot_runtime_error)
 CARROT_DEFINE_SIMPLE_ERROR_TYPE(not_enough_usable_money,   carrot_runtime_error)
 CARROT_DEFINE_SIMPLE_ERROR_TYPE(unexpected_scan_failure,   carrot_runtime_error)
+CARROT_DEFINE_SIMPLE_ERROR_TYPE(burnt_enote,               carrot_runtime_error)
 
 /// one needs to include misc_log_ex.h to use the following macros
 #define CARROT_THROW(errtype, message) {      \

src/carrot_impl/CMakeLists.txt

@@ -31,6 +31,9 @@ set(carrot_impl_sources
   address_utils_compat.cpp
   format_utils.cpp
   input_selection.cpp
+  key_image_device_composed.cpp
+  key_image_device_precomputed.cpp
+  output_opening_types.cpp
   tx_builder_inputs.cpp
   tx_builder_outputs.cpp
   tx_proposal_utils.cpp

src/carrot_impl/address_device.h

@@ -88,9 +88,9 @@ struct hybrid_hierarchy_address_device
 {
     virtual bool supports_address_derivation_type(AddressDeriveType derive_type) const = 0;
 
-    virtual cryptonote_hierarchy_address_device &access_cryptonote_hierarchy_device() const = 0;
+    virtual const cryptonote_hierarchy_address_device &access_cryptonote_hierarchy_device() const = 0;
 
-    virtual carrot_hierarchy_address_device &access_carrot_hierarchy_device() const = 0;
+    virtual const carrot_hierarchy_address_device &access_carrot_hierarchy_device() const = 0;
 
     virtual ~hybrid_hierarchy_address_device() = default;
 };

src/carrot_impl/address_device_ram_borrowed.cpp

@@ -31,6 +31,7 @@
 
 //local headers
 #include "address_utils_compat.h"
+#include "carrot_core/address_utils.h"
 
 //third party headers
 
@@ -53,4 +54,88 @@ void cryptonote_hierarchy_address_device_ram_borrowed::make_legacy_subaddress_ex
         legacy_subaddress_extension_out);
 }
 //-------------------------------------------------------------------------------------------------------------------
+carrot_hierarchy_address_device_ram_borrowed::carrot_hierarchy_address_device_ram_borrowed(
+        const crypto::public_key &account_spend_pubkey,
+        const crypto::public_key &account_view_pubkey,
+        const crypto::public_key &main_address_view_pubkey,
+        const crypto::secret_key &s_generate_address)
+    :
+        m_account_spend_pubkey(account_spend_pubkey),
+        m_account_view_pubkey(account_view_pubkey),
+        m_main_address_view_pubkey(main_address_view_pubkey),
+        m_s_generate_address(s_generate_address)
+{}
+//-------------------------------------------------------------------------------------------------------------------
+void carrot_hierarchy_address_device_ram_borrowed::make_index_extension_generator(const std::uint32_t major_index,
+    const std::uint32_t minor_index,
+    crypto::secret_key &address_generator_out) const
+{
+    make_carrot_index_extension_generator(m_s_generate_address, major_index, minor_index, address_generator_out);
+}
+//-------------------------------------------------------------------------------------------------------------------
+crypto::public_key carrot_hierarchy_address_device_ram_borrowed::get_carrot_account_spend_pubkey() const
+{
+    return m_account_spend_pubkey;
+}
+//-------------------------------------------------------------------------------------------------------------------
+crypto::public_key carrot_hierarchy_address_device_ram_borrowed::get_carrot_account_view_pubkey() const
+{
+    return m_account_view_pubkey;
+}
+//-------------------------------------------------------------------------------------------------------------------
+crypto::public_key carrot_hierarchy_address_device_ram_borrowed::get_carrot_main_address_view_pubkey() const
+{
+    return m_main_address_view_pubkey;
+}
+//-------------------------------------------------------------------------------------------------------------------
+hybrid_hierarchy_address_device_composed::hybrid_hierarchy_address_device_composed(
+        const cryptonote_hierarchy_address_device *cn_addr_dev,
+        const carrot_hierarchy_address_device *carrot_addr_dev)
+    :
+        m_cn_addr_dev(cn_addr_dev),
+        m_carrot_addr_dev(carrot_addr_dev)
+{}
+//-------------------------------------------------------------------------------------------------------------------
+bool hybrid_hierarchy_address_device_composed::supports_address_derivation_type(AddressDeriveType derive_type) const
+{
+    switch (derive_type)
+    {
+        case AddressDeriveType::PreCarrot:
+            return m_cn_addr_dev;
+        case AddressDeriveType::Carrot:
+            return m_carrot_addr_dev;
+        case AddressDeriveType::Auto:
+            return m_cn_addr_dev || m_carrot_addr_dev;
+        default:
+            throw device_error("Default",
+                "hybrid_hierarchy_address_device_composed",
+                "supports_address_derivation_type",
+                "unrecognized derive type", -1);
+    }
+}
+//-------------------------------------------------------------------------------------------------------------------
+const cryptonote_hierarchy_address_device &hybrid_hierarchy_address_device_composed::access_cryptonote_hierarchy_device() const
+{
+    if (!m_cn_addr_dev)
+    {
+        throw device_error("Default",
+            "hybrid_hierarchy_address_device_composed",
+            "access_cryptonote_hierarchy_device",
+            "cryptonote sub-device unavailable", -1);
+    }
+    return *m_cn_addr_dev;
+}
+//-------------------------------------------------------------------------------------------------------------------
+const carrot_hierarchy_address_device &hybrid_hierarchy_address_device_composed::access_carrot_hierarchy_device() const
+{
+    if (!m_carrot_addr_dev)
+    {
+        throw device_error("Default",
+            "hybrid_hierarchy_address_device_composed",
+            "access_carrot_hierarchy_device",
+            "carrot sub-device unavailable", -1);
+    }
+    return *m_carrot_addr_dev;
+}
+//-------------------------------------------------------------------------------------------------------------------
 } //namespace carrot

src/carrot_impl/address_device_ram_borrowed.h

@@ -63,4 +63,47 @@ struct cryptonote_hierarchy_address_device_ram_borrowed:
 protected:
     const crypto::public_key &m_cryptonote_account_spend_pubkey;
 };
+
+class carrot_hierarchy_address_device_ram_borrowed: public carrot_hierarchy_address_device
+{
+public:
+    carrot_hierarchy_address_device_ram_borrowed(
+        const crypto::public_key &account_spend_pubkey,
+        const crypto::public_key &account_view_pubkey,
+        const crypto::public_key &main_address_view_pubkey,
+        const crypto::secret_key &s_generate_address);
+
+    void make_index_extension_generator(const std::uint32_t major_index,
+        const std::uint32_t minor_index,
+        crypto::secret_key &address_generator_out) const override;
+
+    crypto::public_key get_carrot_account_spend_pubkey() const override;
+
+    crypto::public_key get_carrot_account_view_pubkey() const override;
+
+    crypto::public_key get_carrot_main_address_view_pubkey() const override;
+
+protected:
+    const crypto::public_key &m_account_spend_pubkey;
+    const crypto::public_key &m_account_view_pubkey;
+    const crypto::public_key &m_main_address_view_pubkey;
+    const crypto::secret_key &m_s_generate_address;
+};
+
+class hybrid_hierarchy_address_device_composed: public hybrid_hierarchy_address_device
+{
+public:
+    hybrid_hierarchy_address_device_composed(const cryptonote_hierarchy_address_device *cn_addr_dev,
+        const carrot_hierarchy_address_device *carrot_addr_dev);
+
+    bool supports_address_derivation_type(AddressDeriveType derive_type) const override;
+
+    const cryptonote_hierarchy_address_device &access_cryptonote_hierarchy_device() const override;
+
+    const carrot_hierarchy_address_device &access_carrot_hierarchy_device() const override;
+
+protected:
+    const cryptonote_hierarchy_address_device *m_cn_addr_dev;
+    const carrot_hierarchy_address_device *m_carrot_addr_dev;
+};
 } //namespace carrot