bumped RC version

fixed a couple of wallet cache issues; fixed rescan_bc bug
added tx_type setting for payment details - needed for wallet API (#61 )
2025-09-30 22:02:11 +01:00 · 2025-09-30 22:01:35 +01:00 · 2025-09-12 16:34:02 +01:00 · 2025-09-12 09:39:02 +01:00 · 2025-09-10 09:20:17 +01:00 · 2025-09-10 09:16:14 +01:00
21 changed files with 689 additions and 120 deletions
@@ -0,0 +1,35 @@
+# Use Ubuntu 24.04 as base
+FROM ubuntu:24.04 AS builder
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential cmake pkg-config git imagemagick libcap-dev librsvg2-bin libz-dev \
+    g++-mingw-w64-x86-64 clang gcc-arm-none-eabi binutils-x86-64-linux-gnu libtiff-tools \
+    libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev \
+    libreadline-dev libexpat1-dev libpgm-dev qttools5-dev-tools libhidapi-dev libusb-1.0-0-dev \
+    libprotobuf-dev protobuf-compiler libudev-dev libboost-all-dev python3 ccache doxygen graphviz \
+    ca-certificates curl zip libtool gperf \
+ && rm -rf /var/lib/apt/lists/*
+
+# Clone the develop branch
+WORKDIR /opt
+RUN git clone --recursive -b develop https://github.com/salvium/salvium.git
+WORKDIR /opt/salvium
+
+# make the script runnable
+RUN chmod +x make_releases.sh
+
+# Make sure the output folder exists
+RUN mkdir ~/releases
+    
+# Expose the releases directory for copying zip files to the host
+VOLUME ["~/releases"]
+
+ENTRYPOINT ["/opt/salvium/make_releases.sh"]
+
+
+# To access the generated zip files on your host, run the container with:
+#   docker run -v ~/releases:/root/releases <image>
+# This will copy the zip files to your host's ~/salvium-releases directory.
@@ -1381,12 +1381,7 @@ namespace cryptonote

    for (const auto &o: tx.vout)
    {
-      if (hf_version >= HF_VERSION_ENFORCE_CARROT)
-      {
-        // from v10, require outputs be carrot outputs
-        CHECK_AND_ASSERT_MES(o.target.type() == typeid(txout_to_carrot_v1), false, "wrong variant type: "
-          << o.target.type().name() << ", expected txout_to_carrot_v1 in transaction id=" << get_transaction_hash(tx));
-      } else if (hf_version >= HF_VERSION_CARROT) {
+      if (hf_version >= HF_VERSION_CARROT) {
        if (tx.type != cryptonote::transaction_type::PROTOCOL) {
          CHECK_AND_ASSERT_MES(o.target.type() == typeid(txout_to_carrot_v1), false, "wrong variant type: "
            << o.target.type().name() << ", expected txout_to_carrot_v1 in transaction id=" << get_transaction_hash(tx));
@@ -88,8 +88,8 @@
 #define PREMINE_AMOUNT_UPFRONT                          ((uint64_t)650000000000000ull)  // 3.4% of MONEY_SUPPLY
 #define PREMINE_AMOUNT_MONTHLY                          ((uint64_t)65000000000000ull)   // 8.6%/24 of MONEY_SUPPLY 

-#define TREASURY_SAL1_MINT_AMOUNT                       ((uint64_t)65000000000000ull) // 650K
-#define TREASURY_SAL1_MINT_COUNT                        16                            // 16 times
+#define TREASURY_SAL1_MINT_AMOUNT                       ((uint64_t)130000000000000ull)  // 1.3M
+#define TREASURY_SAL1_MINT_COUNT                        8                               // 8 times

 #define DIFFICULTY_TARGET_V2                            120  // seconds
 #define DIFFICULTY_TARGET_V1                            60  // seconds - before first fork
@@ -244,7 +244,6 @@
 #define HF_VERSION_AUDIT2                       8
 #define HF_VERSION_AUDIT2_PAUSE                 9
 #define HF_VERSION_CARROT                       10
-#define HF_VERSION_ENFORCE_CARROT               11

 #define HF_VERSION_REQUIRE_VIEW_TAGS            255
 #define HF_VERSION_ENABLE_CONVERT               255
@@ -320,22 +319,14 @@ namespace config

  // treasury payout {tx-key, output-key, anchor_enc, vie_tag} tuples
  const std::map<uint64_t, std::tuple<std::string, std::string, std::string, std::string>> TREASURY_SAL1_MINT_OUTPUT_DATA = {
-    {1000000ULL, {"a1bdd1da651fbbb845232816e1aa2d4ff29b790f10bbd4f574a012f1199e15a4", "b0733ab6f251b16458efa9ebb3fb99bd54d43173b5768fe9ffc42e0fe46ae3a8", "00", "00"}},
-    {1020000ULL, {"47996eccbcc078b06d0f6ece37bf3a700c2bd60adfdd898b22096f16a9ad315c", "fd6bcceb4799ee067d59b97a6f66a0f9a70f134220259d3b4d6a2278ba4aca4c", "00", "00"}},
-    {1040000ULL, {"a3e6754a849b80c21a77e6065fefdae29eeeabf17c407453356244a00545bdb8", "3d395454df1452d715d27190e022b20395871c99af578f7251c3f9752e0274a6", "00", "00"}},
-    {1060000ULL, {"0d5e97a910e0f9c606ad9c711b6595aaed142d857cde2efa519112b9a29240d5", "56c29e28bdcf4f20b4b45906b93ae7c4bf9ee82e18cd45543cb69a14ce5efb88", "00", "00"}},
-    {1080000ULL, {"495fa363de88915aa8b74818c4b80715a882a688b4f7127ab7cd3b6885f3567a", "d42dfe0da5579c82e8255eba8c0a17170023f14a6a5030da6abf9f10abb52cbb", "00", "00"}},
-    {1100000ULL, {"85ea10ec40390e4f406446fb519e974d89536154045c6df28bb3b538b254e20d", "0ce2b7dd3a8ce8b596889dac8081a62f98fd70f1f043944ab4ac592c3c59e77b", "00", "00"}},
-    {1120000ULL, {"40f201b38a319dda81e7201e57fea7924067a4a332ed71b8e51ec29ac2d67310", "8289aa6963b98d1034e94eae55d8be6b33d0a88f14f174ebcbaec70837986c7c", "00", "00"}},
-    {1140000ULL, {"c5a648cc7846341357b7b4653a58f9eb4800d88b5de587bceec7a5c28f98d05a", "3f308a203845d88e5e728fcebcdcea1f90e2f424d461617993c672a6138ad2d8", "00", "00"}},
-    {1160000ULL, {"4c51d6550b8eeb6cc8f0d395cc83a5f90ec2a4d86501b3f68da48d618ccf5711", "53f0bd8cebeefb3a88fffa5d7f6ad43d4712608ded561732467ca499df940454", "00", "00"}},
-    {1180000ULL, {"ce2f5d82118fed03d5e269e285fc16189a6cd34f38999e5c055a5dea5fce61bc", "f7fc6948b194d9bd6f2df6ecb83f04e6c8d1a2556a63fedb310a4631fe1bfc42", "00", "00"}},
-    {1200000ULL, {"6248028fd77fb02b5c6ea72dea10b417891a2da7aaf9565aed382e063b4981a3", "63986e1177499bdb23cd49afb519ec18f38cb1b0c386220b376d8ffdc2e37890", "00", "00"}},
-    {1220000ULL, {"6adcb695aa5d6d01133c68900f29e501e9549816e827ea0c164bbc78f3534dd6", "6a440ccb18f5e703e8000de3865ac40d4c18f081270d32eef377dc831f28d8d0", "00", "00"}},
-    {1240000ULL, {"b97a4d2259480f34f20e41c489ab5c2e5ae9ee84d8672a7eff8012f2260e121e", "e6eb9147ff40e22209d321d0f1bfbfe20acf5ceb6b9d0bfb13688ad28aa1232e", "00", "00"}},
-    {1260000ULL, {"4fd214602a36902f22d16927244c456e8cc5a406a9570131f138a028214ffdf0", "34060b8bd96009b9b298280ebd84fa9587fa8c9df6fb5ad0270fb6cd2098885c", "00", "00"}},
-    {1280000ULL, {"9d60178ec6d6599d7a31298f2559fb9c3111f2c70494b3a1638db877ea55b808", "7985ed03856a929663e954738d0938713407717835f760c7ca4d54844a128c91", "00", "00"}},
-    {1300000ULL, {"cd65718eab234bf419332e53bd2f48e2ade70af48c5e126ab5080321e1493dfc", "581cb4cca7a0a029ee2cac51dfc00a0c3a657d2eaf67ed3c6ae7bacc11b4f007", "00", "00"}},
+    {334750, {"1b2cd3ff56aa77c0cbab0473bfb96697ebdd0b25ad230136bfe41d5dc1ef265f","718cf02eabca157fd7ad7f8537db217624bfe1ca99dd09e758357e7000a5e57a","789cca3def51fb879eb7fbca271869b7","79bd0c"}},
+    {356350, {"b51acbf35265d09f3cfb83dcabde2746991ddf0d30b5a4ecc34043b349a77031","9dc0d2e9534cdccf83494687c55c67c8c1b29834acf97cce53124a08a9549231","588ebc2918d06c009a18a28a8ab76694","ab8c23"}},
+    {377950, {"771c6865980493846cbb049b34f72b937878cf799ae1126775df35064cf53526","60d340613c7721aeb03f2de1b56e2916d6cb023cc668acaca00e1606e0bb7f64","198bb0e5880c8abf8108158284ca7637","9b93f2"}},
+    {399550, {"d9159f9bb654230382a69bb7a739c14f9d506c21dba5be9f4cdf66126ed1b24e","c3b34e7f9977f31f659abd9306b650416a674ed7bcfb8c75b257040a1a06b8b9","6f0de181716e0a9e100228d58f11d42c","4c87fd"}},
+    {421150, {"1e2ab1ae204e7a9375f5b57fed2524e2d1a4702c4bbc6d420eb65d92af44c60c","826ecca0e2837860a6d2be89a410ff6aab22c5f5a66bd0a318de3abe646aa26a","bad663aa8253c40d00de0a2d1dfca60f","4a04d7"}},
+    {442750, {"18267940a2b37c82850f3fb83d935281ee5cc436b0797ec10ca26c9cc3c0ef01","77bdec7bbc4cabd84cc8cf0666e1fdfe299480b9b2a4cf52cc959d728fa899ab","a8807121e33471cf18aa82af4826c9a7","d35d35"}},
+    {464350, {"9ab50223bfecec2508e8233540dc13c3fc7e15a8d77ecb90939afee96859724d","675a1b3f2a2cd2bd0e7ec073c426125d95e12ad13e541bf019925c481c2bca15","591d2f2331832c347654ab255ad97e2d","d87c9c"}},
+    {485950, {"c0d7299fe0b873687e7319f1a0d1f67712ef3ccf6a579d96c5f99743add6f029","dd3d17b5145b56377e023c169ae858cdf48bd6c23e8b2a77e02765ce316e3ca7","6a9e74df01762e2b32db1dc4d69dc3e9","75debe"}}
  };

  // Hash domain separators
@@ -432,22 +423,14 @@ namespace config

    // treasury payout {tx-key, output-key, anchor_enc, vie_tag} tuples
    const std::map<uint64_t, std::tuple<std::string, std::string, std::string, std::string>> TREASURY_SAL1_MINT_OUTPUT_DATA = {
-      {1100, {"0d82afb3ae9c5de25a06da49e24e64d37ba05d6144f9f6153cea325c61407106","81440913c1484891d25010986806a62d1fae1b2fe045e3ac1396413638d594f1","40864bbf80397c05516368a1397eb5c3","220bda"}},
-      {1120, {"a032f2de4d3b5d880d3a636d9786a4a2f586bee360c323bc7521f987a2ada51b","cf8e5eeb5d37996d86c9c4c88fabaabc1ec77bab9cd5ce610a61b49f1e079ce2","9877a989e0216f76a8cdf0a568e57d45","017549"}},
-      {1140, {"51da7a4c34aa20a800ada615a931fbba5fd1b9f7df78f0f911097ad9d99dc230","dd784a5bf1adf9c01cb44946ca094ed4d38f8d9cccf8edfdab397db3b7631dbf","97314be452f184b54f16a558ee8a7dbe","357ac3"}},
-      {1160, {"a0cf49118c62cea834fabae83e12f26939ce170f308adadacf7275226e5cdf6d","7ec9cb2dfac8dfa45bab1bab2b1e31a4291a9e3d939e9c193740cc191d1b720d","4e950acc71ffd4f3835ec79202dc46fd","e7da3a"}},
-      {1180, {"5193e35f6cd3ff8408a442be5eaf4aa1871419ecb0c485546e9d995c4c9c2730","39fb9792b88290b3377036a150a6681334ebe5cb201e2005d2c1d7b212b3df4d","cb458163806a277c7b3513df0d5b0028","1939b5"}},
-      {1200, {"a2c71a7381bc48576f4cb4313cb6264d2a6e82cd2ddcbbd5460bce1db8d5021e","d0c46f29f4bbdd5538d64a438c0ab93cb0586e67fbfc7d1671f0c9809d6a7fac","af38cc2ddccb9229728ef704e360e15a","8a8dc1"}},
-      {1220, {"8358105081510e907c98da59636eef777460513d827aba400efbb81d82aead4c","b2b8e2f9bb13e7527d0ee1bc3ebf0ca5057139ee4f9302251455b9f27dca3b16","dc226161830e952b2533fe34b1dd3c48","fb7c67"}},
-      {1240, {"90b0bc153b97a93eefd59af9b47d26c0c91aadda6203de91a15f2f76fc949074","06e6a11b8742ee78beafe89f894fb9078a514ee6dd4e099182ac982ead37eacc","4fbfd0f3c2b8d514f2c675b37b9f0b6f","3308ad"}},
-      {1260, {"cd10148b3175804b17e3c68a6a5556364d585dee89953904b32f005a5f6d8f14","d9d6f64119776e9c97fe2fb540cdb5f40bea0c40127fda0f1f2b831cb7fa7d2b","9c21b83d29324e2d91774a623219ae28","1d647c"}},
-      {1280, {"5963697782de7db5111d12c853f3fec0dd53f597d80cc376c7945f1d4afa224b","cc5e5b1273c10016dc855ec1d9bfa0bcf4736a748125f5341717ad9d080fbba0","19dd1f9a0cac118564e2ccb9f36be53a","7ab2c2"}},
-      {1300, {"cf1d4d2d21b7b3f1a54889e0688a4654687e28a302a2ac3ad046ac2ad323f97a","5b5926da5e9199f190e86073ebd09ccb867faf1e9887c9e52a47c194915b2575","5775fa47af3c7226f2ec3017470410c9","2b03b3"}},
-      {1320, {"b565ec8842f3e6c22c7a23eb23f0e5684b462d2261681dff7b2ce71ab02ff170","4f94cf4d811574c9fcc27888cc972ebc6c01ae97146b9882d397b77c9232d1fd","9d142686627c918a26b6c6853b911143","685b18"}},
-      {1340, {"50d1b1bcacf36ba14b23b3827e36a02a7610dd3199a9f1b9d0a23ebcbd1c2d54","38818e41cf0ce7d54391978801c58087ddd5fe517dadb5e61d840f27a7a81a52","55328f4bff5120d44c5d76fc5a9dfdbd","d17be2"}},
-      {1360, {"7657bf97a9be9beac5f999a1e2c1226613849c41c12df5d7185d4d6613a27328","63d96a47f29fab0e727d13905cc843df40ccb76b14dc48857d0dd9ec0873e8c5","ab4f7ffa6431452f0fac7eec33e89e3e","5acd14"}},
-      {1380, {"845e4cbe9b9d2462fae2225da698d6a4e18340f06b312545ee9cfda8127abd41","cc65f1f22f863b31f3c4a53ac3987186c2a699f387a2bf08d8dfed54037912c6","bda3aa3bdd2b42e8183c1013e4350c98","d4a418"}},
-      {1400, {"4b11413fcba49df61537427ff35fdd47ee12a8467751236ff22681bbea343d2c","32d22bba59559489f422298ae653ef55ec8c87e8705daf4c89da7187c8574cbd","8868e1c1d788ce4560beb4afbe77aa5a","5a35d9"}}
+      {1100, {"71336a480440ed24a53b2cfd5a5292d1e618c3e843637227883ea2cc42fb346f","a135f59a05ea9e33539e4502b187b4789cc7fba79616c6902a902cc6601f0359","7f1c6970232254a9b13f7f063df2a853","62073c"}},
+      {1120, {"2cc49b182addc0106b601c9876c01a4b06532c05f9dd9179b2c4f47e5c7c0d74","fd62e59324389f37d0bb628a39f413c11be34d572ec3a40f465e008b9dfd5e0c","fbf8584222e299bb748009eaf2177123","b76a8d"}},
+      {1140, {"50f1dd5244bb6fdc62b5a18b868a4dc9e9ad15f4a7a54e5a98084a3a5213c846","942de90a3347df3e962d9b0a2745f8aedb265a8caf73aabef9aa713f4ec3e493","933702e29d680bf21ad559a2d3243621","dae32b"}},
+      {1160, {"114a1fef3a03c81b3b6308fb4e51db42d86945d8f71ee8798749a4aa2d8bfe57","fd77f0289b7e25ae68c86f4cd2c72ac0211a4d0e7a31c84b8d58a33bbd3c511b","d8048bb76b9313768a4c69100cba6d43","46b0a3"}},
+      {1180, {"cf7fe9d97a7a4cb881bff1d37bb6981bcb0691649c465d660522a43f14b32849","b76908d56108e7111374f60993e9411def7bb2899118f20f49e67a801936a1ad","f203a5acd48f93f1451d32d70716e585","d72097"}},
+      {1200, {"415e8fa4fb6bed8bc59591883f5e098dde6179e980eccfc4cbb3a64c4168cf47","5426c588d7c5750c76b526ef268b45f7414e2ddea40218ee92d123564c5114c4","fb1926bbef8c70ebd796ae77dffca07d","351edf"}},
+      {1220, {"1f47cce00e8e1c77cb3ff007491d261dae75de5bbfdbe0f4913d74a8503aaa5e","4d8aac299306989aa169982d89457852a1bab858c668c9b740d96b682bb1961b","d8c0be7926ce704290cfd8d5e0500f33","750003"}},
+      {1240, {"3afd93c684638d54e68f5d8d417863035f12482251feea5cf7515725a2bb0f4f","7895e6baded473b093b57993ae3497a47b0ea78cf35b37d1387f226f445d9018","76a0c37e6f3d9d508c4bce1d7162514e","09e146"}}
    };
  }

@@ -1403,14 +1403,19 @@ bool Blockchain::prevalidate_protocol_transaction(const block& b, uint64_t heigh
  CHECK_AND_ASSERT_MES(b.protocol_tx.vin[0].type() == typeid(txin_gen), false, "coinbase protocol transaction in the block has the wrong type");
  CHECK_AND_ASSERT_MES(b.protocol_tx.version > 1, false, "Invalid coinbase protocol transaction version");

-  if (hf_version >= HF_VERSION_CARROT) {
-    CHECK_AND_ASSERT_MES(b.protocol_tx.version == TRANSACTION_VERSION_CARROT || 2, false, "protocol transaction has wrong version");
-    CHECK_AND_ASSERT_MES(b.protocol_tx.type == cryptonote::transaction_type::PROTOCOL, false, "protocol transaction has wrong type");
-  }
+  // Work out what the HF version _was_ when the STAKE outputs were created
+  uint64_t stake_lock_period = get_config(m_nettype).STAKE_LOCK_PERIOD;
+  uint8_t hf_version_submitted = get_ideal_hard_fork_version(height - stake_lock_period - 1);

-  if (hf_version >= HF_VERSION_ENFORCE_CARROT) {
-    CHECK_AND_ASSERT_MES(b.protocol_tx.version == TRANSACTION_VERSION_CARROT, false, "protocol transaction has wrong version");
+  if (hf_version >= HF_VERSION_CARROT) {
+    if (hf_version_submitted >= HF_VERSION_CARROT || b.protocol_tx.vout.size() == 0) {
+      CHECK_AND_ASSERT_MES(b.protocol_tx.version == TRANSACTION_VERSION_CARROT, false, "protocol transaction has wrong version");
+    } else {
+      CHECK_AND_ASSERT_MES(b.protocol_tx.version == 2, false, "protocol transaction has wrong version");
+    }
    CHECK_AND_ASSERT_MES(b.protocol_tx.type == cryptonote::transaction_type::PROTOCOL, false, "protocol transaction has wrong type");
+  } else {
+    hf_version_submitted = hf_version;
  }

  // for v2 txes (ringct), we only accept empty rct signatures for protocol transactions,
@@ -1433,8 +1438,7 @@ bool Blockchain::prevalidate_protocol_transaction(const block& b, uint64_t heigh
    return false;
  }

-  CHECK_AND_ASSERT_MES(check_output_types(b.protocol_tx, hf_version), false, "protocol transaction has invalid output type(s) in block " << get_block_hash(b));
-
+  CHECK_AND_ASSERT_MES(check_output_types(b.protocol_tx, hf_version_submitted), false, "protocol transaction has invalid output type(s) in block " << get_block_hash(b));
  return true;
 }
 //------------------------------------------------------------------
@@ -1521,7 +1525,6 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
  case HF_VERSION_AUDIT2:
  case HF_VERSION_AUDIT2_PAUSE:
  case HF_VERSION_CARROT:
-  case HF_VERSION_ENFORCE_CARROT:
    if (b.miner_tx.amount_burnt > 0) {
      CHECK_AND_ASSERT_MES(money_in_use + b.miner_tx.amount_burnt > money_in_use, false, "miner transaction is overflowed by amount_burnt");
      money_in_use += b.miner_tx.amount_burnt;
@@ -2093,6 +2096,7 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
          entry.P_change = audit_entry.first.P_change;
          entry.return_pubkey = audit_entry.first.return_pubkey;
          entry.origin_height = matured_audit_height;
+          entry.is_carrot = false;
          protocol_entries.push_back(entry);
        }
      }
@@ -361,10 +361,13 @@ namespace cryptonote
      LOG_ERROR("Cannot mix Carrot and non-Carrot outputs in the same protocol transaction");
      return false;
    }
+    if (carrot_found && hard_fork_version < HF_VERSION_CARROT) {
+      LOG_ERROR("Carrot outputs found in CryptoNote protocol transaction");
+      return false;
+    }
    
-    if (carrot_found || hard_fork_version >= HF_VERSION_ENFORCE_CARROT)
+    if (carrot_found || (!noncarrot_found && hard_fork_version >= HF_VERSION_CARROT))
    {
-
      // Ensure the TX version is correct
      tx.version = TRANSACTION_VERSION_CARROT;
      try
@@ -594,7 +597,6 @@ namespace cryptonote
      case HF_VERSION_AUDIT2:
      case HF_VERSION_AUDIT2_PAUSE:
      case HF_VERSION_CARROT:
-      case HF_VERSION_ENFORCE_CARROT:
        // SRCG: subtract 20% that will be rewarded to staking users
        CHECK_AND_ASSERT_MES(tx.amount_burnt == 0, false, "while creating outs: amount_burnt is nonzero");
        tx.amount_burnt = amount / 5;
@@ -58,6 +58,9 @@ const hardfork_t mainnet_hard_forks[] = {
  
  // version 9 starts from block 179200, which is on or around the 10th of March, 2025. Fork time finalised on 2025-02-24. No fork voting occurs for the v9 fork.
  { 9, 179200, 0, 1740393800 },
+
+  // version 10 Carrot - including treasury mint - starts from block 334750, which is on or around the 13th of October, 2025. Fork time finalised on 2025-09-29. No fork voting occurs for the v10 fork.
+  {10, 334750, 0, 1759142500 },
 };
 const size_t num_mainnet_hard_forks = sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]);
 const uint64_t mainnet_hard_fork_version_1_till = ((uint64_t)-1);
@@ -92,9 +95,6 @@ const hardfork_t testnet_hard_forks[] = {

  // version 10 Carrot - including treasury mint - starts from block 1100
  {10, 1100, 0, 1739780005 },
-
-  // version 11 Carrot and CryptoNote starts from block 1200
-  {11, 1200, 0, 1756811153 },
 };
 const size_t num_testnet_hard_forks = sizeof(testnet_hard_forks) / sizeof(testnet_hard_forks[0]);
 const uint64_t testnet_hard_fork_version_1_till = ((uint64_t)-1);
@@ -8594,7 +8594,13 @@ bool simple_wallet::burn(const std::vector<std::string> &args_)
  }

  std::vector<std::string> local_args;
-  local_args.push_back(m_wallet->get_subaddress_as_str({m_current_subaddress_account,0}));
+  carrot::AddressDeriveType derive_type;
+  if (m_wallet->use_fork_rules(HF_VERSION_CARROT, 0)) {
+    derive_type = carrot::AddressDeriveType::Carrot;
+  } else {
+    derive_type = carrot::AddressDeriveType::PreCarrot;
+  }
+  local_args.push_back(m_wallet->get_subaddress_as_str({{m_current_subaddress_account, 0}, derive_type, false}));
  local_args.insert(local_args.end(), args_.begin(), args_.end());
  
  // Get the asset type
@@ -8747,7 +8753,13 @@ bool simple_wallet::stake(const std::vector<std::string> &args_)
  }
  
  std::vector<std::string> local_args;
-  local_args.push_back(m_wallet->get_subaddress_as_str({m_current_subaddress_account,0}));
+  carrot::AddressDeriveType derive_type;
+  if (m_wallet->use_fork_rules(HF_VERSION_CARROT, 0)) {
+    derive_type = carrot::AddressDeriveType::Carrot;
+  } else {
+    derive_type = carrot::AddressDeriveType::PreCarrot;
+  }
+  local_args.push_back(m_wallet->get_subaddress_as_str({{m_current_subaddress_account, 0}, derive_type, false}));
  local_args.insert(local_args.end(), args_.begin(), args_.end());

  if (m_wallet->get_current_hard_fork() >= HF_VERSION_SALVIUM_ONE_PROOFS) {
@@ -1,5 +1,5 @@
 #define DEF_SALVIUM_VERSION_TAG "@VERSIONTAG@"
-#define DEF_SALVIUM_VERSION "1.0.0-rc4"
+#define DEF_SALVIUM_VERSION "1.0.0-rc6"
 #define DEF_MONERO_VERSION_TAG "release"
 #define DEF_MONERO_VERSION "0.18.3.4"
 #define DEF_MONERO_RELEASE_NAME "One"
@@ -1590,9 +1590,10 @@ std::string wallet2::get_subaddress_as_str(const carrot::subaddress_index_extend

  // Build the cryptonote::account_public_address
  account_public_address addr{address.address_spend_pubkey, address.address_view_pubkey};
+  addr.m_is_carrot = subaddr.derive_type == carrot::AddressDeriveType::Carrot;

  // change this code into base 58
-  return cryptonote::get_account_address_as_str(m_nettype, address.is_subaddress, addr, subaddr.derive_type == carrot::AddressDeriveType::Carrot);
+  return cryptonote::get_account_address_as_str(m_nettype, address.is_subaddress, addr, addr.m_is_carrot);
 }
 //----------------------------------------------------------------------------------------------------
 std::string wallet2::get_integrated_address_as_str(const crypto::hash8& payment_id) const
@@ -2927,6 +2928,7 @@ void wallet2::process_new_scanned_transaction(
        payment.m_timestamp    = ts;
        payment.m_coinbase     = miner_tx;
        payment.m_subaddr_index = i.first;
+        payment.m_tx_type      = tx.type;
        if (pool) {
          if (emplace_or_replace(m_unconfirmed_payments, payment_id, pool_payment_details{payment, double_spend_seen}))
            all_same = false;
@@ -4518,6 +4520,7 @@ bool wallet2::clear()
  m_transfers.clear();
  m_transfers_indices.clear();
  m_locked_coins.clear();
+  m_salvium_txs.clear();
  m_key_images.clear();
  m_pub_keys.clear();
  m_unconfirmed_txs.clear();
@@ -4536,6 +4539,8 @@ bool wallet2::clear()
  m_pool_info_query_time = 0;
  m_skip_to_height = 0;
  m_background_sync_data = background_sync_data_t{};
+  m_subaddresses_extended.clear();
+  m_return_output_info.clear();
  return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -4545,6 +4550,7 @@ void wallet2::clear_soft(bool keep_key_images)
  m_transfers.clear();
  m_transfers_indices.clear();
  m_locked_coins.clear();
+  m_salvium_txs.clear();
  if (!keep_key_images)
    m_key_images.clear();
  m_pub_keys.clear();
@@ -4557,6 +4563,8 @@ void wallet2::clear_soft(bool keep_key_images)
  m_pool_info_query_time = 0;
  m_skip_to_height = 0;
  m_background_sync_data = background_sync_data_t{};
+  m_subaddresses_extended.clear();
+  m_return_output_info.clear();

  cryptonote::block b;
  generate_genesis(b);
@@ -10772,8 +10780,13 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
  boost::unique_lock<hw::device> hwdev_lock (hwdev);
  hw::reset_mode rst(hwdev);  

-  const bool do_carrot_tx_construction = use_fork_rules(HF_VERSION_CARROT);
-  if (do_carrot_tx_construction)
+  // Sanity check correct CN/Carrot address is being used
+  const uint8_t hf_version = get_current_hard_fork();
+  for (const auto &entry: dsts) {
+    THROW_WALLET_EXCEPTION_IF(entry.addr.m_is_carrot && hf_version < HF_VERSION_CARROT, error::wallet_internal_error, "Carrot address supplied, but Carrot not yet active");
+    THROW_WALLET_EXCEPTION_IF(!entry.addr.m_is_carrot && hf_version >= HF_VERSION_CARROT, error::wallet_internal_error, "CryptoNote address supplied, but Carrot is now active");
+  }
+  if (hf_version >= HF_VERSION_CARROT)
  {
    const auto tx_proposals = tools::wallet::make_carrot_transaction_proposals_wallet2_transfer(*this, dsts, priority, extra, tx_type, subaddr_account, subaddr_indices, subtract_fee_from_outputs);
    std::vector<pending_tx> ptx_vector;
@@ -1419,8 +1419,6 @@ private:
      if (ver < 20)
        return;
      a & m_subaddresses.parent();
-      a & m_subaddresses_extended.parent();
-      a & m_return_output_info.parent();
      std::unordered_map<cryptonote::subaddress_index, crypto::public_key> dummy_subaddresses_inv;
      a & dummy_subaddresses_inv;
      a & m_subaddress_labels;
@@ -1461,9 +1459,13 @@ private:
      if(ver < 31)
      {
        m_background_sync_data = background_sync_data_t{};
+        m_subaddresses_extended = {};
+        m_return_output_info = {};
        return;
      }
      a & m_background_sync_data;
+      a & m_subaddresses_extended.parent();
+      a & m_return_output_info.parent();
    }

    BEGIN_SERIALIZE_OBJECT()
@@ -1487,8 +1489,6 @@ private:
      FIELD(m_scanned_pool_txs[0])
      FIELD(m_scanned_pool_txs[1])
      FIELD(m_subaddresses)
-      FIELD(m_subaddresses_extended)
-      FIELD(m_return_output_info)
      FIELD(m_subaddress_labels)
      FIELD(m_additional_tx_keys)
      FIELD(m_attributes)
@@ -1508,9 +1508,13 @@ private:
      if (version < 2)
      {
        m_background_sync_data = background_sync_data_t{};
+        m_subaddresses_extended = {};
+        m_return_output_info = {};
        return true;
      }
      FIELD(m_background_sync_data)
+      FIELD(m_subaddresses_extended)
+      FIELD(m_return_output_info)
    END_SERIALIZE()

    /*!
@@ -29,11 +29,13 @@
 set(functional_tests_sources
  main.cpp
  transactions_flow_test.cpp
+  stake_tx.cpp
  transactions_generation_from_blockchain.cpp)

 set(functional_tests_headers
  transactions_flow_test.h
-  transactions_generation_from_blockchain.h)
+  transactions_generation_from_blockchain.h
+  stake_tx.h)

 monero_add_minimal_executable(functional_tests
  ${functional_tests_sources}
@@ -37,20 +37,24 @@ using namespace epee;
 #include "common/command_line.h"
 #include "common/util.h"
 #include "transactions_flow_test.h"
+#include "stake_tx.h"

 namespace po = boost::program_options;

 namespace
 {
  const command_line::arg_descriptor<bool> arg_test_transactions_flow = {"test_transactions_flow", ""};
+  const command_line::arg_descriptor<bool> arg_test_stake_tx = {"test_stake_tx", "Test stake transactions"};

  const command_line::arg_descriptor<std::string> arg_working_folder  = {"working-folder", "", "."};
  const command_line::arg_descriptor<std::string> arg_source_wallet   = {"source-wallet",  "", "", true};
  const command_line::arg_descriptor<std::string> arg_dest_wallet     = {"dest-wallet",    "", "", true};
  const command_line::arg_descriptor<std::string> arg_daemon_addr_a   = {"daemon-addr-a",  "", "127.0.0.1:8080"};
  const command_line::arg_descriptor<std::string> arg_daemon_addr_b   = {"daemon-addr-b",  "", "127.0.0.1:8082"};
+  const command_line::arg_descriptor<std::string> arg_daemon_addr_stake = {"daemon-addr-stake",  "", "127.0.0.1:29081"};

  const command_line::arg_descriptor<uint64_t> arg_transfer_amount = {"transfer_amount",   "", 60000000000000};
+  const command_line::arg_descriptor<uint64_t> arg_stake_amount = {"stake_amount", "Amount to stake", 100000000};
  const command_line::arg_descriptor<size_t> arg_mix_in_factor     = {"mix-in-factor",     "", 15};
  const command_line::arg_descriptor<size_t> arg_tx_count          = {"tx-count",          "", 100};
  const command_line::arg_descriptor<size_t> arg_tx_per_second     = {"tx-per-second",     "", 20};
@@ -71,14 +75,17 @@ int main(int argc, char* argv[])
  command_line::add_arg(desc_options, command_line::arg_help);

  command_line::add_arg(desc_options, arg_test_transactions_flow);
+  command_line::add_arg(desc_options, arg_test_stake_tx);

  command_line::add_arg(desc_options, arg_working_folder);
  command_line::add_arg(desc_options, arg_source_wallet);
  command_line::add_arg(desc_options, arg_dest_wallet);
  command_line::add_arg(desc_options, arg_daemon_addr_a);
  command_line::add_arg(desc_options, arg_daemon_addr_b);
+  command_line::add_arg(desc_options, arg_daemon_addr_stake);

  command_line::add_arg(desc_options, arg_transfer_amount);
+  command_line::add_arg(desc_options, arg_stake_amount);
  command_line::add_arg(desc_options, arg_mix_in_factor);
  command_line::add_arg(desc_options, arg_tx_count);
  command_line::add_arg(desc_options, arg_tx_per_second);
@@ -126,6 +133,23 @@ int main(int argc, char* argv[])
    
    return 1;
  }
+  else if (command_line::get_arg(vm, arg_test_stake_tx))
+  {
+    std::string working_folder = command_line::get_arg(vm, arg_working_folder);
+    std::string wallet_name;
+    if(command_line::has_arg(vm, arg_source_wallet))
+      wallet_name = command_line::get_arg(vm, arg_source_wallet);
+    std::string daemon_addr_stake = command_line::get_arg(vm, arg_daemon_addr_stake);
+    uint64_t amount_to_stake = command_line::get_arg(vm, arg_stake_amount);
+
+    if(!stake_transaction_test(working_folder, wallet_name, daemon_addr_stake, amount_to_stake))
+      return 1;
+    
+    std::string s;
+    std::cin >> s;
+    
+    return 0;
+  }
  else
  {
    std::cout << desc_options << std::endl;
@@ -0,0 +1,438 @@
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/random_generator.hpp>
+#include <unordered_map>
+
+#include "include_base_utils.h"
+using namespace epee;
+#include "wallet/wallet2.h"
+
+#include "transactions_flow_test.h"
+#include "stake_tx.h"
+
+using namespace cryptonote;
+
+// fixed-difficulty should be at least 7.
+
+
+bool stop_mining(epee::net_utils::http::http_simple_client& http_client){
+    COMMAND_RPC_STOP_MINING::request stop_mine_req = AUTO_VAL_INIT(stop_mine_req);
+    COMMAND_RPC_STOP_MINING::response stop_mine_rsp = AUTO_VAL_INIT(stop_mine_rsp);
+    bool r = net_utils::invoke_http_json("/stop_mining", stop_mine_req, stop_mine_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to stop mining");
+    return true;
+}
+
+bool stake_transaction_test(std::string& working_folder,
+  std::string wallet_name,
+  std::string& daemon_addr_a,
+  uint64_t amount_to_stake) {
+    LOG_PRINT_L0("-----------------------STARTING STAKE TRANSACTION TEST-----------------------");
+    tools::wallet2 w1(network_type::TESTNET);
+    w1.inactivity_lock_timeout(0);
+    w1.ask_password(tools::wallet2::AskPasswordType::AskPasswordNever);
+    w1.setup_background_mining(tools::wallet2::BackgroundMiningSetupType::BackgroundMiningNo); // disable background mining
+    if(wallet_name.empty())
+        wallet_name = generate_random_wallet_name();
+
+    try
+    {
+        w1.generate(working_folder + "/" + wallet_name, "");
+    }
+    catch (const std::exception& e)
+    {
+        LOG_ERROR("failed to generate wallet: " << e.what());
+        return false;
+    }
+
+    w1.init(daemon_addr_a);
+
+    epee::net_utils::http::http_simple_client http_client;
+    bool r = http_client.set_server(daemon_addr_a, boost::none);
+    CHECK_AND_ASSERT_MES(r, false, "failed to connect to daemon");
+
+    // stop mining just in case
+    stop_mining(http_client);
+
+    // get current height
+    COMMAND_RPC_GET_HEIGHT::request height_req = AUTO_VAL_INIT(height_req);
+    COMMAND_RPC_GET_HEIGHT::response height_rsp = AUTO_VAL_INIT(height_rsp);
+    r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
+
+    // pop blocks to make sure of the start height
+    COMMAND_RPC_POP_BLOCKS::request pop_blocks_req = AUTO_VAL_INIT(pop_blocks_req);
+    COMMAND_RPC_POP_BLOCKS::response pop_blocks_rsp = AUTO_VAL_INIT(pop_blocks_rsp);
+    pop_blocks_req.nblocks = height_rsp.height - 1; //keep at least one block
+    r = net_utils::invoke_http_json("/pop_blocks", pop_blocks_req, pop_blocks_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to pop blocks");
+
+    // flush tx pool to make sure of the start state
+    COMMAND_RPC_FLUSH_TRANSACTION_POOL::request flush_req = AUTO_VAL_INIT(flush_req);
+    COMMAND_RPC_FLUSH_TRANSACTION_POOL::response flush_rsp = AUTO_VAL_INIT(flush_rsp);
+    r = net_utils::invoke_http_json_rpc("/json_rpc", "flush_txpool", flush_req, flush_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to flush tx pool");
+
+    w1.rescan_blockchain(true, true, false);
+    MGINFO_GREEN("Using wallets: " << ENDL
+        << "Source:  " << w1.get_account().get_public_address_str(TESTNET) << ENDL << "Path: " << working_folder + "/" + wallet_name << ENDL);
+
+    //lets make some money
+    COMMAND_RPC_START_MINING::request start_mining_req = AUTO_VAL_INIT(start_mining_req);
+    COMMAND_RPC_START_MINING::response start_mining_rsp = AUTO_VAL_INIT(start_mining_rsp);
+    start_mining_req.miner_address = w1.get_account().get_public_address_str(TESTNET);
+    start_mining_req.threads_count = 1;
+    r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+    CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
+
+    // mine until we reach to block 710
+    height_rsp.height = 1;
+    while (height_rsp.height < 710)
+    {
+        misc_utils::sleep_no_w(1000); // The difficulty should be high enough to stop mining before reaching block 800.”
+        r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+        CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon 1");
+    }
+
+    // stop mining
+    stop_mining(http_client);
+
+    // refresh wallet
+    uint64_t blocks_fetched = 0;
+    bool received_money;
+    w1.refresh(true, 0, blocks_fetched, received_money);
+
+    MGINFO_GREEN("balance: " << w1.balance(0, "SAL", false));
+
+    // create and submit CN SAL stake transaction ~ block 710
+    std::vector<cryptonote::tx_destination_entry> dsts;
+    cryptonote::tx_destination_entry de;
+    de.addr = w1.get_account().get_keys().m_account_address;
+    de.amount = amount_to_stake;
+    de.is_subaddress = false;
+    dsts.push_back(de);
+    try
+    {
+        std::vector<tools::wallet2::pending_tx> ptx;
+        ptx = w1.create_transactions_2(dsts, "SAL", "SAL", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
+        for (auto &p: ptx)
+            w1.commit_tx(p);
+    }
+    catch (const std::exception&)
+    {   
+        LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height <<  "with SAL");
+        return false;
+    }
+
+    // lets make some money
+    r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+    CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
+
+    // mine until we reach to block 1010
+    while (height_rsp.height < 1010) // difficulty should be high enough to stop mining before reaching block 1080
+    {
+      misc_utils::sleep_no_w(1000);
+      r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+      CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
+    }
+
+    // stop mining if not stopped already
+    stop_mining(http_client);
+
+    r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+
+    // Check the height to ensure we are receiving yield payments before the Carrot hard fork at block 1100
+    if (!r)
+    {
+        LOG_ERROR("failed to get height from daemon");
+        return false;
+    }
+    if (height_rsp.height > 1080)
+    {
+        LOG_PRINT_L0("----!! The current height (" << height_rsp.height << ") exceeds the acceptable range for this test. Please restart the node with an increased fixed difficulty. !!----");
+    }
+
+
+    // refresh wallet
+    blocks_fetched = 0;
+    received_money = false;
+    bool ok = false;
+    if(!w1.refresh(true, blocks_fetched, received_money, ok))
+    {
+        LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
+        return false;
+    }
+
+    // check if we have received yield from CN SAL stake transaction ~1010
+    tools::wallet2::transfer_container incoming_transfers;
+    // scan payments
+    w1.get_transfers(incoming_transfers);
+    CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
+    bool found = false;
+    for (const auto& p: incoming_transfers)
+    {
+        if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
+        {
+            if (p.m_amount >  amount_to_stake)
+            {
+                LOG_PRINT_L0("found yield from CN SAL stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+            }
+            else
+            {
+                LOG_ERROR("invalid yield amount from CN SAL stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                return false;
+            }
+            found = true;
+            break;
+        }
+    }
+    CHECK_AND_ASSERT_MES(found, false, "failed to find yield from CN SAL stake transaction");
+
+    //create and submit CN SAL1 stake transaction
+    dsts.clear();
+    de.addr = w1.get_account().get_keys().m_account_address;
+    de.amount = amount_to_stake;
+    de.is_subaddress = false;
+    dsts.push_back(de);
+    try
+    {
+        std::vector<tools::wallet2::pending_tx> ptx;
+        ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
+        for (auto &p: ptx)
+            w1.commit_tx(p);
+    }
+    catch (const std::exception&)
+    {   
+        LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height <<  "with SAL1");
+        return false;
+    }
+
+    // lets make some money
+    r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+    CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
+
+    // mine until we reach to block 1091
+    while (height_rsp.height < 1091)
+    {
+      misc_utils::sleep_no_w(100);
+      r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(1));
+      CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
+    }
+
+    // stop mining if not stopped already
+    stop_mining(http_client);
+
+    // refresh wallet
+    blocks_fetched = 0;
+    received_money = false;
+    ok = false;
+    if(!w1.refresh(true, blocks_fetched, received_money, ok))
+    {
+        LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
+        return false;
+    }
+
+    // check if we have received yield from CN SAL stake transaction
+    incoming_transfers.clear();
+    // scan payments
+    w1.get_transfers(incoming_transfers);
+    CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
+    found = false;
+    for (const auto& p: incoming_transfers)
+    {
+        if (p.m_block_height < 1010) continue; // skip payments from the first stake transaction
+        if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
+        {
+            if (p.m_amount >  amount_to_stake)
+            {
+                LOG_PRINT_L0("found yield from CN SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+            }
+            else
+            {
+                LOG_ERROR("invalid yield amount from CN SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                return false;
+            }
+            found = true;
+            break;
+        }
+    }
+    CHECK_AND_ASSERT_MES(found, false, "failed to find yield from CN SAL1 stake transaction");
+
+    // pop blocks to make sure of the start height
+    pop_blocks_req = AUTO_VAL_INIT(pop_blocks_req);
+    pop_blocks_req.nblocks = height_rsp.height - 1090; //keep at least 1090 blocks
+    r = net_utils::invoke_http_json("/pop_blocks", pop_blocks_req, pop_blocks_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to pop blocks");
+
+    // flush tx pool to make sure of the start state
+    r = net_utils::invoke_http_json_rpc("/json_rpc", "flush_txpool", flush_req, flush_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to flush tx pool");
+
+    // rescan blockchain to ensure wallet is in sync after popping blocks
+    w1.rescan_blockchain(true, true, false);
+    MGINFO_GREEN("Using wallets: " << ENDL
+    << "Source:  " << w1.get_account().get_public_address_str(TESTNET) << ENDL << "Path: " << working_folder + "/" + wallet_name << ENDL);
+
+    // Create and stake CN SAL1 stake transaction and get yield after the Carrot hard fork at block 1100 ~ block 1090
+    dsts.clear();
+    de.addr = w1.get_account().get_keys().m_account_address;
+    de.amount = amount_to_stake;
+    de.is_subaddress = false;
+    dsts.push_back(de);
+    try
+    {
+        std::vector<tools::wallet2::pending_tx> ptx;
+        ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
+        for (auto &p: ptx)
+            w1.commit_tx(p);
+    }
+    catch (const std::exception&)
+    {   
+        LOG_ERROR("failed to create/commit CN stake transaction at height: " << height_rsp.height <<  "with SAL1");
+        return false;
+    }
+
+    /// lets make some money
+    r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+    CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
+
+    // mine until we reach to block 1100
+    while (height_rsp.height < 1100)
+    {
+      misc_utils::sleep_no_w(1000);
+      r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+      CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
+    }
+
+    // stop mining if not stopped already
+    stop_mining(http_client);
+
+    // Carrot will not be able to connect to the network until the node is restarted
+    LOG_PRINT_L0("---------------------- PLEASE RESTART THE NODE NOW ----------------------");
+    misc_utils::sleep_no_w(1000); // wait for the log to be printed
+    LOG_PRINT_L2("Press any key to continue once the node is back online");
+    std::string input;
+    std::cin >> input;
+
+    // restart the http client connection
+    r = http_client.set_server(daemon_addr_a, boost::none);
+    CHECK_AND_ASSERT_MES(r, false, "failed to connect to daemon");
+    r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "Daemon is not yet back online");
+
+    LOG_PRINT_L0("Daemon is back online, continuing tests");
+    LOG_PRINT_L2("Carrot has been enabled.");
+
+    // restart the wallet connection
+    w1.init(daemon_addr_a);
+
+    // Create and stake Carrot SAL1 stake transaction ~ block 1100
+    dsts.clear();
+    de.addr = w1.get_account().get_keys().m_carrot_main_address;
+    de.amount = amount_to_stake;
+    de.is_subaddress = false;
+    dsts.push_back(de);
+    try
+    {
+        std::vector<tools::wallet2::pending_tx> ptx;
+        ptx = w1.create_transactions_2(dsts, "SAL1", "SAL1", cryptonote::transaction_type::STAKE, 15, 0, 0, std::vector<uint8_t>(), 0, {});
+        for (auto &p: ptx)
+            w1.commit_tx(p);
+    }
+    catch (const std::exception&)
+    {   
+        LOG_ERROR("failed to create/commit Carrot stake transaction at height: " << height_rsp.height <<  " with SAL1");
+        return false;
+    }
+
+    // lets make some money
+    start_mining_req.miner_address = w1.get_account().get_carrot_public_address_str(TESTNET);
+    start_mining_req.threads_count = 1;
+    r = net_utils::invoke_http_json("/start_mining", start_mining_req, start_mining_rsp, http_client, std::chrono::seconds(10));
+    CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+    CHECK_AND_ASSERT_MES(start_mining_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
+
+    // mine until we reach to block 1300
+    while (height_rsp.height < 1300)
+    {
+      misc_utils::sleep_no_w(1000);
+      r = net_utils::invoke_http_json("/get_height", height_req, height_rsp, http_client, std::chrono::seconds(10));
+      CHECK_AND_ASSERT_MES(r, false, "failed to get height from daemon");
+    }
+
+    // stop mining
+    stop_mining(http_client);
+
+     // refresh wallet
+    blocks_fetched = 0;
+    received_money = false;
+    ok = false;
+    if(!w1.refresh(true, blocks_fetched, received_money, ok))
+    {
+        LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
+        return false;
+    }
+
+    // check if we have received yield from Carrot SAL1 stake transaction
+    incoming_transfers.clear();
+    // scan payments
+    w1.get_transfers(incoming_transfers);
+    CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
+    found = false;
+    for (const auto& p: incoming_transfers)
+    {
+        if (p.m_block_height > 1112 || p.m_block_height < 1090) continue; // Skip payments originating from CryptoNote stake transactions
+        if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
+        {
+            if (p.m_amount >  amount_to_stake)
+            {
+                LOG_PRINT_L0("found yield from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                LOG_PRINT_L2("Stake was made before the Carrot hard fork and yield received after Carrot hard fork");
+            }
+            else
+            {
+                LOG_ERROR("invalid yield amount from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                return false;
+            }
+            found = true;
+            break;
+        }
+    }
+    CHECK_AND_ASSERT_MES(found, false, "failed to find yield from Carrot SAL1 stake transaction");
+
+
+    // check if we have received yield from Carrot SAL1 stake transaction
+    incoming_transfers.clear();
+    // scan payments
+    w1.get_transfers(incoming_transfers);
+    CHECK_AND_ASSERT_MES(!incoming_transfers.empty(), false, "failed to get payments");
+    found = false;
+    for (const auto& p: incoming_transfers)
+    {
+        if (p.m_block_height <= 1112) continue; // // Skip payments originating from CryptoNote stake transactions
+        if (p.m_tx.type == cryptonote::transaction_type::PROTOCOL)
+        {
+            if (p.m_amount >  amount_to_stake)
+            {
+                LOG_PRINT_L0("found yield from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                LOG_PRINT_L0("All yields from stake transactions have been successfully found!");
+            }
+            else
+            {
+                LOG_ERROR("invalid yield amount from Carrot SAL1 stake transaction: " << p.m_amount - amount_to_stake << " at height: " << p.m_block_height);
+                return false;
+            }
+            found = true;
+            break;
+        }
+    }
+    CHECK_AND_ASSERT_MES(found, false, "failed to find yield from Carrot SAL1 stake transaction");
+    LOG_PRINT_L2("All yields from stake transactions have been successfully found!");
+    LOG_PRINT_L0("-----------------------STAKE TRANSACTION TEST PASSED-----------------------");
+
+    return true;
+}
@@ -0,0 +1,34 @@
+// Copyright (c) 2014-2022, The Monero 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.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+bool stake_transaction_test(std::string& working_folder,
+  std::string wallet_name,
+  std::string& daemon_addr_a,
+  uint64_t amount_to_stake);
@@ -28,6 +28,8 @@
 // 
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers

+std::string generate_random_wallet_name();
+
 bool transactions_flow_test(std::string& working_folder, 
                            std::string path_source_wallet, 
                            std::string path_target_wallet, 
@@ -323,13 +323,10 @@ TEST(carrot_core, main_address_special_scan_completeness)
        const crypto::key_image tx_first_key_image = rct::rct2ki(rct::pkGen()); 

        RCTOutputEnoteProposal enote_proposal;
-        RCTOutputEnoteProposal return_enote;
        get_output_proposal_special_v1(proposal,
            keys.k_view_incoming_dev,
            tx_first_key_image,
-            cryptonote::transaction_type::TRANSFER, // tx_type
            std::nullopt,
-            return_enote,
            enote_proposal);

        ASSERT_EQ(proposal.amount, enote_proposal.amount);
@@ -403,13 +400,10 @@ TEST(carrot_core, subaddress_special_scan_completeness)
        const crypto::key_image tx_first_key_image = rct::rct2ki(rct::pkGen()); 

        RCTOutputEnoteProposal enote_proposal;
-        RCTOutputEnoteProposal return_enote;
        get_output_proposal_special_v1(proposal,
            keys.k_view_incoming_dev,
            tx_first_key_image,
-            cryptonote::transaction_type::TRANSFER, // tx_type
            std::nullopt,
-            return_enote,
            enote_proposal);

        ASSERT_EQ(proposal.amount, enote_proposal.amount);
@@ -460,7 +454,7 @@ TEST(carrot_core, subaddress_special_scan_completeness)
 //----------------------------------------------------------------------------------------------------------------------
 TEST(carrot_core, main_address_internal_scan_completeness)
 {
-    mock::mock_carrot_and_legacy_keys keys;
+    carrot::carrot_and_legacy_account keys;
    keys.generate();

    const CarrotDestinationV1 main_address = keys.cryptonote_address();
@@ -481,10 +475,13 @@ TEST(carrot_core, main_address_internal_scan_completeness)
        const crypto::key_image tx_first_key_image = rct::rct2ki(rct::pkGen()); 

        RCTOutputEnoteProposal enote_proposal;
+        RCTOutputEnoteProposal return_proposal;
        get_output_proposal_internal_v1(proposal,
            keys.s_view_balance_dev,
            tx_first_key_image,
            std::nullopt,
+            cryptonote::transaction_type::TRANSFER, // tx_type
+            return_proposal,
            enote_proposal);

        ASSERT_EQ(proposal.amount, enote_proposal.amount);
@@ -498,15 +495,19 @@ TEST(carrot_core, main_address_internal_scan_completeness)
        crypto::secret_key recovered_amount_blinding_factor;
        CarrotEnoteType recovered_enote_type;
        janus_anchor_t recovered_internal_message;
+        crypto::public_key return_address_out;
+        bool is_return_out;
        const bool scan_success = try_scan_carrot_enote_internal_receiver(enote_proposal.enote,
-            keys.s_view_balance_dev,
+            keys,
            recovered_sender_extension_g,
            recovered_sender_extension_t,
            recovered_address_spend_pubkey,
            recovered_amount,
            recovered_amount_blinding_factor,
            recovered_enote_type,
-            recovered_internal_message);
+            recovered_internal_message,
+            return_address_out,
+            is_return_out);

        ASSERT_TRUE(scan_success);

@@ -527,7 +528,7 @@ TEST(carrot_core, main_address_internal_scan_completeness)
 //----------------------------------------------------------------------------------------------------------------------
 TEST(carrot_core, subaddress_internal_scan_completeness)
 {
-    mock::mock_carrot_and_legacy_keys keys;
+    carrot::carrot_and_legacy_account keys;
    keys.generate();

    const uint32_t j_major = crypto::rand_idx(mock::MAX_SUBADDRESS_MAJOR_INDEX);
@@ -551,10 +552,13 @@ TEST(carrot_core, subaddress_internal_scan_completeness)
        const crypto::key_image tx_first_key_image = rct::rct2ki(rct::pkGen()); 

        RCTOutputEnoteProposal enote_proposal;
+        RCTOutputEnoteProposal return_proposal;
        get_output_proposal_internal_v1(proposal,
            keys.s_view_balance_dev,
            tx_first_key_image,
            std::nullopt,
+            cryptonote::transaction_type::TRANSFER, // tx_type
+            return_proposal,
            enote_proposal);

        ASSERT_EQ(proposal.amount, enote_proposal.amount);
@@ -568,15 +572,19 @@ TEST(carrot_core, subaddress_internal_scan_completeness)
        crypto::secret_key recovered_amount_blinding_factor;
        CarrotEnoteType recovered_enote_type;
        janus_anchor_t recovered_internal_message;
+        crypto::public_key return_address_out;
+        bool is_return_out;
        const bool scan_success = try_scan_carrot_enote_internal_receiver(enote_proposal.enote,
-            keys.s_view_balance_dev,
+            keys,
            recovered_sender_extension_g,
            recovered_sender_extension_t,
            recovered_address_spend_pubkey,
            recovered_amount,
            recovered_amount_blinding_factor,
            recovered_enote_type,
-            recovered_internal_message);
+            recovered_internal_message,
+            return_address_out,
+            is_return_out);

        ASSERT_TRUE(scan_success);

@@ -808,11 +808,11 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_10)
    tx_proposal.self_sender_index = 2;

    // 1 subaddress payment (subtractable)
-    acc0.second.emplace_back().first = CarrotPaymentProposalV1{ = {CarrotPaymentProposalV1{
+    acc0.second.emplace_back().first = CarrotPaymentProposalV1{
        .destination = acc0.first.subaddress({{2, 3}}),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // 1 main address payment
    acc1.second.emplace_back().first = CarrotPaymentProposalV1{
@@ -826,7 +826,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_10)
        .destination = acc3.first.cryptonote_address(gen_payment_id()),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // specify fee per weight
    tx_proposal.fee_per_weight = 314159;
@@ -914,11 +914,11 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_12)
    tx_proposal.self_sender_index = 2;

    // 2 subaddress payment (1 subtractable)
-    acc0.second.emplace_back().first = CarrotPaymentProposalV1{ = {CarrotPaymentProposalV1{
+    acc0.second.emplace_back().first =CarrotPaymentProposalV1{
        .destination = acc0.first.subaddress({{2, 3}}),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };
    acc0.second.push_back(acc0.second.front());
    acc0.second.back().first.randomness = gen_janus_anchor(); //mangle anchor_norm
    acc0.second.back().second = false;                        //set not subtractable, first already is
@@ -937,7 +937,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_12)
        .destination = acc3.first.cryptonote_address(gen_payment_id()),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // 1 main address selfsend
    tx_proposal.explicit_selfsend_proposals.emplace_back().first.proposal = CarrotPaymentProposalSelfSendV1{
@@ -955,7 +955,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_12)
            .enote_type = CarrotEnoteType::CHANGE
        },
        .subaddr_index = {{4, 19}}
-    }, true};
+    };

    // specify fee per weight
    tx_proposal.fee_per_weight = 314159;
@@ -1021,11 +1021,11 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_14)
    tx_proposal.self_sender_index = 2;

    // 1 subaddress payment (subtractable)
-    acc0.second.emplace_back().first = CarrotPaymentProposalV1{ = {CarrotPaymentProposalV1{
+    acc0.second.emplace_back().first = CarrotPaymentProposalV1{
        .destination = acc0.first.subaddress({{2, 3}}),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // 1 main address payment
    acc1.second.emplace_back().first = CarrotPaymentProposalV1{
@@ -1039,7 +1039,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_14)
        .destination = acc3.first.cryptonote_address(gen_payment_id()),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // specify fee per weight
    tx_proposal.fee_per_weight = 314159;
@@ -1071,11 +1071,11 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_15)
    tx_proposal.self_sender_index = 2;

    // 2 subaddress payment (subtractable)
-    acc0.second.emplace_back().first = CarrotPaymentProposalV1{ = {CarrotPaymentProposalV1{
+    acc0.second.emplace_back().first = CarrotPaymentProposalV1{
        .destination = acc0.first.subaddress({{2, 3}}),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };
    acc0.second.push_back(acc0.second.front());
    acc0.second.back().first.randomness = gen_janus_anchor(); //mangle anchor_norm

@@ -1084,7 +1084,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_15)
        .destination = acc1.first.cryptonote_address(),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };
    acc1.second.push_back(acc1.second.front());
    acc1.second.back().first.randomness = gen_janus_anchor(); //mangle anchor_norm

@@ -1093,7 +1093,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_15)
        .destination = acc3.first.cryptonote_address(gen_payment_id()),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // specify fee per weight
    tx_proposal.fee_per_weight = 314159;
@@ -1125,11 +1125,11 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_16)
    tx_proposal.self_sender_index = 2;

    // 2 subaddress payment (subtractable)
-    acc0.second.emplace_back().first = CarrotPaymentProposalV1{ = {CarrotPaymentProposalV1{
+    acc0.second.emplace_back().first = CarrotPaymentProposalV1{
        .destination = acc0.first.subaddress({{2, 3}}),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };
    acc0.second.push_back(acc0.second.front());
    acc0.second.back().first.randomness = gen_janus_anchor(); //mangle anchor_norm

@@ -1138,7 +1138,7 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_16)
        .destination = acc1.first.cryptonote_address(),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };
    acc1.second.push_back(acc1.second.front());
    acc1.second.back().first.randomness = gen_janus_anchor(); //mangle anchor_norm

@@ -1147,14 +1147,16 @@ TEST(carrot_impl, multi_account_transfer_over_transaction_16)
        .destination = acc3.first.cryptonote_address(gen_payment_id()),
        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
        .randomness = gen_janus_anchor()
-    }, true};
+    };

    // 1 main address selfsend (subtractable)
-    tx_proposal.explicit_selfsend_proposals.emplace_back() = {CarrotPaymentProposalSelfSendV1{
-        .destination_address_spend_pubkey = acc2.first.carrot_account_spend_pubkey,
-        .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
-        .enote_type = CarrotEnoteType::PAYMENT,
-        // no internal messages for legacy self-sends
+    tx_proposal.explicit_selfsend_proposals.emplace_back() = {CarrotPaymentProposalVerifiableSelfSendV1{
+        .proposal = CarrotPaymentProposalSelfSendV1{
+            .destination_address_spend_pubkey = acc2.first.carrot_account_spend_pubkey,
+            .amount = crypto::rand_idx<rct::xmr_amount>(1000000),
+            .enote_type = CarrotEnoteType::PAYMENT,
+            // no internal messages for legacy self-sends
+        }
    }, true};

    // 1 subaddress selfsend (subtractable)
@@ -359,15 +359,20 @@ void mock_scan_enote_set(const std::vector<CarrotEnoteV1> &enotes,
        const CarrotEnoteV1 &enote = enotes.at(output_index);

        mock_scan_result_t scan_result{};
+        carrot::carrot_and_legacy_account account;
+        crypto::public_key return_address_out;
+        bool is_return_out;
        const bool r = try_scan_carrot_enote_internal_receiver(enote,
-            keys.s_view_balance_dev,
+            account,
            scan_result.sender_extension_g,
            scan_result.sender_extension_t,
            scan_result.address_spend_pubkey,
            scan_result.amount,
            scan_result.amount_blinding_factor,
            scan_result.enote_type,
-            scan_result.internal_message);
+            scan_result.internal_message,
+            return_address_out,
+            is_return_out);

        scan_result.output_index = output_index;

@@ -54,7 +54,7 @@ static auto auto_wiper(T &obj)
 }
 //----------------------------------------------------------------------------------------------------------------------
 std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_origin_tx(
-    mock::mock_carrot_and_legacy_keys &alice,
+    carrot::carrot_and_legacy_account &alice,
    CarrotDestinationV1 &bob_address
 ) {
    // spend input
@@ -62,9 +62,10 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_origin_

    // make change output
    RCTOutputEnoteProposal enote_proposal_change;
+    RCTOutputEnoteProposal return_proposal;
    get_output_proposal_internal_v1(
        CarrotPaymentProposalSelfSendV1{
-            .destination_address_spend_pubkey = alice.carrot_account_spend_pubkey,
+            .destination_address_spend_pubkey = alice.get_keys().m_carrot_account_address.m_spend_public_key,
            .amount = crypto::rand<rct::xmr_amount>(),
            .enote_type = CarrotEnoteType::CHANGE,
            .enote_ephemeral_pubkey = gen_x25519_pubkey(),
@@ -72,6 +73,8 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_origin_
        alice.s_view_balance_dev,
        tx_first_key_image,
        std::nullopt,
+        cryptonote::transaction_type::TRANSFER, // tx_type
+        return_proposal,
        enote_proposal_change
    );

@@ -138,7 +141,7 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_origin_
 }
 //----------------------------------------------------------------------------------------------------------------------
 std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_return_tx(
-    mock::mock_carrot_and_legacy_keys &bob,
+    carrot::carrot_and_legacy_account &bob,
    std::vector<RCTOutputEnoteProposal> &origin_tx_outputs
 ) {
    // [0] enote is change, [1] enote bob received
@@ -169,7 +172,7 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_return_
        received_output,
        std::nullopt,
        origin_tx_shared_secret_unctx,
-        {&bob.carrot_account_spend_pubkey, 1},
+        {&bob.get_keys().m_carrot_account_address.m_spend_public_key, 1},
        bob.k_view_incoming_dev,
        recovered_sender_extension_g,
        recovered_sender_extension_t,
@@ -182,7 +185,7 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_return_
    EXPECT_TRUE(scan_success);

    // check we can spend it
-    EXPECT_TRUE(bob.can_open_fcmp_onetime_address(bob.carrot_account_spend_pubkey,
+    EXPECT_TRUE(bob.can_open_fcmp_onetime_address(bob.get_keys().m_carrot_account_address.m_spend_public_key,
                                                  recovered_sender_extension_g,
                                                  recovered_sender_extension_t,
                                                  received_output.onetime_address));
@@ -237,7 +240,7 @@ std::tuple<std::vector<RCTOutputEnoteProposal>, crypto::public_key> make_return_
 TEST(carrot_sparc, main_address_return_payment_normal_scan_completeness)
 {
    // these will generate a new format carrot address.
-    mock::mock_carrot_and_legacy_keys alice, bob;
+    carrot::carrot_and_legacy_account alice, bob;
    alice.generate();
    bob.generate();

@@ -332,20 +335,23 @@ TEST(carrot_sparc, main_address_return_payment_normal_scan_completeness)
    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.s_view_balance_dev,
+                                                                             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);
-    
+                                                                             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.carrot_account_spend_pubkey,
+    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));
@@ -353,7 +359,7 @@ TEST(carrot_sparc, main_address_return_payment_normal_scan_completeness)
    // 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.carrot_account_spend_pubkey,
+    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));
@@ -38,9 +38,9 @@
 
 using namespace cryptonote;
 
-const uint64_t AMOUNT_BURNT = 1000000000000; // 1 SAL
-const uint64_t STAKE_REWARD = 10000000000000; // 10 SAL
-const uint64_t STAKE_PAYOUT = 216001000000000000; // 216k SAL
+const uint64_t AMOUNT_BURNT = 1000000000000; // 10000 SAL
+const uint64_t STAKE_REWARD = 10000000000000; // 100000 SAL
+const uint64_t STAKE_PAYOUT = 216001000000000000; // 2160000k SAL
 const uint64_t STAKE_LOCK_PERIOD = get_config(network_type::FAKECHAIN).STAKE_LOCK_PERIOD;
 const auto AUDIT_HARD_FORKS = get_config(network_type::FAKECHAIN).AUDIT_HARD_FORKS;
 
@@ -84,7 +84,7 @@ TEST(wallet_tx_builder, input_selection_basic)
    tools::wallet2::transfer_container transfers;
    for (size_t i = 0; i < 10; ++i)
    {
-        tools::wallet2::transfer_details &td = tools::add_element(transfers);
+        tools::wallet2::transfer_details &td = transfers.emplace_back();
        td = gen_transfer_details();
        td.m_block_height = transfers.size(); // small ascending block heights
    }
@@ -206,7 +206,7 @@ TEST(wallet_tx_builder, make_carrot_transaction_proposals_wallet2_transfer_2)
    std::unordered_map<crypto::key_image, std::size_t> allowed_transfers;
    for (size_t i = 0; i < FCMP_PLUS_PLUS_MAX_INPUTS + 2; ++i)
    {
-        tools::wallet2::transfer_details &td = tools::add_element(transfers);
+        tools::wallet2::transfer_details &td = transfers.emplace_back();
        td = gen_transfer_details();
        td.m_subaddr_index.major = (i % 2 == 0) ? spending_subaddr_account : (spending_subaddr_account - 1);
        td.m_subaddr_index.minor = crypto::rand_range<std::uint32_t>(0, carrot::mock::MAX_SUBADDRESS_MINOR_INDEX);
Author	SHA1	Message	Date
Some Random Crypto Guy	d8b18b17f6	bumped RC version	2025-09-30 22:02:11 +01:00
Some Random Crypto Guy	5347266ed9	fixed a couple of wallet cache issues; fixed rescan_bc bug	2025-09-30 22:01:35 +01:00
somerandomcryptoguy	419c26adbf	added tx_type setting for payment details - needed for wallet API (#61 ) Co-authored-by: Some Random Crypto Guy <somerandomcryptoguy@protonmail.com>	2025-09-12 16:34:02 +01:00
auruya	7727bdb51e	Add stake tests (#60 ) * update unit tests * add stake transaction functional test	2025-09-12 09:39:02 +01:00
Some Random Crypto Guy	37a58646fd	bumped RC version	2025-09-10 09:20:17 +01:00
somerandomcryptoguy	0e747e3f15	remove 2nd fork - STAKE issues resolved cleanly (#58 ) * removed HF11 * fixed problem with AUDIT generation; fixed issue with empty PROTOCOL TX after HF10 * fixed protocol_tx version if empty at HF10 commencement; added validation of correct address type for destinations on TRANSFER * fix is_carrot for stake txs --------- Co-authored-by: Some Random Crypto Guy <somerandomcryptoguy@protonmail.com> Co-authored-by: auruya <dream.glorix@gmail.com>	2025-09-10 09:16:14 +01:00
auruya	caf8a0a962	fix-prevalidate-protocol-tx-for-carrot (#57 )	2025-09-04 20:43:16 +01:00