From 8f25f0d460d697214b48f0d62e90998ea4c49df9 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Wed, 26 Jun 2024 21:15:44 +0200
Subject: [PATCH 01/37] bitcoin-secp256k1 submodule added + native crypto test

---
 .gitmodules                             |  3 ++
 contrib/CMakeLists.txt                  | 11 +++++
 src/CMakeLists.txt                      |  2 +
 tests/functional_tests/crypto_tests.cpp | 60 +++++++++++++++++++++++++
 4 files changed, 76 insertions(+)

diff --git a/.gitmodules b/.gitmodules
index 97a855bd..57896bbb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -12,3 +12,6 @@
 [submodule "contrib/jwt-cpp"]
 	path = contrib/jwt-cpp
 	url = https://github.com/Thalhammer/jwt-cpp.git
+[submodule "contrib/bitcoin-secp256k1"]
+	path = contrib/bitcoin-secp256k1
+	url = https://github.com/bitcoin-core/secp256k1.git
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index abfc4885..c1a5535f 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -5,6 +5,14 @@ add_subdirectory(zlib)
 add_subdirectory(db)
 add_subdirectory(ethereum)
 
+option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." OFF)
+option(SECP256K1_BUILD_TESTS "Build tests." OFF)
+option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." OFF)
+option(SECP256K1_BUILD_CTIME_TESTS "Build constant-time tests." OFF)
+option(SECP256K1_BUILD_EXAMPLES "Build examples." OFF)
+set_property(GLOBAL PROPERTY CTEST_TARGETS_ADDED 1)
+add_subdirectory(bitcoin-secp256k1)
+
 if( NOT DISABLE_TOR)
   add_subdirectory(tor-connect)
 endif()
@@ -23,6 +31,9 @@ set_property(TARGET libminiupnpc-static PROPERTY FOLDER "contrib")
 set_property(TARGET zlibstatic PROPERTY FOLDER "contrib")
 set_property(TARGET mdbx PROPERTY FOLDER "contrib")
 set_property(TARGET lmdb PROPERTY FOLDER "contrib")
+set_property(TARGET secp256k1 PROPERTY FOLDER "contrib")
+set_property(TARGET secp256k1_precomputed PROPERTY FOLDER "contrib")
+
 if( NOT DISABLE_TOR)
   set_property(TARGET tor-connect PROPERTY FOLDER "contrib")
 endif()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 200096f3..563b4266 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -116,6 +116,8 @@ else()
 endif()
 
 add_library(crypto ${CRYPTO})
+add_dependencies(crypto secp256k1)
+target_link_libraries(crypto secp256k1)
 
 add_library(currency_core ${CURRENCY_CORE})
 add_dependencies(currency_core version  ${PCH_LIB_NAME})
diff --git a/tests/functional_tests/crypto_tests.cpp b/tests/functional_tests/crypto_tests.cpp
index 546fff99..6cd876b5 100644
--- a/tests/functional_tests/crypto_tests.cpp
+++ b/tests/functional_tests/crypto_tests.cpp
@@ -1896,6 +1896,66 @@ TEST(crypto, generators_precomp)
 #undef CHECK_PRECOMP
 }
 
+#include "bitcoin-secp256k1/include/secp256k1.h"
+TEST(crypto, secp256k1_ecdsa_native)
+{
+  bool r = false;
+
+  secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+  uint8_t randomness[32];
+  crypto::generate_random_bytes(sizeof randomness, randomness);
+  secp256k1_context_randomize(ctx, randomness);
+
+  uint8_t seckey[32] = {};
+  while(true)
+  {
+    crypto::generate_random_bytes(sizeof seckey, seckey);
+    if (secp256k1_ec_seckey_verify(ctx, seckey))
+      break;
+  }
+
+  secp256k1_pubkey pubkey{};
+  ASSERT_TRUE(secp256k1_ec_pubkey_create(ctx, &pubkey, seckey));
+  
+  uint8_t compressed_pubkey[33] = {};
+  size_t output_len = sizeof compressed_pubkey;
+  ASSERT_TRUE(secp256k1_ec_pubkey_serialize(ctx, compressed_pubkey, &output_len, &pubkey, SECP256K1_EC_COMPRESSED));
+  ASSERT_TRUE(output_len == sizeof compressed_pubkey);
+
+
+  secp256k1_ecdsa_signature secp256k1_ecdsa_sig{};
+  hash msg_hash = hash_helper_t::h("message");
+  ASSERT_TRUE(secp256k1_ecdsa_sign(ctx, &secp256k1_ecdsa_sig, (const unsigned char*)&msg_hash, seckey, NULL, NULL));
+
+  // Serialize the signature in a compact form.
+  unsigned char secp256k1_ecdsa_sig_serialized[64] = {};
+  ASSERT_TRUE(secp256k1_ecdsa_signature_serialize_compact(ctx, secp256k1_ecdsa_sig_serialized, &secp256k1_ecdsa_sig));
+
+  //
+  // Verification
+  //
+
+  secp256k1_ecdsa_sig = secp256k1_ecdsa_signature{};
+  pubkey = secp256k1_pubkey{};
+
+  // Deserialize the signature.
+  ASSERT_TRUE(secp256k1_ecdsa_signature_parse_compact(ctx, &secp256k1_ecdsa_sig, secp256k1_ecdsa_sig_serialized));
+
+  // Deserialize the public key. This will return 0 if the public key can't be parsed correctly. */
+  ASSERT_TRUE(secp256k1_ec_pubkey_parse(ctx, &pubkey, compressed_pubkey, sizeof(compressed_pubkey)));
+
+  // verify a signature
+  ASSERT_TRUE(secp256k1_ecdsa_verify(ctx, &secp256k1_ecdsa_sig, (const unsigned char*)&msg_hash, &pubkey));
+
+  // verify using a static context
+  ASSERT_TRUE(secp256k1_ecdsa_verify(secp256k1_context_static, &secp256k1_ecdsa_sig, (const unsigned char*)&msg_hash, &pubkey));
+
+  
+  // Epilogue
+  secp256k1_context_destroy(ctx);
+  return true;
+}
+
 
 
 //

From 3b6fa728b7fd392bf878b824468567a7a9fd68cf Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 1 Jul 2024 14:14:00 +0200
Subject: [PATCH 02/37] added bitcoin-secp256k1 submodule at version 5.0

---
 contrib/bitcoin-secp256k1 | 1 +
 1 file changed, 1 insertion(+)
 create mode 160000 contrib/bitcoin-secp256k1

diff --git a/contrib/bitcoin-secp256k1 b/contrib/bitcoin-secp256k1
new file mode 160000
index 00000000..e3a885d4
--- /dev/null
+++ b/contrib/bitcoin-secp256k1
@@ -0,0 +1 @@
+Subproject commit e3a885d42a7800c1ccebad94ad1e2b82c4df5c65

From 486fb05f73dbdf13fa3c86e34a80f01cca36c78a Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 1 Jul 2024 21:35:27 +0200
Subject: [PATCH 03/37] updated submodule bitcoin-secp256k1 in attempt to fix
 gcc compilation issue

---
 contrib/bitcoin-secp256k1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/bitcoin-secp256k1 b/contrib/bitcoin-secp256k1
index e3a885d4..a5269373 160000
--- a/contrib/bitcoin-secp256k1
+++ b/contrib/bitcoin-secp256k1
@@ -1 +1 @@
-Subproject commit e3a885d42a7800c1ccebad94ad1e2b82c4df5c65
+Subproject commit a5269373fa13ff845f654d81b90629dd78495641

From f05d14a944df040cb3d8e944009aa8700f66f80e Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Tue, 2 Jul 2024 13:15:48 +0200
Subject: [PATCH 04/37] crypto: basic eth signature implementation + functional
 test

---
 src/crypto/eth_signature.cpp            | 125 ++++++++++++++++++++++++
 src/crypto/eth_signature.h              |  39 ++++++++
 tests/functional_tests/crypto_tests.cpp |  27 +++++
 3 files changed, 191 insertions(+)
 create mode 100644 src/crypto/eth_signature.cpp
 create mode 100644 src/crypto/eth_signature.h

diff --git a/src/crypto/eth_signature.cpp b/src/crypto/eth_signature.cpp
new file mode 100644
index 00000000..3aaec568
--- /dev/null
+++ b/src/crypto/eth_signature.cpp
@@ -0,0 +1,125 @@
+// Copyright (c) 2024 Zano Project
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include "eth_signature.h"
+#include "crypto.h"
+#include "bitcoin-secp256k1/include/secp256k1.h"
+#include "random.h"
+#include "misc_language.h"
+
+
+namespace crypto
+{
+  bool generate_eth_key_pair(eth_secret_key& sec_key, eth_public_key& pub_key) noexcept
+  {
+    try
+    {
+      secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+      auto slh = epee::misc_utils::create_scope_leave_handler([&ctx](){
+          secp256k1_context_destroy(ctx);
+          ctx = nullptr;
+        });
+
+      uint8_t randomness[32];
+      crypto::generate_random_bytes(sizeof randomness, randomness);
+      if (!secp256k1_context_randomize(ctx, randomness))
+        return false;
+
+      for(size_t i = 1024; i != 0; --i)
+      {
+        crypto::generate_random_bytes(sizeof sec_key, sec_key.data);
+        if (secp256k1_ec_seckey_verify(ctx, sec_key.data))
+          break;
+        if (i == 1)
+          return false;
+      }
+
+      secp256k1_pubkey uncompressed_pub_key{};
+      if (!secp256k1_ec_pubkey_create(ctx, &uncompressed_pub_key, sec_key.data))
+        return false;
+
+      size_t output_len = sizeof pub_key;
+      if (!secp256k1_ec_pubkey_serialize(ctx, pub_key.data, &output_len, &uncompressed_pub_key, SECP256K1_EC_COMPRESSED))
+        return false;
+
+      return true;
+    }
+    catch(...)
+    {
+      return false;
+    }
+  }
+
+
+  // generates secp256k1 ECDSA signature
+  bool generate_eth_signature(const hash& m, const eth_secret_key& sec_key, eth_signature& sig) noexcept
+  {
+    try
+    {
+      secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+      auto slh = epee::misc_utils::create_scope_leave_handler([&ctx](){
+          secp256k1_context_destroy(ctx);
+          ctx = nullptr;
+        });
+
+      uint8_t randomness[32];
+      crypto::generate_random_bytes(sizeof randomness, randomness);
+      if (!secp256k1_context_randomize(ctx, randomness))
+        return false;
+      
+      secp256k1_ecdsa_signature secp256k1_ecdsa_sig{};
+      if (!secp256k1_ecdsa_sign(ctx, &secp256k1_ecdsa_sig, (const unsigned char*)m.data, sec_key.data, NULL, NULL))
+        return false;
+
+      if (!secp256k1_ecdsa_signature_serialize_compact(ctx, sig.data, &secp256k1_ecdsa_sig))
+        return false;
+      
+      return true;
+    }
+    catch(...)
+    {
+      return false;
+    }
+  }
+
+  // verifies secp256k1 ECDSA signature
+  bool verify_eth_signature(const hash& m, const eth_public_key& pub_key, const eth_signature& sig) noexcept
+  {
+    try
+    {
+      // TODO (performance) consider using secp256k1_context_static for verification -- sowle
+
+      secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+      auto slh = epee::misc_utils::create_scope_leave_handler([&ctx](){
+        secp256k1_context_destroy(ctx);
+        ctx = nullptr;
+        });
+
+      uint8_t randomness[32];
+      crypto::generate_random_bytes(sizeof randomness, randomness);
+      if (!secp256k1_context_randomize(ctx, randomness))
+        return false;
+
+      secp256k1_ecdsa_signature secp256k1_ecdsa_sig{};
+      secp256k1_pubkey uncompressed_pub_key{};
+
+      if (!secp256k1_ecdsa_signature_parse_compact(ctx, &secp256k1_ecdsa_sig, sig.data))
+        return false;
+
+      if (!secp256k1_ec_pubkey_parse(ctx, &uncompressed_pub_key, pub_key.data, sizeof pub_key))
+        return false;
+
+      // verify a signature
+      if (!secp256k1_ecdsa_verify(ctx, &secp256k1_ecdsa_sig, (const unsigned char*)m.data, &uncompressed_pub_key))
+        return false;
+
+      return true;
+    }
+    catch(...)
+    {
+      return false;
+    }
+  }
+
+
+} // namespace crypto
diff --git a/src/crypto/eth_signature.h b/src/crypto/eth_signature.h
new file mode 100644
index 00000000..c0434525
--- /dev/null
+++ b/src/crypto/eth_signature.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Zano Project
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#pragma once
+#include <cstdint>
+#include "hash.h"
+
+namespace crypto
+{
+
+  // secp256k1 public key in serialized (compressed) form that is used in Etherium
+  struct eth_public_key
+  {
+    uint8_t data[33];
+  };
+
+  // secp256k1 secret key
+  struct eth_secret_key
+  {
+    uint8_t data[32];
+  };
+
+  // secp256k1 ECDSA signature is serialized (compressed) form that is used in Etherium
+  struct eth_signature
+  {
+    uint8_t data[64];
+  };
+
+  // generates secp256k1 keypair
+  bool generate_eth_key_pair(eth_secret_key& sec_key, eth_public_key& pub_key) noexcept;
+
+  // generates secp256k1 ECDSA signature
+  bool generate_eth_signature(const hash& m, const eth_secret_key& sec_key, eth_signature& sig) noexcept;
+
+  // verifies secp256k1 ECDSA signature
+  bool verify_eth_signature(const hash& m, const eth_public_key& pub_key, const eth_signature& sig) noexcept;
+
+
+} // namespace crypto
diff --git a/tests/functional_tests/crypto_tests.cpp b/tests/functional_tests/crypto_tests.cpp
index 6cd876b5..a6907bef 100644
--- a/tests/functional_tests/crypto_tests.cpp
+++ b/tests/functional_tests/crypto_tests.cpp
@@ -1957,6 +1957,33 @@ TEST(crypto, secp256k1_ecdsa_native)
 }
 
 
+TEST(crypto, eth_signature_basics)
+{
+  eth_secret_key sk{};
+  eth_public_key pk{};
+
+  ASSERT_TRUE(generate_eth_key_pair(sk, pk));
+
+  eth_signature sig{};
+  hash m = hash_helper_t::h("How many of you have ever felt personally victimized by elliptic curves?");
+  
+  ASSERT_TRUE(generate_eth_signature(m, sk, sig));
+
+  const eth_signature const_sig = sig;
+  ASSERT_TRUE(verify_eth_signature(m, pk, const_sig));
+
+  for(size_t i = 0; i < sizeof sig; ++i)
+  {
+    eth_signature bad_sig = sig;
+    bad_sig.data[i] ^= 1 + (rand() % 254); // xor with a number fom [1; 255] to make sure this byte will change
+    ASSERT_FALSE(verify_eth_signature(m, pk, bad_sig));
+  }
+
+  return true;
+}
+
+
+
 
 //
 // test's runner

From d7cf27033c6f4cd8e218771b1a9d8bc2c2aa4777 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Tue, 2 Jul 2024 13:16:30 +0200
Subject: [PATCH 05/37] forgotten include

---
 tests/functional_tests/crypto_tests.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/functional_tests/crypto_tests.cpp b/tests/functional_tests/crypto_tests.cpp
index a6907bef..d4217d47 100644
--- a/tests/functional_tests/crypto_tests.cpp
+++ b/tests/functional_tests/crypto_tests.cpp
@@ -20,6 +20,7 @@
 #include "crypto/range_proofs.h"
 #include "../core_tests/random_helper.h"
 #include "crypto_torsion_elements.h"
+#include "crypto/eth_signature.h"
 
 using namespace crypto;
 

From ef7320496046bd4086e1e6a1cc93301ceffe2f5a Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Wed, 17 Jul 2024 19:43:53 +0200
Subject: [PATCH 06/37] added support for std::optional to src/serialization
 and boost serialization

---
 .../keyvalue_serialization_overloads.h        | 23 ++++++++
 src/serialization/boost_types.h               | 55 ++++++++++++++++++-
 2 files changed, 77 insertions(+), 1 deletion(-)

diff --git a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
index cb88897f..23ad8fce 100644
--- a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
+++ b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
@@ -473,6 +473,29 @@ namespace epee
       return r;
     }
     //-------------------------------------------------------------------------------------------------------------------
+    //std::optional 
+    template<class t_type, class t_storage>
+    bool kv_serialize(const std::optional<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      if(d.has_value())
+      {
+        return kv_serialize(*d, stg, hparent_section, pname);
+      }
+      return true;
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::optional<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      d = t_type{};
+      bool r = kv_unserialize(*d, stg, hparent_section, pname);
+      if (!r)
+      {
+        d = std::nullopt;
+      }
+      return r;
+    }
+    //-------------------------------------------------------------------------------------------------------------------
     //boost::shared_ptr 
     template<class t_type, class t_storage>
     bool kv_serialize(const boost::shared_ptr<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
diff --git a/src/serialization/boost_types.h b/src/serialization/boost_types.h
index 154705b8..ca3e3d7b 100644
--- a/src/serialization/boost_types.h
+++ b/src/serialization/boost_types.h
@@ -1,3 +1,4 @@
+// Copyright (c) 2018-2024 Zano Project
 // Copyright (c) 2014-2017 The The Louisdor Project
 // Copyright (c) 2012-2013 The Cryptonote developers
 // Distributed under the MIT/X11 software license, see the accompanying
@@ -7,7 +8,7 @@
 
 #include <boost/serialization/optional.hpp>
 
-
+// boost::optional
 template <template <bool> class Archive, class T>
 bool do_serialize(Archive<false> &ar, boost::optional<T> &o)
 {
@@ -58,3 +59,55 @@ bool do_serialize(Archive<true> &ar, boost::optional<T> &v)
 
   return true;
 }
+
+// std::optional
+template <template <bool> class Archive, class T>
+bool do_serialize(Archive<false> &ar, std::optional<T> &o)
+{
+  //reading flag
+  bool is_none = false;
+  if (!::do_serialize(ar, is_none))
+  {
+    ar.stream().setstate(std::ios::failbit);
+    return false;
+  }
+  if (is_none)
+  {
+    o.reset();
+    return true;
+  }
+  o = T();
+  T& rval = o.value();
+  //reading value
+  if (!::do_serialize(ar, rval))
+  {
+    ar.stream().setstate(std::ios::failbit);
+    return false;
+  }
+
+  return true;
+}
+
+template <template <bool> class Archive, class T>
+bool do_serialize(Archive<true> &ar, std::optional<T> &v)
+{
+  //writing flag
+  bool is_none = !v.has_value();
+  if (!::do_serialize(ar, is_none))
+  {
+    ar.stream().setstate(std::ios::failbit);
+    return false;
+  }
+  if (is_none)
+  {
+    return true;
+  }
+
+  if (!::do_serialize(ar, v.value()))
+  {
+    ar.stream().setstate(std::ios::failbit);
+    return false;
+  }
+
+  return true;
+}

From 0bc14fa47722e35669fe0b3e5a4535bfed4e5cac Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Thu, 18 Jul 2024 00:14:03 +0200
Subject: [PATCH 07/37] eth signature for CA: data structures +
 validate_ado_ownership() adaptation

---
 src/common/crypto_serialization.h        | 15 +++++++
 src/currency_core/blockchain_storage.cpp | 20 +++++++---
 src/currency_core/currency_basic.h       | 51 ++++++++++++++++++------
 3 files changed, 69 insertions(+), 17 deletions(-)

diff --git a/src/common/crypto_serialization.h b/src/common/crypto_serialization.h
index dd988a68..9ac2ac90 100644
--- a/src/common/crypto_serialization.h
+++ b/src/common/crypto_serialization.h
@@ -21,6 +21,7 @@
 #include "crypto/clsag.h"
 #include "crypto/zarcanum.h"
 #include "crypto/one_out_of_many_proofs.h"
+#include "crypto/eth_signature.h"
 #include "boost_serialization_maps.h"
 #include "serialization/keyvalue_enable_POD_serialize_as_string.h"
 //
@@ -230,6 +231,8 @@ BLOB_SERIALIZER(crypto::key_image);
 BLOB_SERIALIZER(crypto::signature);
 BLOB_SERIALIZER(crypto::scalar_t);
 BLOB_SERIALIZER(crypto::point_t);
+BLOB_SERIALIZER(crypto::eth_public_key);
+BLOB_SERIALIZER(crypto::eth_signature);
 
 VARIANT_TAG(debug_archive, crypto::hash, "hash");
 VARIANT_TAG(debug_archive, crypto::public_key, "public_key");
@@ -245,6 +248,8 @@ VARIANT_TAG(debug_archive, crypto::signature, "signature");
 
 KV_ENABLE_POD_SERIALIZATION_AS_HEX(crypto::scalar_t);
 KV_ENABLE_POD_SERIALIZATION_AS_HEX(crypto::hash);
+KV_ENABLE_POD_SERIALIZATION_AS_HEX(crypto::eth_public_key);
+KV_ENABLE_POD_SERIALIZATION_AS_HEX(crypto::eth_signature);
 
 //
 // Boost serialization
@@ -296,5 +301,15 @@ namespace boost
     {
       a & reinterpret_cast<char (&)[sizeof(crypto::point_t)]>(x);
     }    
+    template <class Archive>
+    inline void serialize(Archive &a, crypto::eth_public_key &x, const boost::serialization::version_type ver)
+    {
+      a & reinterpret_cast<char (&)[sizeof(crypto::eth_public_key)]>(x);
+    }    
+    template <class Archive>
+    inline void serialize(Archive &a, crypto::eth_signature &x, const boost::serialization::version_type ver)
+    {
+      a & reinterpret_cast<char (&)[sizeof(crypto::eth_signature)]>(x);
+    }    
   } // namespace serialization
 } // namespace boost
diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 419cdd1c..44d80862 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -4105,14 +4105,24 @@ bool blockchain_storage::pop_asset_info(const crypto::public_key& asset_id)
 //------------------------------------------------------------------
 bool validate_ado_ownership(asset_op_verification_context& avc)
 {
+  bool r = false;
+  CHECK_AND_ASSERT_MES(avc.asset_op_history->size() != 0, false, "asset with id " << avc.asset_id << " has empty history record");
+  const asset_descriptor_operation& last_ado = avc.asset_op_history->back();
+
+  if (last_ado.descriptor.owner_eth_pub_key.has_value())
+  {
+    asset_operation_ownership_proof_eth aoop_eth{};
+    r = get_type_in_variant_container(avc.tx.proofs, aoop_eth);
+    CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed - missing signature (asset_operation_ownership_proof)");
+    return crypto::verify_eth_signature(avc.tx_id, last_ado.descriptor.owner_eth_pub_key.value(), aoop_eth.eth_sig);
+  }
+
+  // owner_eth_pub_key has no value -- falback to default
   asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
-  bool r = get_type_in_variant_container(avc.tx.proofs, aoop);
+  r = get_type_in_variant_container(avc.tx.proofs, aoop);
   CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed - missing signature (asset_operation_ownership_proof)");
 
-  CHECK_AND_ASSERT_MES(avc.asset_op_history->size() != 0, false, "asset with id " << avc.asset_id << " has invalid history size() == 0");
-
-  crypto::public_key owner_key = avc.asset_op_history->back().descriptor.owner;
-  return crypto::verify_schnorr_sig(avc.tx_id, owner_key, aoop.gss);
+  return crypto::verify_schnorr_sig(avc.tx_id, last_ado.descriptor.owner, aoop.gss);
 }
 //------------------------------------------------------------------
 bool blockchain_storage::validate_asset_operation_against_current_blochain_state(asset_op_verification_context& avc) const
diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index 0d3e5891..e7052146 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -40,6 +40,7 @@
 #include "crypto/hash.h"
 #include "crypto/range_proofs.h"
 #include "crypto/zarcanum.h"
+#include "crypto/eth_signature.h"
 #include "misc_language.h"
 #include "block_flags.h"
 #include "etc_custom_serialization.h"
@@ -695,6 +696,7 @@ namespace currency
     }
   };
 
+#define ASSET_DESCRIPTOR_BASE_STRUCTURE_VER  1
 
   struct asset_descriptor_base
   {
@@ -706,9 +708,11 @@ namespace currency
     std::string         meta_info;
     crypto::public_key  owner = currency::null_pkey; // consider premultipling by 1/8
     bool                hidden_supply = false;
-    uint8_t             version = 0;
+    std::optional<crypto::eth_public_key> owner_eth_pub_key;
 
-    BEGIN_VERSIONED_SERIALIZE(0, version)
+    uint8_t             version = ASSET_DESCRIPTOR_BASE_STRUCTURE_VER;
+
+    BEGIN_VERSIONED_SERIALIZE(ASSET_DESCRIPTOR_BASE_STRUCTURE_VER, version)
       FIELD(total_max_supply)
       FIELD(current_supply)
       FIELD(decimal_point)
@@ -717,9 +721,10 @@ namespace currency
       FIELD(meta_info)
       FIELD(owner)
       FIELD(hidden_supply)
+      END_VERSION_UNDER(1)
+      FIELD(owner_eth_pub_key)
     END_SERIALIZE()
 
-
     BEGIN_BOOST_SERIALIZATION()
       BOOST_SERIALIZE(total_max_supply)
       BOOST_SERIALIZE(current_supply)
@@ -729,17 +734,20 @@ namespace currency
       BOOST_SERIALIZE(meta_info)
       BOOST_SERIALIZE(owner)
       BOOST_SERIALIZE(hidden_supply)
+      BOOST_END_VERSION_UNDER(1)
+      BOOST_SERIALIZE(owner_eth_pub_key)
     END_BOOST_SERIALIZATION()
 
     BEGIN_KV_SERIALIZE_MAP()
-      KV_SERIALIZE(total_max_supply)  DOC_DSCR("Maximum possible supply for given asset, can't be changed after deployment") DOC_EXMP(1000000000000000000)   DOC_END
-      KV_SERIALIZE(current_supply)    DOC_DSCR("Currently emitted supply for given asset (ignored for REGISTER operation)") DOC_EXMP(500000000000000000)   DOC_END
-      KV_SERIALIZE(decimal_point)     DOC_DSCR("Decimal point")                       DOC_EXMP(12)                        DOC_END
-      KV_SERIALIZE(ticker)            DOC_DSCR("Ticker associated with asset")        DOC_EXMP("ZUSD")                    DOC_END
-      KV_SERIALIZE(full_name)         DOC_DSCR("Full name of the asset")              DOC_EXMP("Zano wrapped USD")        DOC_END
-      KV_SERIALIZE(meta_info)         DOC_DSCR("Any other information assetiaded with asset in a free form")              DOC_EXMP("Stable and private")        DOC_END
-      KV_SERIALIZE_POD_AS_HEX_STRING(owner) DOC_DSCR("Owner's key, used only for EMIT and UPDATE validation, could be changed by transferring asset ownership")  DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8")        DOC_END
-      KV_SERIALIZE(hidden_supply)    DOC_DSCR("This one reserved for future use, will be documented later") DOC_END
+      KV_SERIALIZE(total_max_supply)  DOC_DSCR("Maximum possible supply for a given asset, cannot be changed after deployment.") DOC_EXMP(1000000000000000000)   DOC_END
+      KV_SERIALIZE(current_supply)    DOC_DSCR("Currently emitted supply for the given asset (ignored for REGISTER operation).") DOC_EXMP(500000000000000000)    DOC_END
+      KV_SERIALIZE(decimal_point)     DOC_DSCR("Decimal point.")                      DOC_EXMP(12)                        DOC_END
+      KV_SERIALIZE(ticker)            DOC_DSCR("Ticker associated with the asset.")   DOC_EXMP("ZABC")                    DOC_END
+      KV_SERIALIZE(full_name)         DOC_DSCR("Full name of the asset.")             DOC_EXMP("Zano wrapped ABC")        DOC_END
+      KV_SERIALIZE(meta_info)         DOC_DSCR("Any other information associated with the asset in free form.")           DOC_EXMP("Stable and private")      DOC_END
+      KV_SERIALIZE_POD_AS_HEX_STRING(owner) DOC_DSCR("Owner's key, used only for EMIT and UPDATE validation, can be changed by transferring asset ownership.")   DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8")        DOC_END
+      KV_SERIALIZE(hidden_supply)     DOC_DSCR("This field is reserved for future use and will be documented later.") DOC_END
+      KV_SERIALIZE(owner_eth_pub_key) DOC_DSCR("[Optional] Owner's key in the case when ETH signature is used.") DOC_END
     END_KV_SERIALIZE_MAP()
   };
 
@@ -833,6 +841,21 @@ namespace currency
   };
 
 
+  struct asset_operation_ownership_proof_eth
+  {
+    crypto::eth_signature eth_sig;
+    uint8_t version = 0;
+
+    BEGIN_VERSIONED_SERIALIZE(0, version)
+      FIELD(eth_sig)
+    END_SERIALIZE()
+
+    BEGIN_BOOST_SERIALIZATION()
+      BOOST_SERIALIZE(eth_sig)
+      BOOST_SERIALIZE(version)
+    END_BOOST_SERIALIZATION()
+  };
+
   struct extra_padding
   {
     std::vector<uint8_t> buff; //stub
@@ -936,7 +959,7 @@ namespace currency
 
   typedef boost::variant<NLSAG_sig, void_sig, ZC_sig, zarcanum_sig> signature_v;
 
-  typedef boost::variant<zc_asset_surjection_proof, zc_outs_range_proof, zc_balance_proof, asset_operation_proof, asset_operation_ownership_proof> proof_v;
+  typedef boost::variant<zc_asset_surjection_proof, zc_outs_range_proof, zc_balance_proof, asset_operation_proof, asset_operation_ownership_proof, asset_operation_ownership_proof_eth> proof_v;
 
 
   //include backward compatibility defintions
@@ -1195,6 +1218,10 @@ SET_VARIANT_TAGS(currency::zc_balance_proof, 48, "zc_balance_proof");
 SET_VARIANT_TAGS(currency::asset_descriptor_operation, 49, "asset_descriptor_base");
 SET_VARIANT_TAGS(currency::asset_operation_proof, 50, "asset_operation_proof");
 SET_VARIANT_TAGS(currency::asset_operation_ownership_proof, 51, "asset_operation_ownership_proof");
+SET_VARIANT_TAGS(currency::asset_operation_ownership_proof_eth, 52, "asset_operation_ownership_proof_eth");
+
+SET_VARIANT_TAGS(crypto::eth_public_key, 60, "eth_public_key");
+//SET_VARIANT_TAGS(crypto::eth_signature, 61, "eth_signature");s
 
 
 

From e97b5856591958dfd39edbaa1a76970e46a84d8d Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 12:00:35 +0200
Subject: [PATCH 08/37] crypto: eth_secret_key_to_public_key() implemented,
 other useful stuff for eth sig added

---
 src/crypto/crypto-sugar.h    | 10 +++++++++
 src/crypto/eth_signature.cpp | 41 ++++++++++++++++++++++++++++++++++--
 src/crypto/eth_signature.h   | 27 ++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 2 deletions(-)

diff --git a/src/crypto/crypto-sugar.h b/src/crypto/crypto-sugar.h
index 846e4572..3738d118 100644
--- a/src/crypto/crypto-sugar.h
+++ b/src/crypto/crypto-sugar.h
@@ -8,6 +8,7 @@
 #include <string>
 #include <boost/multiprecision/cpp_int.hpp>
 #include "crypto.h"
+#include "eth_signature.h"
 
 namespace crypto
 {
@@ -1209,6 +1210,15 @@ namespace crypto
         m_elements.emplace_back(pk);
       }
 
+      void add_eth_pub_key(const crypto::eth_public_key& epk)
+      {
+        static_assert(sizeof epk.data == 33, "unexpected size of eth_public_key");
+        m_elements.emplace_back(c_scalar_0);
+        m_elements.emplace_back(c_scalar_0);
+        char* p = m_elements[m_elements.size() - 2].c; // pointer to the first of the two added items
+        memcpy_s(p, 2 * sizeof(item_t), &epk.data, sizeof epk.data);
+      }
+
       void add_key_image(const crypto::key_image& ki)
       {
         m_elements.emplace_back(ki);
diff --git a/src/crypto/eth_signature.cpp b/src/crypto/eth_signature.cpp
index 3aaec568..0e33c47f 100644
--- a/src/crypto/eth_signature.cpp
+++ b/src/crypto/eth_signature.cpp
@@ -6,6 +6,7 @@
 #include "bitcoin-secp256k1/include/secp256k1.h"
 #include "random.h"
 #include "misc_language.h"
+#include <string_tools.h>
 
 
 namespace crypto
@@ -50,6 +51,32 @@ namespace crypto
     }
   }
 
+  bool eth_secret_key_to_public_key(const eth_secret_key& sec_key, eth_public_key& pub_key) noexcept
+  {
+    try
+    {
+      // TODO: do we need this? consider using static context
+      secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+      auto slh = epee::misc_utils::create_scope_leave_handler([&ctx](){
+        secp256k1_context_destroy(ctx);
+        ctx = nullptr;
+        });
+
+      secp256k1_pubkey uncompressed_pub_key{};
+      if (!secp256k1_ec_pubkey_create(ctx, &uncompressed_pub_key, sec_key.data))
+        return false;
+
+      size_t output_len = sizeof pub_key;
+      if (!secp256k1_ec_pubkey_serialize(ctx, pub_key.data, &output_len, &uncompressed_pub_key, SECP256K1_EC_COMPRESSED))
+        return false;
+
+      return true;
+    }
+    catch(...)
+    {
+      return false;
+    }
+  }
 
   // generates secp256k1 ECDSA signature
   bool generate_eth_signature(const hash& m, const eth_secret_key& sec_key, eth_signature& sig) noexcept
@@ -91,8 +118,8 @@ namespace crypto
 
       secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
       auto slh = epee::misc_utils::create_scope_leave_handler([&ctx](){
-        secp256k1_context_destroy(ctx);
-        ctx = nullptr;
+          secp256k1_context_destroy(ctx);
+          ctx = nullptr;
         });
 
       uint8_t randomness[32];
@@ -121,5 +148,15 @@ namespace crypto
     }
   }
 
+  std::ostream& operator<<(std::ostream& o, const eth_secret_key& v)
+  {
+    return o << epee::string_tools::pod_to_hex(v);
+  }
+
+  std::ostream& operator<<(std::ostream& o, const eth_public_key& v)
+  {
+    return o << epee::string_tools::pod_to_hex(v);
+  }
+
 
 } // namespace crypto
diff --git a/src/crypto/eth_signature.h b/src/crypto/eth_signature.h
index c0434525..b186114a 100644
--- a/src/crypto/eth_signature.h
+++ b/src/crypto/eth_signature.h
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #pragma once
 #include <cstdint>
+#include <iosfwd>
 #include "hash.h"
 
 namespace crypto
@@ -29,6 +30,9 @@ namespace crypto
   // generates secp256k1 keypair
   bool generate_eth_key_pair(eth_secret_key& sec_key, eth_public_key& pub_key) noexcept;
 
+  // converts eth_secret_key to eth_public_key
+  bool eth_secret_key_to_public_key(const eth_secret_key& sec_key, eth_public_key& pub_key) noexcept;
+
   // generates secp256k1 ECDSA signature
   bool generate_eth_signature(const hash& m, const eth_secret_key& sec_key, eth_signature& sig) noexcept;
 
@@ -36,4 +40,27 @@ namespace crypto
   bool verify_eth_signature(const hash& m, const eth_public_key& pub_key, const eth_signature& sig) noexcept;
 
 
+  inline bool operator==(const eth_public_key& lhs, const eth_public_key& rhs)
+  {
+    return memcmp(lhs.data, rhs.data, sizeof lhs.data) == 0;
+  }
+
+  inline bool operator!=(const eth_public_key& lhs, const eth_public_key& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  inline bool operator==(const eth_secret_key& lhs, const eth_secret_key& rhs)
+  {
+    return memcmp(lhs.data, rhs.data, sizeof lhs.data) == 0;
+  }
+
+  inline bool operator!=(const eth_secret_key& lhs, const eth_secret_key& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  std::ostream& operator<<(std::ostream& o, const eth_secret_key& v);
+  std::ostream& operator<<(std::ostream& o, const eth_public_key& v);
+
 } // namespace crypto

From fa4a2680f917e15b2f41d821236726a169e23f6f Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 12:31:33 +0200
Subject: [PATCH 09/37] minor improvements for init_playtime_test_wallet_t()

---
 tests/core_tests/wallet_tests_basic.h | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/core_tests/wallet_tests_basic.h b/tests/core_tests/wallet_tests_basic.h
index 6515b4a7..885f8809 100644
--- a/tests/core_tests/wallet_tests_basic.h
+++ b/tests/core_tests/wallet_tests_basic.h
@@ -29,6 +29,9 @@ struct wallet_test : virtual public test_chain_unit_enchanced
   template<typename wallet_t>
   std::shared_ptr<wallet_t> init_playtime_test_wallet_t(const std::vector<test_event_entry>& events, currency::core& c, const currency::account_base& acc, bool true_http_rpc = false) const
   {
+#define LOCAL_HOST_CSTR "127.0.0.1"
+#define LOCAL_PORT_CSTR "33777"
+
     CHECK_AND_ASSERT_THROW_MES(events.size() > 0 && events[0].type() == typeid(currency::block), "Invalid events queue, can't find genesis block at the beginning");
     crypto::hash genesis_hash = get_block_hash(boost::get<currency::block>(events[0]));
 
@@ -36,14 +39,14 @@ struct wallet_test : virtual public test_chain_unit_enchanced
     {
       m_core_proxy = std::make_shared<tools::default_http_core_proxy>();
       m_core_proxy->set_connectivity(100, 1);
-      CHECK_AND_ASSERT_THROW_MES(m_core_proxy->set_connection_addr("127.0.0.1:33777"), "set_connection_addr failed");
+      CHECK_AND_ASSERT_THROW_MES(m_core_proxy->set_connection_addr(LOCAL_HOST_CSTR ":" LOCAL_PORT_CSTR), "set_connection_addr failed");
       if (!m_core_proxy->check_connection())
       {
         // if there's not http rpc core server yet, create one
         boost::program_options::options_description desc_options;
         currency::core_rpc_server::init_options(desc_options);
         boost::program_options::variables_map vm{};
-        char* argv[] = {"--rpc-bind-ip=127.0.0.1", "--rpc-bind-port=33777"};
+        const char* const argv[] = {"--rpc-bind-ip=" LOCAL_HOST_CSTR, "--rpc-bind-port=" LOCAL_PORT_CSTR};
         boost::program_options::store(boost::program_options::parse_command_line(sizeof argv / sizeof argv[0], argv, desc_options), vm);
         m_http_rpc_server = std::make_shared<core_http_rpc_server_details>(c, vm);
       }
@@ -58,6 +61,9 @@ struct wallet_test : virtual public test_chain_unit_enchanced
     w->set_core_proxy(m_core_proxy);
     w->set_disable_tor_relay(true);
     return w;
+
+#undef LOCAL_HOST_CSTR
+#undef LOCAL_PORT_CSTR
   }
 
 

From 27ecfad1d62b0eabd9db8029d4d126fb4a41e06a Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 12:34:28 +0200
Subject: [PATCH 10/37] asset owner eth signer support for
 currency_format_utils and wallet2

---
 src/currency_core/currency_format_utils.cpp  | 51 +++++++++-----------
 src/currency_core/currency_format_utils.h    | 12 +++--
 src/wallet/wallet2.cpp                       | 12 ++---
 src/wallet/wallet2_base.h                    |  6 +--
 src/wallet/wallet_debug_events_definitions.h |  4 ++
 5 files changed, 42 insertions(+), 43 deletions(-)

diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp
index 2e068644..f8115a47 100644
--- a/src/currency_core/currency_format_utils.cpp
+++ b/src/currency_core/currency_format_utils.cpp
@@ -2192,6 +2192,8 @@ namespace currency
     hsc.add_scalar(crypto::scalar_t(ado.descriptor.total_max_supply));
     hsc.add_scalar(crypto::scalar_t(ado.descriptor.decimal_point));
     hsc.add_pub_key(ado.descriptor.owner);
+    if (ado.descriptor.owner_eth_pub_key.has_value())
+      hsc.add_eth_pub_key(ado.descriptor.owner_eth_pub_key.value());
     crypto::hash h = hsc.calc_hash_no_reduce();
 
     // this hash function needs to be computationally expensive (s.a. the whitepaper)
@@ -2244,7 +2246,8 @@ namespace currency
       // asset_control_key = Hs(CRYPTO_HDS_ASSET_CONTROL_KEY, 8 * tx_key.sec * sender_account_keys.account_address.spend_public_key, 0)
       // ado.descriptor.owner = asset_control_key * G
       
-      ado.descriptor.owner = sender_account_keys.account_address.spend_public_key;
+      if (!ado.descriptor.owner_eth_pub_key.has_value())
+        ado.descriptor.owner = sender_account_keys.account_address.spend_public_key;
 
       CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(ado, &gen_context.ao_asset_id_pt, &gen_context.ao_asset_id), false, "get_or_calculate_asset_id failed");
 
@@ -2334,24 +2337,6 @@ namespace currency
       if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_handle_asset_descriptor_operation_before_seal{ &ado });
 
       ftp.need_to_generate_ado_proof = true;
-      /*
-      //seal it with owners signature
-      crypto::signature sig = currency::null_sig;
-      crypto::hash h = get_signature_hash_for_asset_operation(ado);
-      if (ftp.pthirdparty_sign_handler)
-      {
-        bool r = ftp.pthirdparty_sign_handler->sign(h, ftp.ado_current_asset_owner, sig);
-        CHECK_AND_ASSERT_MES(r, false, "asset thirparty sign failed");
-      }
-      else
-      {
-        crypto::public_key pub_k = currency::null_pkey;
-        crypto::secret_key_to_public_key(sender_account_keys.spend_secret_key, pub_k);
-        CHECK_AND_ASSERT_MES(ftp.ado_current_asset_owner == pub_k, false, "asset owner key not matched with provided private key for asset operation signing");
-        crypto::generate_signature(h, pub_k, account_keys.spend_secret_key, sig);
-      }
-      ado.opt_proof = sig;
-      */
     }
     return true;
   }
@@ -2784,22 +2769,30 @@ namespace currency
       }
       if(ftp.need_to_generate_ado_proof)        
       { 
-        asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
-
-        if (ftp.pthirdparty_sign_handler)
+        if (ftp.p_eth_signer)
         {
-          //ask third party to generate proof
-          r = ftp.pthirdparty_sign_handler->sign(tx_prefix_hash, ftp.ado_current_asset_owner, aoop.gss);
-          CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado by thirdparty");
+          // third party generates eth proof
+          CHECKED_GET_SPECIFIC_VARIANT(ftp.asset_owner, const crypto::eth_public_key, asset_owner_pubkey_eth, false);
+          asset_operation_ownership_proof_eth aoop_eth{};
+          r = ftp.p_eth_signer->sign(tx_prefix_hash, asset_owner_pubkey_eth, aoop_eth.eth_sig);
+          CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado by 3rd party eth signer");
+          // instant verification
+          r = crypto::verify_eth_signature(tx_prefix_hash, asset_owner_pubkey_eth, aoop_eth.eth_sig);
+          CHECK_AND_ASSERT_MES(r, false, "Ado by 3rd party eth signer has been incorrectly signed");
+          if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_eth_proof_generated{ &aoop_eth });
+          tx.proofs.emplace_back(aoop_eth);
         }
         else
         {
-          //generate signature by wallet account 
-          r = crypto::generate_schnorr_sig(tx_prefix_hash, ftp.ado_current_asset_owner, sender_account_keys.spend_secret_key, aoop.gss);
+          // generic Shnorr signature (signing with the spend secret key)
+          CHECKED_GET_SPECIFIC_VARIANT(ftp.asset_owner, const crypto::public_key, asset_owner_pubkey, false);
+          // generate signature by wallet account 
+          asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
+          r = crypto::generate_schnorr_sig(tx_prefix_hash, asset_owner_pubkey, sender_account_keys.spend_secret_key, aoop.gss);
           CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado proof");
+          if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_proof_generated{ &aoop });
+          tx.proofs.emplace_back(aoop);
         }
-        if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_proof_generated{ &aoop });
-        tx.proofs.emplace_back(aoop);
       }
     }
 
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index 3e875c08..0aa22de2 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -139,11 +139,13 @@ namespace currency
     bool hltc_our_out_is_before_expiration;
   };
 
-  struct thirdparty_sign_handler
+  struct asset_eth_signer_i
   {
-    virtual bool sign(const crypto::hash& h, const crypto::public_key& owner_public_key, crypto::generic_schnorr_sig& sig);
+    virtual bool sign(const crypto::hash& h, const crypto::eth_public_key& asset_owner, crypto::eth_signature& sig) = 0;
   };
 
+  typedef boost::variant<crypto::public_key, crypto::eth_public_key> asset_owner_key_v;
+
   struct finalize_tx_param
   {
     uint64_t unlock_time;
@@ -166,8 +168,8 @@ namespace currency
     tx_generation_context gen_context{}; // solely for consolidated txs
     
     //crypto::secret_key asset_control_key = currency::null_skey;
-    crypto::public_key ado_current_asset_owner = null_pkey;
-    thirdparty_sign_handler* pthirdparty_sign_handler = nullptr;
+    asset_owner_key_v asset_owner;
+    asset_eth_signer_i* p_eth_signer = nullptr;
     mutable bool need_to_generate_ado_proof = false;
 
 
@@ -191,7 +193,7 @@ namespace currency
       {
         FIELD(gen_context);
       }
-      FIELD(ado_current_asset_owner)
+      FIELD(asset_owner)
       FIELD(need_to_generate_ado_proof)
     END_SERIALIZE()
   };
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index a59b72cc..1985b18b 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -5403,7 +5403,7 @@ void wallet2::emit_asset(const crypto::public_key asset_id, std::vector<currency
   ctp.dsts = destinations;
   ctp.extra.push_back(asset_emmit_info);
   ctp.need_at_least_1_zc = true;
-  ctp.ado_current_asset_owner = rsp.asset_descriptor.owner;
+  ctp.asset_owner = rsp.asset_descriptor.owner;
   //ctp.asset_deploy_control_key = own_asset_entry_it->second.control_key;
 
   for(auto& dst : ctp.dsts)
@@ -5432,7 +5432,7 @@ void wallet2::update_asset(const crypto::public_key asset_id, const currency::as
   currency::asset_descriptor_base adb = AUTO_VAL_INIT(adb);
   bool r = this->daemon_get_asset_info(asset_id, adb);
   CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
-  ctp.ado_current_asset_owner = adb.owner;
+  ctp.asset_owner = adb.owner;
 
   finalized_tx ft = AUTO_VAL_INIT(ft);
   this->transfer(ctp, ft, true, nullptr);
@@ -5454,7 +5454,7 @@ void wallet2::transfer_asset_ownership(const crypto::public_key asset_id, const
   asset_update_info.opt_asset_id = asset_id;
   asset_update_info.descriptor.owner = new_owner;
   construct_tx_param ctp = get_default_construct_tx_param();
-  ctp.ado_current_asset_owner = adb.owner;
+  ctp.asset_owner = adb.owner;
   ctp.extra.push_back(asset_update_info);
 
   finalized_tx ft = AUTO_VAL_INIT(ft);
@@ -5488,7 +5488,7 @@ void wallet2::burn_asset(const crypto::public_key asset_id, uint64_t amount_to_b
   construct_tx_param ctp = get_default_construct_tx_param();
   ctp.extra.push_back(asset_burn_info);
   ctp.need_at_least_1_zc = true;
-  ctp.ado_current_asset_owner = rsp.asset_descriptor.owner;
+  ctp.asset_owner = rsp.asset_descriptor.owner;
   ctp.dsts.push_back(dst_to_burn);
 
   finalized_tx ft = AUTO_VAL_INIT(ft);
@@ -7599,8 +7599,8 @@ bool wallet2::prepare_transaction(construct_tx_param& ctp, currency::finalize_tx
 
   const currency::transaction& tx_for_mode_separate = msc.tx_for_mode_separate;
   assets_selection_context needed_money_map = get_needed_money(ctp.fee, ctp.dsts);
-  ftp.ado_current_asset_owner = ctp.ado_current_asset_owner;
-  ftp.pthirdparty_sign_handler = ctp.pthirdparty_sign_handler;
+  ftp.asset_owner = ctp.asset_owner;
+  ftp.p_eth_signer = ctp.p_eth_signer;
   //
   // TODO @#@# need to do refactoring over this part to support hidden amounts and asset_id
   //
diff --git a/src/wallet/wallet2_base.h b/src/wallet/wallet2_base.h
index c2ec860b..bcd006df 100644
--- a/src/wallet/wallet2_base.h
+++ b/src/wallet/wallet2_base.h
@@ -224,9 +224,9 @@ namespace tools
     bool shuffle = false;
     bool create_utxo_defragmentation_tx = false;
     bool need_at_least_1_zc = false;
-    //crypto::secret_key asset_deploy_control_key = currency::null_skey;
-    currency::thirdparty_sign_handler* pthirdparty_sign_handler = nullptr;
-    crypto::public_key ado_current_asset_owner = currency::null_pkey;
+
+    currency::asset_eth_signer_i* p_eth_signer = nullptr;
+    currency::asset_owner_key_v asset_owner = currency::null_pkey;
   };
 
   struct mode_separate_context
diff --git a/src/wallet/wallet_debug_events_definitions.h b/src/wallet/wallet_debug_events_definitions.h
index 30d7885c..85eb9614 100644
--- a/src/wallet/wallet_debug_events_definitions.h
+++ b/src/wallet/wallet_debug_events_definitions.h
@@ -30,3 +30,7 @@ struct wde_construct_tx_after_asset_ownership_proof_generated
   currency::asset_operation_ownership_proof* pownership_proof;
 };
 
+struct wde_construct_tx_after_asset_ownership_eth_proof_generated
+{
+  currency::asset_operation_ownership_proof_eth* pownership_proof_eth;
+};

From 896eadd77b7e1da615b736bfba32f51366464807 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 12:35:46 +0200
Subject: [PATCH 11/37] coretests: eth_signed_asset_basics test added

---
 tests/core_tests/chaingen_main.cpp    |   1 +
 tests/core_tests/multiassets_test.cpp | 143 ++++++++++++++++++++++++++
 tests/core_tests/multiassets_test.h   |  10 +-
 3 files changed, 153 insertions(+), 1 deletion(-)

diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp
index d31857a2..de4d3b5c 100644
--- a/tests/core_tests/chaingen_main.cpp
+++ b/tests/core_tests/chaingen_main.cpp
@@ -1291,6 +1291,7 @@ int main(int argc, char* argv[])
     GENERATE_AND_PLAY(asset_depoyment_and_few_zc_utxos);
     GENERATE_AND_PLAY_HF(assets_and_pos_mining, "4-*");
     GENERATE_AND_PLAY_HF(asset_emission_and_unconfirmed_balance, "4-*");
+    GENERATE_AND_PLAY_HF(eth_signed_asset_basics, "4-*"); // TODO
     
     GENERATE_AND_PLAY_HF(pos_fuse_test, "4-*");
     
diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp
index 94a938d2..7dc787c3 100644
--- a/tests/core_tests/multiassets_test.cpp
+++ b/tests/core_tests/multiassets_test.cpp
@@ -887,3 +887,146 @@ bool asset_emission_and_unconfirmed_balance::c1(currency::core& c, size_t ev_ind
 
   return true;
 }
+
+//------------------------------------------------------------------------------
+
+eth_signed_asset_basics::eth_signed_asset_basics()
+{
+  REGISTER_CALLBACK_METHOD(eth_signed_asset_basics, c1);
+}
+
+bool eth_signed_asset_basics::generate(std::vector<test_event_entry>& events) const
+{
+  uint64_t ts = test_core_time::get_time();
+  m_accounts.resize(TOTAL_ACCS_COUNT);
+  account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate(); miner_acc.set_createtime(ts);
+  //account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate(); alice_acc.set_createtime(ts);
+  miner_acc.generate();
+
+  MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, ts);
+  DO_CALLBACK(events, "configure_core"); // default configure_core callback will initialize core runtime config with m_hardforks
+  REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 3);
+
+  DO_CALLBACK(events, "c1");
+
+  return true;
+}
+
+template<typename T>
+struct eth_sign_cb_helper : public currency::asset_eth_signer_i
+{
+  eth_sign_cb_helper(T cb)
+    : m_cb(cb)
+  {}
+
+  virtual bool sign(const crypto::hash& h, const crypto::eth_public_key& asset_owner, crypto::eth_signature& sig) override
+  {
+    return m_cb(h, asset_owner, sig);
+  }
+
+  T m_cb;
+};
+
+template<typename T>
+std::shared_ptr<eth_sign_cb_helper<T>> construct_eth_sign_cb_helper(T&& cb)
+{
+  return std::make_shared<eth_sign_cb_helper<T>>(std::forward<T>(cb));
+}
+
+bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
+{
+  bool r = false;
+  
+  crypto::eth_secret_key eth_sk{};
+  crypto::eth_public_key eth_pk{};
+  r = crypto::generate_eth_key_pair(eth_sk, eth_pk);
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_key_pair failed");
+
+  std::shared_ptr<tools::wallet2> miner_wlt = init_playtime_test_wallet(events, c, MINER_ACC_IDX);
+  miner_wlt->refresh();
+
+  asset_descriptor_base adb{};
+  adb.decimal_point = 2;
+  adb.total_max_supply = 10000;
+  adb.full_name = "Either";
+  adb.ticker = "EITH";
+  adb.owner_eth_pub_key = eth_pk; // note setting owner eth pub key here
+
+  uint64_t initial_emit_amount = adb.total_max_supply / 2;
+
+  //std::vector<currency::tx_destination_entry> destinations;
+  //destinations.emplace_back(initial_emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
+  //currency::transaction tx{};
+
+  //
+  // custom deploy
+  //
+  tools::construct_tx_param ctp = miner_wlt->get_default_construct_tx_param();
+  ctp.dsts.emplace_back(initial_emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
+  ctp.asset_owner = eth_pk; // note using eth pub key here
+  ctp.need_at_least_1_zc = true;
+
+  asset_descriptor_operation ado{};
+  ado.descriptor = adb;
+  ado.operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER;
+  ctp.extra.push_back(ado);
+
+  finalized_tx ft{};
+  miner_wlt->transfer(ctp, ft, true, nullptr);
+
+  crypto::public_key asset_id = currency::null_pkey;
+  CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(ado, nullptr, &asset_id), false, "get_or_calculate_asset_id failed");
+
+  currency::asset_descriptor_operation ado2{};
+  r = get_type_in_variant_container(ft.tx.extra, ado2);
+  CHECK_AND_ASSERT_MES(r, false, "Failed find asset info in tx");
+  crypto::public_key new_asset_id{};
+  CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(ado, nullptr, &new_asset_id), false, "get_or_calculate_asset_id failed");
+
+
+  miner_wlt->add_custom_asset_id(asset_id, adb);
+  //
+  // end of custom deploy
+  //
+
+  const transaction& tx = ft.tx;
+
+
+  LOG_PRINT_L0("Deployed new asset: " << asset_id << ", tx_id: " << currency::get_transaction_hash(tx));
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  r = mine_next_pow_blocks_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+
+  uint64_t emit_amount = adb.total_max_supply - initial_emit_amount;
+
+  //
+  // custom emit
+  //
+  ctp = miner_wlt->get_default_construct_tx_param();
+  ctp.dsts.emplace_back(emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
+  ctp.need_at_least_1_zc = true;
+  ctp.asset_owner = eth_pk; // note using eth pub key here
+
+  ado = asset_descriptor_operation{};
+  ado.descriptor = adb;
+  ado.descriptor.current_supply = initial_emit_amount;
+  ado.operation_type = ASSET_DESCRIPTOR_OPERATION_EMIT;
+  ado.opt_asset_id = asset_id;
+  ctp.extra.push_back(ado);
+
+  auto signer = construct_eth_sign_cb_helper([&](const crypto::hash& h, const crypto::eth_public_key& asset_owner, crypto::eth_signature& sig)->bool {
+    CHECK_AND_ASSERT_EQ(asset_owner, eth_pk);
+    return crypto::generate_eth_signature(h, eth_sk, sig);
+  });
+
+  ctp.p_eth_signer = signer.get();
+
+  ft = finalized_tx{};
+  miner_wlt->transfer(ctp, ft, true, nullptr);
+  //
+  // end of custom emit
+  //
+
+  return true;
+}
diff --git a/tests/core_tests/multiassets_test.h b/tests/core_tests/multiassets_test.h
index bb2fdacc..e07d36c8 100644
--- a/tests/core_tests/multiassets_test.h
+++ b/tests/core_tests/multiassets_test.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2023 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -47,3 +47,11 @@ struct asset_emission_and_unconfirmed_balance : public wallet_test
   bool generate(std::vector<test_event_entry>& events) const;
   bool c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events);
 };
+
+
+struct eth_signed_asset_basics : public wallet_test
+{
+  eth_signed_asset_basics();
+  bool generate(std::vector<test_event_entry>& events) const;
+  bool c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events);
+};

From e816cd969c5ab7905f246aa2745c204f31ca0b94 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 12:36:08 +0200
Subject: [PATCH 12/37] minor improvements

---
 src/currency_core/blockchain_storage.cpp | 6 +++---
 src/currency_core/currency_basic.h       | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 44d80862..7e840273 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -4113,14 +4113,14 @@ bool validate_ado_ownership(asset_op_verification_context& avc)
   {
     asset_operation_ownership_proof_eth aoop_eth{};
     r = get_type_in_variant_container(avc.tx.proofs, aoop_eth);
-    CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed - missing signature (asset_operation_ownership_proof)");
+    CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed: asset_operation_ownership_proof_eth is missing");
     return crypto::verify_eth_signature(avc.tx_id, last_ado.descriptor.owner_eth_pub_key.value(), aoop_eth.eth_sig);
   }
 
-  // owner_eth_pub_key has no value -- falback to default
+  // owner_eth_pub_key has no value -- fallback to default
   asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
   r = get_type_in_variant_container(avc.tx.proofs, aoop);
-  CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed - missing signature (asset_operation_ownership_proof)");
+  CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed: asset_operation_ownership_proof is missing");
 
   return crypto::verify_schnorr_sig(avc.tx_id, last_ado.descriptor.owner, aoop.gss);
 }
diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index e7052146..788f5a69 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -708,7 +708,7 @@ namespace currency
     std::string         meta_info;
     crypto::public_key  owner = currency::null_pkey; // consider premultipling by 1/8
     bool                hidden_supply = false;
-    std::optional<crypto::eth_public_key> owner_eth_pub_key;
+    std::optional<crypto::eth_public_key> owner_eth_pub_key; // note: the size is 33 bytes (if present)
 
     uint8_t             version = ASSET_DESCRIPTOR_BASE_STRUCTURE_VER;
 

From f8c54492f192f19cdaefe259d944551986b65ae6 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 14:11:32 +0200
Subject: [PATCH 13/37] gcc compilation fix

---
 src/crypto/crypto-sugar.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/crypto/crypto-sugar.h b/src/crypto/crypto-sugar.h
index 3738d118..2493360f 100644
--- a/src/crypto/crypto-sugar.h
+++ b/src/crypto/crypto-sugar.h
@@ -6,6 +6,7 @@
 // Note: This file originates from tests/functional_tests/crypto_tests.cpp 
 #pragma once
 #include <string>
+#include <string.h>
 #include <boost/multiprecision/cpp_int.hpp>
 #include "crypto.h"
 #include "eth_signature.h"
@@ -1212,6 +1213,7 @@ namespace crypto
 
       void add_eth_pub_key(const crypto::eth_public_key& epk)
       {
+        static_assert(sizeof(item_t)  == 32, "unexpected size of hs_t::item_t");
         static_assert(sizeof epk.data == 33, "unexpected size of eth_public_key");
         m_elements.emplace_back(c_scalar_0);
         m_elements.emplace_back(c_scalar_0);

From 389662b8c94f9d56d4fad28b7d406666507009fb Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Fri, 2 Aug 2024 16:14:23 +0200
Subject: [PATCH 14/37] gcc compilation fix (2)

---
 src/crypto/crypto-sugar.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/crypto/crypto-sugar.h b/src/crypto/crypto-sugar.h
index 2493360f..b74edc4f 100644
--- a/src/crypto/crypto-sugar.h
+++ b/src/crypto/crypto-sugar.h
@@ -6,7 +6,6 @@
 // Note: This file originates from tests/functional_tests/crypto_tests.cpp 
 #pragma once
 #include <string>
-#include <string.h>
 #include <boost/multiprecision/cpp_int.hpp>
 #include "crypto.h"
 #include "eth_signature.h"
@@ -1218,7 +1217,7 @@ namespace crypto
         m_elements.emplace_back(c_scalar_0);
         m_elements.emplace_back(c_scalar_0);
         char* p = m_elements[m_elements.size() - 2].c; // pointer to the first of the two added items
-        memcpy_s(p, 2 * sizeof(item_t), &epk.data, sizeof epk.data);
+        memcpy(p, &epk.data, sizeof epk.data);
       }
 
       void add_key_image(const crypto::key_image& ki)

From 764e5a2adfd5bc8ce1d00609202c86a2215e6cb1 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 12 Aug 2024 19:41:55 +0200
Subject: [PATCH 15/37] kv serialization support for std::shared_ptr

---
 .../keyvalue_serialization_overloads.h        | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
index 23ad8fce..d0d7c408 100644
--- a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
+++ b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
@@ -1,3 +1,4 @@
+// Copyright (c) 2024, Zano Project
 // Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
 // All rights reserved.
 // 
@@ -519,6 +520,30 @@ namespace epee
       }
       return r;
     }
+    //-------------------------------------------------------------------------------------------------------------------
+    //std::shared_ptr 
+    template<class t_type, class t_storage>
+    bool kv_serialize(const std::shared_ptr<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      if (d.get())
+      {
+        return kv_serialize(*d, stg, hparent_section, pname);
+      }
+      return true;
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::shared_ptr<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      d.reset();
+      t_type* ptr = new t_type();
+      bool r = kv_unserialize(*ptr, stg, hparent_section, pname);
+      if (!r)
+      {
+        d.reset(ptr);
+      }
+      return r;
+    }
 
   }
 }
\ No newline at end of file

From b861d854a9b32f77c260d9a7c9471ae03f9caa24 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 12 Aug 2024 20:04:18 +0200
Subject: [PATCH 16/37] boost::shared_ptr ->std::shared_ptr

---
 src/wallet/decoy_selection.h        | 1 -
 src/wallet/wallet2_base.h           | 3 +--
 src/wallet/wallet_chain_shortener.h | 1 -
 3 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/wallet/decoy_selection.h b/src/wallet/decoy_selection.h
index 0d732b0a..de4cecf9 100644
--- a/src/wallet/decoy_selection.h
+++ b/src/wallet/decoy_selection.h
@@ -9,7 +9,6 @@
 #include <boost/serialization/deque.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/shared_ptr.hpp>
 #include <boost/serialization/optional.hpp>
 #include <atomic>
 
diff --git a/src/wallet/wallet2_base.h b/src/wallet/wallet2_base.h
index bcd006df..f8b4eadf 100644
--- a/src/wallet/wallet2_base.h
+++ b/src/wallet/wallet2_base.h
@@ -11,7 +11,6 @@
 #include <boost/serialization/deque.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/shared_ptr.hpp>
 #include <boost/serialization/optional.hpp>
 #include <atomic>
 
@@ -356,7 +355,7 @@ namespace tools
     uint64_t m_spent_height = 0;
     uint32_t m_flags = 0;
     uint64_t m_amount = 0;
-    boost::shared_ptr<ZC_out_info> m_zc_info_ptr;
+    std::shared_ptr<ZC_out_info> m_zc_info_ptr;
 
     uint64_t amount() const { return m_amount; }
     uint64_t amount_for_global_output_index() const { return is_zc() ? 0 : m_amount; } // amount value for global outputs index, it's zero for outputs with hidden amounts
diff --git a/src/wallet/wallet_chain_shortener.h b/src/wallet/wallet_chain_shortener.h
index e3d851ca..a5e66a9a 100644
--- a/src/wallet/wallet_chain_shortener.h
+++ b/src/wallet/wallet_chain_shortener.h
@@ -10,7 +10,6 @@
 #include <boost/serialization/deque.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/shared_ptr.hpp>
 #include <atomic>
 #include <map>
 

From 19c818ed9b83f897c5cd42b2fe70777343e3e491 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 12 Aug 2024 20:09:22 +0200
Subject: [PATCH 17/37] minor improvements

---
 src/common/boost_serialization_maps.h | 2 +-
 src/common/crypto_serialization.h     | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/common/boost_serialization_maps.h b/src/common/boost_serialization_maps.h
index 7f44e4d2..5fbecea0 100644
--- a/src/common/boost_serialization_maps.h
+++ b/src/common/boost_serialization_maps.h
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#define BEGIN_BOOST_SERIALIZATION()     template <class t_archive> inline void serialize(t_archive &_arch, const unsigned int ver) {
+#define BEGIN_BOOST_SERIALIZATION()     template <class t_archive> void serialize(t_archive &_arch, const unsigned int ver) {
 
 template<size_t A, size_t B> struct TAssertEquality {
   static_assert(A == B, "Serialization map is not updated, sizeof() missmatch");
diff --git a/src/common/crypto_serialization.h b/src/common/crypto_serialization.h
index 9ac2ac90..481b3ff2 100644
--- a/src/common/crypto_serialization.h
+++ b/src/common/crypto_serialization.h
@@ -240,6 +240,8 @@ VARIANT_TAG(debug_archive, crypto::secret_key, "secret_key");
 VARIANT_TAG(debug_archive, crypto::key_derivation, "key_derivation");
 VARIANT_TAG(debug_archive, crypto::key_image, "key_image");
 VARIANT_TAG(debug_archive, crypto::signature, "signature");
+VARIANT_TAG(debug_archive, crypto::eth_public_key, "eth_public_key");
+VARIANT_TAG(debug_archive, crypto::eth_signature, "eth_signature");
 
 
 //

From faa95dd5557006cb1676cf71d3ba29ae33f529c2 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 12 Aug 2024 20:14:31 +0200
Subject: [PATCH 18/37] use boost::optional in asset_descriptor_base to avoid
 gcc compilation issues

---
 src/currency_core/currency_basic.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index 788f5a69..9e25b396 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -708,7 +708,7 @@ namespace currency
     std::string         meta_info;
     crypto::public_key  owner = currency::null_pkey; // consider premultipling by 1/8
     bool                hidden_supply = false;
-    std::optional<crypto::eth_public_key> owner_eth_pub_key; // note: the size is 33 bytes (if present)
+    boost::optional<crypto::eth_public_key> owner_eth_pub_key; // note: the size is 33 bytes (if present) // NOTE: using boost::optional instead of std::optional because of the Boost compilation issue: https://github.com/boostorg/serialization/issues/319 -- sowle
 
     uint8_t             version = ASSET_DESCRIPTOR_BASE_STRUCTURE_VER;
 

From 37e62ac079bfd831dac7562c47191755a5449583 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:13:26 +0200
Subject: [PATCH 19/37] various improvements

---
 src/crypto/zarcanum.h                     | 9 +++++++++
 src/currency_core/currency_basic.h        | 2 +-
 src/currency_core/currency_format_utils.h | 6 ++++++
 src/rpc/core_rpc_server.cpp               | 8 ++++----
 src/serialization/serialization.h         | 3 +--
 5 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/crypto/zarcanum.h b/src/crypto/zarcanum.h
index 3fe4b5c1..55e6b202 100644
--- a/src/crypto/zarcanum.h
+++ b/src/crypto/zarcanum.h
@@ -123,6 +123,15 @@ namespace crypto
     return generate_schnorr_sig(m, point_t(A), scalar_t(secret_a), result);
   }
 
+  inline bool generate_schnorr_sig(const hash& m, const secret_key& secret_a, generic_schnorr_sig& result)
+  {
+    scalar_t secret_a_s(secret_a);
+    if (!secret_a_s.is_reduced())
+      return false;
+    point_t A = secret_a_s * c_point_G;
+    return generate_schnorr_sig_custom_generator(m, A, secret_a_s, result, c_point_G);
+  }
+
 
   template<generator_tag gen = gt_G>
   inline bool verify_schnorr_sig(const hash& m, const public_key& A, const generic_schnorr_sig& sig) noexcept;
diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index 9e25b396..0b68379b 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -843,7 +843,7 @@ namespace currency
 
   struct asset_operation_ownership_proof_eth
   {
-    crypto::eth_signature eth_sig;
+    crypto::eth_signature eth_sig;            // 64 bytes
     uint8_t version = 0;
 
     BEGIN_VERSIONED_SERIALIZE(0, version)
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index 0aa22de2..c654aee6 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -950,6 +950,12 @@ namespace currency
     }
   }
   //---------------------------------------------------------------
+  template<typename invocable_t>
+  typename std::enable_if_t<std::is_invocable_v<invocable_t, std::ostream&>, std::ostream&> operator<<(std::ostream& o, invocable_t callee)
+  {
+    callee(o);
+    return o;
+  }
   //---------------------------------------------------------------
   std::ostream& operator <<(std::ostream& o, const ref_by_id& r);
   std::ostream& operator <<(std::ostream& o, const std::type_info& ti);
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index ee76e1ac..cc81a19e 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -75,7 +75,8 @@ namespace currency
     return true;
   }
 #define check_core_ready() check_core_ready_(LOCAL_FUNCTION_DEF__)
-#define CHECK_CORE_READY() if(!check_core_ready()){res.status =  API_RETURN_CODE_BUSY;return true;}
+#define CHECK_CORE_READY()    if (!check_core_ready()) {res.status =  API_RETURN_CODE_BUSY; return true; }
+#define CHECK_CORE_READY_WE() if (!check_core_ready()) {error_resp.code = CORE_RPC_ERROR_CODE_CORE_BUSY; error_resp.message = "Core is busy."; return false; }
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res, connection_context& cntx)
   {
@@ -1001,7 +1002,7 @@ namespace currency
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_submitblock(const COMMAND_RPC_SUBMITBLOCK::request& req, COMMAND_RPC_SUBMITBLOCK::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
   {
-    CHECK_CORE_READY();
+    CHECK_CORE_READY_WE();
     if(req.size()!=1)
     {
       error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;
@@ -1044,8 +1045,7 @@ namespace currency
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_submitblock2(const COMMAND_RPC_SUBMITBLOCK2::request& req, COMMAND_RPC_SUBMITBLOCK2::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
   {
-    CHECK_CORE_READY();
-
+    CHECK_CORE_READY_WE();
 
     block b = AUTO_VAL_INIT(b);
     if (!parse_and_validate_block_from_blob(req.b, b))
diff --git a/src/serialization/serialization.h b/src/serialization/serialization.h
index bb61001e..02eee4b1 100644
--- a/src/serialization/serialization.h
+++ b/src/serialization/serialization.h
@@ -238,8 +238,7 @@ bool t_unserializable_object_from_blob(t_object& to, const std::string& blob)
   ss << blob;
   binary_archive<false> ba(ss);
   bool r = ::serialization::serialize(ba, to);
-  CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob");
-  return true;
+  return r;
 }
 //---------------------------------------------------------------
 template<class t_object>

From 9d06106a78f617d1cb807fff247d24524fe20002 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:15:28 +0200
Subject: [PATCH 20/37] fxed arguments order for cast_assign_a_to_b()

---
 contrib/epee/include/misc_language.h      |  4 ++--
 src/currency_core/currency_format_utils.h |  2 +-
 src/wallet/wallet2.cpp                    | 10 ++++------
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/contrib/epee/include/misc_language.h b/contrib/epee/include/misc_language.h
index 3ee7001e..c200a3d0 100644
--- a/contrib/epee/include/misc_language.h
+++ b/contrib/epee/include/misc_language.h
@@ -84,9 +84,9 @@ namespace misc_utils
 {
 
   template<typename t_type_a, typename t_type_b>
-  void cast_assign_a_to_b(t_type_a& a, const t_type_b& b)
+  void cast_assign_a_to_b(const t_type_a& a, t_type_b& b)
   {
-    *static_cast<t_type_b*>(&a) = b;
+    *static_cast<t_type_a*>(&b) = a;
   }
 
   template<class _Ty1,
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index c654aee6..21df1afb 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -548,7 +548,7 @@ namespace currency
     {
       assets_list.push_back(currency::asset_descriptor_with_id());
       assets_list.back().asset_id = pr.first;
-      epee::misc_utils::cast_assign_a_to_b(assets_list.back(), static_cast<currency::asset_descriptor_base>(pr.second));
+      epee::misc_utils::cast_assign_a_to_b(static_cast<currency::asset_descriptor_base>(pr.second), assets_list.back());
       //*static_cast<currency::asset_descriptor_base*>(&assets_list.back()) = pr.second;
     }
   }
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 1985b18b..20e8e2e0 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -403,8 +403,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
 
       WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(m_own_asset_descriptors.count(asset_id) == 0, "asset with asset_id " << asset_id << " has already been registered in the wallet as own asset");
       wallet_own_asset_context& asset_context = m_own_asset_descriptors[asset_id];
-      epee::misc_utils::cast_assign_a_to_b(asset_context, ado.descriptor);
-      //*static_cast<asset_descriptor_base*>(&asset_context) = ado.descriptor;
+      epee::misc_utils::cast_assign_a_to_b(ado.descriptor, asset_context);
 
       std::stringstream ss;
       ss << "New Asset Registered:"
@@ -428,7 +427,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
         break;
       //asset had been updated
       add_rollback_event(ptc.height, asset_update_event{ it->first, it->second });
-      epee::misc_utils::cast_assign_a_to_b(it->second, ado.descriptor);
+      epee::misc_utils::cast_assign_a_to_b(ado.descriptor, it->second);
       
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE )
@@ -441,7 +440,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
           // ownership of the asset acquired
 
           wallet_own_asset_context& asset_context = m_own_asset_descriptors[asset_id];
-          epee::misc_utils::cast_assign_a_to_b(asset_context, ado.descriptor);
+          epee::misc_utils::cast_assign_a_to_b(ado.descriptor, asset_context);
 
           std::stringstream ss;
           ss << "Asset ownership acquired:"
@@ -492,8 +491,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
         {
           //just an update of the asset
           add_rollback_event(ptc.height, asset_update_event{ it->first, it->second });
-          epee::misc_utils::cast_assign_a_to_b(it->second, ado.descriptor);
-          
+          epee::misc_utils::cast_assign_a_to_b(ado.descriptor, it->second);
         }
       }
     }

From 3d1ac6124e546c4f3734624f5112a184a9b7b15b Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:17:00 +0200
Subject: [PATCH 21/37] core rpc: decrypt_tx_details call implmented

---
 src/rpc/core_rpc_server.cpp             | 68 +++++++++++++++++++++++++
 src/rpc/core_rpc_server.h               |  5 +-
 src/rpc/core_rpc_server_commands_defs.h | 53 +++++++++++++++++++
 3 files changed, 125 insertions(+), 1 deletion(-)

diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index cc81a19e..6e9a3f4b 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -751,6 +751,74 @@ namespace currency
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_decrypt_tx_details(const COMMAND_RPC_DECRYPT_TX_DETAILS::request& req, COMMAND_RPC_DECRYPT_TX_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
+  {
+#define LOCAL_CHECK(cond, msg)         if (!(cond)) { error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;    error_resp.message = msg; LOG_PRINT_L1("on_decrypt_tx_details: " << error_resp.message); return false; }
+#define LOCAL_CHECK_INT_ERR(cond, msg) if (!(cond)) { error_resp.code = CORE_RPC_ERROR_CODE_INTERNAL_ERROR; error_resp.message = msg; LOG_PRINT_L1("on_decrypt_tx_details: " << error_resp.message); return false; }
+
+    LOCAL_CHECK(req.tx_id.empty() != req.tx_blob.empty(), "One of either tx_id or tx_blob must be specified.");
+
+    transaction tx{};
+    if (!req.tx_id.empty())
+    {
+      CHECK_CORE_READY_WE();
+
+      crypto::hash tx_id{};
+      LOCAL_CHECK(crypto::parse_tpod_from_hex_string(req.tx_id, tx_id), "tx_id is given, but it's invalid");
+      LOCAL_CHECK(m_core.get_transaction(tx_id, tx), "tx with the given tx_id could be found in the blockchain");
+    }
+    else
+    {
+      blobdata decoded_blob = string_encoding::base64_decode(req.tx_blob);
+      if (!t_unserializable_object_from_blob(tx, decoded_blob))
+      {
+        // unable to decode tx_blob as base64, try once again as hex-encoding
+        decoded_blob.clear();
+        string_tools::parse_hexstr_to_binbuff(req.tx_blob, decoded_blob);
+        LOCAL_CHECK(t_unserializable_object_from_blob(tx, decoded_blob), "tx_id is not given, and tx_blob is invalid");
+      }
+    }
+
+    crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
+    crypto::point_t R{};
+    LOCAL_CHECK(tx_pub_key != null_pkey && R.from_public_key(tx_pub_key) && R.is_in_main_subgroup(), "unsigned_tx: tx public key is missing or invalid");
+
+    LOCAL_CHECK(tx_pub_key == (crypto::scalar_t(req.tx_secret_key) * crypto::c_point_G).to_public_key(), "tx_secret_key doesn't match the transaction public key");
+
+    LOCAL_CHECK(req.outputs_addresses.size() == tx.vout.size(), "outputs_addresses count (" + epee::string_tools::num_to_string_fast(req.outputs_addresses.size()) + " doesn't match tx.vout size (" + epee::string_tools::num_to_string_fast(tx.vout.size()) + ")");
+
+    for(size_t i = 0; i < req.outputs_addresses.size(); ++i)
+    {
+      if (req.outputs_addresses[i].empty())
+        continue; // skip this output if the given address is empty string
+
+      account_public_address addr{};
+      payment_id_t payment_id{};
+      LOCAL_CHECK(currency::get_account_address_and_payment_id_from_str(addr, payment_id, req.outputs_addresses[i]) && payment_id.empty(), "output address #" + epee::string_tools::num_to_string_fast(i) + " couldn't be parsed or it is an integrated address (which is not supported)");
+
+      tx_out_v& out_v = tx.vout[i];
+      LOCAL_CHECK(out_v.type() == typeid(tx_out_zarcanum), "tx output #" + epee::string_tools::num_to_string_fast(i) + " has wrong type");
+      const tx_out_zarcanum& zo = boost::get<tx_out_zarcanum>(out_v);
+
+      crypto::key_derivation derivation{};
+      LOCAL_CHECK_INT_ERR(crypto::generate_key_derivation(addr.view_public_key, req.tx_secret_key, derivation), "output #" + epee::string_tools::num_to_string_fast(i) + ": generate_key_derivation failed");
+      
+      auto& decoded_out = res.decoded_outputs.emplace_back();
+      decoded_out.out_index = i;
+      decoded_out.address = req.outputs_addresses[i];
+      crypto::scalar_t amount_blinding_mask{}, asset_id_blinding_mask{};
+      LOCAL_CHECK(currency::decode_output_amount_and_asset_id(zo, derivation, i, decoded_out.amount, decoded_out.asset_id, amount_blinding_mask, asset_id_blinding_mask), "output #" + epee::string_tools::num_to_string_fast(i) + ": cannot be decoded");
+    }
+
+    res.tx_in_json = currency::obj_to_json_str(tx);
+    res.verified_tx_id = get_transaction_hash(tx);
+
+    res.status = API_RETURN_CODE_OK;
+    return true;
+#undef LOCAL_CHECK
+#undef LOCAL_CHECK_INT_ERR
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_get_main_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
   {
     if (!m_core.get_blockchain_storage().get_main_block_rpc_details(req.id, res.block_details))
diff --git a/src/rpc/core_rpc_server.h b/src/rpc/core_rpc_server.h
index 02e7b478..79c5ed69 100644
--- a/src/rpc/core_rpc_server.h
+++ b/src/rpc/core_rpc_server.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2018 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Copyright (c) 2012-2013 The Cryptonote developers
 // Distributed under the MIT/X11 software license, see the accompanying
@@ -89,6 +89,7 @@ namespace currency
     bool on_get_votes(const COMMAND_RPC_GET_VOTES::request& req, COMMAND_RPC_GET_VOTES::response& res, connection_context& cntx);
     bool on_get_asset_info(const COMMAND_RPC_GET_ASSET_INFO::request& req, COMMAND_RPC_GET_ASSET_INFO::response& res, connection_context& cntx);
     bool on_get_assets_list(const COMMAND_RPC_GET_ASSETS_LIST::request& req, COMMAND_RPC_GET_ASSETS_LIST::response& res, connection_context& cntx);
+    bool on_decrypt_tx_details(const COMMAND_RPC_DECRYPT_TX_DETAILS::request& req, COMMAND_RPC_DECRYPT_TX_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
 
     bool on_get_main_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
     bool on_get_alt_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
@@ -150,9 +151,11 @@ namespace currency
         MAP_JON_RPC   ("getrandom_outs1",             on_get_random_outs1,            COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS)
         MAP_JON_RPC   ("getrandom_outs3",             on_get_random_outs3,            COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS3)
         MAP_JON_RPC   ("get_votes",                   on_get_votes,                   COMMAND_RPC_GET_VOTES)
+        
         //assets api
         MAP_JON_RPC   ("get_asset_info",              on_get_asset_info,             COMMAND_RPC_GET_ASSET_INFO)
         MAP_JON_RPC   ("get_assets_list",             on_get_assets_list,            COMMAND_RPC_GET_ASSETS_LIST)
+        MAP_JON_RPC_WE("decrypt_tx_details",          on_decrypt_tx_details,         COMMAND_RPC_DECRYPT_TX_DETAILS)
 
         MAP_JON_RPC_WE("get_main_block_details",      on_get_main_block_details,      COMMAND_RPC_GET_BLOCK_DETAILS)
         MAP_JON_RPC_WE("get_alt_block_details",       on_get_alt_block_details,       COMMAND_RPC_GET_BLOCK_DETAILS)
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index 9a89d043..7c926958 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -23,6 +23,7 @@
 #include <list>
 #include <string>
 #include <vector>
+#include <currency_core/account.h>
 //#include "currency_core/basic_api_response_codes.h"
 
 namespace currency
@@ -178,6 +179,58 @@ namespace currency
     };
   };
 
+
+  struct COMMAND_RPC_DECRYPT_TX_DETAILS
+  {
+    DOC_COMMAND("Decrypts transaction private information. Should be used only with your own local daemon for security reasons.");
+
+    struct request
+    {
+      std::string tx_id;
+      currency::blobdata tx_blob;
+      crypto::secret_key tx_secret_key;
+      std::vector<std::string> outputs_addresses;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(tx_id)                      DOC_DSCR("[either] ID for a transaction if it is already in the blockchain. Can be ommited if tx_blob is provided.") DOC_EXMP("a6e8da986858e6825fce7a192097e6afae4e889cabe853a9c29b964985b23da8") DOC_END
+        KV_SERIALIZE(tx_blob)                    DOC_DSCR("[or] base64-encoded or hex-encoded tx blob. Can be ommited if tx_id is provided.") DOC_EXMP("ewogICJ2ZXJzaW9uIjogMSwgC....iAgInZpbiI6IFsgewogICAgIC") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_secret_key) DOC_DSCR("Hex-encoded transaction secret key.") DOC_EXMP("2e0b840e70dba386effd64c5d988622dea8c064040566e6bf035034cbb54a5c08") DOC_END
+        KV_SERIALIZE(outputs_addresses)          DOC_DSCR("Address of each of tx's output. Order is important and should correspond to order of tx's outputs. Empty strings are ignored.") DOC_EXMP_AGGR("ZxDNaMeZjwCjnHuU5gUNyrP1pM3U5vckbakzzV6dEHyDYeCpW8XGLBFTshcaY8LkG9RQn7FsQx8w2JeJzJwPwuDm2NfixPAXf", "ZxBvJDuQjMG9R2j4WnYUhBYNrwZPwuyXrC7FHdVmWqaESgowDvgfWtiXeNGu8Px9B24pkmjsA39fzSSiEQG1ekB225ZnrMTBp") DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+
+    // TODO consider reusing existing structure transfer_destination -- sowle
+    struct decoded_output
+    {
+      uint64_t amount = 0;
+      std::string address;
+      crypto::public_key asset_id;
+      uint64_t out_index;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(amount)                      DOC_DSCR("Amount begin transferred.") DOC_EXMP(10000000000000)     DOC_END
+        KV_SERIALIZE(address)                     DOC_DSCR("Destination address.") DOC_EXMP("ZxBvJDuQjMG9R2j4WnYUhBYNrwZPwuyXrC7FHdVmWqaESgowDvgfWtiXeNGu8Px9B24pkmjsA39fzSSiEQG1ekB225ZnrMTBp")     DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(asset_id)  DOC_DSCR("Asset id.") DOC_EXMP("cc608f59f8080e2fbfe3c8c80eb6e6a953d47cf2d6aebd345bada3a1cab99852")     DOC_END
+        KV_SERIALIZE(out_index)                   DOC_DSCR("Index of the corresponding output in the transaction.") DOC_EXMP(1) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      std::vector<decoded_output> decoded_outputs;
+      std::string tx_in_json;
+      crypto::hash verified_tx_id;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)                     DOC_DSCR("Status code of operation, OK if success") DOC_EXMP(API_RETURN_CODE_OK) DOC_END
+        KV_SERIALIZE(decoded_outputs)            DOC_DSCR("Transaction's decoded outputs") DOC_EXMP_AUTO(1) DOC_END
+        KV_SERIALIZE_BLOB_AS_BASE64_STRING(tx_in_json) DOC_DSCR("Serialized transaction represented in JSON, encoded in Base64.") DOC_EXMP("ewogICJ2ZXJzaW9uIjogMSwgC....iAgInZpbiI6IFsgewogICAgIC") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(verified_tx_id) DOC_DSCR("(Re)calculated transaction id. Can be used in third-party proof generation.") DOC_EXMP("a6e8da986858e6825fce7a192097e6afae4e889cabe853a9c29b964985b23da8") DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
   struct COMMAND_RPC_GET_HEIGHT
   {
     DOC_COMMAND("Return current blockchain height");

From 5f1defc5a17deaab39a5385d57be51d03990c7fa Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:19:58 +0200
Subject: [PATCH 22/37] core validation: additional condition
 validate_ado_ownership()

---
 src/currency_core/blockchain_storage.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 7e840273..168eedb3 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -4111,6 +4111,7 @@ bool validate_ado_ownership(asset_op_verification_context& avc)
 
   if (last_ado.descriptor.owner_eth_pub_key.has_value())
   {
+    CHECK_AND_ASSERT_MES(last_ado.descriptor.owner == null_pkey, false, "owner_eth_pub_key is set but owner pubkey is nonzero");
     asset_operation_ownership_proof_eth aoop_eth{};
     r = get_type_in_variant_container(avc.tx.proofs, aoop_eth);
     CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed: asset_operation_ownership_proof_eth is missing");

From 3c9d6666cd8041f6f8259cb0c0ab2c2971262a1d Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:25:24 +0200
Subject: [PATCH 23/37] wallet2: various improvements

---
 src/wallet/wallet2.cpp    | 36 ++++++++++++++++++++----------------
 src/wallet/wallet2.h      |  2 +-
 src/wallet/wallet2_base.h |  1 +
 3 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 20e8e2e0..deb7e56e 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -129,7 +129,7 @@ namespace tools
 //----------------------------------------------------------------------------------------------------
 std::string wallet2::transfer_flags_to_str(uint32_t flags)
 {
-  std::string result(5, ' ');
+  std::string result(7, ' ');
   if (flags & WALLET_TRANSFER_DETAIL_FLAG_SPENT)
     result[0] = 's';
   if (flags & WALLET_TRANSFER_DETAIL_FLAG_BLOCKED)
@@ -140,6 +140,10 @@ std::string wallet2::transfer_flags_to_str(uint32_t flags)
     result[3] = 'm';
   if (flags & WALLET_TRANSFER_DETAIL_FLAG_COLD_SIG_RESERVATION)
     result[4] = 'c';
+  if (flags & WALLET_TRANSFER_DETAIL_FLAG_HTLC_REDEEM)
+    result[5] = 'h';
+  if (flags & WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION)
+    result[6] = 'a';
   return result;
 }
 //----------------------------------------------------------------------------------------------------
@@ -465,8 +469,8 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
       }
       else
       {
-        //update event for asset that we control, check if ownership is still ours
-        if (ado.descriptor.owner != m_account.get_public_address().spend_public_key && !it->second.thirdparty_custody)
+        // check our ownership status: we lost it if the asset has new non-null owner (null means a third-party ownership, and in such a case we retain it in the own list whatever happens)
+        if (ado.descriptor.owner != null_pkey && ado.descriptor.owner != m_account.get_public_address().spend_public_key)
         {
           //ownership of the asset had been transfered
           add_rollback_event(ptc.height, asset_unown_event{ it->first, it->second });
@@ -475,7 +479,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
           std::stringstream ss;
           ss << "Asset ownership lost:"
             << ENDL << "asset id:         " << asset_id
-            << ENDL << "New owner:        " << ado.descriptor.owner
+            << ENDL << "New owner:        " << print_ado_owner
             << ENDL << "Name:             " << ado.descriptor.full_name
             << ENDL << "Ticker:           " << ado.descriptor.ticker
             << ENDL << "Total Max Supply: " << print_asset_money(ado.descriptor.total_max_supply, ado.descriptor.decimal_point)
@@ -1149,7 +1153,7 @@ void wallet2::accept_proposal(const crypto::hash& contract_id, uint64_t b_accept
     throw;
   }
 
-  print_tx_sent_message(tx, "(contract <" + epee::string_tools::pod_to_hex(contract_id) + ">)", construct_param.fee);
+  print_tx_sent_message(tx, "contract <" + epee::string_tools::pod_to_hex(contract_id) + ">", true, construct_param.fee);
 
   if (p_acceptance_tx != nullptr)
     *p_acceptance_tx = tx;
@@ -1288,7 +1292,7 @@ void wallet2::request_cancel_contract(const crypto::hash& contract_id, uint64_t
     throw;
   }
 
-  print_tx_sent_message(tx, "(transport for cancel proposal)", fee);
+  print_tx_sent_message(tx, "transport for cancel proposal", true, fee);
 
   if (p_cancellation_proposal_tx != nullptr)
     *p_cancellation_proposal_tx = tx;
@@ -4002,7 +4006,7 @@ bool wallet2::generate_utxo_defragmentation_transaction_if_needed(currency::tran
 //----------------------------------------------------------------------------------------------------
 std::string wallet2::get_transfers_str(bool include_spent /*= true*/, bool include_unspent /*= true*/, bool show_only_unknown /*= false*/, const std::string& filter_asset_ticker /*= std::string{}*/) const
 {
-  static const char* header = " index                 amount  ticker  g_index  flags       block  tx                                                                out#  asset id";
+  static const char* header = " index                 amount  ticker  g_index  flags         block  tx                                                                out#  asset id";
   std::stringstream ss;
   ss << header << ENDL;
   size_t count = 0;
@@ -4034,7 +4038,7 @@ std::string wallet2::get_transfers_str(bool include_spent /*= true*/, bool inclu
       std::setw(6) << std::left << (native_coin ? std::string("      ") : adb.ticker) << "  " << std::right <<
       std::setw(7) << td.m_global_output_index << "  " <<
       std::setw(2) << std::setfill('0') << td.m_flags << std::setfill(' ') << ":" <<
-      std::setw(5) << transfer_flags_to_str(td.m_flags) << "  " <<
+      std::setw(7) << transfer_flags_to_str(td.m_flags) << "  " <<
       std::setw(7) << td.m_ptx_wallet_info->m_block_height << "  " <<
       get_transaction_hash(td.m_ptx_wallet_info->m_tx) << "  " <<
       std::setw(4) << td.m_internal_output_index << "  ";
@@ -4388,7 +4392,7 @@ void wallet2::submit_transfer(const std::string& signed_tx_blob, currency::trans
   }
 
   // TODO: print inputs' key images
-  print_tx_sent_message(tx, "(from submit_transfer)");
+  print_tx_sent_message(tx, "from submit_transfer", true);
 }
 //----------------------------------------------------------------------------------------------------
 void wallet2::submit_transfer_files(const std::string& signed_tx_file, currency::transaction& tx)
@@ -5960,7 +5964,7 @@ void wallet2::send_escrow_proposal(const bc_services::contract_private_details&
   mark_transfers_as_spent(ftp.selected_transfers, std::string("escrow proposal sent, tx <") + epee::string_tools::pod_to_hex(get_transaction_hash(tx)) + ">, contract: " + epee::string_tools::pod_to_hex(ms_id));
   add_sent_tx_detailed_info(tx, ftp.attachments, ftp.prepared_destinations, ftp.selected_transfers);
 
-  print_tx_sent_message(tx, "(from multisig)", fee);
+  print_tx_sent_message(tx, "from multisig", true, fee);
 }
 //----------------------------------------------------------------------------------------------------
 void wallet2::create_htlc_proposal(uint64_t amount, const currency::account_public_address& addr, uint64_t lock_blocks_count, currency::transaction &tx, const crypto::hash& htlc_hash,  std::string &origin)
@@ -7417,20 +7421,20 @@ void wallet2::set_genesis(const crypto::hash& genesis_hash)
   m_chain.set_genesis(genesis_hash);
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::print_tx_sent_message(const currency::transaction& tx, const std::string& description, uint64_t fee /* = UINT64_MAX */)
+void wallet2::print_tx_sent_message(const currency::transaction& tx, const std::string& description, bool broadcasted, uint64_t fee /* = UINT64_MAX */)
 {
   //uint64_t balance_unlocked = 0;
   //uint64_t balance_total = balance(balance_unlocked);
 
   std::stringstream ss;
   if (fee != UINT64_MAX)
-    ss << "Commission: " << std::setw(21) << std::right << print_money(fee) << ENDL;
+    ss << "Fee: " << std::setw(21) << std::right << print_money_brief(fee) << ENDL;
 
-  WLT_LOG_CYAN("Transaction " << get_transaction_hash(tx) << " was successfully sent " << description << ENDL
+  WLT_LOG_CYAN("Transaction " << get_transaction_hash(tx) << " was successfully " << (broadcasted ? "sent" : "created") << " (" << description << ")" << ENDL
     << ss.str()
 //    << "Balance:    " << std::setw(21) << print_money(balance_total) << ENDL
 //    << "Unlocked:   " << std::setw(21) << print_money(balance_unlocked) << ENDL
-    << "Please, wait for confirmation for your balance to be unlocked.",
+    << (broadcasted ? "Please wait for the transaction to be confirmed before your balance is unlocked." : ""),
     LOG_LEVEL_0);
 }
 //----------------------------------------------------------------------------------------------------
@@ -7933,7 +7937,7 @@ void wallet2::transfer(construct_tx_param& ctp,
     << ", mark_transfers_as_spent_time: " << print_fixed_decimal_point(mark_transfers_as_spent_time, 3)
     , LOG_LEVEL_0);
 
-  print_tx_sent_message(result.tx, std::string() + "(transfer)", ctp.fee);
+  print_tx_sent_message(result.tx, tx_description, send_to_network, ctp.fee);
 }
 
 //----------------------------------------------------------------------------------------------------
@@ -8221,7 +8225,7 @@ void wallet2::sweep_below(size_t fake_outs_count, const currency::account_public
   {
     crypto::secret_key sk{};
     finalize_transaction(ftp, *p_tx, sk, true);
-    print_tx_sent_message(*p_tx, "(sweep_below)", get_tx_fee(*p_tx));
+    print_tx_sent_message(*p_tx, "sweep_below", true, get_tx_fee(*p_tx));
   }
   catch (...)
   {
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 2fa7601b..924d643a 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -836,7 +836,7 @@ private:
 
     uint64_t get_tx_expiration_median() const;
 
-    void print_tx_sent_message(const currency::transaction& tx, const std::string& description, uint64_t fee = UINT64_MAX);
+    void print_tx_sent_message(const currency::transaction& tx, const std::string& description, bool broadcasted, uint64_t fee = UINT64_MAX);
 
     // Validates escrow template tx in assumption it's related to wallet's account (wallet's account is either A or B party in escrow process)
     bool validate_escrow_proposal(const wallet_public::wallet_transfer_info& wti, const bc_services::proposal_body& prop,
diff --git a/src/wallet/wallet2_base.h b/src/wallet/wallet2_base.h
index f8b4eadf..d67fc024 100644
--- a/src/wallet/wallet2_base.h
+++ b/src/wallet/wallet2_base.h
@@ -51,6 +51,7 @@
 #define   WALLET_TRANSFER_DETAIL_FLAG_MINED_TRANSFER                   uint32_t(1 << 3)
 #define   WALLET_TRANSFER_DETAIL_FLAG_COLD_SIG_RESERVATION             uint32_t(1 << 4) // transfer is reserved for cold-signing (unsigned tx was created and passed for signing)
 #define   WALLET_TRANSFER_DETAIL_FLAG_HTLC_REDEEM                      uint32_t(1 << 5) // for htlc keeps info if this htlc belong as redeem or as refund
+#define   WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION             uint32_t(1 << 6) // transfer is reserved for an ongoing asset operation with external signing
 
 
 

From e414752976b4c9c74d1b0d1bf7afada26625a8dc Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:27:46 +0200
Subject: [PATCH 24/37] refactored asset ownership handling in tx construction

---
 src/currency_core/currency_basic.h          |  2 +
 src/currency_core/currency_format_utils.cpp | 46 +++++++--------------
 src/currency_core/currency_format_utils.h   |  8 +---
 3 files changed, 20 insertions(+), 36 deletions(-)

diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index 0b68379b..cd7741a1 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -698,6 +698,8 @@ namespace currency
 
 #define ASSET_DESCRIPTOR_BASE_STRUCTURE_VER  1
 
+  typedef boost::variant<crypto::public_key, crypto::eth_public_key> asset_owner_pub_key_v;
+
   struct asset_descriptor_base
   {
     uint64_t            total_max_supply = 0;
diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp
index f8115a47..4cbf730b 100644
--- a/src/currency_core/currency_format_utils.cpp
+++ b/src/currency_core/currency_format_utils.cpp
@@ -2182,8 +2182,10 @@ namespace currency
       return true;
     }
 
-    // otherwise, calculate asset id
+    // otherwise, it must be a register operation
+    CHECK_AND_ASSERT_MES(ado.operation_type == ASSET_DESCRIPTOR_OPERATION_REGISTER, false, "unexpected asset operation type: " << (int)ado.operation_type << ", " << get_asset_operation_type_string(ado.operation_type));
 
+    // calculate asset id
     crypto::hash_helper_t::hs_t hsc;
     hsc.add_32_chars(CRYPTO_HDS_ASSET_ID);
     hsc.add_hash(crypto::hash_helper_t::h(ado.descriptor.ticker));
@@ -2336,7 +2338,6 @@ namespace currency
       }
       if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_handle_asset_descriptor_operation_before_seal{ &ado });
 
-      ftp.need_to_generate_ado_proof = true;
     }
     return true;
   }
@@ -2586,8 +2587,7 @@ namespace currency
     // ASSET oprations handling
     if (tx.version > TRANSACTION_VERSION_PRE_HF4)
     {
-      asset_descriptor_operation* pado = nullptr;
-      pado = get_type_in_variant_container<asset_descriptor_operation>(tx.extra);
+      asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(tx.extra);
       if (pado)
       {
         bool r = construct_tx_handle_ado(sender_account_keys, ftp, *pado, gen_context, gen_context.tx_key, shuffled_dsts);
@@ -2700,7 +2700,8 @@ namespace currency
     // generate proofs and signatures
     // (any changes made below should only affect the signatures/proofs and should not impact the prefix hash calculation)
     //
-    crypto::hash tx_prefix_hash = get_transaction_prefix_hash(tx);
+    result.tx_id = get_transaction_prefix_hash(tx);
+    const crypto::hash &tx_prefix_hash = result.tx_id;
 
     // ring signatures (per-input proofs)
     r = false;
@@ -2756,39 +2757,24 @@ namespace currency
       CHECK_AND_ASSERT_MES(r, false, "generate_tx_balance_proof failed");
       tx.proofs.emplace_back(std::move(balance_proof));
 
-      // asset operation proof (if necessary)
+      // asset operation proofs (if necessary)
       if (gen_context.ao_asset_id != currency::null_pkey)
       {
-        // construct the asset operation proof
-        // TODO @#@# add support for hidden supply
+        // asset amount commitment g proof   (TODO @#@# add support for hidden supply)
         crypto::signature aop_g_sig{};
         crypto::generate_signature(tx_prefix_hash, crypto::point_t(gen_context.ao_amount_blinding_mask * crypto::c_point_G).to_public_key(), gen_context.ao_amount_blinding_mask, aop_g_sig);
         asset_operation_proof aop{};
         aop.opt_amount_commitment_g_proof = aop_g_sig;
         tx.proofs.emplace_back(std::move(aop));
-      }
-      if(ftp.need_to_generate_ado_proof)        
-      { 
-        if (ftp.p_eth_signer)
+
+        // asset ownership proof for standard (non-eth) owner (using generic Shnorr signature with the spend secret key)
+        const asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(tx.extra);
+        CHECK_AND_ASSERT_MES(pado != nullptr, false, "pado is null");
+        if ((pado->operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT || pado->operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE) &&
+            !pado->descriptor.owner_eth_pub_key.has_value())
         {
-          // third party generates eth proof
-          CHECKED_GET_SPECIFIC_VARIANT(ftp.asset_owner, const crypto::eth_public_key, asset_owner_pubkey_eth, false);
-          asset_operation_ownership_proof_eth aoop_eth{};
-          r = ftp.p_eth_signer->sign(tx_prefix_hash, asset_owner_pubkey_eth, aoop_eth.eth_sig);
-          CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado by 3rd party eth signer");
-          // instant verification
-          r = crypto::verify_eth_signature(tx_prefix_hash, asset_owner_pubkey_eth, aoop_eth.eth_sig);
-          CHECK_AND_ASSERT_MES(r, false, "Ado by 3rd party eth signer has been incorrectly signed");
-          if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_eth_proof_generated{ &aoop_eth });
-          tx.proofs.emplace_back(aoop_eth);
-        }
-        else
-        {
-          // generic Shnorr signature (signing with the spend secret key)
-          CHECKED_GET_SPECIFIC_VARIANT(ftp.asset_owner, const crypto::public_key, asset_owner_pubkey, false);
-          // generate signature by wallet account 
-          asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
-          r = crypto::generate_schnorr_sig(tx_prefix_hash, asset_owner_pubkey, sender_account_keys.spend_secret_key, aoop.gss);
+          asset_operation_ownership_proof aoop{};
+          r = crypto::generate_schnorr_sig(tx_prefix_hash, pado->descriptor.owner, sender_account_keys.spend_secret_key, aoop.gss); // owner will be checked against spend secret key within this call
           CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado proof");
           if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_proof_generated{ &aoop });
           tx.proofs.emplace_back(aoop);
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index 21df1afb..99d00fa4 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -167,10 +167,6 @@ namespace currency
     epee::misc_utils::events_dispatcher* pevents_dispatcher;
     tx_generation_context gen_context{}; // solely for consolidated txs
     
-    //crypto::secret_key asset_control_key = currency::null_skey;
-    asset_owner_key_v asset_owner;
-    asset_eth_signer_i* p_eth_signer = nullptr;
-    mutable bool need_to_generate_ado_proof = false;
 
 
     BEGIN_SERIALIZE_OBJECT()
@@ -193,14 +189,13 @@ namespace currency
       {
         FIELD(gen_context);
       }
-      FIELD(asset_owner)
-      FIELD(need_to_generate_ado_proof)
     END_SERIALIZE()
   };
 
   struct finalized_tx
   {
     currency::transaction tx;
+    crypto::hash          tx_id;
     crypto::secret_key    one_time_key;
     finalize_tx_param     ftp;
     std::string           htlc_origin;
@@ -210,6 +205,7 @@ namespace currency
 
     BEGIN_SERIALIZE_OBJECT()
       FIELD(tx)
+      FIELD(tx_id)
       FIELD(one_time_key)
       FIELD(ftp)
       FIELD(htlc_origin)

From bb758a916a051a7f3da87fdb688c3cc2450cbbf6 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:29:57 +0200
Subject: [PATCH 25/37] wallet2: assets-related tx generation refactored

---
 src/wallet/wallet2.cpp    | 190 +++++++++++++++++++++++++-------------
 src/wallet/wallet2.h      |  14 ++-
 src/wallet/wallet2_base.h |   7 +-
 3 files changed, 138 insertions(+), 73 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index deb7e56e..580a918d 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -394,6 +394,10 @@ const crypto::public_key& wallet2::out_get_pub_key(const currency::tx_out_v& out
 //----------------------------------------------------------------------------------------------------
 void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_operation& ado, process_transaction_context& ptc)
 {
+  auto print_ado_owner = [ado](std::ostream& o){
+    ado.descriptor.owner_eth_pub_key.has_value() ? o << ado.descriptor.owner_eth_pub_key.get() << " (ETH)" : o << ado.descriptor.owner;
+  };
+
   do
   {
     crypto::public_key asset_id{};
@@ -402,7 +406,12 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
 
     if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_REGISTER)
     {
-      if (ado.descriptor.owner != m_account.get_public_address().spend_public_key)
+      // Add an asset to ownership list if either:
+      // 1) we're the owner of the asset;
+      //   or
+      // 2) we spent native coins in the tx (i.e. we sent it) AND it registers an asset with third-party ownership.
+      if (ado.descriptor.owner != m_account.get_public_address().spend_public_key && 
+         (!ado.descriptor.owner_eth_pub_key.has_value() || !ptc.spent_own_native_inputs))
         break;
 
       WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(m_own_asset_descriptors.count(asset_id) == 0, "asset with asset_id " << asset_id << " has already been registered in the wallet as own asset");
@@ -412,6 +421,7 @@ void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_op
       std::stringstream ss;
       ss << "New Asset Registered:"
         << ENDL << "asset id:         " << asset_id
+        << ENDL << "Owner:            " << print_ado_owner
         << ENDL << "Name:             " << asset_context.full_name
         << ENDL << "Ticker:           " << asset_context.ticker
         << ENDL << "Total Max Supply: " << print_asset_money(asset_context.total_max_supply, asset_context.decimal_point)
@@ -5362,126 +5372,162 @@ void wallet2::request_alias_registration(currency::extra_alias_entry& ai, curren
   transfer(destinations, 0, 0, fee, extra, attachments, get_current_split_strategy(), tx_dust_policy(DEFAULT_DUST_THRESHOLD), res_tx, CURRENCY_TO_KEY_OUT_RELAXED, false);
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::deploy_new_asset(const currency::asset_descriptor_base& asset_info, const std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx, crypto::public_key& new_asset_id)
+void wallet2::deploy_new_asset(const currency::asset_descriptor_base& asset_info, const std::vector<currency::tx_destination_entry>& destinations, currency::finalized_tx& ft, crypto::public_key& new_asset_id)
 {
-  WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(asset_info.decimal_point <= 18, "too big decimal point: " << asset_info.decimal_point);
+  WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(asset_info.decimal_point <= 18, "too big decimal point: " << (int)asset_info.decimal_point);
 
-  asset_descriptor_operation asset_reg_info = AUTO_VAL_INIT(asset_reg_info);
+  asset_descriptor_operation asset_reg_info{};
   asset_reg_info.descriptor = asset_info;
   asset_reg_info.operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER;
   construct_tx_param ctp = get_default_construct_tx_param();
   ctp.dsts = destinations;
   ctp.extra.push_back(asset_reg_info);
   ctp.need_at_least_1_zc = true;
+  ctp.tx_meaning_for_logs = "asset registration";
 
-  finalized_tx ft = AUTO_VAL_INIT(ft);
   this->transfer(ctp, ft, true, nullptr);
-  result_tx = ft.tx;
   //get generated asset id
-  currency::asset_descriptor_operation ado = AUTO_VAL_INIT(ado);
-  bool r = get_type_in_variant_container(result_tx.extra, ado);
-  CHECK_AND_ASSERT_THROW_MES(r, "Failed find asset info in tx");
+  currency::asset_descriptor_operation ado{};
+  bool r = get_type_in_variant_container(ft.tx.extra, ado);
+  CHECK_AND_ASSERT_THROW_MES(r, "asset_descriptor_operation cannot be found in tx extra as expected");
   CHECK_AND_ASSERT_THROW_MES(get_or_calculate_asset_id(ado, nullptr, &new_asset_id), "get_or_calculate_asset_id failed");
 
   m_custom_assets[new_asset_id] = ado.descriptor;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::emit_asset(const crypto::public_key asset_id, std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx)
+void wallet2::deploy_new_asset(const currency::asset_descriptor_base& asset_info, const std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx, crypto::public_key& new_asset_id)
+{
+  finalized_tx ft{};
+  deploy_new_asset(asset_info, destinations, ft, new_asset_id);
+  result_tx = ft.tx;
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::emit_asset(const crypto::public_key& asset_id, const std::vector<currency::tx_destination_entry>& destinations, currency::finalized_tx& ft)
 {
-
   auto own_asset_entry_it = m_own_asset_descriptors.find(asset_id);
   CHECK_AND_ASSERT_THROW_MES(own_asset_entry_it != m_own_asset_descriptors.end(), "Failed find asset_id " << asset_id << " in own assets list");
-  COMMAND_RPC_GET_ASSET_INFO::request req;
-  req.asset_id = asset_id;
-  COMMAND_RPC_GET_ASSET_INFO::response rsp;
-  bool r = m_core_proxy->call_COMMAND_RPC_GET_ASSET_INFO(req, rsp);
-  CHECK_AND_ASSERT_THROW_MES(r, "Failed to call_COMMAND_RPC_GET_ASSET_INFO");
- 
-  asset_descriptor_operation asset_emmit_info = AUTO_VAL_INIT(asset_emmit_info);
-  asset_emmit_info.descriptor = rsp.asset_descriptor;
+  currency::asset_descriptor_base last_adb{};
+  bool r = daemon_get_asset_info(asset_id, last_adb);
+  CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
+
+  asset_descriptor_operation asset_emmit_info{};
+  asset_emmit_info.descriptor = last_adb;
   asset_emmit_info.operation_type = ASSET_DESCRIPTOR_OPERATION_EMIT;
   asset_emmit_info.opt_asset_id = asset_id;
   construct_tx_param ctp = get_default_construct_tx_param();
   ctp.dsts = destinations;
   ctp.extra.push_back(asset_emmit_info);
   ctp.need_at_least_1_zc = true;
-  ctp.asset_owner = rsp.asset_descriptor.owner;
-  //ctp.asset_deploy_control_key = own_asset_entry_it->second.control_key;
+  ctp.tx_meaning_for_logs = "asset emission";
 
   for(auto& dst : ctp.dsts)
+    dst.asset_id = null_pkey; // emit operation requires null_pkey for emitting asset outputs, fix it ad-hoc here
+
+  bool send_to_network = true;
+  if (last_adb.owner_eth_pub_key.has_value())
   {
-    if (dst.asset_id == asset_id)
-      dst.asset_id = null_pkey; // emit operation requires null_pkey for emitting asset outputs, fix it ad-hoc here
+    send_to_network = false;
+    ctp.additional_transfer_flags_to_mark = WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION;
+    ctp.tx_meaning_for_logs = "asset eth emission";
   }
 
-  finalized_tx ft = AUTO_VAL_INIT(ft);
-  this->transfer(ctp, ft, true, nullptr);
+  this->transfer(ctp, ft, send_to_network, nullptr);
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::emit_asset(const crypto::public_key& asset_id, std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx)
+{
+  finalized_tx ft{};
+  emit_asset(asset_id, destinations, ft);
   result_tx = ft.tx;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::update_asset(const crypto::public_key asset_id, const currency::asset_descriptor_base new_descriptor, currency::transaction& result_tx)
+void wallet2::update_asset(const crypto::public_key& asset_id, const currency::asset_descriptor_base& new_descriptor, currency::finalized_tx& ft)
 {
   auto own_asset_entry_it = m_own_asset_descriptors.find(asset_id);
   CHECK_AND_ASSERT_THROW_MES(own_asset_entry_it != m_own_asset_descriptors.end(), "Failed find asset_id " << asset_id << " in own assets list");
+  currency::asset_descriptor_base last_adb{};
+  bool r = daemon_get_asset_info(asset_id, last_adb);
+  CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
 
-  asset_descriptor_operation asset_update_info = AUTO_VAL_INIT(asset_update_info);
+  asset_descriptor_operation asset_update_info{};
   asset_update_info.descriptor = new_descriptor;
   asset_update_info.operation_type = ASSET_DESCRIPTOR_OPERATION_UPDATE;
   asset_update_info.opt_asset_id = asset_id;
   construct_tx_param ctp = get_default_construct_tx_param();
   ctp.extra.push_back(asset_update_info);
   ctp.need_at_least_1_zc = true;
-  currency::asset_descriptor_base adb = AUTO_VAL_INIT(adb);
-  bool r = this->daemon_get_asset_info(asset_id, adb);
-  CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
-  ctp.asset_owner = adb.owner;
+  ctp.tx_meaning_for_logs = "asset update";
 
-  finalized_tx ft = AUTO_VAL_INIT(ft);
-  this->transfer(ctp, ft, true, nullptr);
+  bool send_to_network = true;
+  if (last_adb.owner_eth_pub_key.has_value())
+  {
+    send_to_network = false;
+    ctp.additional_transfer_flags_to_mark = WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION;
+    ctp.tx_meaning_for_logs = "asset eth update";
+  }
+
+  this->transfer(ctp, ft, send_to_network, nullptr);
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::update_asset(const crypto::public_key& asset_id, const currency::asset_descriptor_base new_descriptor, currency::transaction& result_tx)
+{
+  currency::finalized_tx ft{};
+  update_asset(asset_id, new_descriptor, ft);
   result_tx = ft.tx;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::transfer_asset_ownership(const crypto::public_key asset_id, const crypto::public_key& new_owner, currency::transaction& result_tx)
+void wallet2::transfer_asset_ownership(const crypto::public_key& asset_id, const currency::asset_owner_pub_key_v& new_owner_v, currency::finalized_tx& ft)
 {
   auto own_asset_entry_it = m_own_asset_descriptors.find(asset_id);
   CHECK_AND_ASSERT_THROW_MES(own_asset_entry_it != m_own_asset_descriptors.end(), "Failed find asset_id " << asset_id << " in own assets list");
-
-  currency::asset_descriptor_base adb = AUTO_VAL_INIT(adb);
-  bool r = this->daemon_get_asset_info(asset_id, adb);
+  currency::asset_descriptor_base last_adb{};
+  bool r = this->daemon_get_asset_info(asset_id, last_adb);
   CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
 
-  asset_descriptor_operation asset_update_info = AUTO_VAL_INIT(asset_update_info);
-  asset_update_info.descriptor = adb;
+  asset_descriptor_operation asset_update_info{};
+  asset_update_info.descriptor = last_adb;
   asset_update_info.operation_type = ASSET_DESCRIPTOR_OPERATION_UPDATE;
   asset_update_info.opt_asset_id = asset_id;
-  asset_update_info.descriptor.owner = new_owner;
-  construct_tx_param ctp = get_default_construct_tx_param();
-  ctp.asset_owner = adb.owner;
-  ctp.extra.push_back(asset_update_info);
 
-  finalized_tx ft = AUTO_VAL_INIT(ft);
-  this->transfer(ctp, ft, true, nullptr);
+  if (new_owner_v.type() == typeid(crypto::public_key))
+    asset_update_info.descriptor.owner = boost::get<crypto::public_key>(new_owner_v);
+  else
+    asset_update_info.descriptor.owner_eth_pub_key = boost::get<crypto::eth_public_key>(new_owner_v);
+
+  construct_tx_param ctp = get_default_construct_tx_param();
+  ctp.extra.push_back(asset_update_info);
+  ctp.tx_meaning_for_logs = "transfer asset ownership";
+
+  bool send_to_network = true;
+  if (last_adb.owner_eth_pub_key.has_value())
+  {
+    send_to_network = false;
+    ctp.additional_transfer_flags_to_mark = WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION;
+    ctp.tx_meaning_for_logs = "transfer asset eth ownership";
+  }
+
+  this->transfer(ctp, ft, send_to_network, nullptr);
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::transfer_asset_ownership(const crypto::public_key& asset_id, const currency::asset_owner_pub_key_v& new_owner_v, currency::transaction& result_tx)
+{
+  finalized_tx ft{};
+  transfer_asset_ownership(asset_id, new_owner_v, ft);
   result_tx = ft.tx;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::burn_asset(const crypto::public_key asset_id, uint64_t amount_to_burn, currency::transaction& result_tx)
+void wallet2::burn_asset(const crypto::public_key& asset_id, uint64_t amount_to_burn, currency::finalized_tx& ft)
 {
-  //auto own_asset_entry_it = m_own_asset_descriptors.find(asset_id);
-  //CHECK_AND_ASSERT_THROW_MES(own_asset_entry_it != m_own_asset_descriptors.end(), "Failed find asset_id " << asset_id << " in own assets list");
-  COMMAND_RPC_GET_ASSET_INFO::request req;
-  req.asset_id = asset_id;
-  COMMAND_RPC_GET_ASSET_INFO::response rsp;
-  bool r = m_core_proxy->call_COMMAND_RPC_GET_ASSET_INFO(req, rsp);
-  CHECK_AND_ASSERT_THROW_MES(r, "Failed to call_COMMAND_RPC_GET_ASSET_INFO");
+  currency::asset_descriptor_base last_adb{};
+  bool r = this->daemon_get_asset_info(asset_id, last_adb);
+  CHECK_AND_ASSERT_THROW_MES(r, "Failed to get asset info from daemon");
 
+  asset_descriptor_operation asset_burn_info{};
+  asset_burn_info.descriptor = last_adb;
 
+  CHECK_AND_ASSERT_THROW_MES(last_adb.current_supply >= amount_to_burn, "amount_to_burn is incorrect: " << print_money_brief(amount_to_burn, last_adb.decimal_point) << ", current_supply: " << print_money_brief(last_adb.current_supply, last_adb.decimal_point));
 
-  asset_descriptor_operation asset_burn_info = AUTO_VAL_INIT(asset_burn_info);
-  asset_burn_info.descriptor = rsp.asset_descriptor;
-
-  CHECK_AND_ASSERT_THROW_MES(asset_burn_info.descriptor.current_supply >= amount_to_burn, "Wrong amount to burn (current_supply" << asset_burn_info.descriptor.current_supply << " is less then " << amount_to_burn << ")");
-
-  currency::tx_destination_entry dst_to_burn = AUTO_VAL_INIT(dst_to_burn);
+  currency::tx_destination_entry dst_to_burn{};
   dst_to_burn.amount = amount_to_burn;
   dst_to_burn.asset_id = asset_id;
 
@@ -5490,11 +5536,16 @@ void wallet2::burn_asset(const crypto::public_key asset_id, uint64_t amount_to_b
   construct_tx_param ctp = get_default_construct_tx_param();
   ctp.extra.push_back(asset_burn_info);
   ctp.need_at_least_1_zc = true;
-  ctp.asset_owner = rsp.asset_descriptor.owner;
   ctp.dsts.push_back(dst_to_burn);
+  ctp.tx_meaning_for_logs = "asset burn";
 
-  finalized_tx ft = AUTO_VAL_INIT(ft);
   this->transfer(ctp, ft, true, nullptr);
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::burn_asset(const crypto::public_key& asset_id, uint64_t amount_to_burn, currency::transaction& result_tx)
+{
+  finalized_tx ft{};
+  burn_asset(asset_id, amount_to_burn, ft);
   result_tx = ft.tx;
 }
 //----------------------------------------------------------------------------------------------------
@@ -7601,8 +7652,12 @@ bool wallet2::prepare_transaction(construct_tx_param& ctp, currency::finalize_tx
 
   const currency::transaction& tx_for_mode_separate = msc.tx_for_mode_separate;
   assets_selection_context needed_money_map = get_needed_money(ctp.fee, ctp.dsts);
-  ftp.asset_owner = ctp.asset_owner;
-  ftp.p_eth_signer = ctp.p_eth_signer;
+  if (this->is_auditable() && ctp.fake_outputs_count > 0)
+  {
+    WLT_THROW_IF_FALSE_WITH_CODE(false, "WALLET_RPC_ERROR_CODE_WRONG_MIXINS_FOR_AUDITABLE_WALLET", "WALLET_RPC_ERROR_CODE_WRONG_MIXINS_FOR_AUDITABLE_WALLET");
+  }
+  //ftp.asset_owner = ctp.asset_owner;
+  //ftp.p_eth_signer = ctp.p_eth_signer;
   //
   // TODO @#@# need to do refactoring over this part to support hidden amounts and asset_id
   //
@@ -7735,7 +7790,7 @@ void wallet2::finalize_transaction(currency::finalize_tx_param& ftp, currency::f
   THROW_IF_FALSE_WALLET_EX_MES(tx_blob_size < CURRENCY_MAX_TRANSACTION_BLOB_SIZE, error::tx_too_big, "Transaction size: " << tx_blob_size << " bytes, transaction size limit: " << CURRENCY_MAX_TRANSACTION_BLOB_SIZE << " bytes.");
 
   if (store_tx_secret_key)
-    m_tx_keys.insert(std::make_pair(get_transaction_hash(result.tx), result.one_time_key));
+    m_tx_keys.insert(std::make_pair(result.tx_id, result.one_time_key));
 
   //TIME_MEASURE_START(send_transaction_to_network_time);
   if (broadcast_tx)
@@ -7913,8 +7968,11 @@ void wallet2::transfer(construct_tx_param& ctp,
     return;
   }
 
+  std::string tx_description = ctp.tx_meaning_for_logs.empty() ? std::string("transfer") : ctp.tx_meaning_for_logs;
+  uint32_t transfers_flags = ctp.additional_transfer_flags_to_mark | WALLET_TRANSFER_DETAIL_FLAG_SPENT;
+
   TIME_MEASURE_START(mark_transfers_as_spent_time);
-  mark_transfers_as_spent(ftp.selected_transfers, std::string("money transfer, tx: ") + epee::string_tools::pod_to_hex(get_transaction_hash(result.tx)));
+  mark_transfers_with_flag(ftp.selected_transfers, transfers_flags, std::string("preparing for ") + tx_description);
   TIME_MEASURE_FINISH(mark_transfers_as_spent_time);
 
   TIME_MEASURE_START(finalize_transaction_time);
@@ -7924,7 +7982,7 @@ void wallet2::transfer(construct_tx_param& ctp,
   }
   catch (...)
   {
-    clear_transfers_from_flag(ftp.selected_transfers, WALLET_TRANSFER_DETAIL_FLAG_SPENT, std::string("exception on money transfer, tx: ") + epee::string_tools::pod_to_hex(get_transaction_hash(result.tx)));
+    clear_transfers_from_flag(ftp.selected_transfers, transfers_flags, std::string("exception during") + tx_description + ", tx (maybe incorrect if tx is incomplete): " + epee::string_tools::pod_to_hex(get_transaction_hash(result.tx)));
     throw;
   }
   TIME_MEASURE_FINISH(finalize_transaction_time);
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 924d643a..30f3d84e 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -420,10 +420,16 @@ namespace tools
     bool check_available_sources(std::list<uint64_t>& amounts);
 
     void deploy_new_asset(const currency::asset_descriptor_base& asset_info, const std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx, crypto::public_key& new_asset_id);
-    void emit_asset(const crypto::public_key asset_id, std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx);
-    void update_asset(const crypto::public_key asset_id, const currency::asset_descriptor_base new_descriptor, currency::transaction& result_tx);
-    void burn_asset(const crypto::public_key asset_id, uint64_t amount_to_burn, currency::transaction& result_tx);
-    void transfer_asset_ownership(const crypto::public_key asset_id, const crypto::public_key& new_owner, currency::transaction& result_tx);
+    void emit_asset(const crypto::public_key& asset_id, std::vector<currency::tx_destination_entry>& destinations, currency::transaction& result_tx);
+    void update_asset(const crypto::public_key& asset_id, const currency::asset_descriptor_base new_descriptor, currency::transaction& result_tx);
+    void burn_asset(const crypto::public_key& asset_id, uint64_t amount_to_burn, currency::transaction& result_tx);
+    void transfer_asset_ownership(const crypto::public_key& asset_id, const currency::asset_owner_pub_key_v& new_owner_v, currency::transaction& result_tx);
+
+    void deploy_new_asset(const currency::asset_descriptor_base& asset_info, const std::vector<currency::tx_destination_entry>& destinations, currency::finalized_tx& ft, crypto::public_key& new_asset_id);
+    void emit_asset(const crypto::public_key& asset_id, const std::vector<currency::tx_destination_entry>& destinations, currency::finalized_tx& ft);
+    void update_asset(const crypto::public_key& asset_id, const currency::asset_descriptor_base& new_descriptor, currency::finalized_tx& ft);
+    void burn_asset(const crypto::public_key& asset_id, uint64_t amount_to_burn, currency::finalized_tx& ft);
+    void transfer_asset_ownership(const crypto::public_key& asset_id, const currency::asset_owner_pub_key_v& new_owner_v, currency::finalized_tx& ft);
 
     bool daemon_get_asset_info(const crypto::public_key& asset_id, currency::asset_descriptor_base& adb);
     bool set_core_proxy(const std::shared_ptr<i_core_proxy>& proxy);
diff --git a/src/wallet/wallet2_base.h b/src/wallet/wallet2_base.h
index d67fc024..3bf0e1ee 100644
--- a/src/wallet/wallet2_base.h
+++ b/src/wallet/wallet2_base.h
@@ -224,9 +224,10 @@ namespace tools
     bool shuffle = false;
     bool create_utxo_defragmentation_tx = false;
     bool need_at_least_1_zc = false;
-
-    currency::asset_eth_signer_i* p_eth_signer = nullptr;
-    currency::asset_owner_key_v asset_owner = currency::null_pkey;
+    
+    // misc
+    std::string tx_meaning_for_logs; // used to correctly log things, e.g. "escrow" or "asset emission".
+    uint32_t additional_transfer_flags_to_mark = 0;
   };
 
   struct mode_separate_context

From 44b19dd0704ab6b75a04791ddc92cfbf27c9907c Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:34:55 +0200
Subject: [PATCH 26/37] wallet rpc: send_ext_signed_asset_tx call implemented

---
 src/wallet/wallet2.cpp                  | 33 +++++++++++++++++++
 src/wallet/wallet2.h                    |  1 +
 src/wallet/wallet_public_structs_defs.h | 36 ++++++++++++++++++++-
 src/wallet/wallet_rpc_server.cpp        | 42 ++++++++++++++++++++++++-
 src/wallet/wallet_rpc_server.h          |  2 ++
 5 files changed, 112 insertions(+), 2 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 580a918d..991cebcd 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -4312,6 +4312,39 @@ bool wallet2::get_utxo_distribution(std::map<uint64_t, uint64_t>& distribution)
   return false;
 }
 //----------------------------------------------------------------------------------------------------
+void wallet2::submit_externally_signed_asset_tx(const finalized_tx& ft, const crypto::eth_signature& eth_sig, bool unlock_transfers_on_fail, currency::transaction& result_tx, bool& transfers_unlocked)
+{
+  transaction tx = ft.tx;
+  
+  currency::asset_operation_ownership_proof_eth aoop_eth{};
+  aoop_eth.eth_sig = eth_sig;
+  tx.proofs.push_back(std::move(aoop_eth));
+  
+  // foolproof
+  WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(ft.ftp.spend_pub_key == m_account.get_keys().account_address.spend_public_key, "The given tx was created in a different wallet, keys missmatch, tx hash: " << ft.tx_id);
+
+  try
+  {
+    send_transaction_to_network(tx);
+  }
+  catch (...)
+  {
+    // clear transfers flags if smth went wrong and it was requested
+    if (unlock_transfers_on_fail)
+    {
+      uint32_t flag = WALLET_TRANSFER_DETAIL_FLAG_SPENT | WALLET_TRANSFER_DETAIL_FLAG_ASSET_OP_RESERVATION;
+      clear_transfers_from_flag(ft.ftp.selected_transfers, flag, "broadcasting tx " + epee::string_tools::pod_to_hex(ft.tx_id) + " was unsuccessful");
+      transfers_unlocked = true;
+    }
+    throw;
+  }
+
+  m_tx_keys.insert(std::make_pair(ft.tx_id, ft.one_time_key));
+  add_sent_tx_detailed_info(tx, ft.ftp.attachments, ft.ftp.prepared_destinations, ft.ftp.selected_transfers);
+
+  print_tx_sent_message(tx, "from submit_externally_signed_asset_tx", true, get_tx_fee(tx));
+}
+//----------------------------------------------------------------------------------------------------
 void wallet2::submit_transfer(const std::string& signed_tx_blob, currency::transaction& tx)
 {
   // decrypt sources
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 30f3d84e..c454480a 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -595,6 +595,7 @@ namespace tools
     void sign_transfer_files(const std::string& tx_sources_file, const std::string& signed_tx_file, currency::transaction& tx);
     void submit_transfer(const std::string& signed_tx_blob, currency::transaction& tx);
     void submit_transfer_files(const std::string& signed_tx_file, currency::transaction& tx);
+    void submit_externally_signed_asset_tx(const currency::finalized_tx& ft, const crypto::eth_signature& eth_sig, bool unlock_transfers_on_fail, currency::transaction& result_tx, bool& transfers_unlocked);
 
     void sweep_below(size_t fake_outs_count, const currency::account_public_address& destination_addr, uint64_t threshold_amount, const currency::payment_id_t& payment_id,
       uint64_t fee, size_t& outs_total, uint64_t& amount_total, size_t& outs_swept, uint64_t& amount_swept, currency::transaction* p_result_tx = nullptr, std::string* p_filename_or_unsigned_tx_blob_str = nullptr);
diff --git a/src/wallet/wallet_public_structs_defs.h b/src/wallet/wallet_public_structs_defs.h
index 3c6eb174..af6548c5 100644
--- a/src/wallet/wallet_public_structs_defs.h
+++ b/src/wallet/wallet_public_structs_defs.h
@@ -13,7 +13,7 @@
 #include "currency_core/offers_service_basics.h"
 #include "currency_core/bc_escrow_service.h"
 #include "rpc/core_rpc_server_commands_defs.h"
-
+#include "currency_protocol/blobdatatype.h"
 
 
 const uint64_t WALLET_GLOBAL_OUTPUT_INDEX_UNDEFINED = std::numeric_limits<uint64_t>::max();
@@ -2083,5 +2083,39 @@ namespace wallet_public
     };
   };
 
+  struct COMMAND_ASSET_SEND_EXT_SIGNED_TX
+  {
+    DOC_COMMAND("Inserts externally made asset ownership signature into the given transaction and broadcasts it.");
+
+    struct request
+    {
+      currency::blobdata    finalized_tx;
+      currency::blobdata    unsigned_tx;
+      crypto::eth_signature eth_sig;
+      crypto::hash          expected_tx_id;
+      bool                  unlock_transfers_on_fail = false;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE_BLOB_AS_BASE64_STRING(finalized_tx)DOC_DSCR("Base64-encoded finalized_tx data structure, which was received from emit_asset call.") DOC_EXMP("ewogICJ2ZXJzaW9uIjogMSwgC....iAgInZpbiI6IFsgewogICAgIC") DOC_END
+        KV_SERIALIZE_BLOB_AS_BASE64_STRING(unsigned_tx) DOC_DSCR("Base64-encoded unsigned transaction blob, which was received from emit_asset call.") DOC_EXMP("083737bcfd826a973f74bb56a52b4fa562e6579ccaadd2697463498a66de4f1760b2cd40f11c3a00a7a80000") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(eth_sig)         DOC_DSCR("HEX-encoded ETH signature (64 bytes)") DOC_EXMP("674bb56a5b4fa562e679ccacc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6add697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(expected_tx_id)  DOC_DSCR("The expected transaction id. Tx won't be sent if the calculated one doesn't match this one. Consider using 'verified_tx_id' returned by 'decrypt_tx_details' call.") DOC_EXMP("40fa6db923728b38962718c61b4dc3af1acaa1967479c73703e260dc3609c58d") DOC_END
+        KV_SERIALIZE(unlock_transfers_on_fail)          DOC_DSCR("If true, all locked wallet transfers, corresponding to the transaction, will be unlocked on sending failure. False by default.") DOC_EXMP(false) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string           status;
+      bool                  transfers_were_unlocked;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)                     DOC_DSCR("Status of the call") DOC_EXMP("OK") DOC_END
+        KV_SERIALIZE(transfers_were_unlocked)    DOC_DSCR("If true, all input transfers that were locked when preparing this transaction, are now unlocked and may be spent. Can be true only upon sending failure and if requested.") DOC_EXMP(false) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+
 } // namespace wallet_rpc
 } // namespace tools
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 39c75e27..e4d0b4ee 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2018 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Copyright (c) 2012-2013 The Cryptonote developers
 // Distributed under the MIT/X11 software license, see the accompanying
@@ -1334,6 +1334,46 @@ namespace tools
     currency::transaction result_tx;
     w.get_wallet()->burn_asset(req.asset_id, req.burn_amount, result_tx);
     res.result_tx = currency::get_transaction_hash(result_tx);
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_asset_send_ext_signed_tx(const wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request& req, wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  {
+    WALLET_RPC_BEGIN_TRY_ENTRY();
+
+    currency::finalized_tx ft{};
+    if (!t_unserializable_object_from_blob(ft, req.finalized_tx))
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT;
+      er.message = "finalized_tx couldn't be deserialized";
+      return false;
+    }
+
+    if (t_serializable_object_to_blob(ft.tx) != req.unsigned_tx)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT;
+      er.message = "unsigned_tx doesn't match finalized_tx";
+      return false;
+    }
+
+    crypto::hash tx_id = currency::get_transaction_hash(ft.tx);
+    if (req.expected_tx_id != tx_id)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT;
+      er.message = std::string("expected_tx_id mismatch, real tx id is ") + epee::string_tools::pod_to_hex(tx_id);
+      return false;
+    }
+
+    try
+    {
+      currency::transaction result_tx{};
+      w.get_wallet()->submit_externally_signed_asset_tx(ft, req.eth_sig, req.unlock_transfers_on_fail, result_tx, res.transfers_were_unlocked);
+    }
+    catch(std::exception& e)
+    {
+      // doing this to be able to return 'transfers_were_unlocked' to the caller even in the case of exception
+      res.status = e.what();
+      return true;
+    }
+
     return true;
     WALLET_RPC_CATCH_TRY_ENTRY();
   }
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index 4eac9211..6016d8b5 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -151,6 +151,7 @@ namespace tools
         MAP_JON_RPC_WE("update_asset",                        on_assets_update,                 wallet_public::COMMAND_ASSETS_UPDATE)
         MAP_JON_RPC_WE("burn_asset",                          on_assets_burn,                   wallet_public::COMMAND_ASSETS_BURN)
 
+        MAP_JON_RPC_WE("send_ext_signed_asset_tx",            on_asset_send_ext_signed_tx,      wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX)
 
         //MULTIWALLET APIs
         MAP_JON_RPC_WE("mw_get_wallets",                      on_mw_get_wallets,                wallet_public::COMMAND_MW_GET_WALLETS)
@@ -222,6 +223,7 @@ namespace tools
     bool on_assets_emit(const wallet_public::COMMAND_ASSETS_EMIT::request& req, wallet_public::COMMAND_ASSETS_EMIT::response& res, epee::json_rpc::error& er, connection_context& cntx);
     bool on_assets_update(const wallet_public::COMMAND_ASSETS_UPDATE::request& req, wallet_public::COMMAND_ASSETS_UPDATE::response& res, epee::json_rpc::error& er, connection_context& cntx);
     bool on_assets_burn(const wallet_public::COMMAND_ASSETS_BURN::request& req, wallet_public::COMMAND_ASSETS_BURN::response& res, epee::json_rpc::error& er, connection_context& cntx);
+    bool on_asset_send_ext_signed_tx(const wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request& req, wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response& res, epee::json_rpc::error& er, connection_context& cntx);
 
     bool on_mw_get_wallets(const wallet_public::COMMAND_MW_GET_WALLETS::request& req, wallet_public::COMMAND_MW_GET_WALLETS::response& res, epee::json_rpc::error& er, connection_context& cntx);
     bool on_mw_select_wallet(const wallet_public::COMMAND_MW_SELECT_WALLET::request& req, wallet_public::COMMAND_MW_SELECT_WALLET::response& res, epee::json_rpc::error& er, connection_context& cntx);

From b66c0efc2b92fcd751145a8eb9cda8e3dde83d00 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:37:36 +0200
Subject: [PATCH 27/37] wallet rpc: implemented support for third-party
 external asset operations signing + various

---
 src/wallet/wallet_public_structs_defs.h |  53 +++++++---
 src/wallet/wallet_rpc_server.cpp        | 128 +++++++++++++++++-------
 src/wallet/wallet_rpc_server.h          |  20 ++--
 3 files changed, 142 insertions(+), 59 deletions(-)

diff --git a/src/wallet/wallet_public_structs_defs.h b/src/wallet/wallet_public_structs_defs.h
index af6548c5..b6d78d46 100644
--- a/src/wallet/wallet_public_structs_defs.h
+++ b/src/wallet/wallet_public_structs_defs.h
@@ -1982,31 +1982,49 @@ namespace wallet_public
   struct COMMAND_ASSETS_DEPLOY
   {
     DOC_COMMAND("Deploy new asset in the system.");
-    
+
     struct request
     {
       std::list<transfer_destination> destinations;
       currency::asset_descriptor_base asset_descriptor;
+      bool do_not_split_destinations = false;
 
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(destinations)     DOC_DSCR("Addresses where to receive emitted coins. Asset id in the destinations is irreleant and can be omitted.") DOC_EXMP_AUTO(1) DOC_END
-        KV_SERIALIZE(asset_descriptor) DOC_DSCR("Descriptor that holds all information about asset - ticker, emission, description etc") DOC_END
+        KV_SERIALIZE(destinations)                DOC_DSCR("Addresses where to receive emitted coins. Asset id in the destinations is irreleant and can be omitted.") DOC_EXMP_AUTO(1) DOC_END
+        KV_SERIALIZE(asset_descriptor)            DOC_DSCR("Descriptor that holds all information about asset - ticker, emission, description etc") DOC_END
+        KV_SERIALIZE(do_not_split_destinations)   DOC_DSCR("If true, the provided destinations will be used as-is and won't be splitted (or altered) to avoid common issues. Default is false.") DOC_EXMP(false) DOC_END
       END_KV_SERIALIZE_MAP()
     };
 
 
     struct response
     {
-      crypto::hash result_tx;
+      crypto::hash tx_id;
       crypto::public_key new_asset_id;
 
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE_POD_AS_HEX_STRING(result_tx)   DOC_DSCR("Id of transaction that carries asset registration command, asset would be registered as soon as transaction got confirmed") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_id)    DOC_DSCR("Id of transaction that carries asset registration command, asset would be registered as soon as transaction got confirmed") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
         KV_SERIALIZE_POD_AS_HEX_STRING(new_asset_id)  DOC_DSCR("Issued asset id") DOC_EXMP("40fa6db923728b38962718c61b4dc3af1acaa1967479c73703e260dc3609c58d") DOC_END
       END_KV_SERIALIZE_MAP()
     };
   };
 
+  // contains data for external checking & signing asset-emitting/-updating transaction by a third-party
+  struct data_for_external_asset_signing_tx
+  {
+    currency::blobdata unsigned_tx;
+    crypto::secret_key tx_secret_key;
+    std::vector<std::string> outputs_addresses;
+    currency::blobdata finalized_tx;
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE_BLOB_AS_BASE64_STRING(unsigned_tx) DOC_DSCR("Base64-encoded unsigned transaction blob.") DOC_EXMP("ewogICJ2ZXJzaW9uIjogMSwgC....iAgInZpbiI6IFsgewogICAgIC") DOC_END
+      KV_SERIALIZE_POD_AS_HEX_STRING(tx_secret_key)   DOC_DSCR("Hex-encoded transaction secret key.") DOC_EXMP("2e0b840e70dba386effd64c5d988622dea8c064040566e6bf035034cbb54a5c08") DOC_END
+      KV_SERIALIZE(outputs_addresses)                 DOC_DSCR("Target address for each of the transaction zoutput.") DOC_EXMP_AGGR("ZxDNaMeZjwCjnHuU5gUNyrP1pM3U5vckbakzzV6dEHyDYeCpW8XGLBFTshcaY8LkG9RQn7FsQx8w2JeJzJwPwuDm2NfixPAXf", "ZxBvJDuQjMG9R2j4WnYUhBYNrwZPwuyXrC7FHdVmWqaESgowDvgfWtiXeNGu8Px9B24pkmjsA39fzSSiEQG1ekB225ZnrMTBp") DOC_END
+      KV_SERIALIZE_BLOB_AS_BASE64_STRING(finalized_tx)DOC_DSCR("Base64-encoded finalized_tx data structure, which should be passed along with submitting the transaction.") DOC_EXMP("ewogICJ2ZXJzaW9uIjogMSwgC....iAgInZpbiI6IFsgewogICAgIC") DOC_END
+    END_KV_SERIALIZE_MAP()
+  };
+
   struct COMMAND_ASSETS_EMIT
   {
     DOC_COMMAND("Emmit new coins of the the asset, that is controlled by this wallet.");
@@ -2015,20 +2033,23 @@ namespace wallet_public
     {
       crypto::public_key asset_id;
       std::list<transfer_destination> destinations;
+      bool do_not_split_destinations = false;
 
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE_POD_AS_HEX_STRING(asset_id)  DOC_DSCR("Id of the asset to emit more coins") DOC_EXMP("40fa6db923728b38962718c61b4dc3af1acaa1967479c73703e260dc3609c58d") DOC_END
-        KV_SERIALIZE(destinations)     DOC_DSCR("Addresses where to receive emitted coins. Asset id in the destinations is irreleant and can be omitted.") DOC_EXMP_AUTO(1) DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(asset_id) DOC_DSCR("Id of the asset to emit more coins") DOC_EXMP("40fa6db923728b38962718c61b4dc3af1acaa1967479c73703e260dc3609c58d") DOC_END
+        KV_SERIALIZE(destinations)               DOC_DSCR("Addresses where to receive emitted coins. Asset id in the destinations is irreleant and can be omitted.") DOC_EXMP_AUTO(1) DOC_END
+        KV_SERIALIZE(do_not_split_destinations)  DOC_DSCR("If true, the provided destinations will be used as-is and won't be splitted (or altered) to avoid common issues. Default is false.") DOC_EXMP(false) DOC_END
       END_KV_SERIALIZE_MAP()
     };
 
-
     struct response
     {
-      crypto::hash result_tx;
-
+      crypto::hash tx_id;
+      std::optional<data_for_external_asset_signing_tx> data_for_external_signing;
+    
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE_POD_AS_HEX_STRING(result_tx)   DOC_DSCR("Id of transaction that carries asset registration command, asset would be registered as soon as transaction got confirmed") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_id)    DOC_DSCR("Id of transaction that emits the required asset.") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE(data_for_external_signing)  DOC_DSCR("[optional] Additional data for external asset tx signing.") DOC_EXMP_AGGR() DOC_END
       END_KV_SERIALIZE_MAP()
     };
   };
@@ -2050,10 +2071,12 @@ namespace wallet_public
 
     struct response
     {
-      crypto::hash result_tx;
+      crypto::hash tx_id;
+      std::optional<data_for_external_asset_signing_tx> data_for_external_signing;
 
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE_POD_AS_HEX_STRING(result_tx)   DOC_DSCR("Id of transaction that carries asset registration command, asset would be registered as soon as transaction got confirmed") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_id)    DOC_DSCR("Id of transaction that carries asset registration command, asset would be registered as soon as transaction got confirmed") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE(data_for_external_signing)  DOC_DSCR("[optional] Hex-encoded transaction for external signing. ") DOC_EXMP_AGGR() DOC_END
       END_KV_SERIALIZE_MAP()
     };
   };
@@ -2075,10 +2098,10 @@ namespace wallet_public
 
     struct response
     {
-      crypto::hash result_tx;
+      crypto::hash tx_id;
 
       BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE_POD_AS_HEX_STRING(result_tx)   DOC_DSCR("Id of transaction that carries asset burn operation") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_id)    DOC_DSCR("Id of transaction that carries asset burn operation") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
       END_KV_SERIALIZE_MAP()
     };
   };
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index e4d0b4ee..d60fee98 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1260,13 +1260,46 @@ namespace tools
     WALLET_RPC_CATCH_TRY_ENTRY();
   }
   //------------------------------------------------------------------------------------------------------------------------------
-  void wallet_rpc_server::rpc_destinations_to_currency_destination(const std::list<wallet_public::transfer_destination>& rpc_destinations, std::vector<currency::tx_destination_entry>& currency_destinations)
+  #define DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT 10
+  static_assert(DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT >= CURRENCY_TX_MIN_ALLOWED_OUTS, "DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT must be >= min allowed tx outs");
+  void wallet_rpc_server::rpc_destinations_to_currency_destinations(const std::list<wallet_public::transfer_destination>& rpc_destinations, bool nullify_asset_id, bool try_to_split, std::vector<currency::tx_destination_entry>& result_destinations)
   {
     GET_WALLET();
-    std::vector<currency::tx_destination_entry>& dsts = currency_destinations;
-    for (auto it = rpc_destinations.begin(); it != rpc_destinations.end(); it++)
+
+    WLT_THROW_IF_FALSE_WITH_CODE(!rpc_destinations.empty(), "WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT", "WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT");
+
+    std::list<wallet_public::transfer_destination> local_destinations;
+    if (nullify_asset_id && try_to_split)
     {
-      currency::tx_destination_entry de;
+      bool do_split = true;
+      uint64_t total_amount     = rpc_destinations.front().amount;
+      std::string first_address = rpc_destinations.front().address;
+      for(auto it = std::next(rpc_destinations.begin()); it != rpc_destinations.end(); ++it)
+      {
+        total_amount += it->amount;
+        if (first_address != it->address)
+        {
+          do_split = false;
+          break;
+        }
+      }
+      if (do_split)
+      {
+        const uint64_t el_amount = total_amount / DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT; // approximation, see below
+        wallet_public::transfer_destination td{};
+        td.address = first_address;
+        td.amount = el_amount;
+        for(size_t i = 0; i < DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT - 1; ++i)
+          local_destinations.push_back(td);
+        td.amount = total_amount - (DESTINATIONS_COUNT_FOR_DEPLOY_OR_EMIT - 1) * el_amount; // the last element must account for division error
+        local_destinations.push_back(td);
+      }
+    }
+    const std::list<wallet_public::transfer_destination>& destinations = local_destinations.size() != 0 ? local_destinations : rpc_destinations;
+
+    for (auto it = destinations.begin(); it != destinations.end(); ++it)
+    {
+      currency::tx_destination_entry de{};
       de.addr.resize(1);
       std::string embedded_payment_id;
       //check if address looks like wrapped address
@@ -1274,66 +1307,93 @@ namespace tools
       WLT_THROW_IF_FALSE_WITH_CODE(w.get_wallet()->get_transfer_address(it->address, de.addr.back(), embedded_payment_id), "WALLET_RPC_ERROR_CODE_WRONG_ADDRESS", "WALLET_RPC_ERROR_CODE_WRONG_ADDRESS");
       WLT_THROW_IF_FALSE_WITH_CODE(embedded_payment_id.size() == 0, "WALLET_RPC_ERROR_CODE_WRONG_ADDRESS", "WALLET_RPC_ERROR_CODE_WRONG_ADDRESS");
       de.amount = it->amount;
-      de.asset_id = it->asset_id;
-      dsts.push_back(de);
+      de.asset_id = nullify_asset_id ? currency::null_pkey : it->asset_id;
+      result_destinations.push_back(de);
     }
   }
   //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_assets_deploy(const wallet_public::COMMAND_ASSETS_DEPLOY::request& req, wallet_public::COMMAND_ASSETS_DEPLOY::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  bool wallet_rpc_server::on_asset_deploy(const wallet_public::COMMAND_ASSETS_DEPLOY::request& req, wallet_public::COMMAND_ASSETS_DEPLOY::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
     WALLET_RPC_BEGIN_TRY_ENTRY();
 
-    currency::transaction result_tx;
     std::vector<currency::tx_destination_entry> currency_destinations;
-    rpc_destinations_to_currency_destination(req.destinations, currency_destinations);
-    //fix for default asset_id
-    for (auto& d : currency_destinations)
-    {
-      d.asset_id = currency::null_pkey;
-    }
+    rpc_destinations_to_currency_destinations(req.destinations, true, !req.do_not_split_destinations, currency_destinations);
+
+    currency::finalized_tx ft{};
+    w.get_wallet()->deploy_new_asset(req.asset_descriptor, currency_destinations, ft, res.new_asset_id);
+    res.tx_id = ft.tx_id;
 
-    w.get_wallet()->deploy_new_asset(req.asset_descriptor, currency_destinations, result_tx, res.new_asset_id);
-    res.result_tx = currency::get_transaction_hash(result_tx);
     return true;
     WALLET_RPC_CATCH_TRY_ENTRY();
   }
   //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_assets_emit(const wallet_public::COMMAND_ASSETS_EMIT::request& req, wallet_public::COMMAND_ASSETS_EMIT::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  bool wallet_rpc_server::on_asset_emit(const wallet_public::COMMAND_ASSETS_EMIT::request& req, wallet_public::COMMAND_ASSETS_EMIT::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
     WALLET_RPC_BEGIN_TRY_ENTRY();
-    currency::transaction result_tx;
+    currency::asset_descriptor_base last_adb{};
+    CHECK_AND_ASSERT_THROW_MES(w.get_wallet()->daemon_get_asset_info(req.asset_id, last_adb), "unknown asset_id"); // TODO: bad design, consider refactoring -- sowle
+
     std::vector<currency::tx_destination_entry> currency_destinations;
-    rpc_destinations_to_currency_destination(req.destinations, currency_destinations);
-    //fix for default asset_id
-    for (auto& d : currency_destinations)
+    rpc_destinations_to_currency_destinations(req.destinations, true, !req.do_not_split_destinations, currency_destinations);
+
+    currency::finalized_tx ft{};
+    w.get_wallet()->emit_asset(req.asset_id, currency_destinations, ft);
+    res.tx_id = ft.tx_id;
+
+    if (last_adb.owner_eth_pub_key.has_value())
     {
-      d.asset_id = currency::null_pkey;
+      // include additonal info into response, if it's an external signing asset operation
+      wallet_public::data_for_external_asset_signing_tx data{};
+      data.unsigned_tx = t_serializable_object_to_blob(ft.tx);
+      data.tx_secret_key = ft.one_time_key;
+      std::vector<std::string>& outs_addr = data.outputs_addresses;
+      for(auto d : ft.ftp.prepared_destinations)
+        outs_addr.push_back(currency::get_account_address_as_str(d.addr.back()));
+      data.finalized_tx = t_serializable_object_to_blob(ft);
+
+      res.data_for_external_signing = data;
     }
 
-    w.get_wallet()->emit_asset(req.asset_id, currency_destinations, result_tx);
-    res.result_tx = currency::get_transaction_hash(result_tx);
     return true;
-
     WALLET_RPC_CATCH_TRY_ENTRY();
   }
   //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_assets_update(const wallet_public::COMMAND_ASSETS_UPDATE::request& req, wallet_public::COMMAND_ASSETS_UPDATE::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  bool wallet_rpc_server::on_asset_update(const wallet_public::COMMAND_ASSETS_UPDATE::request& req, wallet_public::COMMAND_ASSETS_UPDATE::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
     WALLET_RPC_BEGIN_TRY_ENTRY();
-    currency::transaction result_tx;
-    w.get_wallet()->update_asset(req.asset_id, req.asset_descriptor, result_tx);
-    res.result_tx = currency::get_transaction_hash(result_tx);
-    return true;
+    currency::finalized_tx ft{};
+    w.get_wallet()->update_asset(req.asset_id, req.asset_descriptor, ft);
+    res.tx_id = ft.tx_id;
 
+    if (req.asset_descriptor.owner_eth_pub_key.has_value())
+    {
+      // include additonal info into response, if it's an external signing asset operation
+      wallet_public::data_for_external_asset_signing_tx data{};
+      data.unsigned_tx = t_serializable_object_to_blob(ft.tx);
+      data.tx_secret_key = ft.one_time_key;
+      std::vector<std::string>& outs_addr = data.outputs_addresses;
+      for(auto d : ft.ftp.prepared_destinations)
+        outs_addr.push_back(currency::get_account_address_as_str(d.addr.back()));
+      data.finalized_tx = t_serializable_object_to_blob(ft);
+
+      res.data_for_external_signing = data;
+    }
+
+    return true;
     WALLET_RPC_CATCH_TRY_ENTRY();
   }  
   //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_assets_burn(const wallet_public::COMMAND_ASSETS_BURN::request& req, wallet_public::COMMAND_ASSETS_BURN::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  bool wallet_rpc_server::on_asset_burn(const wallet_public::COMMAND_ASSETS_BURN::request& req, wallet_public::COMMAND_ASSETS_BURN::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
     WALLET_RPC_BEGIN_TRY_ENTRY();
-    currency::transaction result_tx;
-    w.get_wallet()->burn_asset(req.asset_id, req.burn_amount, result_tx);
-    res.result_tx = currency::get_transaction_hash(result_tx);
+
+    currency::finalized_tx ft{};
+    w.get_wallet()->burn_asset(req.asset_id, req.burn_amount, ft);
+    res.tx_id = ft.tx_id;
+
+    return true;
+    WALLET_RPC_CATCH_TRY_ENTRY();
+  }
   //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_asset_send_ext_signed_tx(const wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request& req, wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index 6016d8b5..70e3458b 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -146,11 +146,10 @@ namespace tools
         MAP_JON_RPC_WE("assets_whitelist_add",                on_assets_whitelist_add,          wallet_public::COMMAND_ASSETS_WHITELIST_ADD)
         MAP_JON_RPC_WE("assets_whitelist_remove",             on_assets_whitelist_remove,       wallet_public::COMMAND_ASSETS_WHITELIST_REMOVE)
         
-        MAP_JON_RPC_WE("deploy_asset",                        on_assets_deploy,                 wallet_public::COMMAND_ASSETS_DEPLOY)
-        MAP_JON_RPC_WE("emit_asset",                          on_assets_emit,                   wallet_public::COMMAND_ASSETS_EMIT)
-        MAP_JON_RPC_WE("update_asset",                        on_assets_update,                 wallet_public::COMMAND_ASSETS_UPDATE)
-        MAP_JON_RPC_WE("burn_asset",                          on_assets_burn,                   wallet_public::COMMAND_ASSETS_BURN)
-
+        MAP_JON_RPC_WE("deploy_asset",                        on_asset_deploy,                  wallet_public::COMMAND_ASSETS_DEPLOY)
+        MAP_JON_RPC_WE("emit_asset",                          on_asset_emit,                    wallet_public::COMMAND_ASSETS_EMIT)
+        MAP_JON_RPC_WE("update_asset",                        on_asset_update,                  wallet_public::COMMAND_ASSETS_UPDATE)
+        MAP_JON_RPC_WE("burn_asset",                          on_asset_burn,                    wallet_public::COMMAND_ASSETS_BURN)
         MAP_JON_RPC_WE("send_ext_signed_asset_tx",            on_asset_send_ext_signed_tx,      wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX)
 
         //MULTIWALLET APIs
@@ -219,10 +218,10 @@ namespace tools
     bool on_assets_whitelist_add(const wallet_public::COMMAND_ASSETS_WHITELIST_ADD::request& req, wallet_public::COMMAND_ASSETS_WHITELIST_ADD::response& res, epee::json_rpc::error& er, connection_context& cntx);
     bool on_assets_whitelist_remove(const wallet_public::COMMAND_ASSETS_WHITELIST_REMOVE::request& req, wallet_public::COMMAND_ASSETS_WHITELIST_REMOVE::response& res, epee::json_rpc::error& er, connection_context& cntx);
     
-    bool on_assets_deploy(const wallet_public::COMMAND_ASSETS_DEPLOY::request& req, wallet_public::COMMAND_ASSETS_DEPLOY::response& res, epee::json_rpc::error& er, connection_context& cntx);
-    bool on_assets_emit(const wallet_public::COMMAND_ASSETS_EMIT::request& req, wallet_public::COMMAND_ASSETS_EMIT::response& res, epee::json_rpc::error& er, connection_context& cntx);
-    bool on_assets_update(const wallet_public::COMMAND_ASSETS_UPDATE::request& req, wallet_public::COMMAND_ASSETS_UPDATE::response& res, epee::json_rpc::error& er, connection_context& cntx);
-    bool on_assets_burn(const wallet_public::COMMAND_ASSETS_BURN::request& req, wallet_public::COMMAND_ASSETS_BURN::response& res, epee::json_rpc::error& er, connection_context& cntx);
+    bool on_asset_deploy(const wallet_public::COMMAND_ASSETS_DEPLOY::request& req, wallet_public::COMMAND_ASSETS_DEPLOY::response& res, epee::json_rpc::error& er, connection_context& cntx);
+    bool on_asset_emit(const wallet_public::COMMAND_ASSETS_EMIT::request& req, wallet_public::COMMAND_ASSETS_EMIT::response& res, epee::json_rpc::error& er, connection_context& cntx);
+    bool on_asset_update(const wallet_public::COMMAND_ASSETS_UPDATE::request& req, wallet_public::COMMAND_ASSETS_UPDATE::response& res, epee::json_rpc::error& er, connection_context& cntx);
+    bool on_asset_burn(const wallet_public::COMMAND_ASSETS_BURN::request& req, wallet_public::COMMAND_ASSETS_BURN::response& res, epee::json_rpc::error& er, connection_context& cntx);
     bool on_asset_send_ext_signed_tx(const wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request& req, wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response& res, epee::json_rpc::error& er, connection_context& cntx);
 
     bool on_mw_get_wallets(const wallet_public::COMMAND_MW_GET_WALLETS::request& req, wallet_public::COMMAND_MW_GET_WALLETS::response& res, epee::json_rpc::error& er, connection_context& cntx);
@@ -240,7 +239,8 @@ namespace tools
     //bool reset_active_wallet(std::shared_ptr<wallet2> w);
 
     bool handle_command_line(const boost::program_options::variables_map& vm);
-    void rpc_destinations_to_currency_destination(const std::list<wallet_public::transfer_destination>& rpc_destinations, std::vector<currency::tx_destination_entry>& currency_destinations);
+    void rpc_destinations_to_currency_destinations(const std::list<wallet_public::transfer_destination>& rpc_destinations, bool nullify_asset_id, bool try_to_split, std::vector<currency::tx_destination_entry>& currency_destinations);
+
 
   private:
     std::shared_ptr<i_wallet_provider> m_pwallet_provider_sh_ptr;

From 8ffbfbe60aff3fa645d459b3ae8a02e259777d9e Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:38:47 +0200
Subject: [PATCH 28/37] minor improvements

---
 src/currency_core/blockchain_storage.cpp | 42 +++++++++++++-----------
 src/simplewallet/simplewallet.cpp        |  7 ++--
 2 files changed, 27 insertions(+), 22 deletions(-)

diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 168eedb3..0a5918b7 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -3880,11 +3880,9 @@ uint64_t blockchain_storage::get_assets(uint64_t offset, uint64_t count, std::li
   m_db_assets.enumerate_items([&](uint64_t i, const crypto::public_key& asset_id, const std::list<asset_descriptor_operation>& asset_descriptor_history)
   {
     if (i < offset)
-    {
-      return true;
-    }
+      return true; // continue
 
-    CHECK_AND_ASSERT_THROW_MES(asset_descriptor_history.size(), "asset_descriptor_history unexpectedly have 0 size");
+    CHECK_AND_ASSERT_THROW_MES(asset_descriptor_history.size(), "asset_descriptor_history unexpectedly have 0 size, asset_id: " << asset_id);
     assets.push_back(asset_descriptor_with_id());
     static_cast<asset_descriptor_base&>(assets.back()) = asset_descriptor_history.back().descriptor;
     assets.back().asset_id = asset_id;
@@ -4010,7 +4008,8 @@ bool blockchain_storage::put_alias_info(const transaction & tx, extra_alias_entr
     //@@ remove get_tx_fee_median();
     LOG_PRINT_MAGENTA("[ALIAS_REGISTERED]: " << ai.m_alias << ": " << get_account_address_as_str(ai.m_address) << ", fee median: " << get_tx_fee_median(), LOG_LEVEL_1);
     rise_core_event(CORE_EVENT_ADD_ALIAS, alias_info_to_rpc_alias_info(ai));
-  }else
+  }
+  else
   {
     //update procedure
     CHECK_AND_ASSERT_MES(ai.m_sign.size() == 1, false, "alias " << ai.m_alias << " can't be update, wrong ai.m_sign.size() count: " << ai.m_sign.size());
@@ -4119,7 +4118,7 @@ bool validate_ado_ownership(asset_op_verification_context& avc)
   }
 
   // owner_eth_pub_key has no value -- fallback to default
-  asset_operation_ownership_proof aoop = AUTO_VAL_INIT(aoop);
+  asset_operation_ownership_proof aoop{};
   r = get_type_in_variant_container(avc.tx.proofs, aoop);
   CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed: asset_operation_ownership_proof is missing");
 
@@ -4147,12 +4146,13 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
   }
   else
   {
-    CHECK_AND_ASSERT_MES(avc.asset_op_history && avc.asset_op_history->size(), false, "asset with id " << avc.asset_id << " has not been registered");
+    CHECK_AND_ASSERT_MES(avc.asset_op_history && avc.asset_op_history->size() > 0, false, "asset with id " << avc.asset_id << " has not been registered");
+    const asset_descriptor_operation& last_ado = avc.asset_op_history->back();
     // check ownership permission
-    if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT || ado.operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE /*|| ado.operation_type == ASSET_DESCRIPTOR_OPERATION_PUBLIC_BURN*/)
+    if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT || ado.operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE)
     {
       bool r = validate_ado_ownership(avc);
-      CHECK_AND_ASSERT_MES(r, false, "Faild to validate ownership of asset_descriptor_operation, rejecting");
+      CHECK_AND_ASSERT_MES(r, false, "Failed to validate ownership of asset_descriptor_operation, rejecting");
     }
 
     avc.amount_to_validate = 0;
@@ -4160,23 +4160,23 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
     if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE)
     {
       //check that total current_supply haven't changed
-      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply == avc.asset_op_history->back().descriptor.current_supply, false, "update operation attempted to change emission, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, avc.asset_op_history->back().descriptor), false, "update operation attempted to change fileds that shouldn't be modified, failed");
+      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply == last_ado.descriptor.current_supply, false, "update operation attempted to change emission, failed");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "update operation attempted to change fileds that shouldn't be modified, failed");
       need_to_validate_balance_proof = false;
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT)
     {
-      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply > avc.asset_op_history->back().descriptor.current_supply, false, "emit operation does not increase the current supply, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, avc.asset_op_history->back().descriptor), false, "emit operation is not allowed to update fields");
-      CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == avc.asset_op_history->back().descriptor.meta_info, false, "emit operation is not allowed to update meta info");
-      avc.amount_to_validate = ado.descriptor.current_supply - avc.asset_op_history->back().descriptor.current_supply;
+      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply > last_ado.descriptor.current_supply, false, "emit operation does not increase the current supply, failed");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "emit operation is not allowed to update fields");
+      CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == last_ado.descriptor.meta_info, false, "emit operation is not allowed to update meta info");
+      avc.amount_to_validate = ado.descriptor.current_supply - last_ado.descriptor.current_supply;
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_PUBLIC_BURN)
     {
-      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply < avc.asset_op_history->back().descriptor.current_supply, false, "burn operation does not decrease the current supply, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, avc.asset_op_history->back().descriptor), false, "burn operation is not allowed to update fields");
-      CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == avc.asset_op_history->back().descriptor.meta_info, false, "burn operation is not allowed to update meta info");
-      avc.amount_to_validate =  avc.asset_op_history->back().descriptor.current_supply - ado.descriptor.current_supply;
+      CHECK_AND_ASSERT_MES(ado.descriptor.current_supply < last_ado.descriptor.current_supply, false, "burn operation does not decrease the current supply, failed");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "burn operation is not allowed to update fields");
+      CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == last_ado.descriptor.meta_info, false, "burn operation is not allowed to update meta info");
+      avc.amount_to_validate =  last_ado.descriptor.current_supply - ado.descriptor.current_supply;
     }
     else
     {
@@ -5945,6 +5945,10 @@ bool blockchain_storage::validate_tx_for_hardfork_specific_terms(const transacti
     }
 
   }
+
+  // TODO @#@#: add check for descriptor.owner_eth_pub_key
+
+
   return true;
 }
 //------------------------------------------------------------------
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index cebf832e..6ab7bfa7 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -2091,11 +2091,11 @@ bool simple_wallet::deploy_new_asset(const std::vector<std::string> &args)
   td.asset_id = currency::null_pkey;
   std::vector<currency::tx_destination_entry> destinations;
   destinations.push_back(td);
-  currency::transaction result_tx = AUTO_VAL_INIT(result_tx);
+  currency::finalized_tx ft{};
   crypto::public_key result_asset_id = currency::null_pkey;
-  m_wallet->deploy_new_asset(adb, destinations, result_tx, result_asset_id);
+  m_wallet->deploy_new_asset(adb, destinations, ft, result_asset_id);
 
-  success_msg_writer(true) << "New asset successfully deployed with tx " << get_transaction_hash(result_tx) << " (unconfirmed) : " << ENDL
+  success_msg_writer(true) << "New asset successfully deployed with tx " << ft.tx_id << " (unconfirmed) : " << ENDL
     << "Asset ID:     " << result_asset_id << ENDL
     << "Title:        " << adb.full_name << ENDL
     << "Ticker:       " << adb.ticker << ENDL
@@ -3222,3 +3222,4 @@ int main(int argc, char* argv[])
   CATCH_ENTRY_L0(__func__, EXIT_FAILURE);
   return EXIT_SUCCESS;
 }
+

From e737bf5e02558bfcff35cdb4312ae5b871c57abf Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:39:40 +0200
Subject: [PATCH 29/37] chaingen: check_balance_via_wallet() various
 improvements

---
 tests/core_tests/chaingen.cpp | 23 +++++++++++++++++------
 tests/core_tests/chaingen.h   |  4 +++-
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp
index 750b0474..8fd3b40d 100644
--- a/tests/core_tests/chaingen.cpp
+++ b/tests/core_tests/chaingen.cpp
@@ -1945,22 +1945,27 @@ void balance_via_wallet(const tools::wallet2& w, const crypto::public_key& asset
 }
 
 bool check_balance_via_wallet(const tools::wallet2& w, const char* account_name,
-  uint64_t expected_total, uint64_t expected_mined, uint64_t expected_unlocked, uint64_t expected_awaiting_in, uint64_t expected_awaiting_out, const crypto::public_key& asset_id /* = currency::native_coin_asset_id */)
+  uint64_t expected_total, uint64_t expected_mined, uint64_t expected_unlocked, uint64_t expected_awaiting_in, uint64_t expected_awaiting_out,
+  const crypto::public_key& asset_id /* = currency::native_coin_asset_id */, size_t asset_decimal_point /* = CURRENCY_DISPLAY_DECIMAL_POINT */)
 {
   uint64_t total, unlocked, awaiting_in, awaiting_out, mined;
   balance_via_wallet(w, asset_id, &total, &unlocked, &awaiting_in, &awaiting_out, &mined);
 
   std::string asset_id_str;
   if (asset_id != currency::native_coin_asset_id)
+  {
     asset_id_str = std::string(", asset_id: ") + epee::string_tools::pod_to_hex(asset_id).erase(4, 56).insert(4, "...");
+    if (asset_decimal_point == CURRENCY_DISPLAY_DECIMAL_POINT)
+      asset_decimal_point = w.get_asset_decimal_point(asset_id, asset_decimal_point);
+  }
 
   LOG_PRINT_CYAN("Balance for wallet " << account_name << " @ height " << w.get_top_block_height() << asset_id_str << ":" << ENDL <<
-    "unlocked:     " << print_money(unlocked) << ENDL <<
-    "awaiting in:  " << print_money(awaiting_in) << ENDL <<
-    "awaiting out: " << print_money(awaiting_out) << ENDL <<
-    "mined:        " << print_money(mined) << ENDL <<
+    "unlocked:     " << print_money(unlocked,     asset_decimal_point) << ENDL <<
+    "awaiting in:  " << print_money(awaiting_in,  asset_decimal_point) << ENDL <<
+    "awaiting out: " << print_money(awaiting_out, asset_decimal_point) << ENDL <<
+    "mined:        " << print_money(mined,        asset_decimal_point) << ENDL <<
     "-----------------------------------------" << ENDL <<
-    "total:        " << print_money(total) << ENDL,
+    "total:        " << print_money(total,        asset_decimal_point) << ENDL,
     LOG_LEVEL_0);
 
   bool r = true;
@@ -1981,6 +1986,12 @@ bool check_balance_via_wallet(const tools::wallet2& w, const char* account_name,
   return r;
 }
 
+bool check_balance_via_wallet(const tools::wallet2& w, const char* account_name, uint64_t expected_total, const crypto::public_key& asset_id, size_t asset_decimal_point /* = CURRENCY_DISPLAY_DECIMAL_POINT */)
+{
+  return check_balance_via_wallet(w, account_name, expected_total, INVALID_BALANCE_VAL, INVALID_BALANCE_VAL, INVALID_BALANCE_VAL, INVALID_BALANCE_VAL, asset_id, asset_decimal_point);
+}
+
+
 // In assumption we have only genesis and few blocks with the same reward (==first_blocks_reward),
 // this function helps to calculate such amount that many outputs have it, and amount, no output has it.
 // It can fail, so check the returning value.
diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h
index d8d49100..58500577 100644
--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@@ -715,7 +715,9 @@ bool check_balance_via_wallet(const tools::wallet2& w, const char* account_name,
                               uint64_t expected_unlocked = INVALID_BALANCE_VAL,
                               uint64_t expected_awaiting_in = INVALID_BALANCE_VAL,
                               uint64_t expected_awaiting_out = INVALID_BALANCE_VAL,
-                              const crypto::public_key& asset_id = currency::native_coin_asset_id);
+                              const crypto::public_key& asset_id = currency::native_coin_asset_id,
+                              size_t asset_decimal_point = CURRENCY_DISPLAY_DECIMAL_POINT);
+bool check_balance_via_wallet(const tools::wallet2& w, const char* account_name, uint64_t expected_total, const crypto::public_key& asset_id, size_t asset_decimal_point = CURRENCY_DISPLAY_DECIMAL_POINT);
 
 bool calculate_amounts_many_outs_have_and_no_outs_have(const uint64_t first_blocks_reward, uint64_t& amount_many_outs_have, uint64_t& amount_no_outs_have);
 bool find_global_index_for_output(const std::vector<test_event_entry>& events, const crypto::hash& head_block_hash, const currency::transaction& reference_tx, const size_t reference_tx_out_index, uint64_t& global_index);

From 7c781ca0ff43214a623058cbcb31b83e9713c4a5 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 05:40:16 +0200
Subject: [PATCH 30/37] chaingen: eth_signed_asset_via_rpc test added

---
 tests/core_tests/chaingen_main.cpp    |   1 +
 tests/core_tests/multiassets_test.cpp | 415 +++++++++++++++++++++++++-
 tests/core_tests/multiassets_test.h   |   7 +
 3 files changed, 420 insertions(+), 3 deletions(-)

diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp
index de4d3b5c..7371e1a7 100644
--- a/tests/core_tests/chaingen_main.cpp
+++ b/tests/core_tests/chaingen_main.cpp
@@ -1292,6 +1292,7 @@ int main(int argc, char* argv[])
     GENERATE_AND_PLAY_HF(assets_and_pos_mining, "4-*");
     GENERATE_AND_PLAY_HF(asset_emission_and_unconfirmed_balance, "4-*");
     GENERATE_AND_PLAY_HF(eth_signed_asset_basics, "4-*"); // TODO
+    GENERATE_AND_PLAY_HF(eth_signed_asset_via_rpc, "4-*");
     
     GENERATE_AND_PLAY_HF(pos_fuse_test, "4-*");
     
diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp
index 7dc787c3..70ad2b7d 100644
--- a/tests/core_tests/multiassets_test.cpp
+++ b/tests/core_tests/multiassets_test.cpp
@@ -9,6 +9,8 @@
 
 #include "random_helper.h"
 #include "wallet/wallet_debug_events_definitions.h"
+#include "wallet/wallet_rpc_server.h"
+#include "wallet/wallet_public_structs_defs.h"
 using namespace currency;
 
 //------------------------------------------------------------------------------
@@ -963,7 +965,7 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
   //
   tools::construct_tx_param ctp = miner_wlt->get_default_construct_tx_param();
   ctp.dsts.emplace_back(initial_emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
-  ctp.asset_owner = eth_pk; // note using eth pub key here
+  // TODO reconsider this =>>> // ctp.asset_owner = eth_pk; // note using eth pub key here
   ctp.need_at_least_1_zc = true;
 
   asset_descriptor_operation ado{};
@@ -1006,7 +1008,7 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
   ctp = miner_wlt->get_default_construct_tx_param();
   ctp.dsts.emplace_back(emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
   ctp.need_at_least_1_zc = true;
-  ctp.asset_owner = eth_pk; // note using eth pub key here
+  // TODO reconsider this =>> ctp.asset_owner = eth_pk; // note using eth pub key here
 
   ado = asset_descriptor_operation{};
   ado.descriptor = adb;
@@ -1020,7 +1022,7 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
     return crypto::generate_eth_signature(h, eth_sk, sig);
   });
 
-  ctp.p_eth_signer = signer.get();
+  // TODO reconsider this ===>> ctp.p_eth_signer = signer.get();
 
   ft = finalized_tx{};
   miner_wlt->transfer(ctp, ft, true, nullptr);
@@ -1030,3 +1032,410 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
 
   return true;
 }
+
+//------------------------------------------------------------------------------
+
+eth_signed_asset_via_rpc::eth_signed_asset_via_rpc()
+{
+  REGISTER_CALLBACK_METHOD(eth_signed_asset_via_rpc, c1);
+}
+
+bool eth_signed_asset_via_rpc::generate(std::vector<test_event_entry>& events) const
+{
+  uint64_t ts = test_core_time::get_time();
+  m_accounts.resize(TOTAL_ACCS_COUNT);
+  account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate(); miner_acc.set_createtime(ts);
+  account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate(); alice_acc.set_createtime(ts);
+  account_base& bob_acc   = m_accounts[BOB_ACC_IDX];   bob_acc.generate();   bob_acc.set_createtime(ts);
+  miner_acc.generate();
+
+  MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, ts);
+  DO_CALLBACK(events, "configure_core"); // default configure_core callback will initialize core runtime config with m_hardforks
+  REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 3);
+
+  DO_CALLBACK(events, "c1");
+
+  return true;
+}
+
+bool eth_signed_asset_via_rpc::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
+{
+  bool r = false;
+
+  crypto::eth_secret_key eth_sk{};
+  crypto::eth_public_key eth_pk{};
+  r = crypto::generate_eth_key_pair(eth_sk, eth_pk);
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_key_pair failed");
+
+  std::shared_ptr<tools::wallet2> miner_wlt = init_playtime_test_wallet(events, c, MINER_ACC_IDX);
+  std::shared_ptr<tools::wallet2> alice_wlt = init_playtime_test_wallet(events, c, ALICE_ACC_IDX);
+  miner_wlt->refresh();
+  alice_wlt->refresh();
+
+  // wallet RPC server
+  tools::wallet_rpc_server miner_wlt_rpc(miner_wlt);
+  epee::json_rpc::error jerr{};
+  tools::wallet_rpc_server::connection_context ctx{};
+
+  // core RPC server
+  currency::t_currency_protocol_handler<currency::core> m_cprotocol(c, nullptr);
+  nodetool::node_server<currency::t_currency_protocol_handler<currency::core> > p2p(m_cprotocol);
+  bc_services::bc_offers_service of(nullptr);
+  currency::core_rpc_server core_rpc_wrapper(c, p2p, of);
+  core_rpc_wrapper.set_ignore_connectivity_status(true);
+
+  // asset description
+  asset_descriptor_base adb{};
+  adb.decimal_point = 2;
+  adb.total_max_supply = 45000;
+  adb.full_name = "P450";
+  adb.ticker = "P450";
+  adb.owner_eth_pub_key = eth_pk; // note setting owner eth pub key here
+
+  uint64_t initial_register_amount = 10000;
+
+  // 1. Miner deploys initial amount of the asset (all go to Alice)
+  // deploy operation don't require eth proof and therefore the corresponding tx will be generated and added to the tx pool as usual
+
+  tools::wallet_public::COMMAND_ASSETS_DEPLOY::request deploy_req{};
+  deploy_req.asset_descriptor = adb;
+  deploy_req.destinations.push_back(tools::wallet_public::transfer_destination{initial_register_amount, m_accounts[ALICE_ACC_IDX].get_public_address_str(), null_pkey});
+  deploy_req.do_not_split_destinations = false;
+  tools::wallet_public::COMMAND_ASSETS_DEPLOY::response deploy_resp{};
+  r = miner_wlt_rpc.on_asset_deploy(deploy_req, deploy_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_asset_deploy failed");
+
+  const crypto::public_key asset_id = deploy_resp.new_asset_id;
+  LOG_PRINT_GREEN_L0("Asset " << asset_id << " was successfully deployed with tx " << deploy_resp.tx_id);
+
+  // make sure tx was added to the pool
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // confirm the tx with a block
+  CHECK_AND_ASSERT_MES(mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c), false, "");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  size_t blocks_fetched = 0;
+  miner_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 1);
+
+  // Alice checks her asset balance
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 1);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", initial_register_amount, asset_id, adb.decimal_point), false, "");
+
+
+  //
+  // 2. Miner emits additional amount of the asset and transfers it to Alice
+  //
+  uint64_t additional_emit_amount = 20000;
+  uint64_t total_asset_amount = initial_register_amount + additional_emit_amount;
+
+  tools::wallet_public::COMMAND_ASSETS_EMIT::request emit_req{};
+  emit_req.asset_id = asset_id;
+  emit_req.destinations.push_back(tools::wallet_public::transfer_destination{additional_emit_amount, m_accounts[ALICE_ACC_IDX].get_public_address_str(), asset_id});
+  emit_req.do_not_split_destinations = false;
+
+  tools::wallet_public::COMMAND_ASSETS_EMIT::response emit_resp{};
+  r = miner_wlt_rpc.on_asset_emit(emit_req, emit_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_asset_emit failed: " << jerr.message);
+
+  // make sure tx was NOT added to the pool (because it's only partially signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // unserialize transaction that we got from RPC
+  transaction emit_tx{};
+  CHECK_AND_ASSERT_MES(emit_resp.data_for_external_signing.has_value(), false, "data_for_external_signing has no value");
+  r = t_unserializable_object_from_blob(emit_tx, emit_resp.data_for_external_signing->unsigned_tx);
+  CHECK_AND_ASSERT_MES(r, false, "t_unserializable_object_from_blob failed");
+  CHECK_AND_ASSERT_EQ(get_transaction_hash(emit_tx), emit_resp.tx_id);
+
+  // make sure emit transaction cannot be added to the transaction pool (it's not fully signed atm)
+  tx_verification_context tvc{};
+  r = c.get_tx_pool().add_tx(emit_tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "emit tx was able to be added to the pool");
+
+  //
+  // decrypt emission transaction outputs prior to ETH signing to make sure it's valid
+  //
+  currency::COMMAND_RPC_DECRYPT_TX_DETAILS::request decrypt_req{};
+  decrypt_req.tx_secret_key = emit_resp.data_for_external_signing->tx_secret_key;
+  decrypt_req.tx_blob = epee::string_encoding::base64_encode(emit_resp.data_for_external_signing->unsigned_tx);
+  // note: decrypt_req.outputs_addresses can be populated using emit_resp.data_for_external_signing->outputs_addresses but we fill it manually here
+  decrypt_req.outputs_addresses.push_back(m_accounts[MINER_ACC_IDX].get_public_address_str()); // we expect that the first output is the cashback and addressed to miner
+  for(size_t i = 0, size = emit_tx.vout.size() - 1; i < size; ++i)
+    decrypt_req.outputs_addresses.push_back(m_accounts[ALICE_ACC_IDX].get_public_address_str()); // we expect all other outputs are asset emission and addresses to Alice
+  currency::COMMAND_RPC_DECRYPT_TX_DETAILS::response decrypt_resp{};
+  r = core_rpc_wrapper.on_decrypt_tx_details(decrypt_req, decrypt_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_decrypt_tx_details failed: " << jerr.message);
+  // make sure that verified_tx_id is the one we expect
+  CHECK_AND_ASSERT_EQ(decrypt_resp.verified_tx_id, emit_resp.tx_id);
+
+  // after a successfull tx outputs decryption, examine them
+  CHECK_AND_ASSERT_EQ(decrypt_resp.decoded_outputs.size(), emit_tx.vout.size());
+  uint64_t decrypted_emission_sum = 0;
+  for(auto& el : decrypt_resp.decoded_outputs)
+  {
+    if (el.asset_id == asset_id)
+      decrypted_emission_sum += el.amount;
+    else
+      CHECK_AND_ASSERT_EQ(el.asset_id, native_coin_asset_id);
+  }
+  // make sure the transaction emits the expected amount of asset
+  CHECK_AND_ASSERT_EQ(decrypted_emission_sum, additional_emit_amount);
+
+  LOG_PRINT_YELLOW(decrypt_resp.tx_in_json, LOG_LEVEL_0); // tx with still missing ownership proof
+
+  //
+  // as everything is allright, sign emit_tx with ETH signature.
+  //
+  crypto::eth_signature eth_sig{};
+  crypto::generate_eth_signature(emit_resp.tx_id, eth_sk, eth_sig);
+  // instant verification, just in case
+  r = crypto::verify_eth_signature(emit_resp.tx_id, eth_pk, eth_sig);
+  CHECK_AND_ASSERT_MES(r, false, "verify_eth_signature failed");
+
+  //
+  // send ETH signature alogn with all previous data to a wallet RPC call for final tx assembling and broadcasting
+  //
+  tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request send_signed_req{};
+  send_signed_req.unsigned_tx     = emit_resp.data_for_external_signing->unsigned_tx;
+  send_signed_req.eth_sig         = eth_sig;
+  send_signed_req.expected_tx_id  = decrypt_resp.verified_tx_id;
+  send_signed_req.finalized_tx    = emit_resp.data_for_external_signing->finalized_tx;
+  send_signed_req.unlock_transfers_on_fail = true;
+  tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response send_signed_resp{};
+  r = miner_wlt_rpc.on_asset_send_ext_signed_tx(send_signed_req, send_signed_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC send_ext_signed_asset_tx failed: " << jerr.message);
+
+  // make sure tx was broadcasted
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // confirm the tx with a block
+  CHECK_AND_ASSERT_MES(mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c), false, "");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // Alice checks her asset balance
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 1);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", total_asset_amount, asset_id, adb.decimal_point), false, "");
+
+
+  //
+  // 3. Miner transfer ownership of the asset to another ETH key (#2)
+  //
+  crypto::eth_secret_key eth_sk_2{};
+  crypto::eth_public_key eth_pk_2{};
+  r = crypto::generate_eth_key_pair(eth_sk_2, eth_pk_2);
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_key_pair failed");
+
+  tools::wallet_public::COMMAND_ASSETS_UPDATE::request to_req{}; // 'to' means transfer of ownership
+  to_req.asset_id = asset_id;
+  {
+    // request the most recent asset info from core to correctly fill to_req
+    currency::COMMAND_RPC_GET_ASSET_INFO::request req{};
+    req.asset_id = asset_id;
+    currency::COMMAND_RPC_GET_ASSET_INFO::response resp{};
+    CHECK_AND_ASSERT_MES(core_rpc_wrapper.on_get_asset_info(req, resp, ctx), false, "on_get_asset_info failed");
+    to_req.asset_descriptor = resp.asset_descriptor;
+  }
+  to_req.asset_descriptor.owner_eth_pub_key = eth_pk_2; // new owner, note using another ETH pub key
+  to_req.asset_descriptor.meta_info = "owner: eth_pk_2"; // it's also possible to change meta_info with this update operation
+  tools::wallet_public::COMMAND_ASSETS_UPDATE::response to_resp{};
+  r = miner_wlt_rpc.on_asset_update(to_req, to_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC send_ext_signed_asset_tx failed: " << jerr.message);
+
+  // make sure tx was NOT added to the pool (because it's only partially signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  CHECK_AND_ASSERT_MES(to_resp.data_for_external_signing.has_value(), false, "data_for_external_signing has no value");
+  transaction to_tx{};
+  r = t_unserializable_object_from_blob(to_tx, to_resp.data_for_external_signing->unsigned_tx);
+  CHECK_AND_ASSERT_MES(r, false, "t_unserializable_object_from_blob failed");
+  CHECK_AND_ASSERT_EQ(get_transaction_hash(to_tx), to_resp.tx_id);
+
+  // make sure ownership transferring transaction cannot be added to the transaction pool (it's not fully signed atm)
+  tvc = tx_verification_context{};
+  r = c.get_tx_pool().add_tx(to_tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "ownership transferring tx was able to be added to the pool");
+
+  //
+  // decrypt ownership transfer transaction prior to ETH signing to make sure it's valid
+  //
+  decrypt_req = currency::COMMAND_RPC_DECRYPT_TX_DETAILS::request{};
+  decrypt_req.tx_secret_key = to_resp.data_for_external_signing->tx_secret_key;
+  decrypt_req.tx_blob = epee::string_encoding::base64_encode(to_resp.data_for_external_signing->unsigned_tx);
+  // note: decrypt_req.outputs_addresses can be populated using to_resp.data_for_external_signing->outputs_addresses but we fill it manually here
+  for(size_t i = 0, size = to_tx.vout.size(); i < size; ++i)
+    decrypt_req.outputs_addresses.push_back(m_accounts[MINER_ACC_IDX].get_public_address_str()); // we expect all outputs goes to Miner
+  decrypt_resp = currency::COMMAND_RPC_DECRYPT_TX_DETAILS::response{};
+  r = core_rpc_wrapper.on_decrypt_tx_details(decrypt_req, decrypt_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_decrypt_tx_details failed: " << jerr.message);
+  // make sure that verified_tx_id is the one we expect
+  CHECK_AND_ASSERT_EQ(decrypt_resp.verified_tx_id, to_resp.tx_id);
+
+  // after a successfull tx outputs decryption, examine them
+  CHECK_AND_ASSERT_EQ(decrypt_resp.decoded_outputs.size(), to_tx.vout.size());
+  uint64_t asset_sum = 0;
+  for(auto& el : decrypt_resp.decoded_outputs)
+  {
+    if (el.asset_id != native_coin_asset_id)
+      asset_sum += el.amount;
+  }
+  // make sure the transaction don't send assets
+  CHECK_AND_ASSERT_EQ(asset_sum, 0);
+
+  // make sure this is an ownership transfer transaction and the ownership is correctly transferred:
+  // Note: this check could also be done by examination of decrypt_resp.tx_in_json
+  asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(to_tx.extra);
+  CHECK_AND_ASSERT_NEQ(pado, nullptr);
+  CHECK_AND_ASSERT_EQ(pado->operation_type, ASSET_DESCRIPTOR_OPERATION_UPDATE);
+  CHECK_AND_ASSERT_EQ(pado->opt_asset_id.has_value(), true);
+  CHECK_AND_ASSERT_EQ(pado->opt_asset_id.get(), asset_id);
+  CHECK_AND_ASSERT_EQ(pado->descriptor.owner_eth_pub_key.has_value(), true);
+  CHECK_AND_ASSERT_EQ(pado->descriptor.owner_eth_pub_key.get(), eth_pk_2); // the most important condition for an ownership transfer
+  // other fileds of pado->descriptor may also be checked here
+
+  //
+  // as everything is allright, sign to_tx with ETH signature.
+  //
+  crypto::eth_signature to_eth_sig{};
+  crypto::generate_eth_signature(to_resp.tx_id, eth_sk, to_eth_sig); // note using old ETH secret key here, because this tx must be signed with the original owner
+  // instant verification, just in case
+  r = crypto::verify_eth_signature(to_resp.tx_id, eth_pk, to_eth_sig);
+  CHECK_AND_ASSERT_MES(r, false, "verify_eth_signature failed");
+
+  //
+  // send ETH signature along with all previous data to a wallet RPC call for final tx assembling and broadcasting
+  //
+  send_signed_req = tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request{};
+  send_signed_req.unsigned_tx     = to_resp.data_for_external_signing->unsigned_tx;
+  send_signed_req.eth_sig         = to_eth_sig;
+  send_signed_req.expected_tx_id  = decrypt_resp.verified_tx_id;
+  send_signed_req.finalized_tx    = to_resp.data_for_external_signing->finalized_tx;
+  send_signed_req.unlock_transfers_on_fail = true;
+  send_signed_resp = tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response{};
+  r = miner_wlt_rpc.on_asset_send_ext_signed_tx(send_signed_req, send_signed_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC send_ext_signed_asset_tx failed: " << jerr.message);
+
+  // make sure tx was broadcasted
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // confirm the tx with a block
+  CHECK_AND_ASSERT_MES(mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c), false, "");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // Alice checks her asset balance, it shouldn't change
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 1);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", total_asset_amount, asset_id, adb.decimal_point), false, "");
+
+  miner_wlt->refresh();
+
+  //
+  // 4. Miner emits additional amount of the asset (signing it with ETH key #2) and transfers it to Bob
+  //
+  additional_emit_amount = 15000;
+  uint64_t alice_amount = total_asset_amount;
+  total_asset_amount += additional_emit_amount;
+
+  emit_req = tools::wallet_public::COMMAND_ASSETS_EMIT::request{};
+  emit_req.asset_id = asset_id;
+  emit_req.destinations.push_back(tools::wallet_public::transfer_destination{additional_emit_amount, m_accounts[BOB_ACC_IDX].get_public_address_str(), asset_id});
+  emit_req.do_not_split_destinations = false;
+
+  emit_resp = tools::wallet_public::COMMAND_ASSETS_EMIT::response{};
+  r = miner_wlt_rpc.on_asset_emit(emit_req, emit_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_asset_emit failed: " << jerr.message);
+
+  // make sure tx was NOT added to the pool (because it's only partially signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // unserialize transaction that we got from RPC
+  emit_tx = transaction{};
+  CHECK_AND_ASSERT_MES(emit_resp.data_for_external_signing.has_value(), false, "data_for_external_signing has no value");
+  r = t_unserializable_object_from_blob(emit_tx, emit_resp.data_for_external_signing->unsigned_tx);
+  CHECK_AND_ASSERT_MES(r, false, "t_unserializable_object_from_blob failed");
+  CHECK_AND_ASSERT_EQ(get_transaction_hash(emit_tx), emit_resp.tx_id);
+
+  // make sure emit transaction cannot be added to the transaction pool (it's not fully signed atm)
+  tvc = tx_verification_context{};
+  r = c.get_tx_pool().add_tx(emit_tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "emit tx was able to be added to the pool");
+
+  //
+  // decrypt emission transaction outputs prior to ETH signing to make sure it's valid
+  //
+  decrypt_req = currency::COMMAND_RPC_DECRYPT_TX_DETAILS::request{};
+  decrypt_req.tx_secret_key = emit_resp.data_for_external_signing->tx_secret_key;
+  decrypt_req.tx_blob = epee::string_encoding::base64_encode(emit_resp.data_for_external_signing->unsigned_tx);
+  // note: decrypt_req.outputs_addresses can be populated using emit_resp.data_for_external_signing->outputs_addresses but we fill it manually here
+  decrypt_req.outputs_addresses.push_back(m_accounts[MINER_ACC_IDX].get_public_address_str()); // we expect that the first output is the cashback and addressed to miner
+  for(size_t i = 0, size = emit_tx.vout.size() - 1; i < size; ++i)
+    decrypt_req.outputs_addresses.push_back(m_accounts[BOB_ACC_IDX].get_public_address_str()); // we expect all other outputs are asset emission and addresses to Bob
+  decrypt_resp = currency::COMMAND_RPC_DECRYPT_TX_DETAILS::response{};
+  r = core_rpc_wrapper.on_decrypt_tx_details(decrypt_req, decrypt_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC on_decrypt_tx_details failed: " << jerr.message);
+  // make sure that verified_tx_id is the one we expect
+  CHECK_AND_ASSERT_EQ(decrypt_resp.verified_tx_id, emit_resp.tx_id);
+
+  // after a successfull tx outputs decryption, examine them
+  CHECK_AND_ASSERT_EQ(decrypt_resp.decoded_outputs.size(), emit_tx.vout.size());
+  decrypted_emission_sum = 0;
+  for(auto& el : decrypt_resp.decoded_outputs)
+  {
+    if (el.asset_id == asset_id)
+      decrypted_emission_sum += el.amount;
+    else
+      CHECK_AND_ASSERT_EQ(el.asset_id, native_coin_asset_id);
+  }
+  // make sure the transaction emits the expected amount of asset
+  CHECK_AND_ASSERT_EQ(decrypted_emission_sum, additional_emit_amount);
+
+  //
+  // as everything is allright, sign emit_tx with ETH signature.
+  //
+  eth_sig = crypto::eth_signature{};
+  crypto::generate_eth_signature(emit_resp.tx_id, eth_sk_2, eth_sig); // note using ETH key #2
+  // instant verification, just in case
+  r = crypto::verify_eth_signature(emit_resp.tx_id, eth_pk_2, eth_sig);
+  CHECK_AND_ASSERT_MES(r, false, "verify_eth_signature failed");
+
+  //
+  // send ETH signature alogn with all previous data to a wallet RPC call for final tx assembling and broadcasting
+  //
+  send_signed_req = tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::request{};
+  send_signed_req.unsigned_tx     = emit_resp.data_for_external_signing->unsigned_tx;
+  send_signed_req.eth_sig         = eth_sig;
+  send_signed_req.expected_tx_id  = decrypt_resp.verified_tx_id;
+  send_signed_req.finalized_tx    = emit_resp.data_for_external_signing->finalized_tx;
+  send_signed_req.unlock_transfers_on_fail = true;
+  send_signed_resp = tools::wallet_public::COMMAND_ASSET_SEND_EXT_SIGNED_TX::response{};
+  r = miner_wlt_rpc.on_asset_send_ext_signed_tx(send_signed_req, send_signed_resp, jerr, ctx);
+  CHECK_AND_ASSERT_MES(r, false, "RPC send_ext_signed_asset_tx failed: " << jerr.message);
+
+  // make sure tx was broadcasted
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // confirm the tx with a block
+  CHECK_AND_ASSERT_MES(mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c), false, "");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // Alice checks her asset balance, it shouldn't change
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 1);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", alice_amount, asset_id, adb.decimal_point), false, "");
+
+  // Bob checks his asset balance
+  std::shared_ptr<tools::wallet2> bob_wlt = init_playtime_test_wallet(events, c, BOB_ACC_IDX);
+  bob_wlt->refresh();
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*bob_wlt, "Bob", additional_emit_amount, asset_id, adb.decimal_point), false, "");
+
+  // finally, check asset's current supply
+  asset_descriptor_base adb_temp{};
+  r = c.get_blockchain_storage().get_asset_info(asset_id, adb_temp);
+  CHECK_AND_ASSERT_MES(r, false, "get_asset_info failed");
+  CHECK_AND_ASSERT_EQ(adb_temp.current_supply, total_asset_amount);
+
+  return true;
+}
diff --git a/tests/core_tests/multiassets_test.h b/tests/core_tests/multiassets_test.h
index e07d36c8..bba172fc 100644
--- a/tests/core_tests/multiassets_test.h
+++ b/tests/core_tests/multiassets_test.h
@@ -55,3 +55,10 @@ struct eth_signed_asset_basics : public wallet_test
   bool generate(std::vector<test_event_entry>& events) const;
   bool c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events);
 };
+
+struct eth_signed_asset_via_rpc : public wallet_test
+{
+  eth_signed_asset_via_rpc();
+  bool generate(std::vector<test_event_entry>& events) const;
+  bool c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events);
+};

From ef5c1f9c03c073337dedb47d98c94b659f344dbb Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 06:15:23 +0200
Subject: [PATCH 31/37] coretests: gcc compilation fixed

---
 tests/core_tests/multiassets_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp
index 70ad2b7d..23326daa 100644
--- a/tests/core_tests/multiassets_test.cpp
+++ b/tests/core_tests/multiassets_test.cpp
@@ -1288,7 +1288,7 @@ bool eth_signed_asset_via_rpc::c1(currency::core& c, size_t ev_index, const std:
   // make sure this is an ownership transfer transaction and the ownership is correctly transferred:
   // Note: this check could also be done by examination of decrypt_resp.tx_in_json
   asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(to_tx.extra);
-  CHECK_AND_ASSERT_NEQ(pado, nullptr);
+  CHECK_AND_ASSERT_NEQ(pado, 0);
   CHECK_AND_ASSERT_EQ(pado->operation_type, ASSET_DESCRIPTOR_OPERATION_UPDATE);
   CHECK_AND_ASSERT_EQ(pado->opt_asset_id.has_value(), true);
   CHECK_AND_ASSERT_EQ(pado->opt_asset_id.get(), asset_id);

From c117a76a049375e6823f88285ed5032c57e05d5d Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 14:33:22 +0200
Subject: [PATCH 32/37] upstream changes

---
 CMakeLists.txt                              |    7 +-
 contrib/epee/include/file_io_utils.h        |   20 +-
 src/common/db_backend_lmdb.cpp              |   59 +-
 src/common/db_backend_lmdb.h                |    5 +-
 src/common/mnemonic-encoding.cpp            |    4 +
 src/common/mnemonic-encoding.h              |    1 +
 src/connectivity_tool/conn_tool.cpp         |   39 +-
 src/crypto/random.c                         |    8 +-
 src/currency_core/account.cpp               |   19 +-
 src/currency_core/currency_basic.h          |   12 +
 src/currency_core/currency_format_utils.cpp |    4 +-
 src/currency_core/currency_format_utils.h   |    6 +-
 src/rpc/core_rpc_server.cpp                 |  104 ++
 src/rpc/core_rpc_server.h                   |    3 +
 src/rpc/core_rpc_server_commands_defs.h     |   56 +-
 src/simplewallet/simplewallet.cpp           |    4 +-
 src/wallet/wallet_rpc_server_error_codes.h  |   15 +-
 tests/unit_tests/amounts_tests.cpp          |  234 +--
 tests/unit_tests/fork_choice_rule.cpp       | 1807 ++++++++++++++++++-
 tests/unit_tests/wallet_seed_test.cpp       |  151 ++
 20 files changed, 2382 insertions(+), 176 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 04790815..e320fafc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -226,7 +226,12 @@ endif()
 message("CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}")    
 if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
   set(CMAKE_OSX_DEPLOYMENT_TARGET 12.00)
-  set(Boost_LIBRARIES "libboost.a")
+  if(NOT DEFINED SKIP_BOOST_FATLIB_LIB OR NOT SKIP_BOOST_FATLIB_LIB)
+	message("Ios: libboost.a included as library")    
+	set(Boost_LIBRARIES "libboost.a")
+  else()
+	message("Ios: libboost.a not included as library")    
+  endif()
   #workaround for new XCode 12 policy for builds(now it includes a slice for the "arm64" when builds for simulator)
   set(__iphoneos_archs "arm64")
   #set(__iphonesimulator_archs "arm64,x86_64")
diff --git a/contrib/epee/include/file_io_utils.h b/contrib/epee/include/file_io_utils.h
index 9d5118cb..bb21ae99 100644
--- a/contrib/epee/include/file_io_utils.h
+++ b/contrib/epee/include/file_io_utils.h
@@ -35,7 +35,19 @@
 #include <iostream>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
-#include <filesystem>
+
+
+#if __has_include(<filesystem>)
+	#include <filesystem>
+	namespace stdfs = std::filesystem;
+#else
+	#if TARGET_OS_IOS
+		#error "This should never happen on ios."	
+	#endif
+	namespace stdfs = boost::filesystem;	
+#endif
+
+//#include <filesystem>
 
 #ifndef MAKE64
 	#define MAKE64(low,high)	((__int64)(((DWORD)(low)) | ((__int64)((DWORD)(high))) << 32))
@@ -562,10 +574,10 @@ namespace file_io_utils
 		try
 		{
 
-			std::filesystem::directory_iterator end_itr; // default construction yields past-the-end
-			for ( std::filesystem::directory_iterator itr( epee::string_encoding::utf8_to_wstring(path) ); itr != end_itr; ++itr )
+			stdfs::directory_iterator end_itr; // default construction yields past-the-end
+			for (stdfs::directory_iterator itr( epee::string_encoding::utf8_to_wstring(path) ); itr != end_itr; ++itr )
 			{
-				if ( only_files && std::filesystem::is_directory(itr->status()) )
+				if ( only_files && stdfs::is_directory(itr->status()) )
 				{
 					continue;
 				}
diff --git a/src/common/db_backend_lmdb.cpp b/src/common/db_backend_lmdb.cpp
index 75e60ce4..d23fff80 100644
--- a/src/common/db_backend_lmdb.cpp
+++ b/src/common/db_backend_lmdb.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project 
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -394,10 +394,67 @@ namespace tools
       }
       return true;
     }
+
     const char* lmdb_db_backend::name()
     {
       return "lmdb";
     }
+
+    bool lmdb_db_backend::convert_db_4kb_page_to_16kb_page(const std::string& source_path, const std::string& destination_path)
+    {
+      #define MDB_CHECK(x, msg) {int rc = x; CHECK_AND_ASSERT_MES(rc == MDB_SUCCESS, false, "LMDB 4k->16k error: " << msg << ": " << mdb_strerror(rc));}
+
+      MDB_env *env_src = nullptr, *env_dst = nullptr;
+
+      // source
+      MDB_CHECK(mdb_env_create(&env_src), "failed to create LMDB environment");
+      MDB_CHECK(mdb_env_set_mapsize(env_src, 4 * 1024 * 1024), "failed to set mapsize"); // mapsize ?
+      MDB_CHECK(mdb_env_open(env_src, source_path.c_str(), 0, 0664), "failed to open source LMDB");
+
+      // destination (16k page size)
+      MDB_CHECK(mdb_env_create(&env_dst), "failed to create LMDB environment");
+      MDB_CHECK(mdb_env_set_mapsize(env_dst, 16 * 1024 * 1024), "failed to set mapsize"); // mapsize ?
+      
+      // TODO uncomment after mdb_env_set_pagesize is supported
+      // MDB_CHECK(mdb_env_set_pagesize(env_dst, 16 * 1024), "failed to set page size to 16K");
+      
+      MDB_CHECK(mdb_env_open(env_dst, destination_path.c_str(), 0, 0664), "failed to open destination LMDB");
+
+      // begin transactions
+      MDB_txn *txn_src = nullptr, *txn_dst = nullptr;
+      MDB_dbi dbi_src, dbi_dst;
+      MDB_CHECK(mdb_txn_begin(env_src, nullptr, MDB_RDONLY, &txn_src), "failed to begin source transaction");
+      MDB_CHECK(mdb_dbi_open(txn_src, nullptr, 0, &dbi_src), "failed to open source database");
+      MDB_CHECK(mdb_txn_begin(env_dst, nullptr, 0, &txn_dst), "failed to begin destination transaction");
+      MDB_CHECK(mdb_dbi_open(txn_dst, nullptr, MDB_CREATE, &dbi_dst), "failed to open destination database");
+
+      MDB_cursor *cursor;
+      MDB_val key, data;
+
+      // Iterate over the source database and copy all key-value pairs to the destination database
+      MDB_CHECK(mdb_cursor_open(txn_src, dbi_src, &cursor), "failed to open cursor");
+
+      while (mdb_cursor_get(cursor, &key, &data, MDB_NEXT) == MDB_SUCCESS)
+      {
+        MDB_CHECK(mdb_put(txn_dst, dbi_dst, &key, &data, 0), "failed to put data in destination database");
+      }
+
+      mdb_cursor_close(cursor);
+
+      // commit transactions
+      MDB_CHECK(mdb_txn_commit(txn_src), "failed to commit source transaction");
+      MDB_CHECK(mdb_txn_commit(txn_dst), "failed to commit destination transaction");
+
+      mdb_dbi_close(env_src, dbi_src);
+      mdb_dbi_close(env_dst, dbi_dst);
+      mdb_env_close(env_src);
+      mdb_env_close(env_dst);
+
+      return true;
+
+      #undef MDB_CHECK
+    }
+
   }
 }
 
diff --git a/src/common/db_backend_lmdb.h b/src/common/db_backend_lmdb.h
index ef56c346..c2920f0c 100644
--- a/src/common/db_backend_lmdb.h
+++ b/src/common/db_backend_lmdb.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project 
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -36,6 +36,7 @@ namespace tools
       boost::recursive_mutex m_write_exclusive_lock;
       std::map<std::thread::id, transactions_list> m_txs; // size_t -> count of nested read_only transactions
       bool pop_tx_entry(tx_entry& txe);
+
     public:
       lmdb_db_backend();
       ~lmdb_db_backend();
@@ -60,6 +61,8 @@ namespace tools
       bool have_tx();
       MDB_txn* get_current_tx();
 
+      static bool convert_db_4kb_page_to_16kb_page(const std::string& source_path, const std::string& destination_path);
+
     };
   }
 }
diff --git a/src/common/mnemonic-encoding.cpp b/src/common/mnemonic-encoding.cpp
index c2e3e307..f52ece6b 100644
--- a/src/common/mnemonic-encoding.cpp
+++ b/src/common/mnemonic-encoding.cpp
@@ -3391,5 +3391,9 @@ namespace tools
       CHECK_AND_ASSERT_THROW_MES(it!= wordsMap.end(), "unable to find word \"" << w << "\" in mnemonic dictionary");
       return it->second;
     }
+		const map<string, uint32_t>& get_words_map()
+		{
+			return wordsMap;
+		}
 	} 
 }  
diff --git a/src/common/mnemonic-encoding.h b/src/common/mnemonic-encoding.h
index 4ce6b9bb..5e235399 100644
--- a/src/common/mnemonic-encoding.h
+++ b/src/common/mnemonic-encoding.h
@@ -47,5 +47,6 @@ namespace tools
     std::string word_by_num(uint32_t n);
     uint64_t num_by_word(const std::string& w);
     bool valid_word(const std::string& w);
+		const std::map<std::string, uint32_t>& get_words_map();
 	}
 }
diff --git a/src/connectivity_tool/conn_tool.cpp b/src/connectivity_tool/conn_tool.cpp
index 07528c56..a7c32892 100644
--- a/src/connectivity_tool/conn_tool.cpp
+++ b/src/connectivity_tool/conn_tool.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 Zano Project
+// Copyright (c) 2014-2024 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Copyright (c) 2012-2013 The Cryptonote developers
 // Distributed under the MIT/X11 software license, see the accompanying
@@ -25,6 +25,7 @@ using namespace epee;
 #include "storages/http_abstract_invoke.h"
 #include "net/http_client.h"
 #include "currency_core/genesis_acc.h"
+#include "common/db_backend_lmdb.h"
 #include <cstdlib>
 
 namespace po = boost::program_options;
@@ -63,6 +64,7 @@ namespace
   const command_line::arg_descriptor<std::string> arg_pack_file           ("pack-file", "perform gzip-packing and calculate hash for a given file");
   const command_line::arg_descriptor<std::string> arg_unpack_file         ("unpack-file", "Perform gzip-unpacking and calculate hash for a given file");
   const command_line::arg_descriptor<std::string> arg_target_file         ("target-file", "Specify target file for pack-file and unpack-file commands");
+  const command_line::arg_descriptor<std::string> arg_lmdb_page_4to16          ("convert-lmdb-4to16", "Perform LMDB conversion from 4k page size to 16k page size");
   //const command_line::arg_descriptor<std::string> arg_send_ipc            ("send-ipc", "Send IPC request to UI");
 }
 
@@ -1220,7 +1222,10 @@ bool handle_pack_file(po::variables_map& vm)
   }
 
   if (!command_line::has_arg(vm, arg_target_file))
+  {
     std::cout << "Error: Parameter target_file is not set." << ENDL;
+    return false;
+  }
   path_target = command_line::get_arg(vm, arg_target_file);
 
   std::ifstream source;
@@ -1251,6 +1256,34 @@ bool handle_pack_file(po::variables_map& vm)
   }
 }
 
+bool handle_lmdb_page_4to16(po::variables_map& vm)
+{
+  std::string path_source;
+  std::string path_target;
+
+  if (!command_line::has_arg(vm, arg_lmdb_page_4to16))
+    return false;
+
+  path_source = command_line::get_arg(vm, arg_lmdb_page_4to16);
+
+  if (!command_line::has_arg(vm, arg_target_file))
+  {
+    std::cout << "Error: Parameter target_file is not set." << ENDL;
+    return false;
+  }
+  path_target = command_line::get_arg(vm, arg_target_file);
+
+  if (tools::db::lmdb_db_backend::convert_db_4kb_page_to_16kb_page(path_source, path_target))
+  {
+    std::cout << "Conversion failed" << ENDL;
+    return false;
+  }
+  
+  std::cout << "Converted successfully" << ENDL;
+  return true;
+}
+
+
 //---------------------------------------------------------------------------------------------------------------
 
 int main(int argc, char* argv[])
@@ -1375,6 +1408,10 @@ int main(int argc, char* argv[])
   {
     return handle_pack_file(vm) ? EXIT_SUCCESS : EXIT_FAILURE;
   }
+  else if (command_line::has_arg(vm, arg_lmdb_page_4to16))
+  {
+    return handle_lmdb_page_4to16(vm) ? EXIT_SUCCESS : EXIT_FAILURE;
+  }
   /*else if (command_line::has_arg(vm, arg_send_ipc))
   {
     handle_send_ipc(command_line::get_arg(vm, arg_send_ipc)) ? EXIT_SUCCESS : EXIT_FAILURE;
diff --git a/src/crypto/random.c b/src/crypto/random.c
index bdac1e7a..a54bdf74 100644
--- a/src/crypto/random.c
+++ b/src/crypto/random.c
@@ -43,7 +43,7 @@ void generate_system_random_bytes(size_t n, void *result) {
 void generate_system_random_bytes(size_t n, void *result) {
   int fd;
   if ((fd = open("/dev/urandom", O_RDONLY | O_NOCTTY | O_CLOEXEC)) < 0) {
-    err(EXIT_FAILURE, "open /dev/urandom");
+    exit(EXIT_FAILURE);
   }
   for (;;) {
     ssize_t res = read(fd, result, n);
@@ -52,17 +52,17 @@ void generate_system_random_bytes(size_t n, void *result) {
     }
     if (res < 0) {
       if (errno != EINTR) {
-        err(EXIT_FAILURE, "read /dev/urandom");
+        exit(EXIT_FAILURE);
       }
     } else if (res == 0) {
-      errx(EXIT_FAILURE, "read /dev/urandom: end of file");
+      exit(EXIT_FAILURE);
     } else {
       result = padd(result, (size_t) res);
       n -= (size_t) res;
     }
   }
   if (close(fd) < 0) {
-    err(EXIT_FAILURE, "close /dev/urandom");
+    exit(EXIT_FAILURE);
   }
 }
 
diff --git a/src/currency_core/account.cpp b/src/currency_core/account.cpp
index 04260dd3..f5663826 100644
--- a/src/currency_core/account.cpp
+++ b/src/currency_core/account.cpp
@@ -91,11 +91,11 @@ namespace currency
     }
 
     std::string keys_seed_text = tools::mnemonic_encoding::binary2text(processed_seed_binary);
-    std::string timestamp_word = currency::get_word_from_timstamp(m_creation_timestamp, !password.empty());
+    std::string timestamp_word = currency::get_word_from_timestamp(m_creation_timestamp, !password.empty());
 
     // floor creation time to WALLET_BRAIN_DATE_QUANTUM to make checksum calculation stable
     bool self_check_is_password_used = false;
-    uint64_t creation_timestamp_rounded = get_timstamp_from_word(timestamp_word, self_check_is_password_used);
+    uint64_t creation_timestamp_rounded = get_timestamp_from_word(timestamp_word, self_check_is_password_used);
     CHECK_AND_ASSERT_THROW_MES(self_check_is_password_used == !password.empty(), "Account seed phrase internal error: password flag encoded wrong");
 
     constexpr uint16_t checksum_max = tools::mnemonic_encoding::NUMWORDS >> 1; // maximum value of checksum
@@ -134,11 +134,12 @@ namespace currency
     return true;
   }
   //-----------------------------------------------------------------
-  bool account_base::restore_from_seed_phrase(const std::string& seed_phrase, const std::string& seed_password)
+  bool account_base::restore_from_seed_phrase(const std::string& seed_phrase_, const std::string& seed_password)
   {
     //cut the last timestamp word from restore_dats
     std::list<std::string> words;
-    boost::split(words, seed_phrase, boost::is_space());
+    std::string seed_phrase = epee::string_tools::trim(seed_phrase_);
+    boost::split(words, seed_phrase, boost::is_space(), boost::token_compress_on);
     
     std::string keys_seed_text, timestamp_word, auditable_flag_and_checksum_word;
     if (words.size() == SEED_PHRASE_V1_WORDS_COUNT)
@@ -183,7 +184,7 @@ namespace currency
 
     bool has_password = false;
     try {
-      m_creation_timestamp = get_timstamp_from_word(timestamp_word, has_password);
+      m_creation_timestamp = get_timestamp_from_word(timestamp_word, has_password);
     }
     catch (...)
     {
@@ -237,11 +238,13 @@ namespace currency
     return seed_phrase.find(':') != std::string::npos;
   }
   //-----------------------------------------------------------------
-  bool account_base::is_seed_password_protected(const std::string& seed_phrase, bool& is_password_protected)
+  bool account_base::is_seed_password_protected(const std::string& seed_phrase_, bool& is_password_protected)
   {
     //cut the last timestamp word from restore_dats
     std::list<std::string> words;
-    boost::split(words, seed_phrase, boost::is_space());
+
+    std::string seed_phrase = epee::string_tools::trim(seed_phrase_);
+    boost::split(words, seed_phrase, boost::is_space(), boost::token_compress_on);
 
     //let's validate each word 
     for (const auto& w: words)
@@ -267,7 +270,7 @@ namespace currency
       return false;
     }
 
-    get_timstamp_from_word(timestamp_word, is_password_protected);
+    get_timestamp_from_word(timestamp_word, is_password_protected);
 
     return true;
   }
diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index cd7741a1..976207ad 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -803,6 +803,13 @@ namespace currency
       BOOST_END_VERSION_UNDER(1)
       BOOST_SERIALIZE(opt_asset_id)
     END_BOOST_SERIALIZATION()
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(operation_type)    DOC_DSCR("Asset operation type identifier") DOC_EXMP(1) DOC_END
+      KV_SERIALIZE(descriptor)        DOC_DSCR("Asset descriptor") DOC_EXMP_AUTO() DOC_END
+      KV_SERIALIZE_POD_AS_HEX_STRING(amount_commitment) DOC_DSCR("Amount commitment") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+      KV_SERIALIZE_POD_AS_HEX_STRING(opt_asset_id)      DOC_DSCR("ID of an asset.") DOC_EXMP("cc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6") DOC_END
+    END_KV_SERIALIZE_MAP()
   };
 
   struct asset_operation_proof
@@ -856,6 +863,11 @@ namespace currency
       BOOST_SERIALIZE(eth_sig)
       BOOST_SERIALIZE(version)
     END_BOOST_SERIALIZATION()
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE_POD_AS_HEX_STRING(eth_sig)    DOC_DSCR("HEX-encoded ETH signature (64 bytes)") DOC_EXMP("674bb56a5b4fa562e679ccacc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6add697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END
+      KV_SERIALIZE(version)                      DOC_DSCR("Structure version") DOC_EXMP(0) DOC_END
+    END_KV_SERIALIZE_MAP()
   };
 
   struct extra_padding
diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp
index 974502d0..f3b1b597 100644
--- a/src/currency_core/currency_format_utils.cpp
+++ b/src/currency_core/currency_format_utils.cpp
@@ -2832,7 +2832,7 @@ namespace currency
     return reward;
   }
   //---------------------------------------------------------------
-  std::string get_word_from_timstamp(uint64_t timestamp, bool use_password)
+  std::string get_word_from_timestamp(uint64_t timestamp, bool use_password)
   {
     uint64_t date_offset = timestamp > WALLET_BRAIN_DATE_OFFSET ? timestamp - WALLET_BRAIN_DATE_OFFSET : 0;
     uint64_t weeks_count = date_offset / WALLET_BRAIN_DATE_QUANTUM;
@@ -2847,7 +2847,7 @@ namespace currency
     return tools::mnemonic_encoding::word_by_num(weeks_count_32);
   }
   //---------------------------------------------------------------
-  uint64_t get_timstamp_from_word(std::string word, bool& password_used)
+  uint64_t get_timestamp_from_word(std::string word, bool& password_used)
   {
     uint64_t count_of_weeks = tools::mnemonic_encoding::num_by_word(word);
     if (count_of_weeks >= WALLET_BRAIN_DATE_MAX_WEEKS_COUNT)
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index 99d00fa4..e1899ea1 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -455,9 +455,9 @@ namespace currency
 
   bool fill_block_rpc_details(block_rpc_extended_info& pei_rpc, const block_extended_info& bei_chain, const crypto::hash& h);
   void append_per_block_increments_for_tx(const transaction& tx, std::unordered_map<uint64_t, uint32_t>& gindices);
-  std::string get_word_from_timstamp(uint64_t timestamp, bool use_password);
-  uint64_t get_timstamp_from_word(std::string word, bool& password_used, const std::string& buff);
-  uint64_t get_timstamp_from_word(std::string word, bool& password_used);
+  std::string get_word_from_timestamp(uint64_t timestamp, bool use_password);
+  uint64_t get_timestamp_from_word(std::string word, bool& password_used, const std::string& buff);
+  uint64_t get_timestamp_from_word(std::string word, bool& password_used);
   bool parse_vote(const std::string& buff, std::list<std::pair<std::string, bool>>& votes);
 
   std::string generate_origin_for_htlc(const txout_htlc& htlc, const account_keys& acc_keys);
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 6e9a3f4b..44712f8b 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -1369,6 +1369,110 @@ namespace currency
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_find_outs_in_recent_blocks(const COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS::request& req, COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS::response& resp, epee::json_rpc::error& error_resp, connection_context& cntx)
+  {
+#define LOCAL_CHECK(cond, msg)         if (!(cond)) { error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;    error_resp.message = msg; LOG_PRINT_L1("on_find_outs_in_recent_blocks: " << msg); return false; }
+#define LOCAL_CHECK_INT_ERR(cond, msg) if (!(cond)) { error_resp.code = CORE_RPC_ERROR_CODE_INTERNAL_ERROR; error_resp.message = msg; LOG_PRINT_L1("on_find_outs_in_recent_blocks: " << msg); return false; }
+
+    LOCAL_CHECK(req.address != account_public_address{}, "address is missing");
+    LOCAL_CHECK(req.viewkey != null_skey, "viewkey is missing");
+    LOCAL_CHECK(0 <= req.blocks_limit && req.blocks_limit <= 5, "blocks_limit is out of allowed bounds");
+
+    // verify addess keys
+    crypto::point_t view_pk, spend_pk;
+    LOCAL_CHECK(view_pk.from_public_key(req.address.view_public_key), "cannon load point from address.view_public_key");
+    LOCAL_CHECK(view_pk.is_in_main_subgroup(), "address.view_public_key isn't in main subgroup");
+    LOCAL_CHECK(spend_pk.from_public_key(req.address.spend_public_key), "cannon load point from address.spend_public_key");
+    LOCAL_CHECK(spend_pk.is_in_main_subgroup(), "address.spend_public_key isn't in main subgroup");
+
+    // verify viewkey
+    crypto::scalar_t view_sc = req.viewkey;
+    LOCAL_CHECK(view_sc.is_reduced(), "viewkey is invalid");
+    LOCAL_CHECK(view_sc * crypto::c_point_G == view_pk, "viewkey doesn't correspond to the given address");
+
+    const blockchain_storage& bcs = m_core.get_blockchain_storage();
+    resp.blockchain_top_block_height = bcs.get_top_block_height();
+    resp.blocks_limit = req.blocks_limit;
+
+    // get blockchain transactions
+    std::unordered_map<uint64_t, std::pair<std::vector<crypto::hash>, std::list<transaction>>> blockchain_txs; // block height -> (vector of tx_ids, list of txs)
+    if (req.blocks_limit > 0)
+    {
+      uint64_t start_offset = resp.blockchain_top_block_height - req.blocks_limit + 1;
+      std::list<block> recent_blocks;
+      LOCAL_CHECK_INT_ERR(bcs.get_blocks(start_offset, static_cast<size_t>(req.blocks_limit), recent_blocks), "cannot get recent blocks");
+      
+      std::vector<crypto::hash> blockchain_tx_ids, missed_tx;
+      for(auto& b : recent_blocks)
+      {
+        blockchain_tx_ids.insert(blockchain_tx_ids.end(), b.tx_hashes.begin(), b.tx_hashes.end());
+        uint64_t height = get_block_height(b);
+        auto& el = blockchain_txs[height];
+        el.first = b.tx_hashes;
+        missed_tx.clear();
+        LOCAL_CHECK_INT_ERR(bcs.get_transactions(b.tx_hashes, el.second, missed_tx), "bcs.get_transactions failed");
+        LOCAL_CHECK_INT_ERR(missed_tx.empty(), "missed_tx is not empty");
+        LOCAL_CHECK_INT_ERR(el.first.size() == el.second.size(), "el.first.size() != el.second.size()");
+      }
+    }
+
+    // get pool transactions
+    std::list<transaction> pool_txs;
+    LOCAL_CHECK_INT_ERR(m_core.get_tx_pool().get_transactions(pool_txs), "cannot get txs from pool");
+
+    // processor lambda
+    auto process_tx = [&](const transaction& tx, const crypto::hash& tx_id, const int64_t height) {
+      crypto::key_derivation derivation{};
+      LOCAL_CHECK(generate_key_derivation(get_tx_pub_key_from_extra(tx), req.viewkey, derivation), "generate_key_derivation failed");
+
+      for(size_t i = 0, sz = tx.vout.size(); i < sz; ++i)
+      {
+        const tx_out_v& outv = tx.vout[i];
+        if (outv.type() != typeid(tx_out_zarcanum))
+          continue;
+
+        uint64_t decoded_amount = 0;
+        crypto::public_key decoded_asset_id{};
+        crypto::scalar_t amount_blinding_mask{}, asset_id_blinding_mask{};
+        if (!is_out_to_acc(req.address, boost::get<tx_out_zarcanum>(outv), derivation, i, decoded_amount, decoded_asset_id, amount_blinding_mask, asset_id_blinding_mask))
+          continue;
+
+        auto& el = resp.outputs.emplace_back();
+        el.amount           = decoded_amount;
+        el.asset_id         = decoded_asset_id;
+        el.tx_id            = tx_id;
+        el.tx_block_height  = height;
+        el.output_tx_index  = i;
+      }
+      return true;
+    };
+
+    // process blockchain txs
+    for(auto& [height, pair] : blockchain_txs)
+    {
+      LOCAL_CHECK(pair.first.size() == pair.second.size(), "container size inconsistency");
+      auto tx_it = pair.second.begin();
+      for(size_t i = 0, sz = pair.first.size(); i < sz; ++i, ++tx_it)
+      {
+        const crypto::hash& tx_id = pair.first[i];
+        LOCAL_CHECK(process_tx(*tx_it, tx_id, height), "process blockchain tx failed for tx " + crypto::pod_to_hex(tx_id));
+      }
+    }
+
+    // process pool txs
+    for(auto& tx : pool_txs)
+    {
+      crypto::hash tx_id = get_transaction_hash(tx);
+      LOCAL_CHECK(process_tx(tx, tx_id, -1), "process pool tx failed for tx " + crypto::pod_to_hex(tx_id));
+    }
+
+    resp.status = resp.outputs.empty() ? API_RETURN_CODE_NOT_FOUND : API_RETURN_CODE_OK;
+    return true;
+
+#undef LOCAL_CHECK_INT_ERR
+#undef LOCAL_CHECK
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_aliases_by_address(const COMMAND_RPC_GET_ALIASES_BY_ADDRESS::request& req, COMMAND_RPC_GET_ALIASES_BY_ADDRESS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
   {
     account_public_address addr = AUTO_VAL_INIT(addr);
diff --git a/src/rpc/core_rpc_server.h b/src/rpc/core_rpc_server.h
index 79c5ed69..e95f5a41 100644
--- a/src/rpc/core_rpc_server.h
+++ b/src/rpc/core_rpc_server.h
@@ -95,6 +95,7 @@ namespace currency
     bool on_get_alt_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
     bool on_get_alt_blocks_details(const COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::request& req, COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::response& res, connection_context& cntx);
     bool on_get_est_height_from_date(const COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& req, COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& res, connection_context& cntx);
+    bool on_find_outs_in_recent_blocks(const COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS::request& req, COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
     bool on_validate_signature(const COMMAND_VALIDATE_SIGNATURE::request& req, COMMAND_VALIDATE_SIGNATURE::response& res, epee::json_rpc::error& er, connection_context& cntx);
     
     
@@ -134,6 +135,8 @@ namespace currency
         MAP_JON_RPC_WE("get_alias_by_address",        on_aliases_by_address,          COMMAND_RPC_GET_ALIASES_BY_ADDRESS)
         MAP_JON_RPC_WE("get_alias_reward",            on_get_alias_reward,            COMMAND_RPC_GET_ALIAS_REWARD)
         MAP_JON_RPC   ("get_est_height_from_date",    on_get_est_height_from_date,    COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE)
+        MAP_JON_RPC_WE("find_outs_in_recent_blocks",  on_find_outs_in_recent_blocks,  COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS)
+
         //block explorer api
         MAP_JON_RPC   ("get_blocks_details",          on_rpc_get_blocks_details,      COMMAND_RPC_GET_BLOCKS_DETAILS)
         MAP_JON_RPC_WE("get_tx_details",              on_get_tx_details,              COMMAND_RPC_GET_TX_DETAILS)
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index 7c926958..324dd18f 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -342,6 +342,58 @@ namespace currency
     };
   };
   //-----------------------------------------------
+  struct COMMAND_RPC_FIND_OUTS_IN_RECENT_BLOCKS
+  {
+    DOC_COMMAND("Retrieves information about outputs in recent blocks that are targeted for the given address with the corresponding secret view key.")
+  
+    static constexpr uint64_t blocks_limit_default = 5;
+
+    struct request
+    {
+      account_public_address  address;
+      crypto::secret_key      viewkey;
+      uint64_t                blocks_limit = blocks_limit_default;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE_ADDRESS_AS_TEXT(address)    DOC_DSCR("Target address for which outputs are being searched") DOC_EXMP("ZxCSpsGGeJsS8fwvQ4HktDU3qBeauoJTR6j73jAWWZxFXdF7XTbGm4YfS2kXJmAP4Rf5BVsSQ9iZ45XANXEYsrLN2L2W77dH7") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(viewkey)  DOC_DSCR("Secret view key corresponding to the given address.") DOC_EXMP("5fa8eaaf231a305053260ff91d69c6ef1ecbd0f5") DOC_END
+        KV_SERIALIZE(blocks_limit)               DOC_DSCR("Block count limit. If 0, only the transaction pool will be searched. Maximum and default is " + epee::string_tools::num_to_string_fast(blocks_limit_default) + ".") DOC_EXMP(1711021795) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct out_entry
+    {
+      uint64_t            amount;
+      crypto::public_key  asset_id;
+      crypto::hash        tx_id;
+      int64_t             tx_block_height;
+      uint64_t            output_tx_index;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(amount)                     DOC_DSCR("The amount of the output.") DOC_EXMP(1000000000000) DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(asset_id) DOC_DSCR("Asset ID of the output.") DOC_EXMP("cc4e69455e63f4a581257382191de6856c2156630b3fba0db4bdd73ffcfb36b6") DOC_END
+        KV_SERIALIZE_POD_AS_HEX_STRING(tx_id)    DOC_DSCR("Transaction ID where the output is present, if found.") DOC_EXMP("a6e8da986858e6825fce7a192097e6afae4e889cabe853a9c29b964985b23da8") DOC_END
+        KV_SERIALIZE(tx_block_height)            DOC_DSCR("Block height where the transaction is present.") DOC_EXMP(2555000) DOC_END
+        KV_SERIALIZE(output_tx_index)            DOC_DSCR("Index of the output in the transaction.") DOC_EXMP(2) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::vector<out_entry> outputs;
+      uint64_t blockchain_top_block_height;
+      uint64_t                blocks_limit;
+      std::string status;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(outputs)                    DOC_DSCR("List of found outputs.") DOC_EXMP_AUTO(1) DOC_END
+        KV_SERIALIZE(blockchain_top_block_height) DOC_DSCR("Height of the most recent block in the blockchain.") DOC_EXMP(2555000) DOC_END
+        KV_SERIALIZE(blocks_limit)               DOC_DSCR("Used limit for block count.") DOC_EXMP(5) DOC_END
+        KV_SERIALIZE(status)                     DOC_DSCR("Status of the call.") DOC_EXMP(API_RETURN_CODE_OK) DOC_END
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+  //-----------------------------------------------
   struct COMMAND_RPC_GET_TX_POOL
   {
     DOC_COMMAND("Retreives transactions from tx pool (and other information).")
@@ -643,12 +695,14 @@ namespace currency
     struct request
 		{
 			std::string tx_as_hex;
+      std::string tx_as_json;
 
 			request() {}
 			explicit request(const transaction &);
 
 			BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(tx_as_hex)                  DOC_DSCR("The transaction data as a hexadecimal string, ready for network broadcast.") DOC_EXMP("00018ed1535b8b4862e.....368cdc5a86") DOC_END
+        KV_SERIALIZE(tx_as_hex)                  DOC_DSCR("[either] The transaction data as a hexadecimal string, ready for network broadcast.") DOC_EXMP("00018ed1535b8b4862e.....368cdc5a86") DOC_END
+        KV_SERIALIZE_BLOB_AS_BASE64_STRING(tx_as_json) DOC_DSCR("[or] The transaction data as a base64-encoded json, ready for network broadcast.") DOC_EXMP("ARMBgKCUpY0dBBoAAAAAAAAAABoCAAAAA.......AAAAAAAAABoPAAAAAAAAACVA4FRLH") DOC_END
       END_KV_SERIALIZE_MAP()
 		};
 
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index a27b58d8..7960328f 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -12,6 +12,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/join.hpp>
 #include "include_base_utils.h"
 #include "common/command_line.h"
 #include "common/util.h"
@@ -26,7 +27,7 @@
 #include "string_coding.h"
 #include "wallet/wrap_service.h"
 #include "common/general_purpose_commands_defs.h"
-
+#include "common/mnemonic-encoding.h"
 #include "wallet/wallet_helpers.h"
 
 
@@ -143,6 +144,7 @@ namespace
   const command_line::arg_descriptor<unsigned int>  arg_set_timeout("set-timeout", "Set timeout for the wallet");
   const command_line::arg_descriptor<std::string>   arg_voting_config_file("voting-config-file", "Set voting config instead of getting if from daemon", "");
   const command_line::arg_descriptor<bool>          arg_no_password_confirmations("no-password-confirmation", "Enable/Disable password confirmation for transactions", false);
+  const command_line::arg_descriptor<bool>          arg_seed_doctor("seed-doctor", "Experimental: if your seed is not working for recovery this is likely because you've made a mistake whene you were doing back up(typo, wrong words order, missing word). This experimental code will attempt to recover seed phrase from with few approaches.");
 
   const command_line::arg_descriptor< std::vector<std::string> > arg_command  ("command", "");
 
diff --git a/src/wallet/wallet_rpc_server_error_codes.h b/src/wallet/wallet_rpc_server_error_codes.h
index d24302e0..676b64ea 100644
--- a/src/wallet/wallet_rpc_server_error_codes.h
+++ b/src/wallet/wallet_rpc_server_error_codes.h
@@ -7,10 +7,11 @@
 #pragma  once 
 
 
-#define WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR           -1
-#define WALLET_RPC_ERROR_CODE_WRONG_ADDRESS           -2
-#define WALLET_RPC_ERROR_CODE_DAEMON_IS_BUSY          -3
-#define WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR  -4
-#define WALLET_RPC_ERROR_CODE_WRONG_PAYMENT_ID        -5
-#define WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT          -6
-#define WALLET_RPC_ERROR_CODE_NOT_ENOUGH_MONEY        -7
+#define WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR                       -1
+#define WALLET_RPC_ERROR_CODE_WRONG_ADDRESS                       -2
+#define WALLET_RPC_ERROR_CODE_DAEMON_IS_BUSY                      -3
+#define WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR              -4
+#define WALLET_RPC_ERROR_CODE_WRONG_PAYMENT_ID                    -5
+#define WALLET_RPC_ERROR_CODE_WRONG_ARGUMENT                      -6
+#define WALLET_RPC_ERROR_CODE_NOT_ENOUGH_MONEY                    -7
+#define WALLET_RPC_ERROR_CODE_WRONG_MIXINS_FOR_AUDITABLE_WALLET   -8
diff --git a/tests/unit_tests/amounts_tests.cpp b/tests/unit_tests/amounts_tests.cpp
index 08abdaff..d2678d3c 100644
--- a/tests/unit_tests/amounts_tests.cpp
+++ b/tests/unit_tests/amounts_tests.cpp
@@ -312,139 +312,139 @@ TEST(decompose_amount_randomly, 1)
 TEST(print_money_brief, 1)
 {
   // decimal point 12 (default)
-  ASSERT_EQ(print_money_brief(                   0),         "0.0");
-  ASSERT_EQ(print_money_brief(                   1),         "0.000000000001");
-  ASSERT_EQ(print_money_brief(       1000000000000),         "1.0");
-  ASSERT_EQ(print_money_brief(       1900000000000),         "1.9");
-  ASSERT_EQ(print_money_brief(       1000000100000),         "1.0000001");
-  ASSERT_EQ(print_money_brief(       1000000000001),         "1.000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999),         "9.999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900),        "90.0099900099");
-  ASSERT_EQ(print_money_brief(10109010000000000000),  "10109010.0");
-  ASSERT_EQ(print_money_brief(10109010010000000000),  "10109010.01");
-  ASSERT_EQ(print_money_brief(18446744073709551610),  "18446744.07370955161");
-  ASSERT_EQ(print_money_brief(18446744073709551614),  "18446744.073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615),  "18446744.073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull),         "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull),         "0.000000000001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull),         "1.0");
+  ASSERT_EQ(print_money_brief(       1900000000000ull),         "1.9");
+  ASSERT_EQ(print_money_brief(       1000000100000ull),         "1.0000001");
+  ASSERT_EQ(print_money_brief(       1000000000001ull),         "1.000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull),         "9.999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull),        "90.0099900099");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull),  "10109010.0");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull),  "10109010.01");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull),  "18446744.07370955161");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull),  "18446744.073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull),  "18446744.073709551615");
 
   // decimal point 0
-  ASSERT_EQ(print_money_brief(                   0,  0),                     "0");
-  ASSERT_EQ(print_money_brief(                   1,  0),                     "1");
-  ASSERT_EQ(print_money_brief(       1000000000000,  0),         "1000000000000");
-  ASSERT_EQ(print_money_brief(       1900000000000,  0),         "1900000000000");
-  ASSERT_EQ(print_money_brief(       1000000100000,  0),         "1000000100000");
-  ASSERT_EQ(print_money_brief(       1000000000001,  0),         "1000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999,  0),         "9999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900,  0),        "90009990009900");
-  ASSERT_EQ(print_money_brief(10109010000000000000,  0),  "10109010000000000000");
-  ASSERT_EQ(print_money_brief(10109010010000000000,  0),  "10109010010000000000");
-  ASSERT_EQ(print_money_brief(18446744073709551610,  0),  "18446744073709551610");
-  ASSERT_EQ(print_money_brief(18446744073709551614,  0),  "18446744073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615,  0),  "18446744073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull,  0),                     "0");
+  ASSERT_EQ(print_money_brief(                   1ull,  0),                     "1");
+  ASSERT_EQ(print_money_brief(       1000000000000ull,  0),         "1000000000000");
+  ASSERT_EQ(print_money_brief(       1900000000000ull,  0),         "1900000000000");
+  ASSERT_EQ(print_money_brief(       1000000100000ull,  0),         "1000000100000");
+  ASSERT_EQ(print_money_brief(       1000000000001ull,  0),         "1000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull,  0),         "9999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull,  0),        "90009990009900");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull,  0),  "10109010000000000000");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull,  0),  "10109010010000000000");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull,  0),  "18446744073709551610");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull,  0),  "18446744073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull,  0),  "18446744073709551615");
 
   // decimal point 1
-  ASSERT_EQ(print_money_brief(                   0,  1),                    "0.0");
-  ASSERT_EQ(print_money_brief(                   1,  1),                    "0.1");
-  ASSERT_EQ(print_money_brief(       1000000000000,  1),         "100000000000.0");
-  ASSERT_EQ(print_money_brief(       1900000000000,  1),         "190000000000.0");
-  ASSERT_EQ(print_money_brief(       1000000100000,  1),         "100000010000.0");
-  ASSERT_EQ(print_money_brief(       1000000000001,  1),         "100000000000.1");
-  ASSERT_EQ(print_money_brief(       9999999999999,  1),         "999999999999.9");
-  ASSERT_EQ(print_money_brief(      90009990009900,  1),        "9000999000990.0");
-  ASSERT_EQ(print_money_brief(10109010000000000000,  1),  "1010901000000000000.0");
-  ASSERT_EQ(print_money_brief(10109010010000000000,  1),  "1010901001000000000.0");
-  ASSERT_EQ(print_money_brief(18446744073709551610,  1),  "1844674407370955161.0");
-  ASSERT_EQ(print_money_brief(18446744073709551614,  1),  "1844674407370955161.4");
-  ASSERT_EQ(print_money_brief(18446744073709551615,  1),  "1844674407370955161.5");
+  ASSERT_EQ(print_money_brief(                   0ull,  1),                    "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull,  1),                    "0.1");
+  ASSERT_EQ(print_money_brief(       1000000000000ull,  1),         "100000000000.0");
+  ASSERT_EQ(print_money_brief(       1900000000000ull,  1),         "190000000000.0");
+  ASSERT_EQ(print_money_brief(       1000000100000ull,  1),         "100000010000.0");
+  ASSERT_EQ(print_money_brief(       1000000000001ull,  1),         "100000000000.1");
+  ASSERT_EQ(print_money_brief(       9999999999999ull,  1),         "999999999999.9");
+  ASSERT_EQ(print_money_brief(      90009990009900ull,  1),        "9000999000990.0");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull,  1),  "1010901000000000000.0");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull,  1),  "1010901001000000000.0");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull,  1),  "1844674407370955161.0");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull,  1),  "1844674407370955161.4");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull,  1),  "1844674407370955161.5");
 
   // decimal point 2
-  ASSERT_EQ(print_money_brief(                   0,  2),                   "0.0");
-  ASSERT_EQ(print_money_brief(                   1,  2),                   "0.01");
-  ASSERT_EQ(print_money_brief(       1000000000000,  2),         "10000000000.0");
-  ASSERT_EQ(print_money_brief(       1900000000000,  2),         "19000000000.0");
-  ASSERT_EQ(print_money_brief(       1000000100000,  2),         "10000001000.0");
-  ASSERT_EQ(print_money_brief(       1000000000001,  2),         "10000000000.01");
-  ASSERT_EQ(print_money_brief(       9999999999999,  2),         "99999999999.99");
-  ASSERT_EQ(print_money_brief(      90009990009900,  2),        "900099900099.0");
-  ASSERT_EQ(print_money_brief(10109010000000000000,  2),  "101090100000000000.0");
-  ASSERT_EQ(print_money_brief(10109010010000000000,  2),  "101090100100000000.0");
-  ASSERT_EQ(print_money_brief(18446744073709551610,  2),  "184467440737095516.1");
-  ASSERT_EQ(print_money_brief(18446744073709551614,  2),  "184467440737095516.14");
-  ASSERT_EQ(print_money_brief(18446744073709551615,  2),  "184467440737095516.15");
+  ASSERT_EQ(print_money_brief(                   0ull,  2),                   "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull,  2),                   "0.01");
+  ASSERT_EQ(print_money_brief(       1000000000000ull,  2),         "10000000000.0");
+  ASSERT_EQ(print_money_brief(       1900000000000ull,  2),         "19000000000.0");
+  ASSERT_EQ(print_money_brief(       1000000100000ull,  2),         "10000001000.0");
+  ASSERT_EQ(print_money_brief(       1000000000001ull,  2),         "10000000000.01");
+  ASSERT_EQ(print_money_brief(       9999999999999ull,  2),         "99999999999.99");
+  ASSERT_EQ(print_money_brief(      90009990009900ull,  2),        "900099900099.0");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull,  2),  "101090100000000000.0");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull,  2),  "101090100100000000.0");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull,  2),  "184467440737095516.1");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull,  2),  "184467440737095516.14");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull,  2),  "184467440737095516.15");
 
   // decimal point 3
-  ASSERT_EQ(print_money_brief(                   0,  3),                  "0.0");
-  ASSERT_EQ(print_money_brief(                   1,  3),                  "0.001");
-  ASSERT_EQ(print_money_brief(       1000000000000,  3),         "1000000000.0");
-  ASSERT_EQ(print_money_brief(       1900000000000,  3),         "1900000000.0");
-  ASSERT_EQ(print_money_brief(       1000000100000,  3),         "1000000100.0");
-  ASSERT_EQ(print_money_brief(       1000000000001,  3),         "1000000000.001");
-  ASSERT_EQ(print_money_brief(       9999999999999,  3),         "9999999999.999");
-  ASSERT_EQ(print_money_brief(      90009990009900,  3),        "90009990009.9");
-  ASSERT_EQ(print_money_brief(10109010000000000000,  3),  "10109010000000000.0");
-  ASSERT_EQ(print_money_brief(10109010010000000000,  3),  "10109010010000000.0");
-  ASSERT_EQ(print_money_brief(18446744073709551610,  3),  "18446744073709551.61");
-  ASSERT_EQ(print_money_brief(18446744073709551614,  3),  "18446744073709551.614");
-  ASSERT_EQ(print_money_brief(18446744073709551615,  3),  "18446744073709551.615");
+  ASSERT_EQ(print_money_brief(                   0ull,  3),                  "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull,  3),                  "0.001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull,  3),         "1000000000.0");
+  ASSERT_EQ(print_money_brief(       1900000000000ull,  3),         "1900000000.0");
+  ASSERT_EQ(print_money_brief(       1000000100000ull,  3),         "1000000100.0");
+  ASSERT_EQ(print_money_brief(       1000000000001ull,  3),         "1000000000.001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull,  3),         "9999999999.999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull,  3),        "90009990009.9");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull,  3),  "10109010000000000.0");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull,  3),  "10109010010000000.0");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull,  3),  "18446744073709551.61");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull,  3),  "18446744073709551.614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull,  3),  "18446744073709551.615");
 
   // decimal point 18
-  ASSERT_EQ(print_money_brief(                   0, 18),   "0.0");
-  ASSERT_EQ(print_money_brief(                   1, 18),   "0.000000000000000001");
-  ASSERT_EQ(print_money_brief(       1000000000000, 18),   "0.000001");
-  ASSERT_EQ(print_money_brief(       1900000000000, 18),   "0.0000019");
-  ASSERT_EQ(print_money_brief(       1000000100000, 18),   "0.0000010000001");
-  ASSERT_EQ(print_money_brief(       1000000000001, 18),   "0.000001000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999, 18),   "0.000009999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900, 18),   "0.0000900099900099");
-  ASSERT_EQ(print_money_brief(10109010000000000000, 18),  "10.10901");
-  ASSERT_EQ(print_money_brief(10109010010000000000, 18),  "10.10901001");
-  ASSERT_EQ(print_money_brief(18446744073709551610, 18),  "18.44674407370955161");
-  ASSERT_EQ(print_money_brief(18446744073709551614, 18),  "18.446744073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615, 18),  "18.446744073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull, 18),   "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull, 18),   "0.000000000000000001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull, 18),   "0.000001");
+  ASSERT_EQ(print_money_brief(       1900000000000ull, 18),   "0.0000019");
+  ASSERT_EQ(print_money_brief(       1000000100000ull, 18),   "0.0000010000001");
+  ASSERT_EQ(print_money_brief(       1000000000001ull, 18),   "0.000001000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull, 18),   "0.000009999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull, 18),   "0.0000900099900099");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull, 18),  "10.10901");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull, 18),  "10.10901001");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull, 18),  "18.44674407370955161");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull, 18),  "18.446744073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull, 18),  "18.446744073709551615");
 
   // decimal point 19
-  ASSERT_EQ(print_money_brief(                   0, 19),  "0.0");
-  ASSERT_EQ(print_money_brief(                   1, 19),  "0.0000000000000000001");
-  ASSERT_EQ(print_money_brief(       1000000000000, 19),  "0.0000001");
-  ASSERT_EQ(print_money_brief(       1900000000000, 19),  "0.00000019");
-  ASSERT_EQ(print_money_brief(       1000000100000, 19),  "0.00000010000001");
-  ASSERT_EQ(print_money_brief(       1000000000001, 19),  "0.0000001000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999, 19),  "0.0000009999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900, 19),  "0.00000900099900099");
-  ASSERT_EQ(print_money_brief(10109010000000000000, 19),  "1.010901");
-  ASSERT_EQ(print_money_brief(10109010010000000000, 19),  "1.010901001");
-  ASSERT_EQ(print_money_brief(18446744073709551610, 19),  "1.844674407370955161");
-  ASSERT_EQ(print_money_brief(18446744073709551614, 19),  "1.8446744073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615, 19),  "1.8446744073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull, 19),  "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull, 19),  "0.0000000000000000001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull, 19),  "0.0000001");
+  ASSERT_EQ(print_money_brief(       1900000000000ull, 19),  "0.00000019");
+  ASSERT_EQ(print_money_brief(       1000000100000ull, 19),  "0.00000010000001");
+  ASSERT_EQ(print_money_brief(       1000000000001ull, 19),  "0.0000001000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull, 19),  "0.0000009999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull, 19),  "0.00000900099900099");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull, 19),  "1.010901");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull, 19),  "1.010901001");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull, 19),  "1.844674407370955161");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull, 19),  "1.8446744073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull, 19),  "1.8446744073709551615");
 
   // TODO: remove it after setting reasonable limit of 18
   // decimal point 20
-  ASSERT_EQ(print_money_brief(                   0, 20),  "0.0");
-  ASSERT_EQ(print_money_brief(                   1, 20),  "0.00000000000000000001");
-  ASSERT_EQ(print_money_brief(       1000000000000, 20),  "0.00000001");
-  ASSERT_EQ(print_money_brief(       1900000000000, 20),  "0.000000019");
-  ASSERT_EQ(print_money_brief(       1000000100000, 20),  "0.000000010000001");
-  ASSERT_EQ(print_money_brief(       1000000000001, 20),  "0.00000001000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999, 20),  "0.00000009999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900, 20),  "0.000000900099900099");
-  ASSERT_EQ(print_money_brief(10109010000000000000, 20),  "0.1010901");
-  ASSERT_EQ(print_money_brief(10109010010000000000, 20),  "0.1010901001");
-  ASSERT_EQ(print_money_brief(18446744073709551610, 20),  "0.1844674407370955161");
-  ASSERT_EQ(print_money_brief(18446744073709551614, 20),  "0.18446744073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615, 20),  "0.18446744073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull, 20),  "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull, 20),  "0.00000000000000000001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull, 20),  "0.00000001");
+  ASSERT_EQ(print_money_brief(       1900000000000ull, 20),  "0.000000019");
+  ASSERT_EQ(print_money_brief(       1000000100000ull, 20),  "0.000000010000001");
+  ASSERT_EQ(print_money_brief(       1000000000001ull, 20),  "0.00000001000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull, 20),  "0.00000009999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull, 20),  "0.000000900099900099");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull, 20),  "0.1010901");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull, 20),  "0.1010901001");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull, 20),  "0.1844674407370955161");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull, 20),  "0.18446744073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull, 20),  "0.18446744073709551615");
 
   // TODO: remove it after setting reasonable limit of 18
   // decimal point 21
-  ASSERT_EQ(print_money_brief(                   0, 21),  "0.0");
-  ASSERT_EQ(print_money_brief(                   1, 21),  "0.000000000000000000001");
-  ASSERT_EQ(print_money_brief(       1000000000000, 21),  "0.000000001");
-  ASSERT_EQ(print_money_brief(       1900000000000, 21),  "0.0000000019");
-  ASSERT_EQ(print_money_brief(       1000000100000, 21),  "0.0000000010000001");
-  ASSERT_EQ(print_money_brief(       1000000000001, 21),  "0.000000001000000000001");
-  ASSERT_EQ(print_money_brief(       9999999999999, 21),  "0.000000009999999999999");
-  ASSERT_EQ(print_money_brief(      90009990009900, 21),  "0.0000000900099900099");
-  ASSERT_EQ(print_money_brief(10109010000000000000, 21),  "0.01010901");
-  ASSERT_EQ(print_money_brief(10109010010000000000, 21),  "0.01010901001");
-  ASSERT_EQ(print_money_brief(18446744073709551610, 21),  "0.01844674407370955161");
-  ASSERT_EQ(print_money_brief(18446744073709551614, 21),  "0.018446744073709551614");
-  ASSERT_EQ(print_money_brief(18446744073709551615, 21),  "0.018446744073709551615");
+  ASSERT_EQ(print_money_brief(                   0ull, 21),  "0.0");
+  ASSERT_EQ(print_money_brief(                   1ull, 21),  "0.000000000000000000001");
+  ASSERT_EQ(print_money_brief(       1000000000000ull, 21),  "0.000000001");
+  ASSERT_EQ(print_money_brief(       1900000000000ull, 21),  "0.0000000019");
+  ASSERT_EQ(print_money_brief(       1000000100000ull, 21),  "0.0000000010000001");
+  ASSERT_EQ(print_money_brief(       1000000000001ull, 21),  "0.000000001000000000001");
+  ASSERT_EQ(print_money_brief(       9999999999999ull, 21),  "0.000000009999999999999");
+  ASSERT_EQ(print_money_brief(      90009990009900ull, 21),  "0.0000000900099900099");
+  ASSERT_EQ(print_money_brief(10109010000000000000ull, 21),  "0.01010901");
+  ASSERT_EQ(print_money_brief(10109010010000000000ull, 21),  "0.01010901001");
+  ASSERT_EQ(print_money_brief(18446744073709551610ull, 21),  "0.01844674407370955161");
+  ASSERT_EQ(print_money_brief(18446744073709551614ull, 21),  "0.018446744073709551614");
+  ASSERT_EQ(print_money_brief(18446744073709551615ull, 21),  "0.018446744073709551615");
 }
diff --git a/tests/unit_tests/fork_choice_rule.cpp b/tests/unit_tests/fork_choice_rule.cpp
index 33014781..1f15eced 100644
--- a/tests/unit_tests/fork_choice_rule.cpp
+++ b/tests/unit_tests/fork_choice_rule.cpp
@@ -88,62 +88,1819 @@ bool if_alt_chain_stronger_hf4(const currency::wide_difficulty_type& pos, const
     return true;
   return false;
 }
+
+
+bool less_or_equal(const currency::wide_difficulty_type& pos, const currency::wide_difficulty_type& pow) {
+  // Example predicate: less or equal to a certain target
+  return !if_alt_chain_stronger_hf4(pos, pow);//mid <= target;
+}
+
+currency::wide_difficulty_type binary_search_custom(currency::wide_difficulty_type low, currency::wide_difficulty_type high, std::function<bool(const currency::wide_difficulty_type&)> less_or_equal) {
+  while (low < high) 
+  {
+    currency::wide_difficulty_type mid = low + (high - low) / 2;
+
+    if (less_or_equal(mid)) {
+      low = mid + 1;
+      LOG_PRINT_L0("mid: less_or_eq_true: " << mid);
+    }
+    else {
+      high = mid;
+      LOG_PRINT_L0("mid: less_or_eq_false: " << mid);
+    }
+  }
+  LOG_PRINT_L0("ret_low: " << low);
+  return low;
+}
+
+currency::wide_difficulty_type find_break_point(const currency::wide_difficulty_type& pos, const currency::wide_difficulty_type& pow)
+{
+  currency::wide_difficulty_type last_takeover_pow = binary_search_custom(0, pow, [&](const currency::wide_difficulty_type& pow_mid) {
+      return less_or_equal(pos, pow_mid);
+    });
+
+  return last_takeover_pow;
+  /*for (currency::wide_difficulty_type pow_now = pow; pow_now != 0; pow_now--)
+  {
+    if(!if_alt_chain_stronger_hf4(pos, pow))
+    {
+      if (pow == pow_now)
+        return 0;
+      return last_takeover_pow;
+    }
+  }*/
+}
+
 TEST(fork_choice_rule_test, fork_choice_rule_test_hf4)
 {
   std::stringstream ss;
   currency::wide_difficulty_type pos_start, pos_end, pos_step, pos_diveder;
-  pos_start.assign("16059734679876525341203446");
-  pos_end.assign  ("16059734679876525341203446400");
-  pos_step.assign ("50000000000000000000000000");
+  pos_start.assign ("500000000000000000000000000");//pos_start.assign("16059734679876525341203446");
+  //                1605973467987652534120344647  <- split point
+  pos_end.assign  ("2500000000000000000000000000");//pos_end.assign  ("16059734679876525341203446400");
+  pos_step.assign ("5000000000000000000000000");
   pos_diveder.assign("100000000000000000000000");
 
   currency::wide_difficulty_type pow_start, pow_end, pow_step, pow_diveder;
-  pow_start.assign("301126455400284498");
-  pow_end.assign  ("30112645540028449810");
-  pow_step.assign ("500000000000000000");
+  pow_start.assign("30112645540028449");   //pow_start.assign("301126455400284498");
+  //                  3011264554002844981     <- split point
+  pow_end.assign  ("301126455400284498100");//  pow_end.assign  ("30112645540028449810");
+  pow_step.assign   ("5000000000000000");
   pow_diveder.assign("1000000000000000");
 
 
+  /************************************************************************
   for (currency::wide_difficulty_type pos = pos_start; pos < pos_end; pos += pos_step)
   {
     for (currency::wide_difficulty_type pow = pow_start; pow < pow_end; pow += pow_step)
     {
       bool r = if_alt_chain_stronger_hf4(pos, pow);
-      if(r)
-        ss << pos/ pos_diveder << "\t" << pow / pow_diveder << std::endl;
-        //ss << pos << "\t" << pow << "\t" << (r ? "1" : "0") << std::endl;     
+      if (r)
+      {
+        ss << pos / pos_diveder << "\t" << pow / pow_diveder << std::endl;
+        break;
+      }
+      //ss << pos << "\t" << pow << "\t" << (r ? "1" : "0") << std::endl;     
     }
   }
   bool r = epee::file_io_utils::save_string_to_file("stat_hf4.txt", ss.str());
+  
+  latest results:
+  https://docs.google.com/spreadsheets/d/e/2PACX-1vSan0_LNlMTzFXTUPc1CxAqeV4RPh-19YLicpNIjPxBcW2BLMjQK06A_tL4GdckXrYotRDD-FlCONvr/pubhtml
+
+    
+  ************************************************************************/
+
+  /*
+  std::vector<std::pair<uint64_t, uint64_t>> break_points_init = {
+    {8100, 173895},
+    {8150, 102145},
+{8200, 72570},
+{8250, 56430},
+{8300, 46265},
+{8350, 39275},
+{8400, 34170},
+{8450, 30285},
+{8500, 27225},
+{8550, 24750},
+{8600, 22715},
+{8650, 21005},
+{8700, 19550},
+{8750, 18295},
+{8800, 17205},
+{8850, 16250},
+{8900, 15400},
+{8950, 14645},
+{9000, 13970},
+{9050, 13360},
+{9100, 12805},
+{9150, 12300},
+{9200, 11840},
+{9250, 11415},
+{9300, 11025},
+{9350, 10665},
+{9400, 10330},
+{9450, 10020},
+{9500, 9730},
+{9550, 9460},
+{9600, 9210},
+{9650, 8970},
+{9700, 8745},
+{9750, 8535},
+{9800, 8340},
+{9850, 8150},
+{9900, 7975},
+{9950, 7805},
+{10000, 7645},
+{10050, 7495},
+{10100, 7350},
+{10150, 7210},
+{10200, 7080},
+{10250, 6955},
+{10300, 6835},
+{10350, 6720},
+{10400, 6610},
+{10450, 6505},
+{10500, 6405},
+{10550, 6305},
+{10600, 6210},
+{10650, 6120},
+{10700, 6035},
+{10750, 5955},
+{10800, 5870},
+{10850, 5795},
+{10900, 5720},
+{10950, 5650},
+{11000, 5580},
+{11050, 5510},
+{11100, 5445},
+{11150, 5385},
+{11200, 5320},
+{11250, 5265},
+{11300, 5205},
+{11350, 5150},
+{11400, 5095},
+{11450, 5045},
+{11500, 4990},
+{11550, 4945},
+{11600, 4895},
+{11650, 4850},
+{11700, 4800},
+{11750, 4760},
+{11800, 4715},
+{11850, 4675},
+{11900, 4630},
+{11950, 4590},
+{12000, 4555},
+{12050, 4515},
+{12100, 4480},
+{12150, 4440},
+{12200, 4405},
+{12250, 4375},
+{12300, 4340},
+{12350, 4305},
+{12400, 4275},
+{12450, 4245},
+{12500, 4215},
+{12550, 4185},
+{12600, 4155},
+{12650, 4125},
+{12700, 4095},
+{12750, 4070},
+{12800, 4045},
+{12850, 4015},
+{12900, 3990},
+{12950, 3965},
+{13000, 3940},
+{13050, 3915},
+{13100, 3895},
+{13150, 3870},
+{13200, 3845},
+{13250, 3825},
+{13300, 3800},
+{13350, 3780},
+{13400, 3760},
+{13450, 3740},
+{13500, 3720},
+{13550, 3700},
+{13600, 3680},
+{13650, 3660},
+{13700, 3640},
+{13750, 3620},
+{13800, 3605},
+{13850, 3585},
+{13900, 3570},
+{13950, 3550},
+{14000, 3535},
+{14050, 3515},
+{14100, 3500},
+{14150, 3485},
+{14200, 3465},
+{14250, 3450},
+{14300, 3435},
+{14350, 3420},
+{14400, 3405},
+{14450, 3390},
+{14500, 3375},
+{14550, 3360},
+{14600, 3350},
+{14650, 3335},
+{14700, 3320},
+{14750, 3305},
+{14800, 3295},
+{14850, 3280},
+{14900, 3270},
+{14950, 3255},
+{15000, 3245},
+{15050, 3230},
+{15100, 3220},
+{15150, 3205},
+{15200, 3195},
+{15250, 3185},
+{15300, 3170},
+{15350, 3160},
+{15400, 3150},
+{15450, 3135},
+{15500, 3125},
+{15550, 3115},
+{15600, 3105},
+{15650, 3095},
+{15700, 3085},
+{15750, 3075},
+{15800, 3065},
+{15850, 3055},
+{15900, 3045},
+{15950, 3035},
+{16000, 3025},
+{16050, 3015},
+{16100, 3005},
+{16150, 2995},
+{16200, 2990},
+{16250, 2980},
+{16300, 2970},
+{16350, 2960},
+{16400, 2950},
+{16450, 2945},
+{16500, 2935},
+{16550, 2925},
+{16600, 2920},
+{16650, 2910},
+{16700, 2900},
+{16750, 2895},
+{16800, 2885},
+{16850, 2880},
+{16900, 2870},
+{16950, 2865},
+{17000, 2855},
+{17050, 2850},
+{17100, 2840},
+{17150, 2835},
+{17200, 2825},
+{17250, 2820},
+{17300, 2810},
+{17350, 2805},
+{17400, 2800},
+{17450, 2790},
+{17500, 2785},
+{17550, 2780},
+{17600, 2770},
+{17650, 2765},
+{17700, 2760},
+{17750, 2750},
+{17800, 2745},
+{17850, 2740},
+{17900, 2735},
+{17950, 2725},
+{18000, 2720},
+{18050, 2715},
+{18100, 2710},
+{18150, 2705},
+{18200, 2695},
+{18250, 2690},
+{18300, 2685},
+{18350, 2680},
+{18400, 2675},
+{18450, 2670},
+{18500, 2665},
+{18550, 2655},
+{18600, 2650},
+{18650, 2645},
+{18700, 2640},
+{18750, 2635},
+{18800, 2630},
+{18850, 2625},
+{18900, 2620},
+{18950, 2615},
+{19000, 2610},
+{19050, 2605},
+{19100, 2600},
+{19150, 2595},
+{19200, 2590},
+{19250, 2585},
+{19300, 2580},
+{19350, 2575},
+{19400, 2570},
+{19450, 2565},
+{19500, 2560},
+{19550, 2555},
+{19600, 2555},
+{19650, 2550},
+{19700, 2545},
+{19750, 2540},
+{19800, 2535},
+{19850, 2530},
+{19900, 2525},
+{19950, 2520},
+{20000, 2520},
+{20050, 2515},
+{20100, 2510},
+{20150, 2505},
+{20200, 2500},
+{20250, 2495},
+{20300, 2495},
+{20350, 2490},
+{20400, 2485},
+{20450, 2480},
+{20500, 2480},
+{20550, 2475},
+{20600, 2470},
+{20650, 2465},
+{20700, 2460},
+{20750, 2460},
+{20800, 2455},
+{20850, 2450},
+{20900, 2445},
+{20950, 2445},
+{21000, 2440},
+{21050, 2435},
+{21100, 2435},
+{21150, 2430},
+{21200, 2425},
+{21250, 2425},
+{21300, 2420},
+{21350, 2415},
+{21400, 2410},
+{21450, 2410},
+{21500, 2405},
+{21550, 2400},
+{21600, 2400},
+{21650, 2395},
+{21700, 2390},
+{21750, 2390},
+{21800, 2385},
+{21850, 2385},
+{21900, 2380},
+{21950, 2375},
+{22000, 2375},
+{22050, 2370},
+{22100, 2365},
+{22150, 2365},
+{22200, 2360},
+{22250, 2360},
+{22300, 2355},
+{22350, 2350},
+{22400, 2350},
+{22450, 2345},
+{22500, 2345},
+{22550, 2340},
+{22600, 2340},
+{22650, 2335},
+{22700, 2330},
+{22750, 2330},
+{22800, 2325},
+{22850, 2325},
+{22900, 2320},
+{22950, 2320},
+{23000, 2315},
+{23050, 2315},
+{23100, 2310},
+{23150, 2310},
+{23200, 2305},
+{23250, 2300},
+{23300, 2300},
+{23350, 2295},
+{23400, 2295},
+{23450, 2290},
+{23500, 2290},
+{23550, 2285},
+{23600, 2285},
+{23650, 2280},
+{23700, 2280},
+{23750, 2275},
+{23800, 2275},
+{23850, 2270},
+{23900, 2270},
+{23950, 2265},
+{24000, 2265},
+{24050, 2265},
+{24100, 2260},
+{24150, 2260},
+{24200, 2255},
+{24250, 2255},
+{24300, 2250},
+{24350, 2250},
+{24400, 2245},
+{24450, 2245},
+{24500, 2240},
+{24550, 2240},
+{24600, 2240},
+{24650, 2235},
+{24700, 2235},
+{24750, 2230},
+{24800, 2230},
+{24850, 2225},
+{24900, 2225},
+{24950, 2225}
+  };*/
+  /*
+  //std::stringstream ss;
+  for (auto bp : break_points_init)
+  {
+    currency::wide_difficulty_type pow_takeover_point = find_break_point(pos_diveder * bp.first, (pow_diveder * bp.second) + pow_step);
+
+    if (pow_takeover_point == 0)
+    {
+      LOG_ERROR("Failed");
+    }
+    else
+    {
+      //self check 
+      if (if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point - 1) == if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point))
+      {
+        bool rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point+1);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point+2);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point+3);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point-1);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point-2);
+        rfrf = if_alt_chain_stronger_hf4(pos_diveder * bp.first, pow_takeover_point - 3);
 
 
+
+        LOG_ERROR("ERROR");
+        return;
+      }
+      ss <<
+        "res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type(\"" << pos_diveder * bp.first << "\"), currency::wide_difficulty_type(\"" << pow_takeover_point << "\"));" << ENDL <<
+        "ASSERT_TRUE(res);" << ENDL <<
+        "res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type(\"" << pos_diveder * bp.first << "\"), currency::wide_difficulty_type(\"" << pow_takeover_point - 1 << "\"));" << ENDL <<
+        "ASSERT_FALSE(res);" << ENDL;
+    }
+  }
+  bool r = epee::file_io_utils::save_string_to_file("script.txt", ss.str());
+  */
   bool res = false;
-  res = if_alt_chain_stronger_hf4(1000000, 1000);
-  ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(1000000, 1500);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("810000000000000000000000000"), currency::wide_difficulty_type("173893610095151033482"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(800000, 1700);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("810000000000000000000000000"), currency::wide_difficulty_type("173893610095151033481"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(800000, 2000);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("815000000000000000000000000"), currency::wide_difficulty_type("102144604566780242768"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(600000, 2200);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("815000000000000000000000000"), currency::wide_difficulty_type("102144604566780242767"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(600000, 2800);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("820000000000000000000000000"), currency::wide_difficulty_type("72567987045706043158"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(400000, 3999);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("820000000000000000000000000"), currency::wide_difficulty_type("72567987045706043157"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(400000, 4001);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("825000000000000000000000000"), currency::wide_difficulty_type("56427184779296592563"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(200000, 7000);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("825000000000000000000000000"), currency::wide_difficulty_type("56427184779296592562"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(200000, 7700);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("830000000000000000000000000"), currency::wide_difficulty_type("46261521639981421968"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(200000, 7000);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("830000000000000000000000000"), currency::wide_difficulty_type("46261521639981421967"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(200000, 7700);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("835000000000000000000000000"), currency::wide_difficulty_type("39271311807228203073"));
   ASSERT_TRUE(res);
-  res = if_alt_chain_stronger_hf4(100000, 10000);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("835000000000000000000000000"), currency::wide_difficulty_type("39271311807228203072"));
   ASSERT_FALSE(res);
-  res = if_alt_chain_stronger_hf4(200000, 14000);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("840000000000000000000000000"), currency::wide_difficulty_type("34169670746435628497"));
   ASSERT_TRUE(res);
-}
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("840000000000000000000000000"), currency::wide_difficulty_type("34169670746435628496"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("845000000000000000000000000"), currency::wide_difficulty_type("30282322585424495014"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("845000000000000000000000000"), currency::wide_difficulty_type("30282322585424495013"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("850000000000000000000000000"), currency::wide_difficulty_type("27221836391522953727"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("850000000000000000000000000"), currency::wide_difficulty_type("27221836391522953726"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("855000000000000000000000000"), currency::wide_difficulty_type("24749755123691287729"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("855000000000000000000000000"), currency::wide_difficulty_type("24749755123691287728"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("860000000000000000000000000"), currency::wide_difficulty_type("22711271409727869596"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("860000000000000000000000000"), currency::wide_difficulty_type("22711271409727869595"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("865000000000000000000000000"), currency::wide_difficulty_type("21001505056620832872"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("865000000000000000000000000"), currency::wide_difficulty_type("21001505056620832871"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("870000000000000000000000000"), currency::wide_difficulty_type("19546877193995594351"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("870000000000000000000000000"), currency::wide_difficulty_type("19546877193995594350"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("875000000000000000000000000"), currency::wide_difficulty_type("18294243761466129083"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("875000000000000000000000000"), currency::wide_difficulty_type("18294243761466129082"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("880000000000000000000000000"), currency::wide_difficulty_type("17204261972931225543"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("880000000000000000000000000"), currency::wide_difficulty_type("17204261972931225542"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("885000000000000000000000000"), currency::wide_difficulty_type("16247183291614714294"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("885000000000000000000000000"), currency::wide_difficulty_type("16247183291614714293"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("890000000000000000000000000"), currency::wide_difficulty_type("15400096882194836021"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("890000000000000000000000000"), currency::wide_difficulty_type("15400096882194836020"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("895000000000000000000000000"), currency::wide_difficulty_type("14645071807644110435"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("895000000000000000000000000"), currency::wide_difficulty_type("14645071807644110434"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("900000000000000000000000000"), currency::wide_difficulty_type("13967873725795875372"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("900000000000000000000000000"), currency::wide_difficulty_type("13967873725795875371"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("905000000000000000000000000"), currency::wide_difficulty_type("13357058979013812170"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("905000000000000000000000000"), currency::wide_difficulty_type("13357058979013812169"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("910000000000000000000000000"), currency::wide_difficulty_type("12803322645925507695"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("910000000000000000000000000"), currency::wide_difficulty_type("12803322645925507694"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("915000000000000000000000000"), currency::wide_difficulty_type("12299021201474213830"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("915000000000000000000000000"), currency::wide_difficulty_type("12299021201474213829"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("920000000000000000000000000"), currency::wide_difficulty_type("11837817557953003092"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("920000000000000000000000000"), currency::wide_difficulty_type("11837817557953003091"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("925000000000000000000000000"), currency::wide_difficulty_type("11414413381540383189"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("925000000000000000000000000"), currency::wide_difficulty_type("11414413381540383188"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("930000000000000000000000000"), currency::wide_difficulty_type("11024344634545981648"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("930000000000000000000000000"), currency::wide_difficulty_type("11024344634545981647"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("935000000000000000000000000"), currency::wide_difficulty_type("10663823580658131959"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("935000000000000000000000000"), currency::wide_difficulty_type("10663823580658131958"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("940000000000000000000000000"), currency::wide_difficulty_type("10329615384232683380"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("940000000000000000000000000"), currency::wide_difficulty_type("10329615384232683379"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("945000000000000000000000000"), currency::wide_difficulty_type("10018940777719244821"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("945000000000000000000000000"), currency::wide_difficulty_type("10018940777719244820"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("950000000000000000000000000"), currency::wide_difficulty_type("9729398591085546371"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("950000000000000000000000000"), currency::wide_difficulty_type("9729398591085546370"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("955000000000000000000000000"), currency::wide_difficulty_type("9458903570152632164"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("955000000000000000000000000"), currency::wide_difficulty_type("9458903570152632163"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("960000000000000000000000000"), currency::wide_difficulty_type("9205636075772937886"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("960000000000000000000000000"), currency::wide_difficulty_type("9205636075772937885"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("965000000000000000000000000"), currency::wide_difficulty_type("8968001097212660715"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("965000000000000000000000000"), currency::wide_difficulty_type("8968001097212660714"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("970000000000000000000000000"), currency::wide_difficulty_type("8744594627814733132"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("970000000000000000000000000"), currency::wide_difficulty_type("8744594627814733131"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("975000000000000000000000000"), currency::wide_difficulty_type("8534175904919445023"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("975000000000000000000000000"), currency::wide_difficulty_type("8534175904919445022"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("980000000000000000000000000"), currency::wide_difficulty_type("8335644354530648558"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("980000000000000000000000000"), currency::wide_difficulty_type("8335644354530648557"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("985000000000000000000000000"), currency::wide_difficulty_type("8148020336034723158"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("985000000000000000000000000"), currency::wide_difficulty_type("8148020336034723157"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("990000000000000000000000000"), currency::wide_difficulty_type("7970428975782931705"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("990000000000000000000000000"), currency::wide_difficulty_type("7970428975782931704"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("995000000000000000000000000"), currency::wide_difficulty_type("7802086526502014600"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("995000000000000000000000000"), currency::wide_difficulty_type("7802086526502014599"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1000000000000000000000000000"), currency::wide_difficulty_type("7642288803812028782"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1000000000000000000000000000"), currency::wide_difficulty_type("7642288803812028781"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1005000000000000000000000000"), currency::wide_difficulty_type("7490401339980245977"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1005000000000000000000000000"), currency::wide_difficulty_type("7490401339980245976"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1010000000000000000000000000"), currency::wide_difficulty_type("7345850964575793868"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1010000000000000000000000000"), currency::wide_difficulty_type("7345850964575793867"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1015000000000000000000000000"), currency::wide_difficulty_type("7208118576466544449"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1015000000000000000000000000"), currency::wide_difficulty_type("7208118576466544448"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1020000000000000000000000000"), currency::wide_difficulty_type("7076732915018020514"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1020000000000000000000000000"), currency::wide_difficulty_type("7076732915018020513"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1025000000000000000000000000"), currency::wide_difficulty_type("6951265172971883569"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1025000000000000000000000000"), currency::wide_difficulty_type("6951265172971883568"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1030000000000000000000000000"), currency::wide_difficulty_type("6831324321237202029"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1030000000000000000000000000"), currency::wide_difficulty_type("6831324321237202028"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1035000000000000000000000000"), currency::wide_difficulty_type("6716553038200005653"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1035000000000000000000000000"), currency::wide_difficulty_type("6716553038200005652"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1040000000000000000000000000"), currency::wide_difficulty_type("6606624154281270723"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1040000000000000000000000000"), currency::wide_difficulty_type("6606624154281270722"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1045000000000000000000000000"), currency::wide_difficulty_type("6501237537228019549"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1045000000000000000000000000"), currency::wide_difficulty_type("6501237537228019548"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1050000000000000000000000000"), currency::wide_difficulty_type("6400117355688827656"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1050000000000000000000000000"), currency::wide_difficulty_type("6400117355688827655"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1055000000000000000000000000"), currency::wide_difficulty_type("6303009668537003243"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1055000000000000000000000000"), currency::wide_difficulty_type("6303009668537003242"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1060000000000000000000000000"), currency::wide_difficulty_type("6209680295581205260"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1060000000000000000000000000"), currency::wide_difficulty_type("6209680295581205259"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1065000000000000000000000000"), currency::wide_difficulty_type("6119912932075478362"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1065000000000000000000000000"), currency::wide_difficulty_type("6119912932075478361"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1070000000000000000000000000"), currency::wide_difficulty_type("6033507475071567420"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1070000000000000000000000000"), currency::wide_difficulty_type("6033507475071567419"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1075000000000000000000000000"), currency::wide_difficulty_type("5950278534355724202"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1075000000000000000000000000"), currency::wide_difficulty_type("5950278534355724201"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1080000000000000000000000000"), currency::wide_difficulty_type("5870054104648172855"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1080000000000000000000000000"), currency::wide_difficulty_type("5870054104648172854"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1085000000000000000000000000"), currency::wide_difficulty_type("5792674379051306677"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1085000000000000000000000000"), currency::wide_difficulty_type("5792674379051306676"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1090000000000000000000000000"), currency::wide_difficulty_type("5717990686521957375"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1090000000000000000000000000"), currency::wide_difficulty_type("5717990686521957374"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1095000000000000000000000000"), currency::wide_difficulty_type("5645864538502512988"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1095000000000000000000000000"), currency::wide_difficulty_type("5645864538502512987"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1100000000000000000000000000"), currency::wide_difficulty_type("5576166771847621697"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1100000000000000000000000000"), currency::wide_difficulty_type("5576166771847621696"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1105000000000000000000000000"), currency::wide_difficulty_type("5508776776886887265"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1105000000000000000000000000"), currency::wide_difficulty_type("5508776776886887264"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1110000000000000000000000000"), currency::wide_difficulty_type("5443581800917917808"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1110000000000000000000000000"), currency::wide_difficulty_type("5443581800917917807"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1115000000000000000000000000"), currency::wide_difficulty_type("5380476318668349354"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1115000000000000000000000000"), currency::wide_difficulty_type("5380476318668349353"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1120000000000000000000000000"), currency::wide_difficulty_type("5319361462333102716"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1120000000000000000000000000"), currency::wide_difficulty_type("5319361462333102715"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1125000000000000000000000000"), currency::wide_difficulty_type("5260144504711571647"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1125000000000000000000000000"), currency::wide_difficulty_type("5260144504711571646"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1130000000000000000000000000"), currency::wide_difficulty_type("5202738389761493946"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1130000000000000000000000000"), currency::wide_difficulty_type("5202738389761493945"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1135000000000000000000000000"), currency::wide_difficulty_type("5147061305570958556"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1135000000000000000000000000"), currency::wide_difficulty_type("5147061305570958555"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1140000000000000000000000000"), currency::wide_difficulty_type("5093036295343277653"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1140000000000000000000000000"), currency::wide_difficulty_type("5093036295343277652"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1145000000000000000000000000"), currency::wide_difficulty_type("5040590902504669188"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1145000000000000000000000000"), currency::wide_difficulty_type("5040590902504669187"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1150000000000000000000000000"), currency::wide_difficulty_type("4989656846493099358"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1150000000000000000000000000"), currency::wide_difficulty_type("4989656846493099357"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1155000000000000000000000000"), currency::wide_difficulty_type("4940169726177716516"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1155000000000000000000000000"), currency::wide_difficulty_type("4940169726177716515"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1160000000000000000000000000"), currency::wide_difficulty_type("4892068748200095632"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1160000000000000000000000000"), currency::wide_difficulty_type("4892068748200095631"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1165000000000000000000000000"), currency::wide_difficulty_type("4845296477827814285"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1165000000000000000000000000"), currency::wide_difficulty_type("4845296477827814284"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1170000000000000000000000000"), currency::wide_difficulty_type("4799798610173485225"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1170000000000000000000000000"), currency::wide_difficulty_type("4799798610173485224"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1175000000000000000000000000"), currency::wide_difficulty_type("4755523759863208997"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1175000000000000000000000000"), currency::wide_difficulty_type("4755523759863208996"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1180000000000000000000000000"), currency::wide_difficulty_type("4712423267441696058"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1180000000000000000000000000"), currency::wide_difficulty_type("4712423267441696057"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1185000000000000000000000000"), currency::wide_difficulty_type("4670451020980647133"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1185000000000000000000000000"), currency::wide_difficulty_type("4670451020980647132"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1190000000000000000000000000"), currency::wide_difficulty_type("4629563291515467266"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1190000000000000000000000000"), currency::wide_difficulty_type("4629563291515467265"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1195000000000000000000000000"), currency::wide_difficulty_type("4589718581075682727"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1195000000000000000000000000"), currency::wide_difficulty_type("4589718581075682726"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1200000000000000000000000000"), currency::wide_difficulty_type("4550877482198821754"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1200000000000000000000000000"), currency::wide_difficulty_type("4550877482198821753"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1205000000000000000000000000"), currency::wide_difficulty_type("4513002547927988098"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1205000000000000000000000000"), currency::wide_difficulty_type("4513002547927988097"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1210000000000000000000000000"), currency::wide_difficulty_type("4476058171391610675"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1210000000000000000000000000"), currency::wide_difficulty_type("4476058171391610674"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1215000000000000000000000000"), currency::wide_difficulty_type("4440010474151375716"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1215000000000000000000000000"), currency::wide_difficulty_type("4440010474151375715"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1220000000000000000000000000"), currency::wide_difficulty_type("4404827202582426266"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1220000000000000000000000000"), currency::wide_difficulty_type("4404827202582426265"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1225000000000000000000000000"), currency::wide_difficulty_type("4370477631619666641"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1225000000000000000000000000"), currency::wide_difficulty_type("4370477631619666640"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1230000000000000000000000000"), currency::wide_difficulty_type("4336932475266411512"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1230000000000000000000000000"), currency::wide_difficulty_type("4336932475266411511"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1235000000000000000000000000"), currency::wide_difficulty_type("4304163803317521313"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1235000000000000000000000000"), currency::wide_difficulty_type("4304163803317521312"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1240000000000000000000000000"), currency::wide_difficulty_type("4272144963799311315"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1240000000000000000000000000"), currency::wide_difficulty_type("4272144963799311314"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1245000000000000000000000000"), currency::wide_difficulty_type("4240850510673562277"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1245000000000000000000000000"), currency::wide_difficulty_type("4240850510673562276"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1250000000000000000000000000"), currency::wide_difficulty_type("4210256136393466936"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1250000000000000000000000000"), currency::wide_difficulty_type("4210256136393466935"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1255000000000000000000000000"), currency::wide_difficulty_type("4180338608935820328"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1255000000000000000000000000"), currency::wide_difficulty_type("4180338608935820327"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1260000000000000000000000000"), currency::wide_difficulty_type("4151075712966644396"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1260000000000000000000000000"), currency::wide_difficulty_type("4151075712966644395"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1265000000000000000000000000"), currency::wide_difficulty_type("4122446194827116866"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1265000000000000000000000000"), currency::wide_difficulty_type("4122446194827116865"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1270000000000000000000000000"), currency::wide_difficulty_type("4094429711053494243"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1270000000000000000000000000"), currency::wide_difficulty_type("4094429711053494242"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1275000000000000000000000000"), currency::wide_difficulty_type("4067006780168981652"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1275000000000000000000000000"), currency::wide_difficulty_type("4067006780168981651"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1280000000000000000000000000"), currency::wide_difficulty_type("4040158737507476210"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1280000000000000000000000000"), currency::wide_difficulty_type("4040158737507476209"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1285000000000000000000000000"), currency::wide_difficulty_type("4013867692849033231"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1285000000000000000000000000"), currency::wide_difficulty_type("4013867692849033230"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1290000000000000000000000000"), currency::wide_difficulty_type("3988116490664986212"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1290000000000000000000000000"), currency::wide_difficulty_type("3988116490664986211"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1295000000000000000000000000"), currency::wide_difficulty_type("3962888672787079503"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1295000000000000000000000000"), currency::wide_difficulty_type("3962888672787079502"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1300000000000000000000000000"), currency::wide_difficulty_type("3938168443329913124"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1300000000000000000000000000"), currency::wide_difficulty_type("3938168443329913123"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1305000000000000000000000000"), currency::wide_difficulty_type("3913940635709600402"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1305000000000000000000000000"), currency::wide_difficulty_type("3913940635709600401"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1310000000000000000000000000"), currency::wide_difficulty_type("3890190681613933281"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1310000000000000000000000000"), currency::wide_difficulty_type("3890190681613933280"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1315000000000000000000000000"), currency::wide_difficulty_type("3866904581790654891"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1315000000000000000000000000"), currency::wide_difficulty_type("3866904581790654890"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1320000000000000000000000000"), currency::wide_difficulty_type("3844068878530759853"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1320000000000000000000000000"), currency::wide_difficulty_type("3844068878530759852"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1325000000000000000000000000"), currency::wide_difficulty_type("3821670629733173919"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1325000000000000000000000000"), currency::wide_difficulty_type("3821670629733173918"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1330000000000000000000000000"), currency::wide_difficulty_type("3799697384445790394"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1330000000000000000000000000"), currency::wide_difficulty_type("3799697384445790393"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1335000000000000000000000000"), currency::wide_difficulty_type("3778137159785737024"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1335000000000000000000000000"), currency::wide_difficulty_type("3778137159785737023"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1340000000000000000000000000"), currency::wide_difficulty_type("3756978419148981611"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1340000000000000000000000000"), currency::wide_difficulty_type("3756978419148981610"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1345000000000000000000000000"), currency::wide_difficulty_type("3736210051626018480"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1345000000000000000000000000"), currency::wide_difficulty_type("3736210051626018479"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1350000000000000000000000000"), currency::wide_difficulty_type("3715821352546466165"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1350000000000000000000000000"), currency::wide_difficulty_type("3715821352546466164"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1355000000000000000000000000"), currency::wide_difficulty_type("3695802005080998506"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1355000000000000000000000000"), currency::wide_difficulty_type("3695802005080998505"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1360000000000000000000000000"), currency::wide_difficulty_type("3676142062834171471"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1360000000000000000000000000"), currency::wide_difficulty_type("3676142062834171470"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1365000000000000000000000000"), currency::wide_difficulty_type("3656831933366436577"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1365000000000000000000000000"), currency::wide_difficulty_type("3656831933366436576"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1370000000000000000000000000"), currency::wide_difficulty_type("3637862362587985060"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1370000000000000000000000000"), currency::wide_difficulty_type("3637862362587985059"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1375000000000000000000000000"), currency::wide_difficulty_type("3619224419971077733"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1375000000000000000000000000"), currency::wide_difficulty_type("3619224419971077732"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1380000000000000000000000000"), currency::wide_difficulty_type("3600909484531213505"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1380000000000000000000000000"), currency::wide_difficulty_type("3600909484531213504"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1385000000000000000000000000"), currency::wide_difficulty_type("3582909231530901607"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1385000000000000000000000000"), currency::wide_difficulty_type("3582909231530901606"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1390000000000000000000000000"), currency::wide_difficulty_type("3565215619862953101"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1390000000000000000000000000"), currency::wide_difficulty_type("3565215619862953100"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1395000000000000000000000000"), currency::wide_difficulty_type("3547820880073118287"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1395000000000000000000000000"), currency::wide_difficulty_type("3547820880073118286"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1400000000000000000000000000"), currency::wide_difficulty_type("3530717502984588252"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1400000000000000000000000000"), currency::wide_difficulty_type("3530717502984588251"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1405000000000000000000000000"), currency::wide_difficulty_type("3513898228889369242"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1405000000000000000000000000"), currency::wide_difficulty_type("3513898228889369241"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1410000000000000000000000000"), currency::wide_difficulty_type("3497356037273844307"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1410000000000000000000000000"), currency::wide_difficulty_type("3497356037273844306"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1415000000000000000000000000"), currency::wide_difficulty_type("3481084137047972976"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1415000000000000000000000000"), currency::wide_difficulty_type("3481084137047972975"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1420000000000000000000000000"), currency::wide_difficulty_type("3465075957249560147"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1420000000000000000000000000"), currency::wide_difficulty_type("3465075957249560146"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1425000000000000000000000000"), currency::wide_difficulty_type("3449325138196862568"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1425000000000000000000000000"), currency::wide_difficulty_type("3449325138196862567"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1430000000000000000000000000"), currency::wide_difficulty_type("3433825523064506644"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1430000000000000000000000000"), currency::wide_difficulty_type("3433825523064506643"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1435000000000000000000000000"), currency::wide_difficulty_type("3418571149859275151"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1435000000000000000000000000"), currency::wide_difficulty_type("3418571149859275150"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1440000000000000000000000000"), currency::wide_difficulty_type("3403556243773792521"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1440000000000000000000000000"), currency::wide_difficulty_type("3403556243773792520"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1445000000000000000000000000"), currency::wide_difficulty_type("3388775209897507173"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1445000000000000000000000000"), currency::wide_difficulty_type("3388775209897507172"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1450000000000000000000000000"), currency::wide_difficulty_type("3374222626265643002"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1450000000000000000000000000"), currency::wide_difficulty_type("3374222626265643001"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1455000000000000000000000000"), currency::wide_difficulty_type("3359893237227977874"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1455000000000000000000000000"), currency::wide_difficulty_type("3359893237227977873"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1460000000000000000000000000"), currency::wide_difficulty_type("3345781947120411526"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1460000000000000000000000000"), currency::wide_difficulty_type("3345781947120411525"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1465000000000000000000000000"), currency::wide_difficulty_type("3331883814223314654"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1465000000000000000000000000"), currency::wide_difficulty_type("3331883814223314653"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1470000000000000000000000000"), currency::wide_difficulty_type("3318194044991611032"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1470000000000000000000000000"), currency::wide_difficulty_type("3318194044991611031"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1475000000000000000000000000"), currency::wide_difficulty_type("3304707988542440156"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1475000000000000000000000000"), currency::wide_difficulty_type("3304707988542440155"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1480000000000000000000000000"), currency::wide_difficulty_type("3291421131387084121"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1480000000000000000000000000"), currency::wide_difficulty_type("3291421131387084120"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1485000000000000000000000000"), currency::wide_difficulty_type("3278329092394623406"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1485000000000000000000000000"), currency::wide_difficulty_type("3278329092394623405"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1490000000000000000000000000"), currency::wide_difficulty_type("3265427617975516113"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1490000000000000000000000000"), currency::wide_difficulty_type("3265427617975516112"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1495000000000000000000000000"), currency::wide_difficulty_type("3252712577473977564"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1495000000000000000000000000"), currency::wide_difficulty_type("3252712577473977563"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1500000000000000000000000000"), currency::wide_difficulty_type("3240179958758675520"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1500000000000000000000000000"), currency::wide_difficulty_type("3240179958758675519"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1505000000000000000000000000"), currency::wide_difficulty_type("3227825864001853654"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1505000000000000000000000000"), currency::wide_difficulty_type("3227825864001853653"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1510000000000000000000000000"), currency::wide_difficulty_type("3215646505637555347"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1510000000000000000000000000"), currency::wide_difficulty_type("3215646505637555346"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1515000000000000000000000000"), currency::wide_difficulty_type("3203638202490143865"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1515000000000000000000000000"), currency::wide_difficulty_type("3203638202490143864"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1520000000000000000000000000"), currency::wide_difficulty_type("3191797376064806144"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1520000000000000000000000000"), currency::wide_difficulty_type("3191797376064806143"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1525000000000000000000000000"), currency::wide_difficulty_type("3180120546992187929"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1525000000000000000000000000"), currency::wide_difficulty_type("3180120546992187928"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1530000000000000000000000000"), currency::wide_difficulty_type("3168604331619740064"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1530000000000000000000000000"), currency::wide_difficulty_type("3168604331619740063"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1535000000000000000000000000"), currency::wide_difficulty_type("3157245438742761163"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1535000000000000000000000000"), currency::wide_difficulty_type("3157245438742761162"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1540000000000000000000000000"), currency::wide_difficulty_type("3146040666468502645"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1540000000000000000000000000"), currency::wide_difficulty_type("3146040666468502644"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1545000000000000000000000000"), currency::wide_difficulty_type("3134986899207059697"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1545000000000000000000000000"), currency::wide_difficulty_type("3134986899207059696"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1550000000000000000000000000"), currency::wide_difficulty_type("3124081104783107851"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1550000000000000000000000000"), currency::wide_difficulty_type("3124081104783107850"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1555000000000000000000000000"), currency::wide_difficulty_type("3113320331662860805"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1555000000000000000000000000"), currency::wide_difficulty_type("3113320331662860804"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1560000000000000000000000000"), currency::wide_difficulty_type("3102701706290922296"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1560000000000000000000000000"), currency::wide_difficulty_type("3102701706290922295"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1565000000000000000000000000"), currency::wide_difficulty_type("3092222430531984521"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1565000000000000000000000000"), currency::wide_difficulty_type("3092222430531984520"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1570000000000000000000000000"), currency::wide_difficulty_type("3081879779212588752"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1570000000000000000000000000"), currency::wide_difficulty_type("3081879779212588751"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1575000000000000000000000000"), currency::wide_difficulty_type("3071671097758411764"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1575000000000000000000000000"), currency::wide_difficulty_type("3071671097758411763"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1580000000000000000000000000"), currency::wide_difficulty_type("3061593799922775157"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1580000000000000000000000000"), currency::wide_difficulty_type("3061593799922775156"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1585000000000000000000000000"), currency::wide_difficulty_type("3051645365602294788"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1585000000000000000000000000"), currency::wide_difficulty_type("3051645365602294787"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1590000000000000000000000000"), currency::wide_difficulty_type("3041823338735795027"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1590000000000000000000000000"), currency::wide_difficulty_type("3041823338735795026"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1595000000000000000000000000"), currency::wide_difficulty_type("3032125325282808256"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1595000000000000000000000000"), currency::wide_difficulty_type("3032125325282808255"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1600000000000000000000000000"), currency::wide_difficulty_type("3022548991278164715"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1600000000000000000000000000"), currency::wide_difficulty_type("3022548991278164714"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1605000000000000000000000000"), currency::wide_difficulty_type("3013092060959352101"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1605000000000000000000000000"), currency::wide_difficulty_type("3013092060959352100"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1610000000000000000000000000"), currency::wide_difficulty_type("3003752314963488897"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1610000000000000000000000000"), currency::wide_difficulty_type("3003752314963488896"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1615000000000000000000000000"), currency::wide_difficulty_type("2994527588590910913"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1615000000000000000000000000"), currency::wide_difficulty_type("2994527588590910912"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1620000000000000000000000000"), currency::wide_difficulty_type("2985415770132517377"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1620000000000000000000000000"), currency::wide_difficulty_type("2985415770132517376"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1625000000000000000000000000"), currency::wide_difficulty_type("2976414799258161798"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1625000000000000000000000000"), currency::wide_difficulty_type("2976414799258161797"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1630000000000000000000000000"), currency::wide_difficulty_type("2967522665463504146"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1630000000000000000000000000"), currency::wide_difficulty_type("2967522665463504145"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1635000000000000000000000000"), currency::wide_difficulty_type("2958737406572865050"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1635000000000000000000000000"), currency::wide_difficulty_type("2958737406572865049"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1640000000000000000000000000"), currency::wide_difficulty_type("2950057107295740304"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1640000000000000000000000000"), currency::wide_difficulty_type("2950057107295740303"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1645000000000000000000000000"), currency::wide_difficulty_type("2941479897834745142"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1645000000000000000000000000"), currency::wide_difficulty_type("2941479897834745141"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1650000000000000000000000000"), currency::wide_difficulty_type("2933003952542863155"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1650000000000000000000000000"), currency::wide_difficulty_type("2933003952542863154"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1655000000000000000000000000"), currency::wide_difficulty_type("2924627488627974429"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1655000000000000000000000000"), currency::wide_difficulty_type("2924627488627974428"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1660000000000000000000000000"), currency::wide_difficulty_type("2916348764902732061"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1660000000000000000000000000"), currency::wide_difficulty_type("2916348764902732060"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1665000000000000000000000000"), currency::wide_difficulty_type("2908166080577945776"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1665000000000000000000000000"), currency::wide_difficulty_type("2908166080577945775"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1670000000000000000000000000"), currency::wide_difficulty_type("2900077774097716347"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1670000000000000000000000000"), currency::wide_difficulty_type("2900077774097716346"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1675000000000000000000000000"), currency::wide_difficulty_type("2892082222014645048"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1675000000000000000000000000"), currency::wide_difficulty_type("2892082222014645047"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1680000000000000000000000000"), currency::wide_difficulty_type("2884177837903518828"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1680000000000000000000000000"), currency::wide_difficulty_type("2884177837903518827"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1685000000000000000000000000"), currency::wide_difficulty_type("2876363071311944416"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1685000000000000000000000000"), currency::wide_difficulty_type("2876363071311944415"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1690000000000000000000000000"), currency::wide_difficulty_type("2868636406746473411"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1690000000000000000000000000"), currency::wide_difficulty_type("2868636406746473410"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1695000000000000000000000000"), currency::wide_difficulty_type("2860996362692825797"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1695000000000000000000000000"), currency::wide_difficulty_type("2860996362692825796"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1700000000000000000000000000"), currency::wide_difficulty_type("2853441490668881421"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1700000000000000000000000000"), currency::wide_difficulty_type("2853441490668881420"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1705000000000000000000000000"), currency::wide_difficulty_type("2845970374309167960"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1705000000000000000000000000"), currency::wide_difficulty_type("2845970374309167959"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1710000000000000000000000000"), currency::wide_difficulty_type("2838581628479629993"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1710000000000000000000000000"), currency::wide_difficulty_type("2838581628479629992"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1715000000000000000000000000"), currency::wide_difficulty_type("2831273898421517086"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1715000000000000000000000000"), currency::wide_difficulty_type("2831273898421517085"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1720000000000000000000000000"), currency::wide_difficulty_type("2824045858923279501"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1720000000000000000000000000"), currency::wide_difficulty_type("2824045858923279500"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1725000000000000000000000000"), currency::wide_difficulty_type("2816896213519408333"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1725000000000000000000000000"), currency::wide_difficulty_type("2816896213519408332"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1730000000000000000000000000"), currency::wide_difficulty_type("2809823693715202785"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1730000000000000000000000000"), currency::wide_difficulty_type("2809823693715202784"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1735000000000000000000000000"), currency::wide_difficulty_type("2802827058236490934"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1735000000000000000000000000"), currency::wide_difficulty_type("2802827058236490933"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1740000000000000000000000000"), currency::wide_difficulty_type("2795905092303371895"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1740000000000000000000000000"), currency::wide_difficulty_type("2795905092303371894"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1745000000000000000000000000"), currency::wide_difficulty_type("2789056606927086901"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1745000000000000000000000000"), currency::wide_difficulty_type("2789056606927086900"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1750000000000000000000000000"), currency::wide_difficulty_type("2782280438229164471"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1750000000000000000000000000"), currency::wide_difficulty_type("2782280438229164470"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1755000000000000000000000000"), currency::wide_difficulty_type("2775575446782020797"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1755000000000000000000000000"), currency::wide_difficulty_type("2775575446782020796"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1760000000000000000000000000"), currency::wide_difficulty_type("2768940516970230676"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1760000000000000000000000000"), currency::wide_difficulty_type("2768940516970230675"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1765000000000000000000000000"), currency::wide_difficulty_type("2762374556371716950"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1765000000000000000000000000"), currency::wide_difficulty_type("2762374556371716949"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1770000000000000000000000000"), currency::wide_difficulty_type("2755876495158137534"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1770000000000000000000000000"), currency::wide_difficulty_type("2755876495158137533"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1775000000000000000000000000"), currency::wide_difficulty_type("2749445285513778759"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1775000000000000000000000000"), currency::wide_difficulty_type("2749445285513778758"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1780000000000000000000000000"), currency::wide_difficulty_type("2743079901072292083"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1780000000000000000000000000"), currency::wide_difficulty_type("2743079901072292082"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1785000000000000000000000000"), currency::wide_difficulty_type("2736779336370638195"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1785000000000000000000000000"), currency::wide_difficulty_type("2736779336370638194"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1790000000000000000000000000"), currency::wide_difficulty_type("2730542606319628350"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1790000000000000000000000000"), currency::wide_difficulty_type("2730542606319628349"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1795000000000000000000000000"), currency::wide_difficulty_type("2724368745690477334"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1795000000000000000000000000"), currency::wide_difficulty_type("2724368745690477333"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1800000000000000000000000000"), currency::wide_difficulty_type("2718256808616805999"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1800000000000000000000000000"), currency::wide_difficulty_type("2718256808616805998"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1805000000000000000000000000"), currency::wide_difficulty_type("2712205868111553685"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1805000000000000000000000000"), currency::wide_difficulty_type("2712205868111553684"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1810000000000000000000000000"), currency::wide_difficulty_type("2706215015598282356"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1810000000000000000000000000"), currency::wide_difficulty_type("2706215015598282355"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1815000000000000000000000000"), currency::wide_difficulty_type("2700283360456374682"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1815000000000000000000000000"), currency::wide_difficulty_type("2700283360456374681"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1820000000000000000000000000"), currency::wide_difficulty_type("2694410029579647946"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1820000000000000000000000000"), currency::wide_difficulty_type("2694410029579647945"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1825000000000000000000000000"), currency::wide_difficulty_type("2688594166947924317"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1825000000000000000000000000"), currency::wide_difficulty_type("2688594166947924316"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1830000000000000000000000000"), currency::wide_difficulty_type("2682834933211115942"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1830000000000000000000000000"), currency::wide_difficulty_type("2682834933211115941"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1835000000000000000000000000"), currency::wide_difficulty_type("2677131505285400445"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1835000000000000000000000000"), currency::wide_difficulty_type("2677131505285400444"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1840000000000000000000000000"), currency::wide_difficulty_type("2671483075961078746"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1840000000000000000000000000"), currency::wide_difficulty_type("2671483075961078745"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1845000000000000000000000000"), currency::wide_difficulty_type("2665888853521722831"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1845000000000000000000000000"), currency::wide_difficulty_type("2665888853521722830"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1850000000000000000000000000"), currency::wide_difficulty_type("2660348061374236044"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1850000000000000000000000000"), currency::wide_difficulty_type("2660348061374236043"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1855000000000000000000000000"), currency::wide_difficulty_type("2654859937689462866"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1855000000000000000000000000"), currency::wide_difficulty_type("2654859937689462865"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1860000000000000000000000000"), currency::wide_difficulty_type("2649423735052998850"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1860000000000000000000000000"), currency::wide_difficulty_type("2649423735052998849"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1865000000000000000000000000"), currency::wide_difficulty_type("2644038720125864563"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1865000000000000000000000000"), currency::wide_difficulty_type("2644038720125864562"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1870000000000000000000000000"), currency::wide_difficulty_type("2638704173314719972"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1870000000000000000000000000"), currency::wide_difficulty_type("2638704173314719971"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1875000000000000000000000000"), currency::wide_difficulty_type("2633419388451307786"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1875000000000000000000000000"), currency::wide_difficulty_type("2633419388451307785"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1880000000000000000000000000"), currency::wide_difficulty_type("2628183672480825857"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1880000000000000000000000000"), currency::wide_difficulty_type("2628183672480825856"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1885000000000000000000000000"), currency::wide_difficulty_type("2622996345158939776"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1885000000000000000000000000"), currency::wide_difficulty_type("2622996345158939775"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1890000000000000000000000000"), currency::wide_difficulty_type("2617856738757157503"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1890000000000000000000000000"), currency::wide_difficulty_type("2617856738757157502"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1895000000000000000000000000"), currency::wide_difficulty_type("2612764197776297996"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1895000000000000000000000000"), currency::wide_difficulty_type("2612764197776297995"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1900000000000000000000000000"), currency::wide_difficulty_type("2607718078667795597"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1900000000000000000000000000"), currency::wide_difficulty_type("2607718078667795596"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1905000000000000000000000000"), currency::wide_difficulty_type("2602717749562591346"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1905000000000000000000000000"), currency::wide_difficulty_type("2602717749562591345"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1910000000000000000000000000"), currency::wide_difficulty_type("2597762590007371298"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1910000000000000000000000000"), currency::wide_difficulty_type("2597762590007371297"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1915000000000000000000000000"), currency::wide_difficulty_type("2592851990707920649"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1915000000000000000000000000"), currency::wide_difficulty_type("2592851990707920648"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1920000000000000000000000000"), currency::wide_difficulty_type("2587985353279370678"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1920000000000000000000000000"), currency::wide_difficulty_type("2587985353279370677"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1925000000000000000000000000"), currency::wide_difficulty_type("2583162090003123494"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1925000000000000000000000000"), currency::wide_difficulty_type("2583162090003123493"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1930000000000000000000000000"), currency::wide_difficulty_type("2578381623590247222"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1930000000000000000000000000"), currency::wide_difficulty_type("2578381623590247221"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1935000000000000000000000000"), currency::wide_difficulty_type("2573643386951141553"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1935000000000000000000000000"), currency::wide_difficulty_type("2573643386951141552"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1940000000000000000000000000"), currency::wide_difficulty_type("2568946822971280653"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1940000000000000000000000000"), currency::wide_difficulty_type("2568946822971280652"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1945000000000000000000000000"), currency::wide_difficulty_type("2564291384292847167"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1945000000000000000000000000"), currency::wide_difficulty_type("2564291384292847166"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1950000000000000000000000000"), currency::wide_difficulty_type("2559676533102077564"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1950000000000000000000000000"), currency::wide_difficulty_type("2559676533102077563"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1955000000000000000000000000"), currency::wide_difficulty_type("2555101740922145295"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1955000000000000000000000000"), currency::wide_difficulty_type("2555101740922145294"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1960000000000000000000000000"), currency::wide_difficulty_type("2550566488411414260"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1960000000000000000000000000"), currency::wide_difficulty_type("2550566488411414259"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1965000000000000000000000000"), currency::wide_difficulty_type("2546070265166900802"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1965000000000000000000000000"), currency::wide_difficulty_type("2546070265166900801"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1970000000000000000000000000"), currency::wide_difficulty_type("2541612569532788044"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1970000000000000000000000000"), currency::wide_difficulty_type("2541612569532788043"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1975000000000000000000000000"), currency::wide_difficulty_type("2537192908413841681"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1975000000000000000000000000"), currency::wide_difficulty_type("2537192908413841680"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1980000000000000000000000000"), currency::wide_difficulty_type("2532810797093581470"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1980000000000000000000000000"), currency::wide_difficulty_type("2532810797093581469"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1985000000000000000000000000"), currency::wide_difficulty_type("2528465759057067615"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1985000000000000000000000000"), currency::wide_difficulty_type("2528465759057067614"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1990000000000000000000000000"), currency::wide_difficulty_type("2524157325818165947"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1990000000000000000000000000"), currency::wide_difficulty_type("2524157325818165946"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1995000000000000000000000000"), currency::wide_difficulty_type("2519885036751160428"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("1995000000000000000000000000"), currency::wide_difficulty_type("2519885036751160427"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2000000000000000000000000000"), currency::wide_difficulty_type("2515648438926585831"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2000000000000000000000000000"), currency::wide_difficulty_type("2515648438926585830"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2005000000000000000000000000"), currency::wide_difficulty_type("2511447086951157734"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2005000000000000000000000000"), currency::wide_difficulty_type("2511447086951157733"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2010000000000000000000000000"), currency::wide_difficulty_type("2507280542811681016"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2010000000000000000000000000"), currency::wide_difficulty_type("2507280542811681015"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2015000000000000000000000000"), currency::wide_difficulty_type("2503148375722821955"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2015000000000000000000000000"), currency::wide_difficulty_type("2503148375722821954"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2020000000000000000000000000"), currency::wide_difficulty_type("2499050161978632830"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2020000000000000000000000000"), currency::wide_difficulty_type("2499050161978632829"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2025000000000000000000000000"), currency::wide_difficulty_type("2494985484807721531"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2025000000000000000000000000"), currency::wide_difficulty_type("2494985484807721530"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2030000000000000000000000000"), currency::wide_difficulty_type("2490953934231962225"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2030000000000000000000000000"), currency::wide_difficulty_type("2490953934231962224"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2035000000000000000000000000"), currency::wide_difficulty_type("2486955106928646474"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2035000000000000000000000000"), currency::wide_difficulty_type("2486955106928646473"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2040000000000000000000000000"), currency::wide_difficulty_type("2482988606095977448"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2040000000000000000000000000"), currency::wide_difficulty_type("2482988606095977447"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2045000000000000000000000000"), currency::wide_difficulty_type("2479054041321813044"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2045000000000000000000000000"), currency::wide_difficulty_type("2479054041321813043"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2050000000000000000000000000"), currency::wide_difficulty_type("2475151028455566714"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2050000000000000000000000000"), currency::wide_difficulty_type("2475151028455566713"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2055000000000000000000000000"), currency::wide_difficulty_type("2471279189483177729"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2055000000000000000000000000"), currency::wide_difficulty_type("2471279189483177728"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2060000000000000000000000000"), currency::wide_difficulty_type("2467438152405065410"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2060000000000000000000000000"), currency::wide_difficulty_type("2467438152405065409"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2065000000000000000000000000"), currency::wide_difficulty_type("2463627551116984585"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2065000000000000000000000000"), currency::wide_difficulty_type("2463627551116984584"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2070000000000000000000000000"), currency::wide_difficulty_type("2459847025293702108"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2070000000000000000000000000"), currency::wide_difficulty_type("2459847025293702107"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2075000000000000000000000000"), currency::wide_difficulty_type("2456096220275416833"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2075000000000000000000000000"), currency::wide_difficulty_type("2456096220275416832"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2080000000000000000000000000"), currency::wide_difficulty_type("2452374786956847850"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2080000000000000000000000000"), currency::wide_difficulty_type("2452374786956847849"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2085000000000000000000000000"), currency::wide_difficulty_type("2448682381678918120"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2085000000000000000000000000"), currency::wide_difficulty_type("2448682381678918119"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2090000000000000000000000000"), currency::wide_difficulty_type("2445018666122962957"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2090000000000000000000000000"), currency::wide_difficulty_type("2445018666122962956"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2095000000000000000000000000"), currency::wide_difficulty_type("2441383307207394935"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2095000000000000000000000000"), currency::wide_difficulty_type("2441383307207394934"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2100000000000000000000000000"), currency::wide_difficulty_type("2437775976986758940"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2100000000000000000000000000"), currency::wide_difficulty_type("2437775976986758939"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2105000000000000000000000000"), currency::wide_difficulty_type("2434196352553113130"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2105000000000000000000000000"), currency::wide_difficulty_type("2434196352553113129"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2110000000000000000000000000"), currency::wide_difficulty_type("2430644115939673490"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2110000000000000000000000000"), currency::wide_difficulty_type("2430644115939673489"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2115000000000000000000000000"), currency::wide_difficulty_type("2427118954026661635"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2115000000000000000000000000"), currency::wide_difficulty_type("2427118954026661634"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2120000000000000000000000000"), currency::wide_difficulty_type("2423620558449297271"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2120000000000000000000000000"), currency::wide_difficulty_type("2423620558449297270"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2125000000000000000000000000"), currency::wide_difficulty_type("2420148625507878558"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2125000000000000000000000000"), currency::wide_difficulty_type("2420148625507878557"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2130000000000000000000000000"), currency::wide_difficulty_type("2416702856079895306"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2130000000000000000000000000"), currency::wide_difficulty_type("2416702856079895305"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2135000000000000000000000000"), currency::wide_difficulty_type("2413282955534121575"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2135000000000000000000000000"), currency::wide_difficulty_type("2413282955534121574"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2140000000000000000000000000"), currency::wide_difficulty_type("2409888633646635875"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2140000000000000000000000000"), currency::wide_difficulty_type("2409888633646635874"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2145000000000000000000000000"), currency::wide_difficulty_type("2406519604518718694"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2145000000000000000000000000"), currency::wide_difficulty_type("2406519604518718693"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2150000000000000000000000000"), currency::wide_difficulty_type("2403175586496578565"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2150000000000000000000000000"), currency::wide_difficulty_type("2403175586496578564"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2155000000000000000000000000"), currency::wide_difficulty_type("2399856302092859343"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2155000000000000000000000000"), currency::wide_difficulty_type("2399856302092859342"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2160000000000000000000000000"), currency::wide_difficulty_type("2396561477909882754"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2160000000000000000000000000"), currency::wide_difficulty_type("2396561477909882753"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2165000000000000000000000000"), currency::wide_difficulty_type("2393290844564581615"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2165000000000000000000000000"), currency::wide_difficulty_type("2393290844564581614"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2170000000000000000000000000"), currency::wide_difficulty_type("2390044136615080450"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2170000000000000000000000000"), currency::wide_difficulty_type("2390044136615080449"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2175000000000000000000000000"), currency::wide_difficulty_type("2386821092488881460"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2175000000000000000000000000"), currency::wide_difficulty_type("2386821092488881459"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2180000000000000000000000000"), currency::wide_difficulty_type("2383621454412615068"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2180000000000000000000000000"), currency::wide_difficulty_type("2383621454412615067"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2185000000000000000000000000"), currency::wide_difficulty_type("2380444968343315390"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2185000000000000000000000000"), currency::wide_difficulty_type("2380444968343315389"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2190000000000000000000000000"), currency::wide_difficulty_type("2377291383901182163"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2190000000000000000000000000"), currency::wide_difficulty_type("2377291383901182162"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2195000000000000000000000000"), currency::wide_difficulty_type("2374160454303791767"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2195000000000000000000000000"), currency::wide_difficulty_type("2374160454303791766"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2200000000000000000000000000"), currency::wide_difficulty_type("2371051936301721016"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2200000000000000000000000000"), currency::wide_difficulty_type("2371051936301721015"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2205000000000000000000000000"), currency::wide_difficulty_type("2367965590115548453"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2205000000000000000000000000"), currency::wide_difficulty_type("2367965590115548452"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2210000000000000000000000000"), currency::wide_difficulty_type("2364901179374198904"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2210000000000000000000000000"), currency::wide_difficulty_type("2364901179374198903"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2215000000000000000000000000"), currency::wide_difficulty_type("2361858471054597963"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2215000000000000000000000000"), currency::wide_difficulty_type("2361858471054597962"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2220000000000000000000000000"), currency::wide_difficulty_type("2358837235422604080"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2220000000000000000000000000"), currency::wide_difficulty_type("2358837235422604079"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2225000000000000000000000000"), currency::wide_difficulty_type("2355837245975186797"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2225000000000000000000000000"), currency::wide_difficulty_type("2355837245975186796"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2230000000000000000000000000"), currency::wide_difficulty_type("2352858279383820553"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2230000000000000000000000000"), currency::wide_difficulty_type("2352858279383820552"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2235000000000000000000000000"), currency::wide_difficulty_type("2349900115439064383"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2235000000000000000000000000"), currency::wide_difficulty_type("2349900115439064382"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2240000000000000000000000000"), currency::wide_difficulty_type("2346962536996298585"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2240000000000000000000000000"), currency::wide_difficulty_type("2346962536996298584"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2245000000000000000000000000"), currency::wide_difficulty_type("2344045329922590311"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2245000000000000000000000000"), currency::wide_difficulty_type("2344045329922590310"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2250000000000000000000000000"), currency::wide_difficulty_type("2341148283044660753"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2250000000000000000000000000"), currency::wide_difficulty_type("2341148283044660752"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2255000000000000000000000000"), currency::wide_difficulty_type("2338271188097927374"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2255000000000000000000000000"), currency::wide_difficulty_type("2338271188097927373"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2260000000000000000000000000"), currency::wide_difficulty_type("2335413839676595372"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2260000000000000000000000000"), currency::wide_difficulty_type("2335413839676595371"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2265000000000000000000000000"), currency::wide_difficulty_type("2332576035184773241"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2265000000000000000000000000"), currency::wide_difficulty_type("2332576035184773240"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2270000000000000000000000000"), currency::wide_difficulty_type("2329757574788588008"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2270000000000000000000000000"), currency::wide_difficulty_type("2329757574788588007"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2275000000000000000000000000"), currency::wide_difficulty_type("2326958261369276374"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2275000000000000000000000000"), currency::wide_difficulty_type("2326958261369276373"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2280000000000000000000000000"), currency::wide_difficulty_type("2324177900477228635"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2280000000000000000000000000"), currency::wide_difficulty_type("2324177900477228634"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2285000000000000000000000000"), currency::wide_difficulty_type("2321416300286962874"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2285000000000000000000000000"), currency::wide_difficulty_type("2321416300286962873"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2290000000000000000000000000"), currency::wide_difficulty_type("2318673271553007540"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2290000000000000000000000000"), currency::wide_difficulty_type("2318673271553007539"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2295000000000000000000000000"), currency::wide_difficulty_type("2315948627566671091"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2295000000000000000000000000"), currency::wide_difficulty_type("2315948627566671090"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2300000000000000000000000000"), currency::wide_difficulty_type("2313242184113677981"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2300000000000000000000000000"), currency::wide_difficulty_type("2313242184113677980"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2305000000000000000000000000"), currency::wide_difficulty_type("2310553759432650776"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2305000000000000000000000000"), currency::wide_difficulty_type("2310553759432650775"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2310000000000000000000000000"), currency::wide_difficulty_type("2307883174174418780"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2310000000000000000000000000"), currency::wide_difficulty_type("2307883174174418779"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2315000000000000000000000000"), currency::wide_difficulty_type("2305230251362134008"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2315000000000000000000000000"), currency::wide_difficulty_type("2305230251362134007"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2320000000000000000000000000"), currency::wide_difficulty_type("2302594816352175903"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2320000000000000000000000000"), currency::wide_difficulty_type("2302594816352175902"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2325000000000000000000000000"), currency::wide_difficulty_type("2299976696795826646"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2325000000000000000000000000"), currency::wide_difficulty_type("2299976696795826645"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2330000000000000000000000000"), currency::wide_difficulty_type("2297375722601699401"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2330000000000000000000000000"), currency::wide_difficulty_type("2297375722601699400"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2335000000000000000000000000"), currency::wide_difficulty_type("2294791725898902291"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2335000000000000000000000000"), currency::wide_difficulty_type("2294791725898902290"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2340000000000000000000000000"), currency::wide_difficulty_type("2292224541000921359"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2340000000000000000000000000"), currency::wide_difficulty_type("2292224541000921358"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2345000000000000000000000000"), currency::wide_difficulty_type("2289674004370206180"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2345000000000000000000000000"), currency::wide_difficulty_type("2289674004370206179"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2350000000000000000000000000"), currency::wide_difficulty_type("2287139954583442248"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2350000000000000000000000000"), currency::wide_difficulty_type("2287139954583442247"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2355000000000000000000000000"), currency::wide_difficulty_type("2284622232297494626"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2355000000000000000000000000"), currency::wide_difficulty_type("2284622232297494625"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2360000000000000000000000000"), currency::wide_difficulty_type("2282120680216007790"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2360000000000000000000000000"), currency::wide_difficulty_type("2282120680216007789"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2365000000000000000000000000"), currency::wide_difficulty_type("2279635143056646954"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2365000000000000000000000000"), currency::wide_difficulty_type("2279635143056646953"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2370000000000000000000000000"), currency::wide_difficulty_type("2277165467518966551"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2370000000000000000000000000"), currency::wide_difficulty_type("2277165467518966550"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2375000000000000000000000000"), currency::wide_difficulty_type("2274711502252891900"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2375000000000000000000000000"), currency::wide_difficulty_type("2274711502252891899"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2380000000000000000000000000"), currency::wide_difficulty_type("2272273097827800467"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2380000000000000000000000000"), currency::wide_difficulty_type("2272273097827800466"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2385000000000000000000000000"), currency::wide_difficulty_type("2269850106702189431"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2385000000000000000000000000"), currency::wide_difficulty_type("2269850106702189430"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2390000000000000000000000000"), currency::wide_difficulty_type("2267442383193916647"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2390000000000000000000000000"), currency::wide_difficulty_type("2267442383193916646"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2395000000000000000000000000"), currency::wide_difficulty_type("2265049783451002382"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2395000000000000000000000000"), currency::wide_difficulty_type("2265049783451002381"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2400000000000000000000000000"), currency::wide_difficulty_type("2262672165422979551"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2400000000000000000000000000"), currency::wide_difficulty_type("2262672165422979550"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2405000000000000000000000000"), currency::wide_difficulty_type("2260309388832780454"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2405000000000000000000000000"), currency::wide_difficulty_type("2260309388832780453"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2410000000000000000000000000"), currency::wide_difficulty_type("2257961315149148341"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2410000000000000000000000000"), currency::wide_difficulty_type("2257961315149148340"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2415000000000000000000000000"), currency::wide_difficulty_type("2255627807559562398"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2415000000000000000000000000"), currency::wide_difficulty_type("2255627807559562397"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2420000000000000000000000000"), currency::wide_difficulty_type("2253308730943665060"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2420000000000000000000000000"), currency::wide_difficulty_type("2253308730943665059"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2425000000000000000000000000"), currency::wide_difficulty_type("2251003951847180788"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2425000000000000000000000000"), currency::wide_difficulty_type("2251003951847180787"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2430000000000000000000000000"), currency::wide_difficulty_type("2248713338456315756"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2430000000000000000000000000"), currency::wide_difficulty_type("2248713338456315755"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2435000000000000000000000000"), currency::wide_difficulty_type("2246436760572628130"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2435000000000000000000000000"), currency::wide_difficulty_type("2246436760572628129"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2440000000000000000000000000"), currency::wide_difficulty_type("2244174089588358868"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2440000000000000000000000000"), currency::wide_difficulty_type("2244174089588358867"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2445000000000000000000000000"), currency::wide_difficulty_type("2241925198462213242"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2445000000000000000000000000"), currency::wide_difficulty_type("2241925198462213241"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2450000000000000000000000000"), currency::wide_difficulty_type("2239689961695583486"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2450000000000000000000000000"), currency::wide_difficulty_type("2239689961695583485"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2455000000000000000000000000"), currency::wide_difficulty_type("2237468255309203239"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2455000000000000000000000000"), currency::wide_difficulty_type("2237468255309203238"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2460000000000000000000000000"), currency::wide_difficulty_type("2235259956820224654"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2460000000000000000000000000"), currency::wide_difficulty_type("2235259956820224653"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2465000000000000000000000000"), currency::wide_difficulty_type("2233064945219709271"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2465000000000000000000000000"), currency::wide_difficulty_type("2233064945219709270"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2470000000000000000000000000"), currency::wide_difficulty_type("2230883100950523974"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2470000000000000000000000000"), currency::wide_difficulty_type("2230883100950523973"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2475000000000000000000000000"), currency::wide_difficulty_type("2228714305885633552"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2475000000000000000000000000"), currency::wide_difficulty_type("2228714305885633551"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2480000000000000000000000000"), currency::wide_difficulty_type("2226558443306781569"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2480000000000000000000000000"), currency::wide_difficulty_type("2226558443306781568"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2485000000000000000000000000"), currency::wide_difficulty_type("2224415397883551498"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2485000000000000000000000000"), currency::wide_difficulty_type("2224415397883551497"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2490000000000000000000000000"), currency::wide_difficulty_type("2222285055652800188"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2490000000000000000000000000"), currency::wide_difficulty_type("2222285055652800187"));
+  ASSERT_FALSE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2495000000000000000000000000"), currency::wide_difficulty_type("2220167303998455999"));
+  ASSERT_TRUE(res);
+  res = if_alt_chain_stronger_hf4(currency::wide_difficulty_type("2495000000000000000000000000"), currency::wide_difficulty_type("2220167303998455998"));
+  ASSERT_FALSE(res);
+
+ }
diff --git a/tests/unit_tests/wallet_seed_test.cpp b/tests/unit_tests/wallet_seed_test.cpp
index efbd2829..cfd6b860 100644
--- a/tests/unit_tests/wallet_seed_test.cpp
+++ b/tests/unit_tests/wallet_seed_test.cpp
@@ -2,10 +2,13 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <exception>
+
 #include "gtest/gtest.h"
 
 #include "include_base_utils.h"
 #include "currency_core/account.h"
+#include "currency_core/currency_format_utils.h"
 
 TEST(wallet_seed, store_restore_test) 
 {
@@ -211,3 +214,151 @@ TEST(wallet_seed, basic_test)
   }
 
 }
+
+TEST(wallet_seed, word_from_timestamp)
+{
+  //timestamp = 0; use_password = false
+  ASSERT_EQ("like", currency::get_word_from_timestamp(0, false));
+
+  // timestamp = 0; use_password = true
+  ASSERT_EQ("among", currency::get_word_from_timestamp(0, true));
+
+  // timestamp = WALLET_BRAIN_DATE_OFFSET = 1543622400; use_password = false
+  ASSERT_EQ("like", currency::get_word_from_timestamp(1543622400, false));
+
+  // timestamp = WALLET_BRAIN_DATE_OFFSET = 1543622400; use_password = true
+  ASSERT_EQ("among", currency::get_word_from_timestamp(1543622400, true));
+
+  // timestamp = WALLET_BRAIN_DATE_OFFSET - 1 = 1543622399; use_password = false
+  ASSERT_EQ("like", currency::get_word_from_timestamp(1543622399, false));
+
+  // timestamp = WALLET_BRAIN_DATE_OFFSET + 1 = 1543622401; use_password = false
+  ASSERT_EQ("like", currency::get_word_from_timestamp(1543622401, false));
+
+  // timestamp = WALLET_BRAIN_DATE_OFFSET + 1 = 1543622401; use_password = true
+  ASSERT_EQ("among", currency::get_word_from_timestamp(1543622401, true));
+
+  /*
+    Values get_word_from_timestamp(1, true),
+    get_word_from_timestamp(1543622401, true) must be equal.
+  */
+
+  ASSERT_EQ("among", currency::get_word_from_timestamp(1, true));
+  ASSERT_EQ(currency::get_word_from_timestamp(1, true),
+            currency::get_word_from_timestamp(1543622401, true));
+
+  /*
+    2027462399 is the largest timestamp argument value under which the
+    inequality weeks_count < WALLET_BRAIN_DATE_MAX_WEEKS_COUNT is satisfied.
+
+    timestamp = 2027462399
+    date_offset = timestamp - WALLET_BRAIN_DATE_OFFSET = 483839999
+    weeks_count = date_offset / WALLET_BRAIN_DATE_QUANTUM = 799
+    WALLET_BRAIN_DATE_MAX_WEEKS_COUNT = 800
+    WALLET_BRAIN_DATE_QUANTUM = 604800
+
+    floor(483839999 / 604800) = 799
+    floor(483840000 / 604800) = 800
+  */
+
+  // weeks_count_32 = 799; wordsArray[799] = "ugly"
+  ASSERT_EQ("ugly", currency::get_word_from_timestamp(2027462399, false));
+
+  // weeks_count_32 = 799 + 800 = 1599; wordsArray[1599] = "moan"
+  ASSERT_EQ("moan", currency::get_word_from_timestamp(2027462399, true));
+
+  /*
+    If you pass values ​​>= 2027462399 + 1, then the inequality
+    weeks_count < WALLET_BRAIN_DATE_MAX_WEEKS_COUNT is not satisfied. The
+    function throws an exception.
+  */
+
+  EXPECT_THROW(currency::get_word_from_timestamp(2027462400, false),
+               std::runtime_error);
+
+  EXPECT_THROW(currency::get_word_from_timestamp(2027462400, true),
+               std::runtime_error);
+}
+
+TEST(wallet_seed, timestamp_from_word)
+{
+  {
+    // WALLET_BRAIN_DATE_OFFSET = 1543622400
+
+    {
+      bool password_used{false};
+
+      ASSERT_EQ(1543622400,
+                currency::get_timestamp_from_word("like", password_used));
+      ASSERT_FALSE(password_used);
+    }
+
+    {
+      bool password_used{true};
+
+      ASSERT_EQ(1543622400,
+                currency::get_timestamp_from_word("like", password_used));
+      ASSERT_FALSE(password_used);
+    }
+  }
+
+  {
+    // WALLET_BRAIN_DATE_OFFSET = 1543622400
+
+    {
+      bool password_used{true};
+
+      ASSERT_EQ(1543622400,
+                currency::get_timestamp_from_word("among", password_used));
+      ASSERT_TRUE(password_used);
+    }
+
+    {
+      bool password_used{false};
+
+      ASSERT_EQ(1543622400,
+                currency::get_timestamp_from_word("among", password_used));
+      ASSERT_TRUE(password_used);
+    }
+  }
+
+  {
+    // (1625 - 800) * 604800 + 1543622400 = 2042582400
+
+    {
+      bool password_used{false};
+
+      ASSERT_EQ(2026857600,
+                currency::get_timestamp_from_word("ugly", password_used));
+      ASSERT_FALSE(password_used);
+    }
+
+    {
+      bool password_used{true};
+
+      ASSERT_EQ(2026857600,
+                currency::get_timestamp_from_word("ugly", password_used));
+      ASSERT_FALSE(password_used);
+    }
+  }
+
+  {
+    // (1625 - 800) * 604800 + 1543622400 = 2042582400
+
+    {
+      bool password_used{false};
+
+      ASSERT_EQ(2042582400,
+                currency::get_timestamp_from_word("weary", password_used));
+      ASSERT_TRUE(password_used);
+    }
+
+    {
+      bool password_used{true};
+
+      ASSERT_EQ(2042582400,
+                currency::get_timestamp_from_word("weary", password_used));
+      ASSERT_TRUE(password_used);
+    }
+  }
+}

From 7b9c728de20022b876cd4fdc3a8f1eaaebad4a32 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 20:34:17 +0200
Subject: [PATCH 33/37] core: minor readability improvement in
 validate_asset_operation_against_current_blochain_state()

---
 src/currency_core/blockchain_storage.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 0a5918b7..3ed02173 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -4134,11 +4134,12 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
 
   const asset_descriptor_operation& ado = avc.ado;
 
+  bool need_to_validate_ao_amount_commitment = true;
+
   if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_REGISTER)
   {
     CHECK_AND_ASSERT_MES(!avc.asset_op_history, false, "asset with id " << avc.asset_id << " has already been registered");
     avc.amount_to_validate = ado.descriptor.current_supply;
-    CHECK_AND_ASSERT_MES(validate_asset_operation_amount_commitment(avc), false, "validate_asset_operation_amount_commitment failed!");
     if(this->is_hardfork_active(ZANO_HARDFORK_05))
     {
       CHECK_AND_ASSERT_MES(validate_ado_initial(ado.descriptor), false, "validate_ado_initial failed!");
@@ -4156,13 +4157,12 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
     }
 
     avc.amount_to_validate = 0;
-    bool need_to_validate_balance_proof = true;
     if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE)
     {
       //check that total current_supply haven't changed
       CHECK_AND_ASSERT_MES(ado.descriptor.current_supply == last_ado.descriptor.current_supply, false, "update operation attempted to change emission, failed");
       CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "update operation attempted to change fileds that shouldn't be modified, failed");
-      need_to_validate_balance_proof = false;
+      need_to_validate_ao_amount_commitment = false;
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT)
     {
@@ -4183,12 +4183,12 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
       LOG_ERROR("Unknown operation type: " << (int)ado.operation_type);
       return false;
     }
+  }
 
-    if (need_to_validate_balance_proof)
-    {
-      bool r = validate_asset_operation_amount_commitment(avc);
-      CHECK_AND_ASSERT_MES(r, false, "Balance proof validation failed for asset_descriptor_operation");
-    }
+  if (need_to_validate_ao_amount_commitment)
+  {
+    bool r = validate_asset_operation_amount_commitment(avc);
+    CHECK_AND_ASSERT_MES(r, false, "Balance proof validation failed for asset_descriptor_operation");
   }
 
   return true;

From d610c38c4ecac2c1dc654dfd42af45ed1a21ceb2 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Mon, 23 Sep 2024 20:35:22 +0200
Subject: [PATCH 34/37] fixed an error in construct_tx when asset update
 operation is ongoing with standard owner (non eth)

---
 src/currency_core/currency_format_utils.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp
index f3b1b597..9dfae001 100644
--- a/src/currency_core/currency_format_utils.cpp
+++ b/src/currency_core/currency_format_utils.cpp
@@ -2759,7 +2759,7 @@ namespace currency
       CHECK_AND_ASSERT_MES(r, false, "generate_tx_balance_proof failed");
       tx.proofs.emplace_back(std::move(balance_proof));
 
-      // asset operation proofs (if necessary)
+      // optional asset operation proofs: amount commitment proof (required for register, emit, public burn)
       if (gen_context.ao_asset_id != currency::null_pkey)
       {
         // asset amount commitment g proof   (TODO @#@# add support for hidden supply)
@@ -2768,15 +2768,17 @@ namespace currency
         asset_operation_proof aop{};
         aop.opt_amount_commitment_g_proof = aop_g_sig;
         tx.proofs.emplace_back(std::move(aop));
+      }
 
-        // asset ownership proof for standard (non-eth) owner (using generic Shnorr signature with the spend secret key)
-        const asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(tx.extra);
-        CHECK_AND_ASSERT_MES(pado != nullptr, false, "pado is null");
+      // optional asset operation proofs: ownership proof for standard (non-eth) owner (using generic Shnorr signature with the spend secret key)
+      const asset_descriptor_operation* pado = get_type_in_variant_container<asset_descriptor_operation>(tx.extra);
+      if (pado != nullptr)
+      {
         if ((pado->operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT || pado->operation_type == ASSET_DESCRIPTOR_OPERATION_UPDATE) &&
             !pado->descriptor.owner_eth_pub_key.has_value())
         {
           asset_operation_ownership_proof aoop{};
-          r = crypto::generate_schnorr_sig(tx_prefix_hash, pado->descriptor.owner, sender_account_keys.spend_secret_key, aoop.gss); // owner will be checked against spend secret key within this call
+          r = crypto::generate_schnorr_sig(tx_prefix_hash, sender_account_keys.spend_secret_key, aoop.gss);
           CHECK_AND_ASSERT_MES(r, false, "Failed to sign ado proof");
           if (ftp.pevents_dispatcher) ftp.pevents_dispatcher->RAISE_DEBUG_EVENT(wde_construct_tx_after_asset_ownership_proof_generated{ &aoop });
           tx.proofs.emplace_back(aoop);

From f0891a36e8d9e4625e8de75a3424b0829375d802 Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Tue, 24 Sep 2024 01:24:42 +0200
Subject: [PATCH 35/37] minor improvements

---
 src/currency_core/blockchain_storage.cpp | 6 +++---
 tests/core_tests/chaingen_main.cpp       | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 3ed02173..c72b8d2d 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -4161,20 +4161,20 @@ bool blockchain_storage::validate_asset_operation_against_current_blochain_state
     {
       //check that total current_supply haven't changed
       CHECK_AND_ASSERT_MES(ado.descriptor.current_supply == last_ado.descriptor.current_supply, false, "update operation attempted to change emission, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "update operation attempted to change fileds that shouldn't be modified, failed");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "update operation modifies asset descriptor in a prohibited manner");
       need_to_validate_ao_amount_commitment = false;
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_EMIT)
     {
       CHECK_AND_ASSERT_MES(ado.descriptor.current_supply > last_ado.descriptor.current_supply, false, "emit operation does not increase the current supply, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "emit operation is not allowed to update fields");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "emit operation modifies asset descriptor in a prohibited manner");
       CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == last_ado.descriptor.meta_info, false, "emit operation is not allowed to update meta info");
       avc.amount_to_validate = ado.descriptor.current_supply - last_ado.descriptor.current_supply;
     }
     else if (ado.operation_type == ASSET_DESCRIPTOR_OPERATION_PUBLIC_BURN)
     {
       CHECK_AND_ASSERT_MES(ado.descriptor.current_supply < last_ado.descriptor.current_supply, false, "burn operation does not decrease the current supply, failed");
-      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "burn operation is not allowed to update fields");
+      CHECK_AND_ASSERT_MES(validate_ado_update_allowed(ado.descriptor, last_ado.descriptor), false, "burn operation modifies asset descriptor in a prohibited manner");
       CHECK_AND_ASSERT_MES(ado.descriptor.meta_info == last_ado.descriptor.meta_info, false, "burn operation is not allowed to update meta info");
       avc.amount_to_validate =  last_ado.descriptor.current_supply - ado.descriptor.current_supply;
     }
diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp
index 5e8102ce..7b0a81f9 100644
--- a/tests/core_tests/chaingen_main.cpp
+++ b/tests/core_tests/chaingen_main.cpp
@@ -264,13 +264,13 @@ bool generate_and_play(const char* const genclass_name, size_t hardfork_id = SIZ
 
   if (result)
   {
-    LOG_PRINT_GREEN(std::string(100, '=') << std::endl <<
+    LOG_PRINT_GREEN(std::string(72, '=') << std::endl <<
       "#TEST# >>>> " << genclass_name << " <<<< Succeeded" << std::endl <<
       std::string(100, '=') << std::endl, LOG_LEVEL_0 );
   }
   else
   {
-    LOG_PRINT_RED( std::string(100, '=') << std::endl <<
+    LOG_PRINT_RED( std::string(72, '=') << std::endl <<
       "#TEST# >>>> " << genclass_name << " <<<< FAILED" << std::endl <<
       std::string(100, '=') << std::endl, LOG_LEVEL_0);
     result = false;

From 2fc37934cf7156368148c68b0ac2aa3bec2958be Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Tue, 24 Sep 2024 01:26:04 +0200
Subject: [PATCH 36/37] removed forcefully nullifying asset_id in emit_asset()
 (it's up to the caller now)

---
 src/wallet/wallet2.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 991cebcd..fb87bd2f 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -5453,9 +5453,6 @@ void wallet2::emit_asset(const crypto::public_key& asset_id, const std::vector<c
   ctp.need_at_least_1_zc = true;
   ctp.tx_meaning_for_logs = "asset emission";
 
-  for(auto& dst : ctp.dsts)
-    dst.asset_id = null_pkey; // emit operation requires null_pkey for emitting asset outputs, fix it ad-hoc here
-
   bool send_to_network = true;
   if (last_adb.owner_eth_pub_key.has_value())
   {

From 82403dba513ddcec773c4eba34295bdf3f34ac7d Mon Sep 17 00:00:00 2001
From: sowle <crypto.sowle@gmail.com>
Date: Tue, 24 Sep 2024 01:34:08 +0200
Subject: [PATCH 37/37] coretests: eth_signed_asset_basics fixed and then
 greatly improved

---
 tests/core_tests/multiassets_test.cpp | 236 +++++++++++++++++---------
 1 file changed, 155 insertions(+), 81 deletions(-)

diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp
index 3b16394f..813999e4 100644
--- a/tests/core_tests/multiassets_test.cpp
+++ b/tests/core_tests/multiassets_test.cpp
@@ -1338,10 +1338,16 @@ eth_signed_asset_basics::eth_signed_asset_basics()
 
 bool eth_signed_asset_basics::generate(std::vector<test_event_entry>& events) const
 {
+  //
+  // Test idea: register an asset, then emit, public burn, transfer ownership, and then emit it once again.
+  // Update (ownership transferring) and emit operations are done using third-party external asset operation signing (ETH signature)
+  // Public burn operation is done by an entity, who isn't controlling the asset.
+  //
+
   uint64_t ts = test_core_time::get_time();
   m_accounts.resize(TOTAL_ACCS_COUNT);
   account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate(); miner_acc.set_createtime(ts);
-  //account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate(); alice_acc.set_createtime(ts);
+  account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate(); alice_acc.set_createtime(ts);
   miner_acc.generate();
 
   MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, ts);
@@ -1353,27 +1359,6 @@ bool eth_signed_asset_basics::generate(std::vector<test_event_entry>& events) co
   return true;
 }
 
-template<typename T>
-struct eth_sign_cb_helper : public currency::asset_eth_signer_i
-{
-  eth_sign_cb_helper(T cb)
-    : m_cb(cb)
-  {}
-
-  virtual bool sign(const crypto::hash& h, const crypto::eth_public_key& asset_owner, crypto::eth_signature& sig) override
-  {
-    return m_cb(h, asset_owner, sig);
-  }
-
-  T m_cb;
-};
-
-template<typename T>
-std::shared_ptr<eth_sign_cb_helper<T>> construct_eth_sign_cb_helper(T&& cb)
-{
-  return std::make_shared<eth_sign_cb_helper<T>>(std::forward<T>(cb));
-}
-
 bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
 {
   bool r = false;
@@ -1385,7 +1370,12 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
 
   std::shared_ptr<tools::wallet2> miner_wlt = init_playtime_test_wallet(events, c, MINER_ACC_IDX);
   miner_wlt->refresh();
+  std::shared_ptr<tools::wallet2> alice_wlt = init_playtime_test_wallet(events, c, ALICE_ACC_IDX);
+  alice_wlt->refresh();
 
+  //
+  // register
+  //
   asset_descriptor_base adb{};
   adb.decimal_point = 2;
   adb.total_max_supply = 10000;
@@ -1395,79 +1385,159 @@ bool eth_signed_asset_basics::c1(currency::core& c, size_t ev_index, const std::
 
   uint64_t initial_emit_amount = adb.total_max_supply / 2;
 
-  //std::vector<currency::tx_destination_entry> destinations;
-  //destinations.emplace_back(initial_emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
-  //currency::transaction tx{};
-
-  //
-  // custom deploy
-  //
-  tools::construct_tx_param ctp = miner_wlt->get_default_construct_tx_param();
-  ctp.dsts.emplace_back(initial_emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
-  // TODO reconsider this =>>> // ctp.asset_owner = eth_pk; // note using eth pub key here
-  ctp.need_at_least_1_zc = true;
-
-  asset_descriptor_operation ado{};
-  ado.descriptor = adb;
-  ado.operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER;
-  ctp.extra.push_back(ado);
-
+  std::vector<tx_destination_entry> destinations{tx_destination_entry{initial_emit_amount, m_accounts[ALICE_ACC_IDX].get_public_address(), null_pkey}};
   finalized_tx ft{};
-  miner_wlt->transfer(ctp, ft, true, nullptr);
-
   crypto::public_key asset_id = currency::null_pkey;
-  CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(ado, nullptr, &asset_id), false, "get_or_calculate_asset_id failed");
-
-  currency::asset_descriptor_operation ado2{};
-  r = get_type_in_variant_container(ft.tx.extra, ado2);
-  CHECK_AND_ASSERT_MES(r, false, "Failed find asset info in tx");
-  crypto::public_key new_asset_id{};
-  CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(ado, nullptr, &new_asset_id), false, "get_or_calculate_asset_id failed");
-
-
-  miner_wlt->add_custom_asset_id(asset_id, adb);
-  //
-  // end of custom deploy
-  //
+  miner_wlt->deploy_new_asset(adb, destinations, ft, asset_id);
 
   const transaction& tx = ft.tx;
 
+  LOG_PRINT_L0("Deployed new asset: " << asset_id << ", tx_id: " << ft.tx_id);
 
-  LOG_PRINT_L0("Deployed new asset: " << asset_id << ", tx_id: " << currency::get_transaction_hash(tx));
   CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+  r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  miner_wlt->refresh();
+
+  //
+  // emit
+  //
+  destinations.clear();
+  destinations.emplace_back(initial_emit_amount, m_accounts[ALICE_ACC_IDX].get_public_address(), null_pkey); // asset
+  destinations.emplace_back(MK_TEST_COINS(100), m_accounts[ALICE_ACC_IDX].get_public_address()); // some native coins for fee
+  uint64_t emit_amount = adb.total_max_supply - initial_emit_amount;
+  ft = finalized_tx{};
+  miner_wlt->emit_asset(asset_id, destinations, ft);
+
+  // make sure the transaction didn't get into tx pool (as it's not fully signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // make sure emit transaction cannot be added to the transaction pool (it's not fully signed atm)
+  tx_verification_context tvc{};
+  r = c.get_tx_pool().add_tx(ft.tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "unsigned emit tx was able to be added to the pool");
+
+  // sign asset emit operation with ETH signature
+  crypto::eth_signature eth_sig{};
+  r = crypto::generate_eth_signature(ft.tx_id, eth_sk, eth_sig);
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_signature failed");
+
+  transaction emit_tx{};
+  bool transfers_unlocked = false;
+  miner_wlt->submit_externally_signed_asset_tx(ft, eth_sig, true, emit_tx, transfers_unlocked);
+
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+  r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // Alice checks her asset balance
+  size_t blocks_fetched = 0;
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 2);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", adb.total_max_supply, asset_id, adb.decimal_point), false, "");
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", MK_TEST_COINS(100)), false, "");
+
+
+  //
+  // public burn (by Alice, as anyone can do public burn)
+  //
+  uint64_t amount_to_burn = initial_emit_amount / 2;
+  uint64_t total_amount_expected = adb.total_max_supply - amount_to_burn;
 
   r = mine_next_pow_blocks_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
   CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
-
-  uint64_t emit_amount = adb.total_max_supply - initial_emit_amount;
-
-  //
-  // custom emit
-  //
-  ctp = miner_wlt->get_default_construct_tx_param();
-  ctp.dsts.emplace_back(emit_amount, m_accounts[MINER_ACC_IDX].get_public_address(), null_pkey);
-  ctp.need_at_least_1_zc = true;
-  // TODO reconsider this =>> ctp.asset_owner = eth_pk; // note using eth pub key here
-
-  ado = asset_descriptor_operation{};
-  ado.descriptor = adb;
-  ado.descriptor.current_supply = initial_emit_amount;
-  ado.operation_type = ASSET_DESCRIPTOR_OPERATION_EMIT;
-  ado.opt_asset_id = asset_id;
-  ctp.extra.push_back(ado);
-
-  auto signer = construct_eth_sign_cb_helper([&](const crypto::hash& h, const crypto::eth_public_key& asset_owner, crypto::eth_signature& sig)->bool {
-    CHECK_AND_ASSERT_EQ(asset_owner, eth_pk);
-    return crypto::generate_eth_signature(h, eth_sk, sig);
-    });
-
-  // TODO reconsider this ===>> ctp.p_eth_signer = signer.get();
+  miner_wlt->refresh();
+  alice_wlt->refresh();
 
   ft = finalized_tx{};
-  miner_wlt->transfer(ctp, ft, true, nullptr);
+  alice_wlt->burn_asset(asset_id, amount_to_burn, ft);
+
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+  r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  asset_descriptor_base adb_recent{};
+  r = c.get_blockchain_storage().get_asset_info(asset_id, adb_recent);
+  CHECK_AND_ASSERT_MES(r, false, "get_asset_info failed");
+
+  // make sure the current supply of the asset did change accordingly
+  CHECK_AND_ASSERT_EQ(adb_recent.current_supply, total_amount_expected);
+
+
   //
-  // end of custom emit
+  // ownership transfer (to another ETH key)
   //
+  crypto::eth_secret_key eth_sk_2{};
+  crypto::eth_public_key eth_pk_2{};
+  r = crypto::generate_eth_key_pair(eth_sk_2, eth_pk_2);
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_key_pair failed");
+
+  ft = finalized_tx{};
+  miner_wlt->transfer_asset_ownership(asset_id, eth_pk_2, ft);
+
+  // make sure the transaction didn't get into tx pool (as it's not fully signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // make sure ownership transaction cannot be added to the transaction pool (it's not fully signed atm)
+  tvc = tx_verification_context{};
+  r = c.get_tx_pool().add_tx(ft.tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "unsigned tx was able to be added to the pool");
+
+  // sign asset emit operation with ETH signature
+  eth_sig = crypto::eth_signature{};
+  r = crypto::generate_eth_signature(ft.tx_id, eth_sk, eth_sig); // signing with old eth key
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_signature failed");
+
+  transaction to_tx{};
+  transfers_unlocked = false;
+  miner_wlt->submit_externally_signed_asset_tx(ft, eth_sig, true, to_tx, transfers_unlocked);
+
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+  r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  miner_wlt->refresh();
+
+  //
+  // emit #2
+  //
+  emit_amount = adb.total_max_supply - total_amount_expected; // up to max
+  destinations.clear();
+  destinations.emplace_back(emit_amount, m_accounts[ALICE_ACC_IDX].get_public_address(), null_pkey); // asset
+  ft = finalized_tx{};
+  miner_wlt->emit_asset(asset_id, destinations, ft);
+
+  // make sure the transaction didn't get into tx pool (as it's not fully signed)
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // make sure emit transaction cannot be added to the transaction pool (it's not fully signed atm)
+  r = c.get_tx_pool().add_tx(ft.tx, tvc, false);
+  CHECK_AND_ASSERT_MES(!r, false, "unsigned emit tx was able to be added to the pool");
+
+  // sign asset emit operation with ETH signature
+  eth_sig = crypto::eth_signature{};
+  r = crypto::generate_eth_signature(ft.tx_id, eth_sk_2, eth_sig); // note using ETH key #2 here
+  CHECK_AND_ASSERT_MES(r, false, "generate_eth_signature failed");
+
+  emit_tx = transaction{};
+  transfers_unlocked = false;
+  miner_wlt->submit_externally_signed_asset_tx(ft, eth_sig, true, emit_tx, transfers_unlocked);
+
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 1, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+  r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
+  CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
+  CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Unexpected number of txs in the pool: " << c.get_pool_transactions_count());
+
+  // Alice checks her asset balance
+  alice_wlt->refresh(blocks_fetched);
+  CHECK_AND_ASSERT_EQ(blocks_fetched, 3);
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", adb.total_max_supply, asset_id, adb.decimal_point), false, "");
+  CHECK_AND_ASSERT_MES(check_balance_via_wallet(*alice_wlt, "Alice", MK_TEST_COINS(100) - TESTS_DEFAULT_FEE), false, "");
 
   return true;
 }
@@ -1481,6 +1551,10 @@ eth_signed_asset_via_rpc::eth_signed_asset_via_rpc()
 
 bool eth_signed_asset_via_rpc::generate(std::vector<test_event_entry>& events) const
 {
+  //
+  // Test idea: make sure register, emit, and ownership transfer operations with external signing (ETH signature)
+  // can be done entirely using JSON RPC calls (both, the core RPC and the wallet RPC)
+  //
   uint64_t ts = test_core_time::get_time();
   m_accounts.resize(TOTAL_ACCS_COUNT);
   account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate(); miner_acc.set_createtime(ts);