diff --git a/src/cryptonote_basic/account.cpp b/src/cryptonote_basic/account.cpp
index 4e87d4477..1c552e34b 100644
--- a/src/cryptonote_basic/account.cpp
+++ b/src/cryptonote_basic/account.cpp
@@ -34,6 +34,7 @@
 #include "account.h"
 #include "warnings.h"
 #include "crypto/crypto.h"
+#include "crypto/generators.h"
 extern "C"
 {
 #include "crypto/keccak.h"
@@ -41,6 +42,7 @@ extern "C"
 #include "cryptonote_basic_impl.h"
 #include "cryptonote_format_utils.h"
 #include "cryptonote_config.h"
+#include "ringct/rctOps.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "account"
@@ -126,7 +128,10 @@ DISABLE_VS_WARNINGS(4244 4345)
     encrypt_viewkey(key);
   }
   //-----------------------------------------------------------------
-  account_base::account_base()
+  account_base::account_base() :
+    k_view_incoming_dev(m_keys.m_view_secret_key),
+    s_view_balance_dev(m_keys.s_view_balance),
+    s_generate_address_dev(m_keys.s_generate_address)
   {
     set_null();
   }
@@ -281,4 +286,178 @@ DISABLE_VS_WARNINGS(4244 4345)
     return get_account_integrated_address_as_str(nettype, m_keys.m_account_address, payment_id);
   }
   //-----------------------------------------------------------------
+  carrot::AddressDeriveType account_base::resolve_derive_type(const carrot::AddressDeriveType derive_type) const
+  {
+    return derive_type == carrot::AddressDeriveType::Auto ? carrot::AddressDeriveType::Carrot : derive_type;
+  }
+  //----------------------------------------------------------------------------------------------------------------------
+  carrot::CarrotDestinationV1 account_base::cryptonote_address(const carrot::payment_id_t payment_id,
+                                                               const carrot::AddressDeriveType derive_type) const
+  {
+    carrot::CarrotDestinationV1 addr;
+    switch (resolve_derive_type(derive_type))
+      {
+      case carrot::AddressDeriveType::Carrot:
+        make_carrot_integrated_address_v1(m_keys.carrot_account_spend_pubkey,
+                                          m_keys.m_account_address.m_view_public_key,
+                                          payment_id,
+                                          addr);
+        break;
+      case carrot::AddressDeriveType::PreCarrot:
+        make_carrot_integrated_address_v1(m_keys.m_account_address.m_spend_public_key,
+                                          m_keys.m_account_address.m_view_public_key,
+                                          payment_id,
+                                          addr);
+        break;
+      default:
+        throw std::runtime_error("address derive type not recognized");
+      }
+    return addr;
+  }
+  //-------------------------------------------------------------------------------------------------------------------
+  carrot::CarrotDestinationV1 account_base::subaddress(const carrot::subaddress_index_extended &subaddress_index) const
+  {
+    if (!subaddress_index.index.is_subaddress())
+      return cryptonote_address(carrot::null_payment_id, subaddress_index.derive_type);
+    
+    const cryptonote::account_keys &lkeys = m_keys;
+    
+    carrot::CarrotDestinationV1 addr;
+    cryptonote::account_public_address cnaddr;
+    switch (resolve_derive_type(subaddress_index.derive_type))
+    {
+    case carrot::AddressDeriveType::Carrot:
+        make_carrot_subaddress_v1(m_keys.carrot_account_spend_pubkey,
+                                  m_keys.carrot_account_view_pubkey,
+                                  s_generate_address_dev,
+                                  subaddress_index.index.major,
+                                  subaddress_index.index.minor,
+                                  addr);
+        break;
+    case carrot::AddressDeriveType::PreCarrot:
+      cnaddr =
+        lkeys.m_device->get_subaddress(lkeys, {subaddress_index.index.major, subaddress_index.index.minor});
+      addr = carrot::CarrotDestinationV1{
+        .address_spend_pubkey = cnaddr.m_spend_public_key,
+        .address_view_pubkey = cnaddr.m_view_public_key,
+        .is_subaddress = true,
+        .payment_id = carrot::null_payment_id
+      };
+      break;
+    default:
+      throw std::runtime_error("address derive type not recognized");
+    }
+    return addr;
+  }
+  //-------------------------------------------------------------------------------------------------------------------
+  void account_base::opening_for_subaddress(
+                                            const carrot::subaddress_index_extended &subaddress_index,
+                                            crypto::secret_key &address_privkey_g_out,
+                                            crypto::secret_key &address_privkey_t_out,
+                                            crypto::public_key &address_spend_pubkey_out) const
+  {
+    const bool is_subaddress = subaddress_index.index.is_subaddress();
+    const uint32_t major_index = subaddress_index.index.major;
+    const uint32_t minor_index = subaddress_index.index.minor;
+
+    const cryptonote::account_keys &lkeys = m_keys;
+
+    crypto::secret_key address_index_generator;
+    crypto::secret_key subaddress_scalar;
+    crypto::secret_key subaddress_extension;
+    
+    switch (resolve_derive_type(subaddress_index.derive_type))
+    {
+    case carrot::AddressDeriveType::Carrot:
+      // s^j_gen = H_32[s_ga](j_major, j_minor)
+      carrot::make_carrot_index_extension_generator(lkeys.s_generate_address, major_index, minor_index, address_index_generator);
+      
+      if (is_subaddress)
+      {
+        // k^j_subscal = H_n(K_s, j_major, j_minor, s^j_gen)
+        carrot::make_carrot_subaddress_scalar(lkeys.carrot_account_spend_pubkey, address_index_generator, major_index, minor_index, subaddress_scalar);
+      }
+      else
+      {
+        // k^j_subscal = 1
+        sc_1(to_bytes(subaddress_scalar));
+      }
+      
+      // k^g_a = k_gi * k^j_subscal
+      sc_mul(to_bytes(address_privkey_g_out), to_bytes(lkeys.k_generate_image), to_bytes(subaddress_scalar));
+      
+      // k^t_a = k_ps * k^j_subscal
+      sc_mul(to_bytes(address_privkey_t_out), to_bytes(lkeys.k_prove_spend), to_bytes(subaddress_scalar));
+      break;
+    case carrot::AddressDeriveType::PreCarrot:
+      // m = Hn(k_v || j_major || j_minor) if subaddress else 0
+      subaddress_extension = is_subaddress
+        ? lkeys.get_device().get_subaddress_secret_key(lkeys.m_view_secret_key, {major_index, minor_index})
+        : crypto::null_skey;
+      
+      // k^g_a = k_s + m
+      sc_add(to_bytes(address_privkey_g_out), to_bytes(lkeys.m_spend_secret_key), to_bytes(subaddress_extension));
+      
+      // k^t_a = 0
+      memset(address_privkey_t_out.data, 0, sizeof(address_privkey_t_out));
+      break;
+    default:
+      throw std::runtime_error("address derive type not recognized");
+    }
+
+    // perform sanity check
+    const carrot::CarrotDestinationV1 addr = subaddress(subaddress_index);
+    rct::key recomputed_address_spend_pubkey;
+    rct::addKeys2(recomputed_address_spend_pubkey,
+                  rct::sk2rct(address_privkey_g_out),
+                  rct::sk2rct(address_privkey_t_out),
+                  rct::pk2rct(crypto::get_T()));
+    CHECK_AND_ASSERT_THROW_MES(rct::rct2pk(recomputed_address_spend_pubkey) == addr.address_spend_pubkey,
+                               "mock carrot or legacy keys: opening for subaddress: failed sanity check");
+    address_spend_pubkey_out = addr.address_spend_pubkey;
+  }
+  //-------------------------------------------------------------------------------------------------------------------
+  bool account_base::try_searching_for_opening_for_subaddress(
+                                                              const crypto::public_key &address_spend_pubkey,
+                                                              crypto::secret_key &address_privkey_g_out,
+                                                              crypto::secret_key &address_privkey_t_out) const
+  {
+    const auto it = subaddress_map.find(address_spend_pubkey);
+    if (it == subaddress_map.cend())
+      return false;
+    
+    crypto::public_key recomputed_address_spend_pubkey;
+    opening_for_subaddress(it->second,
+                           address_privkey_g_out,
+                           address_privkey_t_out,
+                           recomputed_address_spend_pubkey);
+    
+    return address_spend_pubkey == recomputed_address_spend_pubkey;
+  }
+  //-------------------------------------------------------------------------------------------------------------------
+  bool account_base::try_searching_for_opening_for_onetime_address(
+                                                                   const crypto::public_key &address_spend_pubkey,
+                                                                   const crypto::secret_key &sender_extension_g,
+                                                                   const crypto::secret_key &sender_extension_t,
+                                                                   crypto::secret_key &x_out,
+                                                                   crypto::secret_key &y_out) const
+  {
+    // k^{j,g}_addr, k^{j,t}_addr
+    crypto::secret_key address_privkey_g;
+    crypto::secret_key address_privkey_t;
+    if (!try_searching_for_opening_for_subaddress(address_spend_pubkey,
+                                                  address_privkey_g,
+                                                  address_privkey_t))
+      return false;
+    
+    // x = k^{j,g}_addr + k^g_o
+    sc_add(to_bytes(x_out), to_bytes(address_privkey_g), to_bytes(sender_extension_g));
+    
+    // y = k^{j,t}_addr + k^t_o
+    sc_add(to_bytes(y_out), to_bytes(address_privkey_t), to_bytes(sender_extension_t));
+    
+    return true;
+  }
 }
+//-------------------------------------------------------------------------------------------------------------------
+
diff --git a/src/cryptonote_basic/account.h b/src/cryptonote_basic/account.h
index 93d1d28f0..467a55365 100644
--- a/src/cryptonote_basic/account.h
+++ b/src/cryptonote_basic/account.h
@@ -34,6 +34,13 @@
 #include "crypto/crypto.h"
 #include "serialization/keyvalue_serialization.h"
 
+#include "carrot_core/account_secrets.h"
+#include "carrot_core/address_utils.h"
+#include "carrot_core/destination.h"
+#include "carrot_core/device_ram_borrowed.h"
+#include "carrot_core/enote_utils.h"
+#include "carrot_impl/subaddress_index.h"
+
 namespace cryptonote
 {
 
@@ -46,6 +53,17 @@ namespace cryptonote
     hw::device *m_device = &hw::get_device("default");
     crypto::chacha_iv m_encryption_iv;
 
+    // carrot secret keys (minus k_v, which is shared with legacy k_v)
+    crypto::secret_key s_master;
+    crypto::secret_key k_prove_spend;
+    crypto::secret_key s_view_balance;
+    crypto::secret_key k_generate_image;
+    crypto::secret_key s_generate_address;
+
+    // carrot public keys (minus K^0_v, which is shared with legacy K^0_v)
+    crypto::public_key carrot_account_spend_pubkey;
+    crypto::public_key carrot_account_view_pubkey;
+    
     BEGIN_KV_SERIALIZE_MAP()
       KV_SERIALIZE(m_account_address)
       KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(m_spend_secret_key)
@@ -103,6 +121,46 @@ namespace cryptonote
     void encrypt_viewkey(const crypto::chacha_key &key) { m_keys.encrypt_viewkey(key); }
     void decrypt_viewkey(const crypto::chacha_key &key) { m_keys.decrypt_viewkey(key); }
 
+    carrot::AddressDeriveType resolve_derive_type(const carrot::AddressDeriveType derive_type) const;
+
+    carrot::CarrotDestinationV1 cryptonote_address(const carrot::payment_id_t payment_id = carrot::null_payment_id,
+        const carrot::AddressDeriveType derive_type = carrot::AddressDeriveType::Auto) const;
+
+    carrot::CarrotDestinationV1 subaddress(const carrot::subaddress_index_extended &subaddress_index) const;
+
+    std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddress_map_cn() const;
+
+    // brief: opening_for_subaddress - return (k^g_a, k^t_a) for j s.t. K^j_s = (k^g_a * G + k^t_a * T)
+    void opening_for_subaddress(const carrot::subaddress_index_extended &subaddress_index,
+        crypto::secret_key &address_privkey_g_out,
+        crypto::secret_key &address_privkey_t_out,
+        crypto::public_key &address_spend_pubkey_out) const;
+
+    bool try_searching_for_opening_for_subaddress(const crypto::public_key &address_spend_pubkey,
+        crypto::secret_key &address_privkey_g_out,
+        crypto::secret_key &address_privkey_t_out) const;
+
+    bool try_searching_for_opening_for_onetime_address(const crypto::public_key &address_spend_pubkey,
+        const crypto::secret_key &sender_extension_g,
+        const crypto::secret_key &sender_extension_t,
+        crypto::secret_key &x_out,
+        crypto::secret_key &y_out) const;
+    /*
+    bool can_open_fcmp_onetime_address(const crypto::public_key &address_spend_pubkey,
+        const crypto::secret_key &sender_extension_g,
+        const crypto::secret_key &sender_extension_t,
+        const crypto::public_key &onetime_address) const;
+
+    crypto::key_image derive_key_image(const crypto::public_key &address_spend_pubkey,
+        const crypto::secret_key &sender_extension_g,
+        const crypto::secret_key &sender_extension_t,
+        const crypto::public_key &onetime_address) const;
+
+    void generate_subaddress_map();
+
+    void generate(const carrot::AddressDeriveType default_derive_type = carrot::AddressDeriveType::Carrot);
+    */
+    
     template <class t_archive>
     inline void serialize(t_archive &a, const unsigned int /*ver*/)
     {
@@ -119,5 +177,11 @@ namespace cryptonote
     void set_null();
     account_keys m_keys;
     uint64_t m_creation_timestamp;
+
+    std::unordered_map<crypto::public_key, carrot::subaddress_index_extended> subaddress_map;
+
+    carrot::view_incoming_key_ram_borrowed_device k_view_incoming_dev;
+    carrot::view_balance_secret_ram_borrowed_device s_view_balance_dev;
+    carrot::generate_address_secret_ram_borrowed_device s_generate_address_dev;
   };
 }
diff --git a/src/wallet/tx_builder.cpp b/src/wallet/tx_builder.cpp
index ac46dbaf3..ada4a1a92 100644
--- a/src/wallet/tx_builder.cpp
+++ b/src/wallet/tx_builder.cpp
@@ -723,178 +723,6 @@ std::vector<cryptonote::tx_source_entry> get_sources(
 
     return sources;
 }
-//----------------------------------------------------------------------------------------------------------------------
-carrot::CarrotDestinationV1 cryptonote_address(const carrot::payment_id_t payment_id,
-    const carrot::AddressDeriveType derive_type)
-{
-    carrot::CarrotDestinationV1 addr;
-    switch (resolve_derive_type(derive_type))
-    {
-    case carrot::AddressDeriveType::Carrot:
-        make_carrot_integrated_address_v1(carrot_account_spend_pubkey,
-            legacy_acb.get_keys().m_account_address.m_view_public_key,
-            payment_id,
-            addr);
-        break;
-    case carrot::AddressDeriveType::PreCarrot:
-        make_carrot_integrated_address_v1(legacy_acb.get_keys().m_account_address.m_spend_public_key,
-            legacy_acb.get_keys().m_account_address.m_view_public_key,
-            payment_id,
-            addr);
-        break;
-    default:
-        throw std::runtime_error("address derive type not recognized");
-    }
-    return addr;
-}
-//-------------------------------------------------------------------------------------------------------------------
-carrot::CarrotDestinationV1 subaddress(const carrot::subaddress_index_extended &subaddress_index)
-{
-    if (!subaddress_index.index.is_subaddress())
-        return cryptonote_address(carrot::null_payment_id, subaddress_index.derive_type);
-
-    const cryptonote::account_keys &lkeys = legacy_acb.get_keys();
-
-    carrot::CarrotDestinationV1 addr;
-    cryptonote::account_public_address cnaddr;
-    switch (resolve_derive_type(subaddress_index.derive_type))
-    {
-    case carrot::AddressDeriveType::Carrot:
-        make_carrot_subaddress_v1(carrot_account_spend_pubkey,
-            carrot_account_view_pubkey,
-            s_generate_address_dev,
-            subaddress_index.index.major,
-            subaddress_index.index.minor,
-            addr);
-        break;
-    case carrot::AddressDeriveType::PreCarrot:
-        cnaddr =
-            lkeys.m_device->get_subaddress(lkeys, {subaddress_index.index.major, subaddress_index.index.minor});
-        addr = carrot::CarrotDestinationV1{
-            .address_spend_pubkey = cnaddr.m_spend_public_key,
-            .address_view_pubkey = cnaddr.m_view_public_key,
-            .is_subaddress = true,
-            .payment_id = carrot::null_payment_id
-        };
-        break;
-    default:
-        throw std::runtime_error("address derive type not recognized");
-    }
-    return addr;
-}
-//-------------------------------------------------------------------------------------------------------------------
-carrot::AddressDeriveType resolve_derive_type(const carrot::AddressDeriveType derive_type)
-{
-    return derive_type == carrot::AddressDeriveType::Auto ? carrot::AddressDeriveType::Carrot : derive_type;
-}
-//-------------------------------------------------------------------------------------------------------------------
-void opening_for_subaddress(
-    const carrot::subaddress_index_extended &subaddress_index,
-    crypto::secret_key &address_privkey_g_out,
-    crypto::secret_key &address_privkey_t_out,
-    crypto::public_key &address_spend_pubkey_out,
-    const cryptonote::account_keys &lkeys)
-{
-    const bool is_subaddress = subaddress_index.index.is_subaddress();
-    const uint32_t major_index = subaddress_index.index.major;
-    const uint32_t minor_index = subaddress_index.index.minor;
-
-    crypto::secret_key address_index_generator;
-    crypto::secret_key subaddress_scalar;
-    crypto::secret_key subaddress_extension;
-
-    switch (resolve_derive_type(subaddress_index.derive_type))
-    {
-    case carrot::AddressDeriveType::Carrot:
-        // s^j_gen = H_32[s_ga](j_major, j_minor)
-        carrot::make_carrot_index_extension_generator(s_generate_address, major_index, minor_index, address_index_generator);
-
-        if (is_subaddress)
-        {
-            // k^j_subscal = H_n(K_s, j_major, j_minor, s^j_gen)
-            carrot::make_carrot_subaddress_scalar(carrot_account_spend_pubkey, address_index_generator, major_index, minor_index, subaddress_scalar);
-        }
-        else
-        {
-            // k^j_subscal = 1
-            sc_1(to_bytes(subaddress_scalar));
-        }
-
-        // k^g_a = k_gi * k^j_subscal
-        sc_mul(to_bytes(address_privkey_g_out), to_bytes(k_generate_image), to_bytes(subaddress_scalar));
-
-        // k^t_a = k_ps * k^j_subscal
-        sc_mul(to_bytes(address_privkey_t_out), to_bytes(k_prove_spend), to_bytes(subaddress_scalar));
-        break;
-    case carrot::AddressDeriveType::PreCarrot:
-        // m = Hn(k_v || j_major || j_minor) if subaddress else 0
-        subaddress_extension = is_subaddress
-            ? lkeys.get_device().get_subaddress_secret_key(lkeys.m_view_secret_key, {major_index, minor_index})
-            : crypto::null_skey;
-
-        // k^g_a = k_s + m
-        sc_add(to_bytes(address_privkey_g_out), to_bytes(lkeys.m_spend_secret_key), to_bytes(subaddress_extension));
-
-        // k^t_a = 0
-        memset(address_privkey_t_out.data, 0, sizeof(address_privkey_t_out));
-        break;
-    default:
-        throw std::runtime_error("address derive type not recognized");
-    }
-
-    // perform sanity check
-    const carrot::CarrotDestinationV1 addr = subaddress(subaddress_index);
-    rct::key recomputed_address_spend_pubkey;
-    rct::addKeys2(recomputed_address_spend_pubkey,
-        rct::sk2rct(address_privkey_g_out),
-        rct::sk2rct(address_privkey_t_out),
-        rct::pk2rct(crypto::get_T()));
-    CHECK_AND_ASSERT_THROW_MES(rct::rct2pk(recomputed_address_spend_pubkey) == addr.address_spend_pubkey,
-        "mock carrot or legacy keys: opening for subaddress: failed sanity check");
-    address_spend_pubkey_out = addr.address_spend_pubkey;
-}
-//-------------------------------------------------------------------------------------------------------------------
-bool try_searching_for_opening_for_subaddress(
-    const crypto::public_key &address_spend_pubkey,
-    crypto::secret_key &address_privkey_g_out,
-    crypto::secret_key &address_privkey_t_out)
-{
-    const auto it = subaddress_map.find(address_spend_pubkey);
-    if (it == subaddress_map.cend())
-        return false;
-
-    crypto::public_key recomputed_address_spend_pubkey;
-    opening_for_subaddress(it->second,
-        address_privkey_g_out,
-        address_privkey_t_out,
-        recomputed_address_spend_pubkey);
-
-    return address_spend_pubkey == recomputed_address_spend_pubkey;
-}
-//-------------------------------------------------------------------------------------------------------------------
-bool try_searching_for_opening_for_onetime_address(
-    const crypto::public_key &address_spend_pubkey,
-    const crypto::secret_key &sender_extension_g,
-    const crypto::secret_key &sender_extension_t,
-    crypto::secret_key &x_out,
-    crypto::secret_key &y_out)
-{
-    // k^{j,g}_addr, k^{j,t}_addr
-    crypto::secret_key address_privkey_g;
-    crypto::secret_key address_privkey_t;
-    if (!try_searching_for_opening_for_subaddress(address_spend_pubkey,
-            address_privkey_g,
-            address_privkey_t))
-        return false;
-
-    // x = k^{j,g}_addr + k^g_o
-    sc_add(to_bytes(x_out), to_bytes(address_privkey_g), to_bytes(sender_extension_g));
-
-    // y = k^{j,t}_addr + k^t_o
-    sc_add(to_bytes(y_out), to_bytes(address_privkey_t), to_bytes(sender_extension_t));
-
-    return true;
-}
 //-------------------------------------------------------------------------------------------------------------------
 cryptonote::transaction finalize_all_proofs_from_transfer_details(
     const carrot::CarrotTransactionProposalV1 &tx_proposal,
diff --git a/src/wallet/tx_builder.h b/src/wallet/tx_builder.h
index a1d51ce95..8ea5c95fe 100644
--- a/src/wallet/tx_builder.h
+++ b/src/wallet/tx_builder.h
@@ -29,6 +29,7 @@
 #pragma once
 
 //local headers
+#include "carrot_impl/subaddress_index.h"
 #include "carrot_impl/tx_proposal_utils.h"
 #include "wallet2.h"
 
@@ -142,5 +143,7 @@ wallet2::pending_tx finalize_all_proofs_from_transfer_details_as_pending_tx(
 wallet2::pending_tx finalize_all_proofs_from_transfer_details_as_pending_tx(
     const carrot::CarrotTransactionProposalV1 &tx_proposal,
     const wallet2 &w);
+
+carrot::AddressDeriveType resolve_derive_type(const carrot::AddressDeriveType derive_type);
 } //namespace wallet
 } //namespace tools