diff --git a/src/blockchain_utilities/blockchain_blackball.cpp b/src/blockchain_utilities/blockchain_blackball.cpp
index 522e40c3c8..cf41134d15 100644
--- a/src/blockchain_utilities/blockchain_blackball.cpp
+++ b/src/blockchain_utilities/blockchain_blackball.cpp
@@ -33,7 +33,6 @@
 #include "common/command_line.h"
 #include "common/varint.h"
 #include "serialization/crypto.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
 #include "cryptonote_core/tx_pool.h"
 #include "cryptonote_core/cryptonote_core.h"
 #include "cryptonote_core/blockchain.h"
diff --git a/src/blockchain_utilities/blockchain_stats.cpp b/src/blockchain_utilities/blockchain_stats.cpp
index 3fbdae5489..7c8fb228b2 100644
--- a/src/blockchain_utilities/blockchain_stats.cpp
+++ b/src/blockchain_utilities/blockchain_stats.cpp
@@ -30,7 +30,6 @@
 #include <boost/filesystem.hpp>
 #include "common/command_line.h"
 #include "common/varint.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
 #include "cryptonote_core/cryptonote_core.h"
 #include "blockchain_db/blockchain_db.h"
 #include "time_helper.h"
diff --git a/src/blockchain_utilities/blocksdat_file.h b/src/blockchain_utilities/blocksdat_file.h
index 4e63361a74..d28ccb1089 100644
--- a/src/blockchain_utilities/blocksdat_file.h
+++ b/src/blockchain_utilities/blocksdat_file.h
@@ -36,7 +36,6 @@
 #include <boost/filesystem/operations.hpp>
 
 #include "cryptonote_basic/cryptonote_basic.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
 #include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
 
diff --git a/src/blockchain_utilities/bootstrap_serialization.h b/src/blockchain_utilities/bootstrap_serialization.h
index 667ab32076..27fe1e4505 100644
--- a/src/blockchain_utilities/bootstrap_serialization.h
+++ b/src/blockchain_utilities/bootstrap_serialization.h
@@ -28,7 +28,7 @@
 
 #pragma once
 
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
+#include "cryptonote_basic/cryptonote_basic.h"
 #include "serialization/difficulty_type.h"
 
 
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 0b3b9b7206..87aa1e50ef 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -40,7 +40,6 @@
 #include "tx_pool.h"
 #include "blockchain.h"
 #include "blockchain_db/blockchain_db.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
 #include "cryptonote_basic/events.h"
 #include "cryptonote_config.h"
 #include "cryptonote_basic/miner.h"
diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index d2de250446..c63465e4a1 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -36,7 +36,6 @@
 
 #include "tx_pool.h"
 #include "cryptonote_tx_utils.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
 #include "cryptonote_basic/events.h"
 #include "cryptonote_config.h"
 #include "blockchain.h"
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index a2929516b4..0d9f84b13f 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -3031,11 +3031,8 @@ bool simple_wallet::set_load_deprecated_formats(const std::vector<std::string> &
   if (pwd_container)
   {
     parse_bool_and_use(args[1], [&](bool r) {
-      m_wallet->load_deprecated_formats(r);
-      m_wallet->rewrite(m_wallet_file, pwd_container->password());
-
       if (r)
-        message_writer() << tr("Warning: deprecated formats use boost serialization, which has buffer overflows and crashers. Only load deprecated formats from sources you trust.");
+        fail_msg_writer() << tr("Warning: deprecated formats use boost serialization, which has buffer overflows and crashes. Support for them has been discontinued.");
     });
   }
   return true;
@@ -3766,7 +3763,6 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
         << " (disabled on Windows)"
 #endif
         ;
-    success_msg_writer() << "load-deprecated-formats = " << m_wallet->load_deprecated_formats();
     success_msg_writer() << "enable-multisig-experimental = " << m_wallet->is_multisig_enabled();
     return true;
   }
diff --git a/src/wallet/message_store.cpp b/src/wallet/message_store.cpp
index 87fa6936e7..f72048559c 100644
--- a/src/wallet/message_store.cpp
+++ b/src/wallet/message_store.cpp
@@ -767,7 +767,7 @@ void message_store::write_to_file(const multisig_wallet_state &state, const std:
   THROW_WALLET_EXCEPTION_IF(!success, tools::error::file_save_error, filename);
 }
 
-void message_store::read_from_file(const multisig_wallet_state &state, const std::string &filename, bool load_deprecated_formats)
+void message_store::read_from_file(const multisig_wallet_state &state, const std::string &filename)
 {
   boost::system::error_code ignored_ec;
   bool file_exists = boost::filesystem::exists(filename, ignored_ec);
@@ -793,22 +793,6 @@ void message_store::read_from_file(const multisig_wallet_state &state, const std
         loaded = true;
   }
   catch (...) {}
-  if (!loaded && load_deprecated_formats)
-  {
-    try
-    {
-      std::stringstream iss;
-      iss << buf;
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> read_file_data;
-      loaded = true;
-    }
-    catch (const std::exception &e)
-    {
-      MERROR("MMS file " << filename << " has bad structure <iv,encrypted_data>: " << e.what());
-      THROW_WALLET_EXCEPTION_IF(true, tools::error::file_read_error, filename);
-    }
-  }
   if (!loaded)
   {
     MERROR("MMS file " << filename << " has bad structure <iv,encrypted_data>");
@@ -830,22 +814,6 @@ void message_store::read_from_file(const multisig_wallet_state &state, const std
         loaded = true;
   }
   catch(...) {}
-  if (!loaded && load_deprecated_formats)
-  {
-    try
-    {
-      std::stringstream iss;
-      iss << decrypted_data;
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> *this;
-      loaded = true;
-    }
-    catch (const std::exception &e)
-    {
-      MERROR("MMS file " << filename << " has bad structure: " << e.what());
-      THROW_WALLET_EXCEPTION_IF(true, tools::error::file_read_error, filename);
-    }
-  }
   if (!loaded)
   {
     MERROR("MMS file " << filename << " has bad structure");
diff --git a/src/wallet/message_store.h b/src/wallet/message_store.h
index 466c2acba8..f0978540a6 100644
--- a/src/wallet/message_store.h
+++ b/src/wallet/message_store.h
@@ -38,8 +38,6 @@
 #include <boost/program_options/options_description.hpp>
 #include <boost/optional/optional.hpp>
 #include "serialization/serialization.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
-#include "cryptonote_basic/account_boost_serialization.h"
 #include "cryptonote_basic/cryptonote_basic.h"
 #include "common/i18n.h"
 #include "common/command_line.h"
@@ -352,7 +350,7 @@ namespace mms
     void stop() { m_run.store(false, std::memory_order_relaxed); m_transporter.stop(); }
 
     void write_to_file(const multisig_wallet_state &state, const std::string &filename);
-    void read_from_file(const multisig_wallet_state &state, const std::string &filename, bool load_deprecated_formats = false);
+    void read_from_file(const multisig_wallet_state &state, const std::string &filename);
 
     template <class t_archive>
     inline void serialize(t_archive &a, const unsigned int ver)
@@ -418,88 +416,3 @@ namespace mms
     void save(const multisig_wallet_state &state);
   };
 }
-
-BOOST_CLASS_VERSION(mms::file_data, 0)
-BOOST_CLASS_VERSION(mms::message_store, 0)
-BOOST_CLASS_VERSION(mms::message, 0)
-BOOST_CLASS_VERSION(mms::file_transport_message, 0)
-BOOST_CLASS_VERSION(mms::authorized_signer, 1)
-BOOST_CLASS_VERSION(mms::auto_config_data, 0)
-
-namespace boost
-{
-  namespace serialization
-  {
-    template <class Archive>
-    inline void serialize(Archive &a, mms::file_data &x, const boost::serialization::version_type ver)
-    {
-      a & x.magic_string;
-      a & x.file_version;
-      a & x.iv;
-      a & x.encrypted_data;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, mms::message &x, const boost::serialization::version_type ver)
-    {
-      a & x.id;
-      a & x.type;
-      a & x.direction;
-      a & x.content;
-      a & x.created;
-      a & x.modified;
-      a & x.sent;
-      a & x.signer_index;
-      a & x.hash;
-      a & x.state;
-      a & x.wallet_height;
-      a & x.round;
-      a & x.signature_count;
-      a & x.transport_id;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, mms::authorized_signer &x, const boost::serialization::version_type ver)
-    {
-      a & x.label;
-      a & x.transport_address;
-      a & x.monero_address_known;
-      a & x.monero_address;
-      a & x.me;
-      a & x.index;
-      if (ver < 1)
-      {
-        return;
-      }
-      a & x.auto_config_token;
-      a & x.auto_config_public_key;
-      a & x.auto_config_secret_key;
-      a & x.auto_config_transport_address;
-      a & x.auto_config_running;  
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, mms::auto_config_data &x, const boost::serialization::version_type ver)
-    {
-      a & x.label;
-      a & x.transport_address;
-      a & x.monero_address;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, mms::file_transport_message &x, const boost::serialization::version_type ver)
-    {
-      a & x.sender_address;
-      a & x.iv;
-      a & x.encryption_public_key;
-      a & x.internal_message;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, crypto::chacha_iv &x, const boost::serialization::version_type ver)
-    {
-      a & x.data;
-    }
-
-  }
-}
diff --git a/src/wallet/message_transporter.h b/src/wallet/message_transporter.h
index 342e418366..6d818f4a04 100644
--- a/src/wallet/message_transporter.h
+++ b/src/wallet/message_transporter.h
@@ -30,8 +30,6 @@
 #pragma once
 #include "serialization/keyvalue_serialization.h"
 #include "cryptonote_basic/cryptonote_basic.h"
-#include "cryptonote_basic/cryptonote_boost_serialization.h"
-#include "cryptonote_basic/account_boost_serialization.h"
 #include "net/http_server_impl_base.h"
 #include "net/http_client.h"
 #include "net/abstract_http_client.h"
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index a88e6c5642..e19c3bdc16 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -1250,7 +1250,6 @@ wallet2::wallet2(network_type nettype, uint64_t kdf_rounds, bool unattended, std
   m_offline(false),
   m_rpc_version(0),
   m_export_format(ExportFormat::Binary),
-  m_load_deprecated_formats(false),
   m_enable_multisig(false),
   m_pool_info_query_time(0),
   m_has_ever_refreshed_from_node(false),
@@ -4736,7 +4735,7 @@ boost::optional<wallet2::keys_file_data> wallet2::get_keys_file_data(const crypt
   value2.SetInt(m_export_format);
   json.AddMember("export_format", value2, json.GetAllocator());
 
-  value2.SetInt(m_load_deprecated_formats);
+  value2.SetInt(false);
   json.AddMember("load_deprecated_formats", value2, json.GetAllocator());
 
   value2.SetUint(1);
@@ -5002,7 +5001,6 @@ bool wallet2::load_keys_buf(const std::string& keys_buf, const epee::wipeable_st
     m_subaddress_lookahead_minor = SUBADDRESS_LOOKAHEAD_MINOR;
     m_original_keys_available = false;
     m_export_format = ExportFormat::Binary;
-    m_load_deprecated_formats = false;
     m_device_name = "";
     m_device_derivation_path = "";
     m_key_device_type = hw::device::device_type::SOFTWARE;
@@ -5187,9 +5185,6 @@ bool wallet2::load_keys_buf(const std::string& keys_buf, const epee::wipeable_st
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, export_format, ExportFormat, Int, false, Binary);
     m_export_format = field_export_format;
 
-    GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, load_deprecated_formats, int, Int, false, false);
-    m_load_deprecated_formats = field_load_deprecated_formats;
-
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, device_name, std::string, String, false, std::string());
     if (m_device_name.empty())
     {
@@ -6544,7 +6539,7 @@ void wallet2::load(const std::string& wallet_, const epee::wipeable_string& pass
   try
   {
     if (use_fs)
-      m_message_store.read_from_file(get_multisig_wallet_state(), m_mms_file, m_load_deprecated_formats);
+      m_message_store.read_from_file(get_multisig_wallet_state(), m_mms_file);
   }
   catch (const std::exception &e)
   {
@@ -7719,50 +7714,13 @@ bool wallet2::parse_unsigned_tx_from_str(const std::string &unsigned_tx_st, unsi
   s = s.substr(1);
   if (version == '\003')
   {
-    if (!m_load_deprecated_formats)
-    {
       LOG_PRINT_L0("Not loading deprecated format");
       return false;
-    }
-    try
-    {
-      std::istringstream iss(s);
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> exported_txs;
-    }
-    catch (...)
-    {
-      LOG_PRINT_L0("Failed to parse data from unsigned tx");
-      return false;
-    }
   }
   else if (version == '\004')
   {
-    if (!m_load_deprecated_formats)
-    {
       LOG_PRINT_L0("Not loading deprecated format");
       return false;
-    }
-    try
-    {
-      s = decrypt_with_view_secret_key(s);
-      try
-      {
-        std::istringstream iss(s);
-        boost::archive::portable_binary_iarchive ar(iss);
-        ar >> exported_txs;
-      }
-      catch (...)
-      {
-        LOG_PRINT_L0("Failed to parse data from unsigned tx");
-        return false;
-      }
-    }
-    catch (const std::exception &e)
-    {
-      LOG_PRINT_L0("Failed to decrypt unsigned tx: " << e.what());
-      return false;
-    }
   }
   else if (version == '\005')
   {
@@ -8034,50 +7992,13 @@ bool wallet2::parse_tx_from_str(const std::string &signed_tx_st, std::vector<too
   s = s.substr(1);
   if (version == '\003')
   {
-    if (!m_load_deprecated_formats)
-    {
       LOG_PRINT_L0("Not loading deprecated format");
       return false;
-    }
-    try
-    {
-      std::istringstream iss(s);
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> signed_txs;
-    }
-    catch (...)
-    {
-      LOG_PRINT_L0("Failed to parse data from signed transaction");
-      return false;
-    }
   }
   else if (version == '\004')
   {
-    if (!m_load_deprecated_formats)
-    {
       LOG_PRINT_L0("Not loading deprecated format");
       return false;
-    }
-    try
-    {
-      s = decrypt_with_view_secret_key(s);
-      try
-      {
-        std::istringstream iss(s);
-        boost::archive::portable_binary_iarchive ar(iss);
-        ar >> signed_txs;
-      }
-      catch (...)
-      {
-        LOG_PRINT_L0("Failed to parse decrypted data from signed transaction");
-        return false;
-      }
-    }
-    catch (const std::exception &e)
-    {
-      LOG_PRINT_L0("Failed to decrypt signed transaction: " << e.what());
-      return false;
-    }
   }
   else if (version == '\005')
   {
@@ -8229,17 +8150,6 @@ bool wallet2::parse_multisig_tx_from_str(std::string multisig_tx_st, multisig_tx
         loaded = true;
   }
   catch (...) {}
-  try
-  {
-    if (!loaded && m_load_deprecated_formats)
-    {
-      std::istringstream iss(multisig_tx_st);
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> exported_txs;
-      loaded = true;
-    }
-  }
-  catch(...) {}
 
   if (!loaded)
   {
@@ -12805,12 +12715,6 @@ bool wallet2::check_reserve_proof(const cryptonote::account_public_address &addr
           loaded = true;
   }
   catch(...) {}
-  if (!loaded && m_load_deprecated_formats)
-  {
-    std::istringstream iss(sig_decoded);
-    boost::archive::portable_binary_iarchive ar(iss);
-    ar >> proofs >> subaddr_spendkeys;
-  }
 
   THROW_WALLET_EXCEPTION_IF(subaddr_spendkeys.count(address.m_spend_public_key) == 0, error::wallet_internal_error,
     "The given address isn't found in the proof");
@@ -14533,19 +14437,6 @@ size_t wallet2::import_outputs_from_str(const std::string &outputs_st)
     }
     catch (...) {}
 
-    if (!loaded && m_load_deprecated_formats)
-    {
-      try
-      {
-        std::stringstream iss;
-        iss << body;
-        boost::archive::portable_binary_iarchive ar(iss);
-        ar >> outputs;
-        loaded = true;
-      }
-      catch (...) {}
-    }
-
     if (!loaded)
     {
       std::get<0>(outputs) = 0;
@@ -14807,13 +14698,6 @@ size_t wallet2::import_multisig(std::vector<cryptonote::blobdata> blobs)
           loaded = true;
     }
     catch(...) {}
-    if (!loaded && m_load_deprecated_formats)
-    {
-      std::istringstream iss(body);
-      boost::archive::portable_binary_iarchive ar(iss);
-      ar >> i;
-      loaded = true;
-    }
     CHECK_AND_ASSERT_THROW_MES(loaded, "Failed to load output data");
 
     for (const auto &e: i)
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 41f1dffaa4..69f99c335e 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -1488,8 +1488,6 @@ private:
     void device_derivation_path(const std::string &device_derivation_path) { m_device_derivation_path = device_derivation_path; }
     const ExportFormat & export_format() const { return m_export_format; }
     inline void set_export_format(const ExportFormat& export_format) { m_export_format = export_format; }
-    bool load_deprecated_formats() const { return m_load_deprecated_formats; }
-    void load_deprecated_formats(bool load) { m_load_deprecated_formats = load; }
     bool is_multisig_enabled() const { return m_enable_multisig; }
     void enable_multisig(bool enable) { m_enable_multisig = enable; }
     bool is_mismatched_daemon_version_allowed() const { return m_allow_mismatched_daemon_version; }
@@ -2042,7 +2040,6 @@ private:
     std::unique_ptr<wallet_device_callback> m_device_callback;
 
     ExportFormat m_export_format;
-    bool m_load_deprecated_formats;
 
     bool m_has_ever_refreshed_from_node;
 
@@ -2058,18 +2055,11 @@ BOOST_CLASS_VERSION(tools::wallet2, 31)
 BOOST_CLASS_VERSION(tools::wallet2::transfer_details, 12)
 BOOST_CLASS_VERSION(tools::wallet2::multisig_info, 1)
 BOOST_CLASS_VERSION(tools::wallet2::multisig_info::LR, 0)
-BOOST_CLASS_VERSION(tools::wallet2::multisig_tx_set, 1)
 BOOST_CLASS_VERSION(tools::wallet2::payment_details, 5)
 BOOST_CLASS_VERSION(tools::wallet2::pool_payment_details, 1)
 BOOST_CLASS_VERSION(tools::wallet2::unconfirmed_transfer_details, 8)
 BOOST_CLASS_VERSION(tools::wallet2::confirmed_transfer_details, 6)
 BOOST_CLASS_VERSION(tools::wallet2::address_book_row, 18)
-BOOST_CLASS_VERSION(tools::wallet2::reserve_proof_entry, 0)
-BOOST_CLASS_VERSION(tools::wallet2::unsigned_tx_set, 1)
-BOOST_CLASS_VERSION(tools::wallet2::signed_tx_set, 1)
-BOOST_CLASS_VERSION(tools::wallet2::tx_construction_data, 4)
-BOOST_CLASS_VERSION(tools::wallet2::pending_tx, 3)
-BOOST_CLASS_VERSION(tools::wallet2::multisig_sig, 1)
 BOOST_CLASS_VERSION(tools::wallet2::background_synced_tx_t, 0)
 BOOST_CLASS_VERSION(tools::wallet2::background_sync_data_t, 0)
 
@@ -2250,13 +2240,6 @@ namespace boost
       a & x.m_partial_key_images;
     }
 
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::multisig_tx_set &x, const boost::serialization::version_type ver)
-    {
-      a & x.m_ptx;
-      a & x.m_signers;
-    }
-
     template <class Archive>
     inline void serialize(Archive &a, tools::wallet2::unconfirmed_transfer_details &x, const boost::serialization::version_type ver)
     {
@@ -2433,144 +2416,6 @@ namespace boost
         a & x.m_payment_id;
     }
 
-    template <class Archive>
-    inline void serialize(Archive& a, tools::wallet2::reserve_proof_entry& x, const boost::serialization::version_type ver)
-    {
-      a & x.txid;
-      a & x.index_in_tx;
-      a & x.shared_secret;
-      a & x.key_image;
-      a & x.shared_secret_sig;
-      a & x.key_image_sig;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::unsigned_tx_set &x, const boost::serialization::version_type ver)
-    {
-      a & x.txes;
-      if (ver == 0)
-      {
-        // load old version
-        std::pair<size_t, tools::wallet2::transfer_container> old_transfers;
-        a & old_transfers;
-        std::get<0>(x.transfers) = std::get<0>(old_transfers);
-        std::get<1>(x.transfers) = std::get<0>(old_transfers) + std::get<1>(old_transfers).size();
-        std::get<2>(x.transfers) = std::get<1>(old_transfers);
-        return;
-      }
-      throw std::runtime_error("Boost serialization not supported for newest unsigned_tx_set");
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::signed_tx_set &x, const boost::serialization::version_type ver)
-    {
-      a & x.ptx;
-      a & x.key_images;
-      if (ver < 1)
-        return;
-      a & x.tx_key_images;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::tx_construction_data &x, const boost::serialization::version_type ver)
-    {
-      a & x.sources;
-      a & x.change_dts;
-      a & x.splitted_dsts;
-      if (ver < 2)
-      {
-        // load list to vector
-        std::list<size_t> selected_transfers;
-        a & selected_transfers;
-        x.selected_transfers.clear();
-        x.selected_transfers.reserve(selected_transfers.size());
-        for (size_t t: selected_transfers)
-          x.selected_transfers.push_back(t);
-      }
-      a & x.extra;
-      a & x.unlock_time;
-      a & x.use_rct;
-      a & x.dests;
-      if (ver < 1)
-      {
-        x.subaddr_account = 0;
-        return;
-      }
-      a & x.subaddr_account;
-      a & x.subaddr_indices;
-      if (ver < 2)
-      {
-        if (!typename Archive::is_saving())
-          x.rct_config = { rct::RangeProofBorromean, 0 };
-        return;
-      }
-      a & x.selected_transfers;
-      if (ver < 3)
-      {
-        if (!typename Archive::is_saving())
-          x.rct_config = { rct::RangeProofBorromean, 0 };
-        return;
-      }
-      if (ver < 4)
-      {
-        bool use_bulletproofs = x.rct_config.range_proof_type != rct::RangeProofBorromean;
-        a & use_bulletproofs;
-        if (!typename Archive::is_saving())
-          x.rct_config = { use_bulletproofs ? rct::RangeProofPaddedBulletproof : rct::RangeProofBorromean, 0 };
-        return;
-      }
-      a & x.rct_config;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::multisig_sig &x, const boost::serialization::version_type ver)
-    {
-      a & x.sigs;
-      a & x.ignore;
-      a & x.used_L;
-      a & x.signing_keys;
-      a & x.msout;
-      if (ver < 1)
-        return;
-      a & x.total_alpha_G;
-      a & x.total_alpha_H;
-      a & x.c_0;
-      a & x.s;
-    }
-
-    template <class Archive>
-    inline void serialize(Archive &a, tools::wallet2::pending_tx &x, const boost::serialization::version_type ver)
-    {
-      a & x.tx;
-      a & x.dust;
-      a & x.fee;
-      a & x.dust_added_to_fee;
-      a & x.change_dts;
-      if (ver < 2)
-      {
-        // load list to vector
-        std::list<size_t> selected_transfers;
-        a & selected_transfers;
-        x.selected_transfers.clear();
-        x.selected_transfers.reserve(selected_transfers.size());
-        for (size_t t: selected_transfers)
-          x.selected_transfers.push_back(t);
-      }
-      a & x.key_images;
-      a & x.tx_key;
-      a & x.dests;
-      a & x.construction_data;
-      if (ver < 1)
-        return;
-      a & x.additional_tx_keys;
-      if (ver < 2)
-        return;
-      a & x.selected_transfers;
-      if (ver < 3)
-        return;
-      a & x.multisig_sigs;
-    }
-
     template <class Archive>
     inline void serialize(Archive& a, tools::wallet2::background_synced_tx_t &x, const boost::serialization::version_type ver)
     {
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 03e92ed6ee..fd89511dee 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1912,18 +1912,6 @@ namespace tools
     }
     catch(...) {}
 
-    if (!loaded && !m_restricted)
-    {
-      try
-      {
-        std::istringstream iss(blob);
-        boost::archive::portable_binary_iarchive ar(iss);
-        ar >> ptx;
-        loaded = true;
-      }
-      catch (...) {}
-    }
-
     if (!loaded)
     {
       er.code = WALLET_RPC_ERROR_CODE_BAD_TX_METADATA;
diff --git a/tests/data/signed_monero_tx b/tests/data/signed_monero_tx
deleted file mode 100644
index f1aa1ee8a6..0000000000
Binary files a/tests/data/signed_monero_tx and /dev/null differ
diff --git a/tests/data/unsigned_monero_tx b/tests/data/unsigned_monero_tx
deleted file mode 100644
index 4e644bc450..0000000000
Binary files a/tests/data/unsigned_monero_tx and /dev/null differ
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index 1ca9687a84..d15e3f378d 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -899,287 +899,6 @@ TEST(Serialization, portability_outputs)
   ASSERT_TRUE(td2.m_pk_index == 0);
 }
 
-struct unsigned_tx_set
-{
-  std::vector<tools::wallet2::tx_construction_data> txes;
-  tools::wallet2::transfer_container transfers;
-};
-template <class Archive>
-inline void serialize(Archive &a, unsigned_tx_set &x, const boost::serialization::version_type ver)
-{
-  a & x.txes;
-  a & x.transfers;
-}
-#define UNSIGNED_TX_PREFIX "Monero unsigned tx set\003"
-TEST(Serialization, portability_unsigned_tx)
-{
-  const boost::filesystem::path filename = unit_test::data_dir / "unsigned_monero_tx";
-  std::string s;
-  const cryptonote::network_type nettype = cryptonote::TESTNET;
-  bool r = epee::file_io_utils::load_file_to_string(filename.string(), s);
-  ASSERT_TRUE(r);
-  const size_t magiclen = strlen(UNSIGNED_TX_PREFIX);
-  ASSERT_FALSE(strncmp(s.c_str(), UNSIGNED_TX_PREFIX, magiclen));
-  unsigned_tx_set exported_txs;
-  s = s.substr(magiclen);
-  r = false;
-  try
-  {
-    std::istringstream iss(s);
-    boost::archive::portable_binary_iarchive ar(iss);
-    ar >> exported_txs;
-    r = true;
-  }
-  catch (...)  
-  {}
-  ASSERT_TRUE(r);
-  /*
-  fields of tools::wallet2::unsigned_tx_set to be checked:
-    std::vector<tx_construction_data> txes
-    std::vector<wallet2::transfer_details> m_transfers
-
-  fields of toolw::wallet2::tx_construction_data to be checked:
-    std::vector<cryptonote::tx_source_entry>      sources
-    cryptonote::tx_destination_entry              change_dts
-    std::vector<cryptonote::tx_destination_entry> splitted_dsts
-    std::list<size_t>                             selected_transfers
-    std::vector<uint8_t>                          extra
-    uint64_t                                      unlock_time
-    bool                                          use_rct
-    std::vector<cryptonote::tx_destination_entry> dests
-  
-  fields of cryptonote::tx_source_entry to be checked:
-    std::vector<std::pair<uint64_t, rct::ctkey>>  outputs
-    size_t                                        real_output
-    crypto::public_key                            real_out_tx_key
-    size_t                                        real_output_in_tx_index
-    uint64_t                                      amount
-    bool                                          rct
-    rct::key                                      mask
-  
-  fields of cryptonote::tx_destination_entry to be checked:
-    uint64_t                amount
-    account_public_address  addr
-  */
-  // txes
-  ASSERT_TRUE(exported_txs.txes.size() == 1);
-  auto& tcd = exported_txs.txes[0];
-  // tcd.sources
-  ASSERT_TRUE(tcd.sources.size() == 1);
-  auto& tse = tcd.sources[0];
-  // tcd.sources[0].outputs
-  ASSERT_TRUE(tse.outputs.size() == 5);
-  auto& out0 = tse.outputs[0];
-  auto& out1 = tse.outputs[1];
-  auto& out2 = tse.outputs[2];
-  auto& out3 = tse.outputs[3];
-  auto& out4 = tse.outputs[4];
-  ASSERT_TRUE(out0.first == 6295);
-  ASSERT_TRUE(out1.first == 14302);
-  ASSERT_TRUE(out2.first == 17598);
-  ASSERT_TRUE(out3.first == 18671);
-  ASSERT_TRUE(out4.first == 19760);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out0.second) == "e7272cb589954ddeedd20de9411ed57265f154d41f33cec9ff69e5d642e09814096490b0ac85308342acf436cc0270d53abef9dc04c6202f2459e879bfd40ce6");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out1.second) == "c3a9f49d1fe75939cc3feb39871ce0a7366c2879a63faa1a5cf34e65723b120a272ff0c7d84ab8b6ee3528d196450b0e28b3fed276bc2597a2b5b17afb9354ab");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out2.second) == "176e239c8c39000c2275e2f63ed7d55c55e0843524091522bbd3d3b869044969021fad70fc1244115449d4754829ae7c47346342ee5d52a2cdd47dfc351d0ab0");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out3.second) == "ef12d7946302fb064f2ba9df1a73d72233ac74664ed3b370580fa3bdc377542ad93f64898bd95851d6efe0d7bf2dbbea9b7c6b3c57e2c807e7b17d55b4622259");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out4.second) == "0d8467e16e73d16510452b78823e082e05ee3a63788d40de577cf31eb555f0c8525096cbc88d00a841eed66f3cdb6f0a018e6ce9fb9433ed61afba15cbbebd04");
-  // tcd.sources[0].{real_output, real_out_tx_key, real_output_in_tx_index, amount, rct, mask}
-  ASSERT_TRUE(tse.real_output == 4);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.real_out_tx_key) == "4d86c7ba1c285fe4bc1cd7b54ba894fa89fa02fc6b0bbeea67d53251acd14a05");
-  ASSERT_TRUE(tse.real_output_in_tx_index == 1); 
-  ASSERT_TRUE(tse.amount == 11066009260865);
-  ASSERT_TRUE(tse.rct);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
-  // tcd.change_dts
-  ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
-  // tcd.splitted_dsts
-  ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
-  auto& splitted_dst0 = tcd.splitted_dsts[0];
-  auto& splitted_dst1 = tcd.splitted_dsts[1];
-  ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
-  ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
-  // tcd.selected_transfers
-  ASSERT_TRUE(tcd.selected_transfers.size() == 1);
-  ASSERT_TRUE(tcd.selected_transfers.front() == 2);
-  // tcd.extra
-  ASSERT_TRUE(tcd.extra.size() == 68);
-  // tcd.{unlock_time, use_rct}
-  ASSERT_TRUE(tcd.unlock_time == 0);
-  ASSERT_TRUE(tcd.use_rct);
-  // tcd.dests
-  ASSERT_TRUE(tcd.dests.size() == 1);
-  auto& dest = tcd.dests[0];
-  ASSERT_TRUE(dest.amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  // transfers
-  ASSERT_TRUE(exported_txs.transfers.size() == 3);
-  auto& td0 = exported_txs.transfers[0];
-  auto& td1 = exported_txs.transfers[1];
-  auto& td2 = exported_txs.transfers[2];
-  ASSERT_TRUE(td0.m_block_height == 818424);
-  ASSERT_TRUE(td1.m_block_height == 818522);
-  ASSERT_TRUE(td2.m_block_height == 818522);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_txid) == "15024343b38e77a1a9860dfed29921fa17e833fec837191a6b04fa7cb9605b8e");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_txid) == "ec34c9bb12b99af33d49691384eee5bed9171498ff04e59516505f35d1fc5efc");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_txid) == "6e7013684d35820f66c6679197ded9329bfe0e495effa47e7b25258799858dba");
-  ASSERT_TRUE(td0.m_internal_output_index == 0);
-  ASSERT_TRUE(td1.m_internal_output_index == 0);
-  ASSERT_TRUE(td2.m_internal_output_index == 1);
-  ASSERT_TRUE(td0.m_global_output_index == 19642);
-  ASSERT_TRUE(td1.m_global_output_index == 19757);
-  ASSERT_TRUE(td2.m_global_output_index == 19760);
-  ASSERT_TRUE (td0.m_spent);
-  ASSERT_FALSE(td1.m_spent);
-  ASSERT_FALSE(td2.m_spent);
-  ASSERT_TRUE(td0.m_spent_height == 0);
-  ASSERT_TRUE(td1.m_spent_height == 0);
-  ASSERT_TRUE(td2.m_spent_height == 0);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_key_image) == "c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_key_image) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_key_image) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td0.m_mask) == "0100000000000000000000000000000000000000000000000000000000000000");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td1.m_mask) == "d3997a7b27fa199a377643b88cbd3f20f447496746dabe92d288730ecaeda007");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(td2.m_mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
-  ASSERT_TRUE(td0.m_amount == 13400845012231);
-  ASSERT_TRUE(td1.m_amount == 1200000000000);
-  ASSERT_TRUE(td2.m_amount == 11066009260865);
-  ASSERT_TRUE(td0.m_rct);
-  ASSERT_TRUE(td1.m_rct);
-  ASSERT_TRUE(td2.m_rct);
-  ASSERT_TRUE(td0.m_key_image_known);
-  ASSERT_TRUE(td1.m_key_image_known);
-  ASSERT_TRUE(td2.m_key_image_known);
-  ASSERT_TRUE(td0.m_pk_index == 0);
-  ASSERT_TRUE(td1.m_pk_index == 0);
-  ASSERT_TRUE(td2.m_pk_index == 0);
-}
-
-#define SIGNED_TX_PREFIX "Monero signed tx set\003"
-TEST(Serialization, portability_signed_tx)
-{
-  const boost::filesystem::path filename = unit_test::data_dir / "signed_monero_tx";
-  const cryptonote::network_type nettype = cryptonote::TESTNET;
-  std::string s;
-  bool r = epee::file_io_utils::load_file_to_string(filename.string(), s);
-  ASSERT_TRUE(r);
-  const size_t magiclen = strlen(SIGNED_TX_PREFIX);
-  ASSERT_FALSE(strncmp(s.c_str(), SIGNED_TX_PREFIX, magiclen));
-  tools::wallet2::signed_tx_set exported_txs;
-  s = s.substr(magiclen);
-  r = false;
-  try
-  {
-    std::istringstream iss(s);
-    boost::archive::portable_binary_iarchive ar(iss);
-    ar >> exported_txs;
-    r = true;
-  }
-  catch (...)
-  {}
-  ASSERT_TRUE(r);
-  /*
-  fields of tools::wallet2::signed_tx_set to be checked:
-    std::vector<pending_tx>         ptx
-    std::vector<crypto::key_image>  key_images
-  
-  fields of tools::walllet2::pending_tx to be checked:
-    cryptonote::transaction                       tx                  // TODO
-    uint64_t                                      dust
-    uint64_t                                      fee
-    bool                                          dust_added_to_fee
-    cryptonote::tx_destination_entry              change_dts
-    std::list<size_t>                             selected_transfers
-    std::string                                   key_images
-    crypto::secret_key                            tx_key
-    std::vector<cryptonote::tx_destination_entry> dests
-    tx_construction_data                          construction_data
-  */
-  // ptx
-  ASSERT_TRUE(exported_txs.ptx.size() == 1);
-  auto& ptx = exported_txs.ptx[0];
-  // ptx.{dust, fee, dust_added_to_fee}
-  ASSERT_TRUE (ptx.dust == 0);
-  ASSERT_TRUE (ptx.fee == 34800487462);
-  ASSERT_FALSE(ptx.dust_added_to_fee);
-  // ptx.change.{amount, addr}
-  ASSERT_TRUE(ptx.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, ptx.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
-  // ptx.selected_transfers
-  ASSERT_TRUE(ptx.selected_transfers.size() == 1);
-  ASSERT_TRUE(ptx.selected_transfers.front() == 2);
-  // ptx.{key_images, tx_key}
-  ASSERT_TRUE(ptx.key_images == "<6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76> ");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(unwrap(unwrap(ptx.tx_key))) == "0100000000000000000000000000000000000000000000000000000000000000");
-  // ptx.dests
-  ASSERT_TRUE(ptx.dests.size() == 1);
-  ASSERT_TRUE(ptx.dests[0].amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, ptx.dests[0].addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  // ptx.construction_data
-  auto& tcd = ptx.construction_data;
-  ASSERT_TRUE(tcd.sources.size() == 1);
-  auto& tse = tcd.sources[0];
-  // ptx.construction_data.sources[0].outputs
-  ASSERT_TRUE(tse.outputs.size() == 5);
-  auto& out0 = tse.outputs[0];
-  auto& out1 = tse.outputs[1];
-  auto& out2 = tse.outputs[2];
-  auto& out3 = tse.outputs[3];
-  auto& out4 = tse.outputs[4];
-  ASSERT_TRUE(out0.first == 6295);
-  ASSERT_TRUE(out1.first == 14302);
-  ASSERT_TRUE(out2.first == 17598);
-  ASSERT_TRUE(out3.first == 18671);
-  ASSERT_TRUE(out4.first == 19760);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out0.second) == "e7272cb589954ddeedd20de9411ed57265f154d41f33cec9ff69e5d642e09814096490b0ac85308342acf436cc0270d53abef9dc04c6202f2459e879bfd40ce6");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out1.second) == "c3a9f49d1fe75939cc3feb39871ce0a7366c2879a63faa1a5cf34e65723b120a272ff0c7d84ab8b6ee3528d196450b0e28b3fed276bc2597a2b5b17afb9354ab");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out2.second) == "176e239c8c39000c2275e2f63ed7d55c55e0843524091522bbd3d3b869044969021fad70fc1244115449d4754829ae7c47346342ee5d52a2cdd47dfc351d0ab0");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out3.second) == "ef12d7946302fb064f2ba9df1a73d72233ac74664ed3b370580fa3bdc377542ad93f64898bd95851d6efe0d7bf2dbbea9b7c6b3c57e2c807e7b17d55b4622259");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(out4.second) == "0d8467e16e73d16510452b78823e082e05ee3a63788d40de577cf31eb555f0c8525096cbc88d00a841eed66f3cdb6f0a018e6ce9fb9433ed61afba15cbbebd04");
-  // ptx.construction_data.sources[0].{real_output, real_out_tx_key, real_output_in_tx_index, amount, rct, mask}
-  ASSERT_TRUE(tse.real_output == 4);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.real_out_tx_key) == "4d86c7ba1c285fe4bc1cd7b54ba894fa89fa02fc6b0bbeea67d53251acd14a05");
-  ASSERT_TRUE(tse.real_output_in_tx_index == 1); 
-  ASSERT_TRUE(tse.amount == 11066009260865);
-  ASSERT_TRUE(tse.rct);
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
-  // ptx.construction_data.change_dts
-  ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
-  // ptx.construction_data.splitted_dsts
-  ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
-  auto& splitted_dst0 = tcd.splitted_dsts[0];
-  auto& splitted_dst1 = tcd.splitted_dsts[1];
-  ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
-  ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
-  // ptx.construction_data.selected_transfers
-  ASSERT_TRUE(tcd.selected_transfers.size() == 1);
-  ASSERT_TRUE(tcd.selected_transfers.front() == 2);
-  // ptx.construction_data.extra
-  ASSERT_TRUE(tcd.extra.size() == 68);
-  // ptx.construction_data.{unlock_time, use_rct}
-  ASSERT_TRUE(tcd.unlock_time == 0);
-  ASSERT_TRUE(tcd.use_rct);
-  // ptx.construction_data.dests
-  ASSERT_TRUE(tcd.dests.size() == 1);
-  auto& dest = tcd.dests[0];
-  ASSERT_TRUE(dest.amount == 1400000000000);
-  ASSERT_TRUE(cryptonote::get_account_address_as_str(nettype, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
-  // key_images
-  ASSERT_TRUE(exported_txs.key_images.size() == 3);
-  auto& ki0 = exported_txs.key_images[0];
-  auto& ki1 = exported_txs.key_images[1];
-  auto& ki2 = exported_txs.key_images[2];
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(ki0) == "c5680d3735b90871ca5e3d90cd82d6483eed1151b9ab75c2c8c3a7d89e00a5a8");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(ki1) == "d54cbd435a8d636ad9b01b8d4f3eb13bd0cf1ce98eddf53ab1617f9b763e66c0");
-  ASSERT_TRUE(epee::string_tools::pod_to_hex(ki2) == "6c3cd6af97c4070a7aef9b1344e7463e29c7cd245076fdb65da447a34da3ca76");
-}
-
 TEST(Serialization, difficulty_type)
 {
   std::vector<cryptonote::difficulty_type> v_original;