// Copyright (c) 2014-2026, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers

#include <atomic>
#include <boost/algorithm/string.hpp>
#include "wipeable_string.h"
#include "string_tools.h"
#include "string_tools_lexical.h"
#include "serialization/string.h"
#include "cryptonote_format_utils.h"
#include "cryptonote_config.h"
#include "crypto/crypto.h"
#include "crypto/hash.h"
#include "crypto/hash-ops.h"
#include "fcmp_pp/fcmp_pp_types.h"
#include "ringct/rctOps.h"

using namespace epee;

#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY "cn"

// #define ENABLE_HASH_CASH_INTEGRITY_CHECK

using namespace crypto;

static std::atomic<unsigned int> default_decimal_point(CRYPTONOTE_DISPLAY_DECIMAL_POINT);


#define CHECK_AND_ASSERT_THROW_MES_L1(expr, message) {if(!(expr)) {MWARNING(message); throw std::runtime_error(message);}}

namespace cryptonote
{
  static inline unsigned char *operator &(ec_point &point) {
    return &reinterpret_cast<unsigned char &>(point);
  }
  static inline const unsigned char *operator &(const ec_point &point) {
    return &reinterpret_cast<const unsigned char &>(point);
  }

  // a copy of rct::addKeys, since we can't link to libringct to avoid circular dependencies
  static void add_public_key(crypto::public_key &AB, const crypto::public_key &A, const crypto::public_key &B) {
      ge_p3 B2, A2;
      CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, &B) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
      CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A2, &A) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
      ge_cached tmp2;
      ge_p3_to_cached(&tmp2, &B2);
      ge_p1p1 tmp3;
      ge_add(&tmp3, &A2, &tmp2);
      ge_p1p1_to_p3(&A2, &tmp3);
      ge_p3_tobytes(&AB, &A2);
  }
  //---------------------------------------------------------------
  static uint64_t get_transaction_weight_clawback(const bool plus, const size_t n_outputs, const size_t n_padded_outputs)
  {
    const uint64_t bp_base = (32 * ((plus ? 6 : 9) + 7 * 2)) / 2; // notional size of a 2 output proof, normalized to 1 proof (ie, divided by 2)
    if (n_padded_outputs <= 2)
      return 0;
    size_t nlr = 0;
    while ((1u << nlr) < n_padded_outputs)
      ++nlr;
    nlr += 6;
    const size_t bp_size = 32 * ((plus ? 6 : 9) + 2 * nlr);
    CHECK_AND_ASSERT_THROW_MES_L1(n_outputs <= BULLETPROOF_MAX_OUTPUTS, "maximum number of outputs is " + std::to_string(BULLETPROOF_MAX_OUTPUTS) + " per transaction");
    CHECK_AND_ASSERT_THROW_MES_L1(bp_base * n_padded_outputs >= bp_size, "Invalid bulletproof clawback: bp_base " + std::to_string(bp_base) + ", n_padded_outputs "
        + std::to_string(n_padded_outputs) + ", bp_size " + std::to_string(bp_size));
    const uint64_t bp_clawback = (bp_base * n_padded_outputs - bp_size) * 4 / 5;
    return bp_clawback;
  }

  static void get_tree_hash(const std::vector<crypto::hash>& tx_hashes, crypto::hash& h)
  {
    tree_hash(tx_hashes.data(), tx_hashes.size(), h);
  }

  static crypto::hash get_tree_hash(const std::vector<crypto::hash>& tx_hashes)
  {
    crypto::hash h = null_hash;
    get_tree_hash(tx_hashes, h);
    return h;
  }
  //---------------------------------------------------------------
  static uint64_t get_transaction_weight_clawback(const transaction &tx, const size_t n_padded_outputs)
  {
    const rct::rctSig &rv = tx.rct_signatures;
    const bool plus = rv.type == rct::RCTTypeBulletproofPlus || rv.type == rct::RCTTypeFcmpPlusPlus;
    const size_t n_outputs = tx.vout.size();
    return get_transaction_weight_clawback(plus, n_outputs, n_padded_outputs);
  }
  //---------------------------------------------------------------
  // Helper function to group outputs by last locked block idx
  static uint64_t set_tx_outs_by_last_locked_block(const cryptonote::transaction &tx,
    const std::unordered_map<uint64_t, rct::key> &transparent_amount_commitments,
    const uint64_t &first_unified_id,
    const uint64_t block_idx,
    fcmp_pp::OutsByLastLockedBlock &outs_by_last_locked_block_inout,
    std::unordered_map<uint64_t/*unified_id*/, uint64_t/*last locked block_id*/> &timelocked_outputs_inout)
  {
    const uint64_t last_locked_block = cryptonote::get_last_locked_block_index(tx.unlock_time, block_idx);
    const bool has_custom_timelock = cryptonote::is_custom_timelocked(tx.is_coinbase(),
      last_locked_block,
      block_idx);

    for (std::size_t i = 0; i < tx.vout.size(); ++i)
    {
      const uint64_t unified_id = first_unified_id + i;
      const auto &out = tx.vout[i];

      rct::key commitment;
      CHECK_AND_ASSERT_THROW_MES(cryptonote::get_commitment(tx, i, transparent_amount_commitments, commitment),
          "failed to get tx commitment");

      const fcmp_pp::UnifiedOutput unified_output{
              .unified_id  = unified_id,
              .output_pair = cryptonote::to_output_pair(out.target, commitment)
          };

      if (has_custom_timelock)
      {
          timelocked_outputs_inout[unified_id] = last_locked_block;
      }

      outs_by_last_locked_block_inout[last_locked_block].emplace_back(unified_output);
    }

    return tx.vout.size();
  }
  //---------------------------------------------------------------
  bool passes_max_size_check(const bool max_size_check, const blobdata_ref &tx_blob)
  {
    if (!max_size_check)
      return true;
    return tx_blob.size() <= get_max_tx_size();
  }
  //---------------------------------------------------------------
}

namespace cryptonote
{
  //---------------------------------------------------------------
  void get_transaction_prefix_hash(const transaction_prefix& tx, crypto::hash& h, hw::device &hwdev)
  {
    hwdev.get_transaction_prefix_hash(tx,h);    
  }

  //---------------------------------------------------------------  
  crypto::hash get_transaction_prefix_hash(const transaction_prefix& tx, hw::device &hwdev)
  {
    crypto::hash h = null_hash;
    get_transaction_prefix_hash(tx, h, hwdev);
    return h;
  }
  
  bool expand_transaction_1(transaction &tx, bool base_only)
  {
    if (tx.version >= 2 && !tx.is_coinbase())
    {
      rct::rctSig &rv = tx.rct_signatures;
      if (rv.type == rct::RCTTypeNull)
        return true;
      if (rv.outPk.size() != tx.vout.size())
      {
        LOG_PRINT_L1("Failed to parse transaction from blob, bad outPk size in tx " << get_transaction_hash(tx));
        return false;
      }
      for (size_t n = 0; n < tx.rct_signatures.outPk.size(); ++n)
      {
        crypto::public_key output_public_key;
        if (!get_output_public_key(tx.vout[n], output_public_key))
        {
          LOG_PRINT_L1("Failed to get output public key for output " << n << " in tx " << get_transaction_hash(tx));
          return false;
        }
        rv.outPk[n].dest = rct::pk2rct(output_public_key);
      }

      if (!base_only)
      {
        const bool bulletproof = rct::is_rct_bulletproof(rv.type);
        const bool bulletproof_plus = rct::is_rct_bulletproof_plus(rv.type);
        if (bulletproof_plus)
        {
          if (rv.p.bulletproofs_plus.size() != 1)
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus size in tx " << get_transaction_hash(tx));
            return false;
          }
          if (rv.p.bulletproofs_plus[0].L.size() < 6)
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus L size in tx " << get_transaction_hash(tx));
            return false;
          }
          const size_t max_outputs = rct::n_bulletproof_plus_max_amounts(rv.p.bulletproofs_plus[0]);
          if (max_outputs < tx.vout.size())
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus max outputs in tx " << get_transaction_hash(tx));
            return false;
          }
          const size_t n_amounts = tx.vout.size();
          CHECK_AND_ASSERT_MES(n_amounts == rv.outPk.size(), false, "Internal error filling out V");
          rv.p.bulletproofs_plus[0].V.resize(n_amounts);
          for (size_t i = 0; i < n_amounts; ++i)
            rv.p.bulletproofs_plus[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
        }
        else if (bulletproof)
        {
          if (rv.p.bulletproofs.size() != 1)
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs size in tx " << get_transaction_hash(tx));
            return false;
          }
          if (rv.p.bulletproofs[0].L.size() < 6)
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs L size in tx " << get_transaction_hash(tx));
            return false;
          }
          const size_t max_outputs = 1 << (rv.p.bulletproofs[0].L.size() - 6);
          if (max_outputs < tx.vout.size())
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs max outputs in tx " << get_transaction_hash(tx));
            return false;
          }
          const size_t n_amounts = tx.vout.size();
          CHECK_AND_ASSERT_MES(n_amounts == rv.outPk.size(), false, "Internal error filling out V");
          rv.p.bulletproofs[0].V.resize(n_amounts);
          for (size_t i = 0; i < n_amounts; ++i)
            rv.p.bulletproofs[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
        }
      }
    }
    return true;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_tx_from_blob(const blobdata_ref& tx_blob, transaction& tx, const bool max_size_check)
  {
    CHECK_AND_ASSERT_MES(passes_max_size_check(max_size_check, tx_blob), false, "Tx blob too big");
    binary_archive<false> ba{epee::strspan<std::uint8_t>(tx_blob)};
    bool r = ::serialization::serialize(ba, tx);
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
    CHECK_AND_ASSERT_MES(expand_transaction_1(tx, false), false, "Failed to expand transaction data");
    tx.invalidate_hashes();
    tx.set_blob_size(tx_blob.size());
    return true;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_tx_base_from_blob(const blobdata_ref& tx_blob, transaction& tx, const bool max_size_check)
  {
    CHECK_AND_ASSERT_MES(passes_max_size_check(max_size_check, tx_blob), false, "Tx blob too big");
    binary_archive<false> ba{epee::strspan<std::uint8_t>(tx_blob)};
    bool r = tx.serialize_base(ba);
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
    CHECK_AND_ASSERT_MES(expand_transaction_1(tx, true), false, "Failed to expand transaction data");
    tx.invalidate_hashes();
    return true;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_tx_prefix_from_blob(const blobdata_ref& tx_blob, transaction_prefix& tx, const bool max_size_check)
  {
    CHECK_AND_ASSERT_MES(passes_max_size_check(max_size_check, tx_blob), false, "Tx blob too big");
    binary_archive<false> ba{epee::strspan<std::uint8_t>(tx_blob)};
    bool r = ::serialization::serialize_noeof(ba, tx);
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction prefix from blob");
    return true;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_tx_from_blob(const blobdata_ref& tx_blob, transaction& tx, crypto::hash& tx_hash, const bool max_size_check)
  {
    CHECK_AND_ASSERT_MES(passes_max_size_check(max_size_check, tx_blob), false, "Tx blob too big");
    binary_archive<false> ba{epee::strspan<std::uint8_t>(tx_blob)};
    bool r = ::serialization::serialize(ba, tx);
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
    CHECK_AND_ASSERT_MES(expand_transaction_1(tx, false), false, "Failed to expand transaction data");
    tx.invalidate_hashes();
    tx.set_blob_size(tx_blob.size());
    //TODO: validate tx

    return get_transaction_hash(tx, tx_hash);
  }
  //---------------------------------------------------------------
  bool parse_and_validate_tx_from_blob(const blobdata_ref& tx_blob, transaction& tx, crypto::hash& tx_hash, crypto::hash& tx_prefix_hash, const bool max_size_check)
  {
    if (!parse_and_validate_tx_from_blob(tx_blob, tx, tx_hash, max_size_check))
      return false;
    get_transaction_prefix_hash(tx, tx_prefix_hash);
    return true;
  }
  //------------------------------------------------------------------
  size_t get_tx_version(const blobdata_ref tx_blob)
  {
    size_t version;
    const char* begin = reinterpret_cast<const char*>(tx_blob.data());
    const char* end = begin + tx_blob.size();
    int read = tools::read_varint(begin, end, version);
    if (read <= 0)
      throw std::runtime_error("Internal error getting transaction version");
    return version;
  }
  //---------------------------------------------------------------
  bool is_v1_tx(const blobdata_ref& tx_blob)
  {
    uint64_t version;
    const char* begin = static_cast<const char*>(tx_blob.data());
    const char* end = begin + tx_blob.size();
    int read = tools::read_varint(begin, end, version);
    if (read <= 0)
      throw std::runtime_error("Internal error getting transaction version");
    return version <= 1;
  }
  //---------------------------------------------------------------
  bool is_v1_tx(const blobdata& tx_blob)
  {
    return is_v1_tx(blobdata_ref{tx_blob.data(), tx_blob.size()});
  }
  //---------------------------------------------------------------
  bool get_transaction_unprunable_summary(const blobdata_ref tx_blob, unprunable_summary_t &summary_out)
  {
    const unsigned char *p = reinterpret_cast<const unsigned char*>(tx_blob.data());
    const unsigned char *end = reinterpret_cast<const unsigned char*>(tx_blob.data() + tx_blob.size());

    #define READ_VARINT(v) if (tools::read_varint(p, end, v) <= 0) return false
    #define READ_BYTE(v) if (end <= p ) { return false; } else { v = *p; ++p; }
    #define SKIP(n) if (end - p < static_cast<std::ptrdiff_t>(n)) { return false; } else { p += (n); }

    // read and validate tx version
    READ_VARINT(summary_out.version);
    if (summary_out.version < 1 || summary_out.version > 2)
      return false;

    // skip unlock_time
    std::uint64_t dummy;
    READ_VARINT(dummy);

    // read number of inputs
    READ_VARINT(summary_out.n_inputs);

    // skip n_inputs inputs, checking for coinbase inputs
    summary_out.is_coinbase = false;
    for (std::size_t i = 0; i < summary_out.n_inputs; ++i)
    {
      std::size_t input_tag = 0;
      READ_BYTE(input_tag);
      switch (input_tag)
      {
      case 0xff: //txin_gen
        summary_out.is_coinbase = true;
        READ_VARINT(dummy); //height
        break;
      case 0x02: //txin_to_key
        READ_VARINT(dummy); //amount
        READ_VARINT(input_tag); //key_offsets.size()
        for (;input_tag-->0;)
          READ_VARINT(dummy);
        SKIP(32); //k_image
        break;
      default:
        return false;
      }
    }

    // read number of outputs
    READ_VARINT(summary_out.n_outputs);

    // skip n_outputs outputs
    for (std::size_t i = 0; i < summary_out.n_outputs; ++i)
    {
      READ_VARINT(dummy); //amount
      std::size_t output_tag = 0;
      READ_BYTE(output_tag); //target variant tag
      std::ptrdiff_t output_length = 0;
      switch (output_tag)
      {
      case 0x01: //txout_to_carrot_v1
        output_length = 32 + 3 + 16;
        static_assert(sizeof(cryptonote::txout_to_carrot_v1) == 32+3+16, "Unexpected sizeof txout_to_carrot_v1");
        break;
      case 0x02: //txout_to_key
        output_length = 32;
        static_assert(sizeof(cryptonote::txout_to_key) == 32, "Unexpected sizeof txout_to_key");
        break;
      case 0x03: //txout_to_tagged_key
        output_length = 32 + 1;
        static_assert(sizeof(cryptonote::txout_to_tagged_key) == 32+1, "Unexpected sizeof txout_to_tagged_key");
        break;
      default:
        return false;
      }
      SKIP(output_length);
    }

    // read extra length and skip that
    READ_VARINT(summary_out.extra_len);
    if (summary_out.extra_len > CRYPTONOTE_MAX_TX_SIZE)
      return false;
    SKIP(summary_out.extra_len);

    // now `p` is at end of tx prefix...
    summary_out.prefix_size = reinterpret_cast<const char*>(p) - tx_blob.data();

    if (2 == summary_out.version)
    {
      // read RingCT type
      std::uint8_t rct_type = std::numeric_limits<std::uint8_t>::max();
      READ_BYTE(rct_type);
      if (rct_type > rct::RCTTypeFcmpPlusPlus)
        return false;

      // skip unprunable RingCT fields
      if (rct_type != rct::RCTTypeNull)
      {
        // skip txnFee
        READ_VARINT(dummy);

        // if RCTTypeSimple, skip pseudoOutputs
        if (rct_type == rct::RCTTypeSimple)
        {
          SKIP(32 * summary_out.n_inputs);
        }

        // skip ECDH info and amount commitments
        const bool short_amount = rct_type >= rct::RCTTypeBulletproof2;
        const std::ptrdiff_t ecdh_tuple_len = short_amount ? 8 : 64;
        const std::ptrdiff_t output_stuff_len = summary_out.n_outputs * (ecdh_tuple_len + 32);
        SKIP(output_stuff_len);
      }
    }

    #undef READ_VARINT
    #undef READ_BYTE
    #undef SKIP

    // now `p` is at end of unprunable part of v2 tx...
    summary_out.unprunable_size = reinterpret_cast<const char*>(p) - tx_blob.data();

    return true;
  }
  //---------------------------------------------------------------
  bool generate_key_image_helper(const account_keys& ack, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, const crypto::public_key& out_key, const crypto::public_key& tx_public_key, const std::vector<crypto::public_key>& additional_tx_public_keys, size_t real_output_index, keypair& in_ephemeral, crypto::key_image& ki, hw::device &hwdev)
  {
    crypto::key_derivation recv_derivation{};
    bool r = hwdev.generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
    if (!r)
    {
      MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", <viewkey>)");
      memcpy(&recv_derivation, rct::identity().bytes, sizeof(recv_derivation));
    }

    std::vector<crypto::key_derivation> additional_recv_derivations;
    for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
    {
      crypto::key_derivation additional_recv_derivation{};
      r = hwdev.generate_key_derivation(additional_tx_public_keys[i], ack.m_view_secret_key, additional_recv_derivation);
      if (!r)
      {
        MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", <viewkey>)");
        memcpy(&additional_recv_derivation, rct::identity().bytes, sizeof(additional_recv_derivation));
      }
      additional_recv_derivations.push_back(additional_recv_derivation);
    }

    boost::optional<subaddress_receive_info> subaddr_recv_info = is_out_to_acc_precomp(subaddresses, out_key, recv_derivation, additional_recv_derivations, real_output_index,hwdev);
    CHECK_AND_ASSERT_MES(subaddr_recv_info, false, "key image helper: given output pubkey doesn't seem to belong to this address");

    return generate_key_image_helper_precomp(ack, out_key, subaddr_recv_info->derivation, real_output_index, subaddr_recv_info->index, in_ephemeral, ki, hwdev);
  }
  //---------------------------------------------------------------
  bool generate_key_image_helper_precomp(const account_keys& ack, const crypto::public_key& out_key, const crypto::key_derivation& recv_derivation, size_t real_output_index, const subaddress_index& received_index, keypair& in_ephemeral, crypto::key_image& ki, hw::device &hwdev)
  {
    if (hwdev.compute_key_image(ack, out_key, recv_derivation, real_output_index, received_index, in_ephemeral, ki))
    {
      return true;
    }

    if (ack.m_spend_secret_key == crypto::null_skey)
    {
      // for watch-only wallet, simply copy the known output pubkey
      in_ephemeral.pub = out_key;
      in_ephemeral.sec = crypto::null_skey;
    }
    else
    {
      // derive secret key with subaddress - step 1: original CN derivation
      crypto::secret_key scalar_step1;
      crypto::secret_key spend_skey = crypto::null_skey;

      if (ack.m_multisig_keys.empty())
      {
        // if not multisig, use normal spend skey
        spend_skey = ack.m_spend_secret_key;
      }
      else
      {
        // if multisig, use sum of multisig privkeys (local account's share of aggregate spend key)
        for (const auto &multisig_key : ack.m_multisig_keys)
        {
          sc_add((unsigned char*)spend_skey.data,
            (const unsigned char*)multisig_key.data,
            (const unsigned char*)spend_skey.data);
        }
      }

      // computes Hs(a*R || idx) + b
      hwdev.derive_secret_key(recv_derivation, real_output_index, spend_skey, scalar_step1);

      // step 2: add Hs(a || index_major || index_minor)
      crypto::secret_key subaddr_sk;
      crypto::secret_key scalar_step2;
      if (received_index.is_zero())
      {
        scalar_step2 = scalar_step1;    // treat index=(0,0) as a special case representing the main address
      }
      else
      {
        subaddr_sk = hwdev.get_subaddress_secret_key(ack.m_view_secret_key, received_index);
        hwdev.sc_secret_add(scalar_step2, scalar_step1,subaddr_sk);
      }

      in_ephemeral.sec = scalar_step2;

      if (ack.m_multisig_keys.empty())
      {
        // when not in multisig, we know the full spend secret key, so the output pubkey can be obtained by scalarmultBase
        CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(in_ephemeral.sec, in_ephemeral.pub), false, "Failed to derive public key");
      }
      else
      {
        // when in multisig, we only know the partial spend secret key. but we do know the full spend public key, so the output pubkey can be obtained by using the standard CN key derivation
        CHECK_AND_ASSERT_MES(hwdev.derive_public_key(recv_derivation, real_output_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub), false, "Failed to derive public key");
        // and don't forget to add the contribution from the subaddress part
        if (!received_index.is_zero())
        {
          crypto::public_key subaddr_pk;
          CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(subaddr_sk, subaddr_pk), false, "Failed to derive public key");
          add_public_key(in_ephemeral.pub, in_ephemeral.pub, subaddr_pk);
        }
      }

      CHECK_AND_ASSERT_MES(in_ephemeral.pub == out_key,
           false, "key image helper precomp: given output pubkey doesn't match the derived one");
    }

    hwdev.generate_key_image(in_ephemeral.pub, in_ephemeral.sec, ki);
    return true;
  }
  //---------------------------------------------------------------
  bool parse_amount(uint64_t& amount, const std::string& str_amount_)
  {
    std::string str_amount = str_amount_;
    boost::algorithm::trim(str_amount);

    size_t point_index = str_amount.find_first_of('.');
    size_t fraction_size;
    if (std::string::npos != point_index)
    {
      fraction_size = str_amount.size() - point_index - 1;
      while (default_decimal_point < fraction_size && '0' == str_amount.back())
      {
        str_amount.erase(str_amount.size() - 1, 1);
        --fraction_size;
      }
      if (default_decimal_point < fraction_size)
        return false;
      str_amount.erase(point_index, 1);
    }
    else
    {
      fraction_size = 0;
    }

    if (str_amount.empty())
      return false;

    if (fraction_size < default_decimal_point)
    {
      str_amount.append(default_decimal_point - fraction_size, '0');
    }

    return string_tools::get_xtype_from_string(amount, str_amount);
  }
  //---------------------------------------------------------------
  uint64_t get_fcmp_pp_prefix_weight_v1(const size_t n_inputs, const size_t n_outputs, const size_t extra_len)
  {
    MTRACE(__func__ << "(n_inputs=" << n_inputs << ", n_outputs=" << n_outputs << ", extra_len=" << extra_len);

    CHECK_AND_ASSERT_MES(n_inputs && n_inputs <= FCMP_PLUS_PLUS_MAX_INPUTS,
      std::numeric_limits<uint64_t>::max(),
      "invalid n_inputs: " << n_inputs);
    CHECK_AND_ASSERT_MES(n_outputs >= 2 && n_outputs <= FCMP_PLUS_PLUS_MAX_OUTPUTS,
      std::numeric_limits<uint64_t>::max(),
      "invalid n_outputs: " << n_outputs);
    CHECK_AND_ASSERT_MES(extra_len <= MAX_TX_EXTRA_SIZE,
      std::numeric_limits<uint64_t>::max(),
      "invalid extra_len: " << extra_len);

    static constexpr uint64_t txin_to_key_weight = 1 /*amount=0*/ + 1 /*key_offsets.size()=0*/ + 32 /*k_image*/;
    static constexpr uint64_t txout_to_carrot_weight = 32 /*key*/ + 3 /*view_tag*/ + 16 /*encrypted_janus_anchor*/;
    static constexpr uint64_t tx_out_weight = 1 /*amount=0*/ + txout_to_carrot_weight + 1 /*txout_target_v tag*/;

    // varint len bumps from 2 to 3 at 16384
    static_assert(16384 > FCMP_PLUS_PLUS_MAX_INPUTS, "16384 expected > FCMP_PLUS_PLUS_MAX_INPUTS");
    static_assert(16384 > MAX_TX_EXTRA_SIZE,         "16384 expected > MAX_TX_EXTRA_SIZE");

    // varint len bumps from 1 to 2 at 128
    static_assert(128 > FCMP_PLUS_PLUS_MAX_OUTPUTS, "128 expected > FCMP_PLUS_PLUS_MAX_OUTPUTS");

    return
      1 /*version=2*/
      + 1 /*unlock_time=0*/
      + (n_inputs >= 128 ? 2 : 1) /*vin.size()<=FCMP_PLUS_PLUS_MAX_INPUTS*/
      + n_inputs * (txin_to_key_weight /*txin_to_key*/ + 1 /*txin_v tag*/)
      + 1 /*vout.size()<=FCMP_PLUS_PLUS_MAX_OUTPUTS*/
      + (n_outputs * tx_out_weight /*tx_out*/)
      + (extra_len >= 128 ? 2 : 1) /*extra.size()*/
      + extra_len;
  }
  //---------------------------------------------------------------
  uint64_t get_fcmp_pp_unprunable_weight_v1(const size_t n_inputs, const size_t n_outputs, const size_t extra_len)
  {
    MTRACE(__func__ << "(n_inputs=" << n_inputs << ", n_outputs=" << n_outputs << ", extra_len=" << extra_len);

    const uint64_t prefix_weight = get_fcmp_pp_prefix_weight_v1(n_inputs, n_outputs, extra_len);
    if (prefix_weight == std::numeric_limits<uint64_t>::max())
      return prefix_weight;

    static constexpr uint64_t max_u64_varint_len = 10;        // size of varint storing 2**64-1
    static constexpr uint64_t rct_sig_base_per_out_weight = 8 /*ecdhInfo.at(i).amount*/ + 32 /*outPk.at(i).mask*/;

    return prefix_weight
      + 1 /*type*/
      + max_u64_varint_len /*txnFee*/
      + (n_outputs * rct_sig_base_per_out_weight);
  }
  //---------------------------------------------------------------
  uint64_t get_fcmp_pp_transaction_weight_v1(const size_t n_inputs, const size_t n_outputs, const size_t extra_len)
  {
    MTRACE(__func__ << "(n_inputs=" << n_inputs << ", n_outputs=" << n_outputs << ", extra_len=" << extra_len);

    const uint64_t unprunable_weight = get_fcmp_pp_unprunable_weight_v1(n_inputs, n_outputs, extra_len);
    if (unprunable_weight == std::numeric_limits<uint64_t>::max())
      return unprunable_weight;

    static constexpr uint64_t max_block_index_varint_len = 5; // size of varint storing CRYPTONOTE_MAX_BLOCK_NUMBER

    static constexpr uint64_t rerandomized_output_weight = FCMP_PP_INPUT_TUPLE_SIZE_V1 + 32 /*C~ AKA pseudoOut*/;

    const uint64_t total_sal_weight = n_inputs * (rerandomized_output_weight + FCMP_PP_SAL_PROOF_SIZE_V1);
    const uint64_t misc_fcmp_pp_weight = max_block_index_varint_len /*reference_block*/ + 1 /*n_tree_layers*/;

    // Calculate deterministic bulletproofs size (assumes canonical BP format)
    size_t nrl = 0, n_padded_outputs;
    while ((n_padded_outputs = (1u << nrl)) < n_outputs)
      ++nrl;
    nrl += 6;
    uint64_t bp_weight = 32 * (6 + 2 * nrl) + 2;
    bp_weight += 1 /*nbp*/;

    // There's a few reasons why we treat n_tree_layers as a fixed value for weight calculation:
    //     a. If we took n_tree_layers into account when calculating weight, then fee calculation
    //        would be a function of the number of layers in the FCMP tree. This has a couple
    //        implications:
    //            i.  To determine the "correct" fee in multi-signer/cold-signer contexts, signers
    //                would have to transmit and agree upon what the current n_tree_layers value is,
    //                which complicates these protocols, and is inherently difficult to validate
    //                for offline signers. It also just complicates the process for normal wallets.
    //            ii. If signers need guarantees that a signature for a transaction proposal with a
    //                certain fee isn't reused for similar transaction but with a different
    //                n_tree_layers, and thus weight, then n_tree_layers would have to be included
    //                in rctSigBase and hashed into the signable_tx_hash, which means an extra byte
    //                per pruned transaction when wallets are refreshing. Also, more subjectively,
    //                putting n_tree_layers into rctSigBase feels misplaced.
    //     b. Dropping the weight for low values of n_tree_layers directly incentivizes spenders of
    //        old enotes to use as small a value of n_tree_layers as possible, which hurts their
    //        anonymity.
    //
    // We chose 7 specifically because at the time of writing (9 April 2025), the current layer size
    // of the Monero mainnet would be 6. 7 is approaching relatively quickly, and would be the value
    // for many decades at the current tx volume.
    static constexpr size_t fake_n_tree_layers = 7;
    const uint64_t fcmp_weight = fcmp_pp::membership_proof_len(n_inputs, fake_n_tree_layers);

    const uint64_t rct_sig_prunable_weight = bp_weight + total_sal_weight + misc_fcmp_pp_weight + fcmp_weight;

    return unprunable_weight + rct_sig_prunable_weight;
  }
  //---------------------------------------------------------------
  uint64_t get_fcmp_pp_transaction_weight_v1(const transaction_prefix &tx_prefix)
  {
    return get_fcmp_pp_transaction_weight_v1(tx_prefix.vin.size(), tx_prefix.vout.size(), tx_prefix.extra.size());
  }
  //---------------------------------------------------------------
  uint64_t get_transaction_weight(const transaction &tx, size_t blob_size)
  {
    CHECK_AND_ASSERT_MES(!tx.pruned, std::numeric_limits<uint64_t>::max(), "get_transaction_weight does not support pruned txes");
    CHECK_AND_ASSERT_MES(tx.rct_signatures.type <= rct::RCTTypeFcmpPlusPlus,
      std::numeric_limits<uint64_t>::max(),
      "get_transaction_weight does not support transactions newer than FCMP++ v1");
    if (tx.version < 2)
      return blob_size;
    else if (tx.rct_signatures.type == rct::RCTTypeFcmpPlusPlus)
      return get_fcmp_pp_transaction_weight_v1(tx);
    const rct::rctSig &rv = tx.rct_signatures;
    const bool bulletproof = rct::is_rct_bulletproof(rv.type);
    const bool bulletproof_plus = rct::is_rct_bulletproof_plus(rv.type);
    if (!bulletproof && !bulletproof_plus)
      return blob_size;
    const size_t n_padded_outputs = bulletproof_plus ? rct::n_bulletproof_plus_max_amounts(rv.p.bulletproofs_plus) : rct::n_bulletproof_max_amounts(rv.p.bulletproofs);
    uint64_t bp_clawback = get_transaction_weight_clawback(tx, n_padded_outputs);
    CHECK_AND_ASSERT_THROW_MES_L1(bp_clawback <= std::numeric_limits<uint64_t>::max() - blob_size, "Weight overflow");
    return blob_size + bp_clawback;
  }
  //---------------------------------------------------------------
  uint64_t get_pruned_transaction_weight(const transaction &tx)
  {
    CHECK_AND_ASSERT_MES(tx.pruned, std::numeric_limits<uint64_t>::max(), "get_pruned_transaction_weight does not support non pruned txes");
    CHECK_AND_ASSERT_MES(tx.version >= 2, std::numeric_limits<uint64_t>::max(), "get_pruned_transaction_weight does not support v1 txes");

    if (tx.rct_signatures.type == rct::RCTTypeFcmpPlusPlus)
      return get_fcmp_pp_transaction_weight_v1(tx);

    CHECK_AND_ASSERT_MES(tx.rct_signatures.type == rct::RCTTypeBulletproof2 || tx.rct_signatures.type == rct::RCTTypeCLSAG || tx.rct_signatures.type == rct::RCTTypeBulletproofPlus,
        std::numeric_limits<uint64_t>::max(), "Unsupported rct_signatures type in get_pruned_transaction_weight");
    CHECK_AND_ASSERT_MES(!tx.vin.empty(), std::numeric_limits<uint64_t>::max(), "empty vin");
    CHECK_AND_ASSERT_MES(tx.vin[0].type() == typeid(cryptonote::txin_to_key), std::numeric_limits<uint64_t>::max(), "empty vin");

    // get pruned data size
    std::ostringstream s;
    binary_archive<true> a(s);
    ::serialization::serialize(a, const_cast<transaction&>(tx));
    uint64_t weight = s.str().size(), extra;

    // nbps (technically varint)
    weight += 1;

    // calculate deterministic bulletproofs size (assumes canonical BP format)
    size_t nrl = 0, n_padded_outputs;
    while ((n_padded_outputs = (1u << nrl)) < tx.vout.size())
      ++nrl;
    nrl += 6;
    extra = 32 * ((rct::is_rct_bulletproof_plus(tx.rct_signatures.type) ? 6 : 9) + 2 * nrl) + 2;
    weight += extra;

    // calculate deterministic CLSAG/MLSAG data size
    // TODO: update for fcmp_pp
    const size_t ring_size = boost::get<cryptonote::txin_to_key>(tx.vin[0]).key_offsets.size();
    if (rct::is_rct_clsag(tx.rct_signatures.type))
      extra = tx.vin.size() * (ring_size + 2) * 32;
    else
      extra = tx.vin.size() * (ring_size * (1 + 1) * 32 + 32 /* cc */);
    weight += extra;

    // calculate deterministic pseudoOuts size
    extra =  32 * (tx.vin.size());
    weight += extra;

    // clawback
    uint64_t bp_clawback = get_transaction_weight_clawback(tx, n_padded_outputs);
    CHECK_AND_ASSERT_THROW_MES_L1(bp_clawback <= std::numeric_limits<uint64_t>::max() - weight, "Weight overflow");
    weight += bp_clawback;

    return weight;
  }
  //---------------------------------------------------------------
  uint64_t get_transaction_weight(const transaction &tx)
  {
    size_t blob_size;
    if (tx.is_blob_size_valid())
    {
      blob_size = tx.blob_size;
    }
    else
    {
      std::ostringstream s;
      binary_archive<true> a(s);
      ::serialization::serialize(a, const_cast<transaction&>(tx));
      blob_size = s.str().size();
    }
    return get_transaction_weight(tx, blob_size);
  }
  //---------------------------------------------------------------
  uint64_t get_transaction_blob_size(const transaction& tx)
  {
    if (!tx.is_blob_size_valid())
    {
      const cryptonote::blobdata tx_blob = tx_to_blob(tx);
      tx.set_blob_size(tx_blob.size());
    }

    CHECK_AND_ASSERT_THROW_MES(tx.is_blob_size_valid(), "BUG: blob size valid not set");

    return tx.blob_size;
  }
  //---------------------------------------------------------------
  bool prune_transaction_blob(cryptonote::blobdata &tx_blob)
  {
    // Deserialize unprunable part to retrieve size
    unprunable_summary_t desc;
    if (!get_transaction_unprunable_summary(tx_blob, desc))
      return false;

    CHECK_AND_ASSERT_MES(desc.unprunable_size <= tx_blob.size(), false, "Unprunable size is larger than tx blob");
    tx_blob.resize(desc.unprunable_size);

    return true;
  }
  //---------------------------------------------------------------
  bool get_tx_fee(const transaction& tx, uint64_t & fee)
  {
    if (tx.version > 1)
    {
      fee = tx.rct_signatures.txnFee;
      return true;
    }
    uint64_t amount_in = 0;
    uint64_t amount_out = 0;
    for(auto& in: tx.vin)
    {
      CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), 0, "unexpected type id in transaction");
      amount_in += boost::get<txin_to_key>(in).amount;
    }
    for(auto& o: tx.vout)
      amount_out += o.amount;

    CHECK_AND_ASSERT_MES(amount_in >= amount_out, false, "transaction spend (" <<amount_in << ") more than it has (" << amount_out << ")");
    fee = amount_in - amount_out;
    return true;
  }
  //---------------------------------------------------------------
  uint64_t get_tx_fee(const transaction& tx)
  {
    uint64_t r = 0;
    if(!get_tx_fee(tx, r))
      return 0;
    return r;
  }
  //---------------------------------------------------------------
  bool parse_tx_extra(const std::vector<uint8_t>& tx_extra, std::vector<tx_extra_field>& tx_extra_fields)
  {
    tx_extra_fields.clear();

    if(tx_extra.empty())
      return true;

    binary_archive<false> ar{epee::to_span(tx_extra)};

    do
    {
      tx_extra_field field;
      bool r = ::do_serialize(ar, field);
      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
      tx_extra_fields.push_back(field);
    } while (!ar.eof());
    CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));

    return true;
  }
  //---------------------------------------------------------------
  template<typename T>
  static bool pick(binary_archive<true> &ar, std::vector<tx_extra_field> &fields, uint8_t tag)
  {
    std::vector<tx_extra_field>::iterator it;
    while ((it = std::find_if(fields.begin(), fields.end(), [](const tx_extra_field &f) { return f.type() == typeid(T); })) != fields.end())
    {
      bool r = ::do_serialize(ar, tag);
      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to serialize tx extra field");
      r = ::do_serialize(ar, boost::get<T>(*it));
      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to serialize tx extra field");
      fields.erase(it);
    }
    return true;
  }
  //---------------------------------------------------------------
  bool sort_tx_extra(const std::vector<uint8_t>& tx_extra, std::vector<uint8_t> &sorted_tx_extra, bool allow_partial)
  {
    std::vector<tx_extra_field> tx_extra_fields;

    if(tx_extra.empty())
    {
      sorted_tx_extra.clear();
      return true;
    }

    binary_archive<false> ar{epee::to_span(tx_extra)};

    size_t processed = 0;
    do
    {
      tx_extra_field field;
      bool r = ::do_serialize(ar, field);
      if (!r)
      {
        MWARNING("failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
        if (!allow_partial)
          return false;
        break;
      }
      tx_extra_fields.push_back(field);
      processed = ar.getpos();
    } while (!ar.eof());
    if (!::serialization::check_stream_state(ar))
    {
      MWARNING("failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
      if (!allow_partial)
        return false;
    }
    MTRACE("Sorted " << processed << "/" << tx_extra.size());

    std::ostringstream oss;
    binary_archive<true> nar(oss);

    // sort by:
    if (!pick<tx_extra_pub_key>(nar, tx_extra_fields, TX_EXTRA_TAG_PUBKEY)) return false;
    if (!pick<tx_extra_additional_pub_keys>(nar, tx_extra_fields, TX_EXTRA_TAG_ADDITIONAL_PUBKEYS)) return false;
    if (!pick<tx_extra_nonce>(nar, tx_extra_fields, TX_EXTRA_NONCE)) return false;
    if (!pick<tx_extra_merge_mining_tag>(nar, tx_extra_fields, TX_EXTRA_MERGE_MINING_TAG)) return false;
    if (!pick<tx_extra_mysterious_minergate>(nar, tx_extra_fields, TX_EXTRA_MYSTERIOUS_MINERGATE_TAG)) return false;
    if (!pick<tx_extra_padding>(nar, tx_extra_fields, TX_EXTRA_TAG_PADDING)) return false;

    // if not empty, someone added a new type and did not add a case above
    if (!tx_extra_fields.empty())
    {
      MERROR("tx_extra_fields not empty after sorting, someone forgot to add a case above");
      return false;
    }

    std::string oss_str = oss.str();
    if (allow_partial && processed < tx_extra.size())
    {
      MDEBUG("Appending unparsed data");
      oss_str += std::string((const char*)tx_extra.data() + processed, tx_extra.size() - processed);
    }
    sorted_tx_extra = std::vector<uint8_t>(oss_str.begin(), oss_str.end());
    return true;
  }
  //---------------------------------------------------------------
  crypto::public_key get_tx_pub_key_from_extra(const std::vector<uint8_t>& tx_extra, size_t pk_index)
  {
    std::vector<tx_extra_field> tx_extra_fields;
    parse_tx_extra(tx_extra, tx_extra_fields);

    tx_extra_pub_key pub_key_field;
    if(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index))
      return null_pkey;

    return pub_key_field.pub_key;
  }
  //---------------------------------------------------------------
  crypto::public_key get_tx_pub_key_from_extra(const transaction_prefix& tx_prefix, size_t pk_index)
  {
    return get_tx_pub_key_from_extra(tx_prefix.extra, pk_index);
  }
  //---------------------------------------------------------------
  crypto::public_key get_tx_pub_key_from_extra(const transaction& tx, size_t pk_index)
  {
    return get_tx_pub_key_from_extra(tx.extra, pk_index);
  }
  //---------------------------------------------------------------
  bool add_tx_pub_key_to_extra(transaction& tx, const crypto::public_key& tx_pub_key)
  {
    return add_tx_pub_key_to_extra(tx.extra, tx_pub_key);
  }
  //---------------------------------------------------------------
  bool add_tx_pub_key_to_extra(transaction_prefix& tx, const crypto::public_key& tx_pub_key)
  {
    return add_tx_pub_key_to_extra(tx.extra, tx_pub_key);
  }
  //---------------------------------------------------------------
  bool add_tx_pub_key_to_extra(std::vector<uint8_t>& tx_extra, const crypto::public_key& tx_pub_key)
  {
    tx_extra.resize(tx_extra.size() + 1 + sizeof(crypto::public_key));
    tx_extra[tx_extra.size() - 1 - sizeof(crypto::public_key)] = TX_EXTRA_TAG_PUBKEY;
    *reinterpret_cast<crypto::public_key*>(&tx_extra[tx_extra.size() - sizeof(crypto::public_key)]) = tx_pub_key;
    return true;
  }
  //---------------------------------------------------------------
  std::vector<crypto::public_key> get_additional_tx_pub_keys_from_extra(const std::vector<uint8_t>& tx_extra)
  {
    // parse
    std::vector<tx_extra_field> tx_extra_fields;
    parse_tx_extra(tx_extra, tx_extra_fields);
    // find corresponding field
    tx_extra_additional_pub_keys additional_pub_keys;
    if(!find_tx_extra_field_by_type(tx_extra_fields, additional_pub_keys))
      return {};
    return additional_pub_keys.data;
  }
  //---------------------------------------------------------------
  std::vector<crypto::public_key> get_additional_tx_pub_keys_from_extra(const transaction_prefix& tx)
  {
    return get_additional_tx_pub_keys_from_extra(tx.extra);
  }
  //---------------------------------------------------------------
  bool add_additional_tx_pub_keys_to_extra(std::vector<uint8_t>& tx_extra, const std::vector<crypto::public_key>& additional_pub_keys)
  {
    // convert to variant
    tx_extra_field field = tx_extra_additional_pub_keys{ additional_pub_keys };
    // serialize
    std::ostringstream oss;
    binary_archive<true> ar(oss);
    bool r = ::do_serialize(ar, field);
    CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to serialize tx extra additional tx pub keys");
    // append
    std::string tx_extra_str = oss.str();
    size_t pos = tx_extra.size();
    tx_extra.resize(tx_extra.size() + tx_extra_str.size());
    memcpy(&tx_extra[pos], tx_extra_str.data(), tx_extra_str.size());
    return true;
  }
  //---------------------------------------------------------------
  bool add_extra_nonce_to_tx_extra(std::vector<uint8_t>& tx_extra, const blobdata& extra_nonce)
  {
    CHECK_AND_ASSERT_MES(extra_nonce.size() <= TX_EXTRA_NONCE_MAX_COUNT, false, "extra nonce could be 255 bytes max");
    size_t start_pos = tx_extra.size();
    const std::size_t len_varint_bytes = tools::get_varint_byte_size(extra_nonce.size());
    tx_extra.resize(tx_extra.size() + 1 + len_varint_bytes + extra_nonce.size());
    //write tag
    tx_extra[start_pos] = TX_EXTRA_NONCE;
    //write len
    ++start_pos;
    unsigned char * vp = tx_extra.data() + start_pos;
    tools::write_varint(vp, extra_nonce.size());
    assert(vp == tx_extra.data() + tx_extra.size() - extra_nonce.size());
    //write data
    start_pos += len_varint_bytes;
    if (!extra_nonce.empty())
      memcpy(&tx_extra[start_pos], extra_nonce.data(), extra_nonce.size());
    return true;
  }
  //---------------------------------------------------------------
  bool add_mm_merkle_root_to_tx_extra(std::vector<uint8_t>& tx_extra, const crypto::hash& mm_merkle_root, uint64_t mm_merkle_tree_depth)
  {
    size_t start_pos = tx_extra.size();
    static const size_t max_varint_size = 16;
    tx_extra.resize(tx_extra.size() + 2 + 32 + max_varint_size);
    //write tag
    tx_extra[start_pos] = TX_EXTRA_MERGE_MINING_TAG;
    //write data size
    ++start_pos;
    const off_t len_bytes = start_pos;
    // one byte placeholder for length since we'll only know the size later after writing a varint
    tx_extra[start_pos] = 0;
    //write depth varint
    ++start_pos;
    uint8_t *ptr = &tx_extra[start_pos], *start = ptr;
    tools::write_varint(ptr, mm_merkle_tree_depth);
    //write data
    const size_t varint_size = ptr - start;
    start_pos += varint_size;
    memcpy(&tx_extra[start_pos], &mm_merkle_root, 32);
    tx_extra.resize(tx_extra.size() - (max_varint_size - varint_size));
    tx_extra[len_bytes] = 32 + varint_size;
    return true;
  }
  //---------------------------------------------------------------
  bool remove_field_from_tx_extra(std::vector<uint8_t>& tx_extra, const std::type_info &type)
  {
    if (tx_extra.empty())
      return true;
    std::string extra_str(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size());
    binary_archive<false> ar{epee::strspan<std::uint8_t>(extra_str)};
    std::ostringstream oss;
    binary_archive<true> newar(oss);

    do
    {
      tx_extra_field field;
      bool r = ::do_serialize(ar, field);
      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
      if (field.type() != type)
        ::do_serialize(newar, field);
    } while (!ar.eof());
    CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
    tx_extra.clear();
    std::string s = oss.str();
    tx_extra.reserve(s.size());
    std::copy(s.begin(), s.end(), std::back_inserter(tx_extra));
    return true;
  }
  //---------------------------------------------------------------
  void set_payment_id_to_tx_extra_nonce(blobdata& extra_nonce, const crypto::hash& payment_id)
  {
    extra_nonce.clear();
    extra_nonce.push_back(TX_EXTRA_NONCE_PAYMENT_ID);
    const uint8_t* payment_id_ptr = reinterpret_cast<const uint8_t*>(&payment_id);
    std::copy(payment_id_ptr, payment_id_ptr + sizeof(payment_id), std::back_inserter(extra_nonce));
  }
  //---------------------------------------------------------------
  void set_encrypted_payment_id_to_tx_extra_nonce(blobdata& extra_nonce, const crypto::hash8& payment_id)
  {
    extra_nonce.clear();
    extra_nonce.push_back(TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID);
    const uint8_t* payment_id_ptr = reinterpret_cast<const uint8_t*>(&payment_id);
    std::copy(payment_id_ptr, payment_id_ptr + sizeof(payment_id), std::back_inserter(extra_nonce));
  }
  //---------------------------------------------------------------
  bool get_payment_id_from_tx_extra_nonce(const blobdata& extra_nonce, crypto::hash& payment_id)
  {
    if(sizeof(crypto::hash) + 1 != extra_nonce.size())
      return false;
    if(TX_EXTRA_NONCE_PAYMENT_ID != extra_nonce[0])
      return false;
    memcpy(&payment_id, extra_nonce.data() + 1, sizeof(payment_id));
    return true;
  }
  //---------------------------------------------------------------
  bool get_encrypted_payment_id_from_tx_extra_nonce(const blobdata& extra_nonce, crypto::hash8& payment_id)
  {
    if(sizeof(crypto::hash8) + 1 != extra_nonce.size())
      return false;
    if (TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID != extra_nonce[0])
      return false;
    memcpy(&payment_id, extra_nonce.data() + 1, sizeof(payment_id));
    return true;
  }
  //---------------------------------------------------------------
  bool get_inputs_money_amount(const transaction& tx, uint64_t& money)
  {
    money = 0;
    for(const auto& in: tx.vin)
    {
      CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
      money += tokey_in.amount;
    }
    return true;
  }
  //---------------------------------------------------------------
  uint64_t get_block_height(const block& b)
  {
    CHECK_AND_ASSERT_MES(b.miner_tx.vin.size() == 1, 0, "wrong miner tx in block: " << get_block_hash(b) << ", b.miner_tx.vin.size() != 1");
    CHECKED_GET_SPECIFIC_VARIANT(b.miner_tx.vin[0], const txin_gen, coinbase_in, 0);
    return coinbase_in.height;
  }
  //---------------------------------------------------------------
  bool check_inputs_types_supported(const transaction& tx)
  {
    for(const auto& in: tx.vin)
    {
      CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), false, "wrong variant type: "
        << in.type().name() << ", expected " << typeid(txin_to_key).name()
        << ", in transaction id=" << get_transaction_hash(tx));

    }
    return true;
  }
  //-----------------------------------------------------------------------------------------------
  bool check_outs_valid(const transaction& tx)
  {
    for(const tx_out& out: tx.vout)
    {
      crypto::public_key output_public_key;
      CHECK_AND_ASSERT_MES(get_output_public_key(out, output_public_key), false, "Failed to get output public key (output type: "
        << out.target.type().name() << "), in transaction id=" << get_transaction_hash(tx));

      if (tx.version == 1)
      {
        CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount output in transaction id=" << get_transaction_hash(tx));
      }

      if(!check_key(output_public_key))
        return false;
    }
    return true;
  }
  //-----------------------------------------------------------------------------------------------
  bool check_money_overflow(const transaction& tx)
  {
    return check_inputs_overflow(tx) && check_outs_overflow(tx);
  }
  //---------------------------------------------------------------
  bool check_inputs_overflow(const transaction& tx)
  {
    uint64_t money = 0;
    for(const auto& in: tx.vin)
    {
      CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
      if(money > tokey_in.amount + money)
        return false;
      money += tokey_in.amount;
    }
    return true;
  }
  //---------------------------------------------------------------
  bool check_outs_overflow(const transaction& tx)
  {
    uint64_t money = 0;
    for(const auto& o: tx.vout)
    {
      if(money > o.amount + money)
        return false;
      money += o.amount;
    }
    return true;
  }
  //---------------------------------------------------------------
  uint64_t get_outs_money_amount(const transaction& tx)
  {
    uint64_t outputs_amount = 0;
    for(const auto& o: tx.vout)
      outputs_amount += o.amount;
    return outputs_amount;
  }
  //---------------------------------------------------------------
  bool get_output_public_key(const cryptonote::tx_out& out, crypto::public_key& output_public_key)
  {
    // before HF_VERSION_VIEW_TAGS, outputs with public keys are of type txout_to_key
    // after HF_VERSION_VIEW_TAGS, outputs with public keys are of type txout_to_tagged_key
    // after HF_VERSION_FCMP_PLUS_PLUS, outputs with public keys are of type txout_to_carrot_v1
    if (out.target.type() == typeid(txout_to_key))
      output_public_key = boost::get< txout_to_key >(out.target).key;
    else if (out.target.type() == typeid(txout_to_tagged_key))
      output_public_key = boost::get< txout_to_tagged_key >(out.target).key;
    else if (out.target.type() == typeid(txout_to_carrot_v1))
      output_public_key = boost::get< txout_to_carrot_v1 >(out.target).key;
    else
    {
      LOG_ERROR("Unexpected output target type found: " << out.target.type().name());
      return false;
    }

    return true;
  }
  //---------------------------------------------------------------
  boost::optional<crypto::view_tag> get_output_view_tag(const cryptonote::tx_out& out)
  {
    return out.target.type() == typeid(txout_to_tagged_key)
      ? boost::optional<crypto::view_tag>(boost::get< txout_to_tagged_key >(out.target).view_tag)
      : boost::optional<crypto::view_tag>();
  }
  //---------------------------------------------------------------
  bool get_commitment(const transaction& tx, std::size_t o_idx, const std::unordered_map<uint64_t, rct::key> &transparent_amount_commitments, rct::key &c_out)
  {
    static_assert(CURRENT_TRANSACTION_VERSION == 2, "This section of code was written with 2 tx versions in mind. "
      "Revisit this section and update for the new tx version.");
    CHECK_AND_ASSERT_THROW_MES(tx.version == 1 || tx.version == 2, "encountered unexpected tx version");

    if (tx.version >= 2 && !tx.is_coinbase())
    {
      CHECK_AND_ASSERT_MES(tx.rct_signatures.outPk.size() > o_idx, false, "get_commitment: o_idx must be < tx.rct_signatures.outPk.size()");
      c_out = tx.rct_signatures.outPk.at(o_idx).mask;
      return true;
    }

    // tx version 1 OR miner tx
    // return the pre-calculated transparent amount commitment
    CHECK_AND_ASSERT_MES(tx.vout.size() > o_idx, false, "get_commitment: o_idx must be < tx.vout.size()");
    const auto it = transparent_amount_commitments.find(tx.vout.at(o_idx).amount);
    CHECK_AND_ASSERT_MES(it != transparent_amount_commitments.end(), false, "get_commitment: transparent amount commitment missing");
    c_out = it->second;
    return true;
  }
  //---------------------------------------------------------------
  void set_tx_out(const uint64_t amount, const crypto::public_key& output_public_key, const bool use_view_tags, const crypto::view_tag& view_tag, tx_out& out)
  {
    out.amount = amount;
    if (use_view_tags)
    {
      txout_to_tagged_key ttk;
      ttk.key = output_public_key;
      ttk.view_tag = view_tag;
      out.target = ttk;
    }
    else
    {
      txout_to_key tk;
      tk.key = output_public_key;
      out.target = tk;
    }
  }
  //---------------------------------------------------------------
  bool check_output_types(const transaction& tx, const uint8_t hf_version)
  {
    if (tx.vout.empty())
      return true;

    // require all outputs in a tx be of the same type
    const std::type_info &o_type = tx.vout.at(0).target.type();
    for (const auto &o: tx.vout)
    {
      const std::type_info &cur_type = o.target.type();
      CHECK_AND_ASSERT_MES(cur_type == o_type, false, "non-matching variant types: "
        << o_type.name() << " and " << cur_type.name() << ", "
        << "expected matching variant types in transaction id=" << get_transaction_hash(tx));
    }

    const bool is_coinbase = tx.is_coinbase();

    bool is_correct_output_type = false;
    if (hf_version < HF_VERSION_VIEW_TAGS)
      is_correct_output_type = o_type == typeid(txout_to_key);
    else if (hf_version == HF_VERSION_VIEW_TAGS)
      is_correct_output_type = (o_type == typeid(txout_to_key) || o_type == typeid(txout_to_tagged_key));
    else if (hf_version < HF_VERSION_CARROT)
      is_correct_output_type = o_type == typeid(txout_to_tagged_key);
    else if (hf_version == HF_VERSION_CARROT)
      is_correct_output_type = (o_type == typeid(txout_to_tagged_key) && !is_coinbase)
        || (o_type == typeid(txout_to_carrot_v1));
    else // (hf_version > HF_VERSION_CARROT)
      is_correct_output_type = o_type == typeid(txout_to_carrot_v1);

    CHECK_AND_ASSERT_MES(is_correct_output_type, false,
      "wrong " << (is_coinbase ? "" : "non-") << "coinbase transaction output type '" << o_type.name()
      << "' for fork v" << static_cast<int>(hf_version) << " in transaction id=" << get_transaction_hash(tx));

    // during v17, require non-coinbase carrot txs use FCMP++ and legacy use BP+
    if (hf_version == HF_VERSION_CARROT && !is_coinbase)
    {
      CHECK_AND_ASSERT_MES(
        (o_type == typeid(txout_to_carrot_v1) && tx.rct_signatures.type == rct::RCTTypeFcmpPlusPlus) ||
        (o_type == typeid(txout_to_tagged_key) && tx.rct_signatures.type == rct::RCTTypeBulletproofPlus),
        false, "mismatched output type to tx proof type in transaction id=" << get_transaction_hash(tx));
    }

    return true;
  }
  //---------------------------------------------------------------
  bool out_can_be_to_acc(const boost::optional<crypto::view_tag>& view_tag_opt, const crypto::key_derivation& derivation, const size_t output_index, hw::device* hwdev)
  {
    // If there is no view tag to check, the output can possibly belong to the account.
    // Will need to derive the output pub key to be certain whether or not the output belongs to the account.
    if (!view_tag_opt)
      return true;

    crypto::view_tag view_tag = *view_tag_opt;

    // If the output's view tag does *not* match the derived view tag, the output should not belong to the account.
    // Therefore can fail out early to avoid expensive crypto ops needlessly deriving output public key to
    // determine if output belongs to the account.
    crypto::view_tag derived_view_tag;
    if (hwdev != nullptr)
    {
      bool r = hwdev->derive_view_tag(derivation, output_index, derived_view_tag);
      CHECK_AND_ASSERT_MES(r, false, "Failed to derive view tag");
    }
    else
    {
      crypto::derive_view_tag(derivation, output_index, derived_view_tag);
    }
    return view_tag == derived_view_tag;
  }
  //---------------------------------------------------------------
  bool is_out_to_acc(const account_keys& acc, const crypto::public_key& output_public_key, const crypto::public_key& tx_pub_key, const std::vector<crypto::public_key>& additional_tx_pub_keys, size_t output_index, const boost::optional<crypto::view_tag>& view_tag_opt)
  {
    crypto::key_derivation derivation;
    bool r = acc.get_device().generate_key_derivation(tx_pub_key, acc.m_view_secret_key, derivation);
    CHECK_AND_ASSERT_MES(r, false, "Failed to generate key derivation");
    crypto::public_key pk;
    if (out_can_be_to_acc(view_tag_opt, derivation, output_index, &acc.get_device()))
    {
      r = acc.get_device().derive_public_key(derivation, output_index, acc.m_account_address.m_spend_public_key, pk);
      CHECK_AND_ASSERT_MES(r, false, "Failed to derive public key");
      if (pk == output_public_key)
        return true;
    }

    // try additional tx pubkeys if available
    if (!additional_tx_pub_keys.empty())
    {
      CHECK_AND_ASSERT_MES(output_index < additional_tx_pub_keys.size(), false, "wrong number of additional tx pubkeys");
      r = acc.get_device().generate_key_derivation(additional_tx_pub_keys[output_index], acc.m_view_secret_key, derivation);
      CHECK_AND_ASSERT_MES(r, false, "Failed to generate key derivation");
      if (out_can_be_to_acc(view_tag_opt, derivation, output_index, &acc.get_device()))
      {
        r = acc.get_device().derive_public_key(derivation, output_index, acc.m_account_address.m_spend_public_key, pk);
        CHECK_AND_ASSERT_MES(r, false, "Failed to derive public key");
        return pk == output_public_key;
      }
    }
    return false;
  }
  //---------------------------------------------------------------
  boost::optional<subaddress_receive_info> is_out_to_acc_precomp(
    const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses,
    const crypto::public_key& out_key,
    const crypto::key_derivation& derivation,
    const epee::span<const crypto::key_derivation> additional_derivations,
    size_t output_index,
    hw::device &hwdev,
    const boost::optional<crypto::view_tag>& view_tag_opt)
  {
    // try the shared tx pubkey
    crypto::public_key subaddress_spendkey;
    if (out_can_be_to_acc(view_tag_opt, derivation, output_index, &hwdev))
    {
      CHECK_AND_ASSERT_MES(hwdev.derive_subaddress_public_key(out_key, derivation, output_index, subaddress_spendkey), boost::none, "Failed to derive subaddress public key");
      auto found = subaddresses.find(subaddress_spendkey);
      if (found != subaddresses.end())
        return subaddress_receive_info{ found->second, derivation };
    }

    // try additional tx pubkeys if available
    if (!additional_derivations.empty())
    {
      CHECK_AND_ASSERT_MES(output_index < additional_derivations.size(), boost::none, "wrong number of additional derivations");
      if (out_can_be_to_acc(view_tag_opt, additional_derivations[output_index], output_index, &hwdev))
      {
        CHECK_AND_ASSERT_MES(hwdev.derive_subaddress_public_key(out_key, additional_derivations[output_index], output_index, subaddress_spendkey), boost::none, "Failed to derive subaddress public key");
        auto found = subaddresses.find(subaddress_spendkey);
        if (found != subaddresses.end())
          return subaddress_receive_info{ found->second, additional_derivations[output_index] };
      }
    }
    return boost::none;
  }
  //---------------------------------------------------------------
  boost::optional<subaddress_receive_info> is_out_to_acc_precomp(
    const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses,
    const crypto::public_key& out_key,
    const crypto::key_derivation& derivation,
    const std::vector<crypto::key_derivation>& additional_derivations,
    size_t output_index,
    hw::device &hwdev,
    const boost::optional<crypto::view_tag>& view_tag_opt)
  {
    return is_out_to_acc_precomp(subaddresses,
      out_key,
      derivation,
      epee::to_span(additional_derivations),
      output_index,
      hwdev,
      view_tag_opt);
  }
  //---------------------------------------------------------------
  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, std::vector<size_t>& outs, uint64_t& money_transfered)
  {
    crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
    if(null_pkey == tx_pub_key)
      return false;
    std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
    return lookup_acc_outs(acc, tx, tx_pub_key, additional_tx_pub_keys, outs, money_transfered);
  }
  //---------------------------------------------------------------
  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, const crypto::public_key& tx_pub_key, const std::vector<crypto::public_key>& additional_tx_pub_keys, std::vector<size_t>& outs, uint64_t& money_transfered)
  {
    CHECK_AND_ASSERT_MES(additional_tx_pub_keys.empty() || additional_tx_pub_keys.size() == tx.vout.size(), false, "wrong number of additional pubkeys" );
    money_transfered = 0;
    size_t i = 0;
    for(const tx_out& o:  tx.vout)
    {
      crypto::public_key output_public_key;
      CHECK_AND_ASSERT_MES(get_output_public_key(o, output_public_key), false, "unable to get output public key from transaction out" );
      if(is_out_to_acc(acc, output_public_key, tx_pub_key, additional_tx_pub_keys, i, get_output_view_tag(o)))
      {
        outs.push_back(i);
        money_transfered += o.amount;
      }
      i++;
    }
    return true;
  }
  //---------------------------------------------------------------
  void get_blob_hash(const blobdata_ref& blob, crypto::hash& res)
  {
    cn_fast_hash(blob.data(), blob.size(), res);
  }
  //---------------------------------------------------------------
  void get_blob_hash(const blobdata& blob, crypto::hash& res)
  {
    cn_fast_hash(blob.data(), blob.size(), res);
  }
  //---------------------------------------------------------------
  void set_default_decimal_point(unsigned int decimal_point)
  {
    switch (decimal_point)
    {
      case 12:
      case 9:
      case 6:
      case 3:
      case 0:
        default_decimal_point = decimal_point;
        break;
      default:
        ASSERT_MES_AND_THROW("Invalid decimal point specification: " << decimal_point);
    }
  }
  //---------------------------------------------------------------
  unsigned int get_default_decimal_point()
  {
    return default_decimal_point;
  }
  //---------------------------------------------------------------
  std::string get_unit(unsigned int decimal_point)
  {
    if (decimal_point == (unsigned int)-1)
      decimal_point = default_decimal_point;
    switch (decimal_point)
    {
      case 12:
        return "monero";
      case 9:
        return "millinero";
      case 6:
        return "micronero";
      case 3:
        return "nanonero";
      case 0:
        return "piconero";
      default:
        ASSERT_MES_AND_THROW("Invalid decimal point specification: " << decimal_point);
    }
  }
  //---------------------------------------------------------------
  static void insert_money_decimal_point(std::string &s, unsigned int decimal_point)
  {
    if (decimal_point == (unsigned int)-1)
      decimal_point = default_decimal_point;
    if(s.size() < decimal_point+1)
    {
      s.insert(0, decimal_point+1 - s.size(), '0');
    }
    if (decimal_point > 0)
      s.insert(s.size() - decimal_point, ".");
  }
  //---------------------------------------------------------------
  std::string print_money(uint64_t amount, unsigned int decimal_point)
  {
    std::string s = std::to_string(amount);
    insert_money_decimal_point(s, decimal_point);
    return s;
  }
  //---------------------------------------------------------------
  std::string print_money(const boost::multiprecision::uint128_t &amount, unsigned int decimal_point)
  {
    std::stringstream ss;
    ss << amount;
    std::string s = ss.str();
    insert_money_decimal_point(s, decimal_point);
    return s;
  }
  //---------------------------------------------------------------
  uint64_t round_money_up(uint64_t amount, unsigned significant_digits)
  {
    // round monetary amount up with the requested amount of significant digits

    CHECK_AND_ASSERT_THROW_MES(significant_digits > 0, "significant_digits must not be 0");
    static_assert(sizeof(unsigned long long) == sizeof(uint64_t), "Unexpected unsigned long long size");

    // we don't need speed, so we do it via text, as it's easier to get right
    char buf[32];
    snprintf(buf, sizeof(buf), "%llu", (unsigned long long)amount);
    const size_t len = strlen(buf);
    if (len > significant_digits)
    {
      bool bump = false;
      char *ptr;
      for (ptr = buf + significant_digits; *ptr; ++ptr)
      {
        // bump digits by one if the following digits past significant digits were to be 5 or more
        if (*ptr != '0')
        {
          bump = true;
          *ptr = '0';
        }
      }
      ptr = buf + significant_digits;
      while (bump && ptr > buf)
      {
        --ptr;
        // bumping a nine overflows
        if (*ptr == '9')
          *ptr = '0';
        else
        {
          // bumping another digit means we can stop bumping (no carry)
          ++*ptr;
          bump = false;
        }
      }
      if (bump)
      {
        // carry reached the highest digit, we need to add a 1 in front
        size_t offset = strlen(buf);
        for (size_t i = offset + 1; i > 0; --i)
          buf[i] = buf[i - 1];
        buf[0] = '1';
      }
    }
    char *end = NULL;
    errno = 0;
    const unsigned long long ull = strtoull(buf, &end, 10);
    CHECK_AND_ASSERT_THROW_MES(ull != ULLONG_MAX || errno == 0, "Failed to parse rounded amount: " << buf);
    CHECK_AND_ASSERT_THROW_MES(ull != 0 || amount == 0, "Overflow in rounding");
    return ull;
  }
  //---------------------------------------------------------------
  std::string round_money_up(const std::string &s, unsigned significant_digits)
  {
    uint64_t amount;
    CHECK_AND_ASSERT_THROW_MES(parse_amount(amount, s), "Failed to parse amount: " << s);
    amount = round_money_up(amount, significant_digits);
    return print_money(amount);
  }
  //---------------------------------------------------------------
  crypto::hash get_blob_hash(const blobdata& blob)
  {
    crypto::hash h = null_hash;
    get_blob_hash(blob, h);
    return h;
  }
  //---------------------------------------------------------------
  crypto::hash get_blob_hash(const blobdata_ref& blob)
  {
    crypto::hash h = null_hash;
    get_blob_hash(blob, h);
    return h;
  }
  //---------------------------------------------------------------
  crypto::hash get_transaction_hash(const transaction& t)
  {
    crypto::hash h = null_hash;
    CHECK_AND_ASSERT_THROW_MES(get_transaction_hash(t, h, NULL), "Failed to calculate transaction hash");
    return h;
  }
  //---------------------------------------------------------------
  bool get_transaction_hash(const transaction& t, crypto::hash& res)
  {
    return get_transaction_hash(t, res, NULL);
  }
  //---------------------------------------------------------------
  bool calculate_transaction_prunable_hash(const std::size_t tx_version, const blobdata_ref prunable_tx_blob, crypto::hash &res)
  {
    switch (tx_version)
    {
    case 2:
      cryptonote::get_blob_hash(prunable_tx_blob, res);
      return true;
    default:
      return false;
    }
  }
  //---------------------------------------------------------------
  bool calculate_transaction_prunable_hash(const transaction& t, const cryptonote::blobdata_ref *blob, crypto::hash& res)
  {
    if (t.version == 1)
      return false;
    const unsigned int unprunable_size = t.unprunable_size;
    if (blob && unprunable_size)
    {
      CHECK_AND_ASSERT_MES(unprunable_size <= blob->size(), false, "Inconsistent transaction unprunable and blob sizes");
      return calculate_transaction_prunable_hash(t.version,
        blobdata_ref(blob->data() + unprunable_size, blob->size() - unprunable_size), res);
    }
    else
    {
      transaction &tt = const_cast<transaction&>(t);
      std::stringstream ss;
      binary_archive<true> ba(ss);
      const size_t inputs = t.vin.size();
      const size_t outputs = t.vout.size();
      const size_t mixin = (t.vin.empty() || t.rct_signatures.type == rct::RCTTypeFcmpPlusPlus || t.vin[0].type() != typeid(txin_to_key))
        ? 0 : boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1;
      bool r = tt.rct_signatures.p.serialize_rctsig_prunable(ba, t.rct_signatures.type, inputs, outputs, mixin);
      CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures prunable");
      cryptonote::get_blob_hash(ss.str(), res);
    }
    return true;
  }
  //---------------------------------------------------------------
  crypto::hash get_transaction_prunable_hash(const transaction& t, const cryptonote::blobdata_ref *blobdata)
  {
    crypto::hash res;
    if (t.is_prunable_hash_valid())
    {
#ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
      CHECK_AND_ASSERT_THROW_MES(!calculate_transaction_prunable_hash(t, blobdata, res) || t.hash == res, "tx hash cash integrity failure");
#endif
      res = t.prunable_hash;
      return res;
    }

    CHECK_AND_ASSERT_THROW_MES(calculate_transaction_prunable_hash(t, blobdata, res), "Failed to calculate tx prunable hash");
    t.set_prunable_hash(res);
    return res;
  }
  //---------------------------------------------------------------
  bool get_pruned_transaction_hash(const transaction& t, const crypto::hash &pruned_data_hash, crypto::hash &res)
  {
    // v1 transactions hash the entire blob
    CHECK_AND_ASSERT_MES(t.version > 1, false, "Hash for pruned v1 tx cannot be calculated");

    // v2 transactions hash different parts together, than hash the set of those hashes
    crypto::hash hashes[3];

    // prefix
    get_transaction_prefix_hash(t, hashes[0]);

    transaction &tt = const_cast<transaction&>(t);

    // base rct
    {
      std::stringstream ss;
      binary_archive<true> ba(ss);
      const size_t inputs = t.vin.size();
      const size_t outputs = t.vout.size();
      bool r = tt.rct_signatures.serialize_rctsig_base(ba, inputs, outputs);
      CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures base");
      cryptonote::get_blob_hash(ss.str(), hashes[1]);
    }

    // prunable rct
    if (t.rct_signatures.type == rct::RCTTypeNull)
      hashes[2] = crypto::null_hash;
    else
    {
      hashes[2] = pruned_data_hash;
      t.set_prunable_hash(pruned_data_hash);
    }

    // the tx hash is the hash of the 3 hashes
    res = cn_fast_hash(hashes, sizeof(hashes));
    t.set_hash(res);
    return true;
  }
  //---------------------------------------------------------------
  bool calculate_transaction_hash(const transaction& t, crypto::hash& res, size_t* blob_size)
  {
    CHECK_AND_ASSERT_MES(!t.pruned, false, "Cannot calculate the hash of a pruned transaction");

    // v1 transactions hash the entire blob
    if (t.version == 1)
    {
      size_t ignored_blob_size, &blob_size_ref = blob_size ? *blob_size : ignored_blob_size;
      return get_object_hash(t, res, blob_size_ref);
    }

    // v2 transactions hash different parts together, than hash the set of those hashes
    crypto::hash hashes[3];

    // prefix
    get_transaction_prefix_hash(t, hashes[0]);

    const blobdata blob = tx_to_blob(t);
    const unsigned int unprunable_size = t.unprunable_size;
    const unsigned int prefix_size = t.prefix_size;

    // base rct
    CHECK_AND_ASSERT_MES(prefix_size <= unprunable_size && unprunable_size <= blob.size(), false, "Inconsistent transaction prefix, unprunable and blob sizes");
    cryptonote::get_blob_hash(blobdata_ref(blob.data() + prefix_size, unprunable_size - prefix_size), hashes[1]);

    // prunable rct
    if (t.rct_signatures.type == rct::RCTTypeNull)
    {
      hashes[2] = crypto::null_hash;
    }
    else
    {
      cryptonote::blobdata_ref blobref(blob);
      CHECK_AND_ASSERT_MES(calculate_transaction_prunable_hash(t, &blobref, hashes[2]), false, "Failed to get tx prunable hash");
    }

    // the tx hash is the hash of the 3 hashes
    res = cn_fast_hash(hashes, sizeof(hashes));

    // we still need the size
    if (blob_size)
    {
      if (!t.is_blob_size_valid())
      {
        t.set_blob_size(blob.size());
      }
      *blob_size = t.blob_size;
    }

    return true;
  }
  //---------------------------------------------------------------
  bool get_transaction_hash(const transaction& t, crypto::hash& res, size_t* blob_size)
  {
    if (t.is_hash_valid())
    {
#ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
      CHECK_AND_ASSERT_THROW_MES(!calculate_transaction_hash(t, res, blob_size) || t.hash == res, "tx hash cash integrity failure");
#endif
      res = t.hash;
      if (blob_size)
      {
        if (!t.is_blob_size_valid())
        {
          t.set_blob_size(get_object_blobsize(t));
        }
        *blob_size = t.blob_size;
      }
      return true;
    }
    bool ret = calculate_transaction_hash(t, res, blob_size);
    if (!ret)
      return false;
    t.set_hash(res);
    if (blob_size)
    {
      t.set_blob_size(*blob_size);
    }
    return true;
  }
  //---------------------------------------------------------------
  bool get_transaction_hash(const transaction& t, crypto::hash& res, size_t& blob_size)
  {
    return get_transaction_hash(t, res, &blob_size);
  }
  //---------------------------------------------------------------
  blobdata get_block_hashing_blob(const block& b)
  {
    blobdata blob = t_serializable_object_to_blob(static_cast<block_header>(b));
    crypto::hash block_content_hash = get_block_content_hash(b);
    blob.append(reinterpret_cast<const char*>(&block_content_hash), sizeof(block_content_hash));
    blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
    return blob;
  }
  //---------------------------------------------------------------
  bool calculate_block_hash(const block& b, crypto::hash& res, const blobdata_ref *blob)
  {
    blobdata bd;
    blobdata_ref bdref;
    if (!blob)
    {
      bd = block_to_blob(b);
      bdref = bd;
      blob = &bdref;
    }

    bool hash_result = get_object_hash(get_block_hashing_blob(b), res);
    if (!hash_result)
      return false;

    if (b.miner_tx.vin.size() == 1 && b.miner_tx.vin[0].type() == typeid(cryptonote::txin_gen))
    {
      const cryptonote::txin_gen &txin_gen = boost::get<cryptonote::txin_gen>(b.miner_tx.vin[0]);
      if (txin_gen.height != 202612)
        return true;
    }

    // EXCEPTION FOR BLOCK 202612
    const std::string correct_blob_hash_202612 = "3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966";
    const std::string existing_block_id_202612 = "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698";
    crypto::hash block_blob_hash = get_blob_hash(*blob);

    if (string_tools::pod_to_hex(block_blob_hash) == correct_blob_hash_202612)
    {
      string_tools::hex_to_pod(existing_block_id_202612, res);
      return true;
    }

    {
      // make sure that we aren't looking at a block with the 202612 block id but not the correct blobdata
      if (string_tools::pod_to_hex(res) == existing_block_id_202612)
      {
        LOG_ERROR("Block with block id for 202612 but incorrect block blob hash found!");
        res = null_hash;
        return false;
      }
    }
    return hash_result;
  }
  //---------------------------------------------------------------
  bool get_block_hash(const block& b, crypto::hash& res)
  {
    if (b.is_hash_valid())
    {
#ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
      CHECK_AND_ASSERT_THROW_MES(!calculate_block_hash(b, res) || b.hash == res, "block hash cash integrity failure");
#endif
      res = b.hash;
      return true;
    }
    bool ret = calculate_block_hash(b, res);
    if (!ret)
      return false;
    b.set_hash(res);
    return true;
  }
  //---------------------------------------------------------------
  crypto::hash get_block_hash(const block& b)
  {
    crypto::hash p = null_hash;
    get_block_hash(b, p);
    return p;
  }
  //---------------------------------------------------------------
  std::vector<uint64_t> relative_output_offsets_to_absolute(const std::vector<uint64_t>& off)
  {
    std::vector<uint64_t> res = off;
    for(size_t i = 1; i < res.size(); i++)
      res[i] += res[i-1];
    return res;
  }
  //---------------------------------------------------------------
  std::vector<uint64_t> absolute_output_offsets_to_relative(const std::vector<uint64_t>& off)
  {
    std::vector<uint64_t> res = off;
    if(!off.size())
      return res;
    std::sort(res.begin(), res.end());//just to be sure, actually it is already should be sorted
    for(size_t i = res.size()-1; i != 0; i--)
      res[i] -= res[i-1];

    return res;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b, crypto::hash *block_hash)
  {
    binary_archive<false> ba{epee::strspan<std::uint8_t>(b_blob)};
    bool r = ::serialization::serialize(ba, b);
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob");
    b.invalidate_hashes();
    b.miner_tx.invalidate_hashes();
    if (block_hash)
    {
      calculate_block_hash(b, *block_hash, &b_blob);
      b.set_hash(*block_hash);
    }
    return true;
  }
  //---------------------------------------------------------------
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b)
  {
    return parse_and_validate_block_from_blob(b_blob, b, NULL);
  }
  //---------------------------------------------------------------
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b, crypto::hash &block_hash)
  {
    return parse_and_validate_block_from_blob(b_blob, b, &block_hash);
  }
  //---------------------------------------------------------------
  blobdata block_to_blob(const block& b)
  {
    return t_serializable_object_to_blob(b);
  }
  //---------------------------------------------------------------
  bool block_to_blob(const block& b, blobdata& b_blob)
  {
    return t_serializable_object_to_blob(b, b_blob);
  }
  //---------------------------------------------------------------
  blobdata tx_to_blob(const transaction& tx)
  {
    return t_serializable_object_to_blob(tx);
  }
  //---------------------------------------------------------------
  bool tx_to_blob(const transaction& tx, blobdata& b_blob)
  {
    return t_serializable_object_to_blob(tx, b_blob);
  }
  //---------------------------------------------------------------
  crypto::hash get_block_content_hash(const block& b)
  {
    // The miner transaction goes first in the Merkle tree so that mining software can update nonces
    // within, and then the block content hash can be recalculated by re-hashing the left-hand side
    // of the tree. The number of FCMP tree layers and FCMP tree root go in the following slots so
    // that they are at a fixed index.

    std::vector<crypto::hash> hashes;
    hashes.reserve(1 + 1 + 1 + b.tx_hashes.size());
    // 1. Miner tx
    hashes.push_back(get_transaction_hash(b.miner_tx));
    if (b.major_version >= HF_VERSION_FCMP_PLUS_PLUS)
    {
      // 2. n tree layers in FCMP++ tree
      static_assert(sizeof(crypto::hash) >= sizeof(uint8_t), "crypto::hash is too small");
      hashes.push_back(crypto::hash{static_cast<char>(b.fcmp_pp_n_tree_layers)});
      // 3. FCMP++ tree root
      crypto::hash &h = hashes.emplace_back();
      static_assert(sizeof(crypto::hash) == sizeof(crypto::ec_point), "hash/ec_point size mismatch");
      memcpy(&h, &b.fcmp_pp_tree_root, sizeof(crypto::hash));
    }
    // 4. All other txs
    for(auto& th: b.tx_hashes)
      hashes.push_back(th);
    return get_tree_hash(hashes);
  }
  //---------------------------------------------------------------
  static bool get_block_longhash_202612(const blobdata_ref block_hashing_blob, crypto::hash &res)
  {
    static constexpr const char longhash_202612[] = "84f64766475d51837ac9efbef1926486e58563c95a19fef4aec3254f03000000";
    // Object hashes of get_block_hashing_blob(block). The mainnet value differs
    // from the public block id because calculate_block_hash() replaces that id.
    static constexpr const char * const block_hashing_blob_ids_202612[] =
    {
      "426d16cff04c71f8b16340b722dc4010a2dd3831c22041431f772547ba6e331a", // mainnet
      "248fde4b96b829c4ddbd00e3f76d35b03d01257898bc1b5578bc9e04b379a676", // testnet
      "f3449e658b5f880c4b0e69007ed5d092c9c883ac3a518166fa652d5cc505e7b1", // stagenet
    };

    crypto::hash block_id;
    const blobdata block_hashing_blob_copy(block_hashing_blob.data(), block_hashing_blob.size());
    get_object_hash(block_hashing_blob_copy, block_id);
    const std::string block_id_hex = string_tools::pod_to_hex(block_id);
    for (const char * const expected_block_id: block_hashing_blob_ids_202612)
    {
      if (block_id_hex == expected_block_id)
      {
        return epee::string_tools::hex_to_pod(longhash_202612, res);
      }
    }
    return false;
  }
  //---------------------------------------------------------------
  crypto::hash get_block_longhash(const blobdata_ref block_hashing_blob,
    const uint64_t height,
    const uint8_t major_version,
    const crypto::hash &seed_hash)
  {
    crypto::hash res;

    if (height == 202612 && get_block_longhash_202612(block_hashing_blob, res))
      return res;

    if (major_version >= RX_BLOCK_VERSION) // RandomX
    {
      crypto::rx_slow_hash(seed_hash.data, block_hashing_blob.data(), block_hashing_blob.size(), res.data);
    }
    else // CryptoNight
    {
      static_assert(HF_VERSION_CRYPTONIGHT_VARIANT_1 >= 1);
      const int pow_variant = major_version >= HF_VERSION_CRYPTONIGHT_VARIANT_1
        ? major_version - (HF_VERSION_CRYPTONIGHT_VARIANT_1 - 1) : 0;
      crypto::cn_slow_hash(block_hashing_blob.data(), block_hashing_blob.size(), res, pow_variant, height);
    }

    return res;
  }
  //---------------------------------------------------------------
  bool is_valid_decomposed_amount(uint64_t amount)
  {
    if (0 == amount)
      return false;

    // divide out all trailing zeros (in base 10)
    while (amount % 10 == 0)
      amount /= 10;

    return amount < 10; // are we left with 1 leading digit?
  }
  //---------------------------------------------------------------
  crypto::secret_key encrypt_key(crypto::secret_key key, const epee::wipeable_string &passphrase)
  {
    crypto::hash hash;
    crypto::cn_slow_hash(passphrase.data(), passphrase.size(), hash);
    sc_add((unsigned char*)key.data, (const unsigned char*)key.data, (const unsigned char*)hash.data);
    return key;
  }
  //---------------------------------------------------------------
  crypto::secret_key decrypt_key(crypto::secret_key key, const epee::wipeable_string &passphrase)
  {
    crypto::hash hash;
    crypto::cn_slow_hash(passphrase.data(), passphrase.size(), hash);
    sc_sub((unsigned char*)key.data, (const unsigned char*)key.data, (const unsigned char*)hash.data);
    return key;
  }
  //---------------------------------------------------------------
  uint64_t get_default_last_locked_block_index(const uint64_t block_included_in_chain)
  {
    static_assert(CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE > 0, "unexpected default spendable age");
    return block_included_in_chain + (CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE - 1);
  }
  //---------------------------------------------------------------
  // TODO: write tests for this func that match with current daemon logic
  uint64_t get_last_locked_block_index(uint64_t unlock_time, uint64_t block_included_in_chain)
  {
    uint64_t last_locked_block_index = 0;

    const uint64_t default_block_index = get_default_last_locked_block_index(block_included_in_chain);

    if (unlock_time == 0)
    {
      last_locked_block_index = default_block_index;
    }
    else if (unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER)
    {
      // The unlock_time in this case is supposed to be the chain height at which the output unlocks
      // The chain height is 1 higher than the highest block index, so we subtract 1 for this delta
      last_locked_block_index = unlock_time > 0 ? (unlock_time - 1) : 0;
    }
    else
    {
      // Interpret the unlock_time as time
      // TODO: hardcode correct times for each network and take in nettype
      const auto hf_v15_time = 1656629118;
      const auto hf_v15_height = 2689608;

      // Use the last hard fork's time and block combo to convert the time-based timelock into an last locked block
      // TODO: consider taking into account 60s block times when that was consensus
      if (hf_v15_time > unlock_time)
      {
        const auto seconds_since_unlock = hf_v15_time - unlock_time;
        const auto blocks_since_unlock = seconds_since_unlock / DIFFICULTY_TARGET_V2;

        last_locked_block_index = hf_v15_height > blocks_since_unlock
          ? (hf_v15_height - blocks_since_unlock)
          : default_block_index;
      }
      else
      {
        const auto seconds_until_unlock = unlock_time - hf_v15_time;
        const auto blocks_until_unlock = seconds_until_unlock / DIFFICULTY_TARGET_V2;
        last_locked_block_index = hf_v15_height + blocks_until_unlock;
      }

      /* Note: since this function was introduced for the hf that included fcmp's, it's possible for an output to be
          spent before it reaches the last_locked_block_index going by the old rules; this is ok. It can't be spent again b/c
          it'll have a duplicate key image. It's also possible for an output to unlock by old rules, and then re-lock
          again at the fork. This is also ok, we just need to be sure that the new hf rules use this last_locked_block_index
          starting at the fork for fcmp's.
      */

      // TODO: double check the accuracy of this calculation
      MDEBUG("unlock time: " << unlock_time << " , last_locked_block_index: " << last_locked_block_index);
    }

    // Can't unlock earlier than the default last locked block
    return std::max(last_locked_block_index, default_block_index);
  }
  //---------------------------------------------------------------
  bool is_custom_timelocked(bool is_coinbase, uint64_t last_locked_block_idx, uint64_t block_included_in_chain)
  {
    if (is_coinbase)
      return false;

    return last_locked_block_idx > cryptonote::get_default_last_locked_block_index(block_included_in_chain);
  }
  //---------------------------------------------------------------
  OutsByLastLockedBlockMeta get_outs_by_last_locked_block(
    const std::vector<std::reference_wrapper<const cryptonote::transaction>> &txs,
    const std::unordered_map<uint64_t, rct::key> &transparent_amount_commitments,
    const uint64_t first_unified_id,
    const uint64_t block_idx)
  {
    OutsByLastLockedBlockMeta outs_by_last_locked_block_meta_out;
    outs_by_last_locked_block_meta_out.next_unified_id = first_unified_id;

    for (const auto &tx : txs)
    {
      outs_by_last_locked_block_meta_out.next_unified_id += set_tx_outs_by_last_locked_block(
        tx.get(),
        transparent_amount_commitments,
        outs_by_last_locked_block_meta_out.next_unified_id,
        block_idx,
        outs_by_last_locked_block_meta_out.outs_by_last_locked_block,
        outs_by_last_locked_block_meta_out.timelocked_outputs);
    }

    return outs_by_last_locked_block_meta_out;
  }
  //---------------------------------------------------------------
  fcmp_pp::OutputPair to_output_pair(const cryptonote::txout_target_v &tx_out, const rct::key &commitment)
  {
    struct tx_out_visitor
    {
        const crypto::public_key &O;
        const crypto::ec_point &C;

        fcmp_pp::OutputPair operator()(const cryptonote::txout_to_carrot_v1&) const
        { return fcmp_pp::CarrotOutputPairV1{{O, C}}; }
        fcmp_pp::OutputPair operator()(const cryptonote::txout_to_tagged_key&) const
        { return fcmp_pp::LegacyOutputPair{{O, C}}; }
        fcmp_pp::OutputPair operator()(const cryptonote::txout_to_key&) const
        { return fcmp_pp::LegacyOutputPair{{O, C}}; }
        fcmp_pp::OutputPair operator()(const cryptonote::txout_to_script&) const
        { throw std::logic_error("cannot convert txout to script into an output pair"); }
    };

    const crypto::public_key &O = cryptonote::output_pubkey_cref(tx_out);
    const crypto::ec_point &C = rct::rct2pt(commitment);
    return boost::apply_visitor(tx_out_visitor{O, C}, tx_out);
  }
}