boost::serialization Namespace Reference

Functions
template<class Archive, class h_key, class hval>
void	save (Archive &a, const std::unordered_map< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class h_key, class hval>
void	load (Archive &a, std::unordered_map< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class h_key, class hval>
void	save (Archive &a, const std::unordered_multimap< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class h_key, class hval>
void	load (Archive &a, std::unordered_multimap< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class hval>
void	save (Archive &a, const std::unordered_set< hval > &x, const boost::serialization::version_type ver)
template<class Archive, class hval>
void	load (Archive &a, std::unordered_set< hval > &x, const boost::serialization::version_type ver)
template<class Archive, class h_key, class hval>
void	serialize (Archive &a, std::unordered_map< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class h_key, class hval>
void	serialize (Archive &a, std::unordered_multimap< h_key, hval > &x, const boost::serialization::version_type ver)
template<class Archive, class hval>
void	serialize (Archive &a, std::unordered_set< hval > &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::account_keys &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::public_key &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::secret_key &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::key_derivation &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::key_image &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::signature &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::hash &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::hash8 &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txout_to_script &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txout_to_key &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txout_to_key_public &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::account_public_address &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txout_to_scripthash &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txin_gen &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txin_to_script &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txin_to_scripthash &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txin_to_key &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::txin_to_key_public &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::tx_out &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::transaction_prefix &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::transaction &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::block &b, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::key &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::ctkey &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::rangeSig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::Bulletproof &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::boroSig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::mgSig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::ecdhTuple &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::multisig_kLRki &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::multisig_out &x, const boost::serialization::version_type ver)
template<class Archive>
std::enable_if< Archive::is_loading::value, void >::type	serializeOutPk (Archive &a, rct::ctkeyV &outPk_, const boost::serialization::version_type ver)
template<class Archive>
std::enable_if< Archive::is_saving::value, void >::type	serializeOutPk (Archive &a, rct::ctkeyV &outPk_, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::rctSigBase &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::rctSigPrunable &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::rctSig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, rct::RCTConfig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::difficulty_type &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::subaddress_index &x, const boost::serialization::version_type ver)
template<class archive_t>
void	serialize (archive_t &ar, cryptonote::blockchain_storage::transaction_chain_entry &te, const unsigned int version)
template<class archive_t>
void	serialize (archive_t &ar, cryptonote::blockchain_storage::block_extended_info &ei, const unsigned int version)
template<class Archive>
void	serialize (Archive &a, cryptonote::tx_source_entry &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, cryptonote::tx_destination_entry &x, const boost::serialization::version_type ver)
template<class archive_t>
void	serialize (archive_t &ar, cryptonote::tx_memory_pool::tx_details &td, const unsigned int version)
template<class T, class Archive>
void	do_serialize (boost::mpl::false_, Archive &a, epee::net_utils::network_address &na)
template<class T, class Archive>
void	do_serialize (boost::mpl::true_, Archive &a, const epee::net_utils::network_address &na)
template<class Archive, class ver_type>
void	serialize (Archive &a, epee::net_utils::network_address &na, const ver_type ver)
template<class Archive, class ver_type>
void	serialize (Archive &a, epee::net_utils::ipv4_network_address &na, const ver_type ver)
template<class Archive, class ver_type>
void	save (Archive &a, const net::tor_address &na, const ver_type)
template<class Archive, class ver_type>
void	save (Archive &a, const net::i2p_address &na, const ver_type)
template<class Archive, class ver_type>
void	load (Archive &a, net::tor_address &na, const ver_type)
template<class Archive, class ver_type>
void	load (Archive &a, net::i2p_address &na, const ver_type)
template<class Archive, class ver_type>
void	serialize (Archive &a, net::tor_address &na, const ver_type ver)
template<class Archive, class ver_type>
void	serialize (Archive &a, net::i2p_address &na, const ver_type ver)
template<class Archive, class ver_type>
void	serialize (Archive &a, nodetool::peerlist_entry &pl, const ver_type ver)
template<class Archive, class ver_type>
void	serialize (Archive &a, nodetool::anchor_peerlist_entry &pl, const ver_type ver)
template<class Archive>
void	serialize (Archive &a, mms::file_data &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, mms::message &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, mms::authorized_signer &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, mms::auto_config_data &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, mms::file_transport_message &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, crypto::chacha_iv &x, const boost::serialization::version_type ver)
template<class Archive>
std::enable_if<!Archive::is_loading::value, void >::type	initialize_transfer_details (Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
template<class Archive>
std::enable_if< Archive::is_loading::value, void >::type	initialize_transfer_details (Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::multisig_info::LR &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::multisig_info &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::multisig_tx_set &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::unconfirmed_transfer_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::confirmed_transfer_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::payment_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::pool_payment_details &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::address_book_row &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::reserve_proof_entry &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::unsigned_tx_set &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::signed_tx_set &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::tx_construction_data &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::multisig_sig &x, const boost::serialization::version_type ver)
template<class Archive>
void	serialize (Archive &a, tools::wallet2::pending_tx &x, const boost::serialization::version_type ver)

Function Documentation

do_serialize() [1/2]

template<class T, class Archive>

void boost::serialization::do_serialize ( boost::mpl::false_ , Archive & a, epee::net_utils::network_address & na )

inline

Definition at line 53 of file net_peerlist_boost_serialization.h.

    {
      T addr{};
      a & addr;
      na = std::move(addr);
    }

do_serialize() [2/2]

template<class T, class Archive>

void boost::serialization::do_serialize ( boost::mpl::true_ , Archive & a, const epee::net_utils::network_address & na )

inline

Definition at line 61 of file net_peerlist_boost_serialization.h.

    {
      a & na.as<T>();
    }

Here is the call graph for this function:

initialize_transfer_details() [1/2]

template<class Archive>

std::enable_if< Archive::is_loading::value, void >::type boost::serialization::initialize_transfer_details ( Archive & a, tools::wallet2::transfer_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1648 of file wallet2.h.

    {
        if (ver < 1)
        {
          x.m_mask = rct::identity();
          x.m_amount = x.m_tx.vout[x.m_internal_output_index].amount;
        }
        if (ver < 2)
        {
          x.m_spent_height = 0;
        }
        if (ver < 4)
        {
          x.m_rct = x.m_tx.vout[x.m_internal_output_index].amount == 0;
        }
        if (ver < 6)
        {
          x.m_key_image_known = true;
        }
        if (ver < 7)
        {
          x.m_pk_index = 0;
        }
        if (ver < 8)
        {
          x.m_subaddr_index = {};
        }
        if (ver < 9)
        {
          x.m_key_image_partial = false;
          x.m_multisig_k.clear();
          x.m_multisig_info.clear();
        }
        if (ver < 10)
        {
          x.m_key_image_request = false;
        }
        if (ver < 12)
        {
          x.m_frozen = false;
        }
    }

Here is the call graph for this function:

initialize_transfer_details() [2/2]

template<class Archive>

std::enable_if<!Archive::is_loading::value, void >::type boost::serialization::initialize_transfer_details ( Archive & a, tools::wallet2::transfer_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1644 of file wallet2.h.

    {
    }

Here is the call graph for this function:

Here is the caller graph for this function:

load() [1/5]

template<class Archive, class ver_type>

void boost::serialization::load ( Archive & a, net::i2p_address & na, const ver_type  )

inline

Definition at line 153 of file net_peerlist_boost_serialization.h.

    {
      uint16_t port = 0;
      uint8_t length = 0;
      a & port;
      a & length;
 
      const size_t buffer_size = net::i2p_address::buffer_size();
      if (length > buffer_size)
        ELECTRONEUM_THROW(net::error::invalid_i2p_address, "i2p address too long");
 
      char host[buffer_size] = {0};
      a.load_binary(host, length);
      host[sizeof(host) - 1] = 0;
 
      if (std::strcmp(host, net::i2p_address::unknown_str()) == 0)
        na = net::i2p_address::unknown();
      else
        na = ELECTRONEUM_UNWRAP(net::i2p_address::make(host, port));
    }

Here is the call graph for this function:

load() [2/5]

template<class Archive, class ver_type>

void boost::serialization::load ( Archive & a, net::tor_address & na, const ver_type  )

inline

Definition at line 131 of file net_peerlist_boost_serialization.h.

    {
      uint16_t port = 0;
      uint8_t length = 0;
      a & port;
      a & length;
 
      const size_t buffer_size = net::tor_address::buffer_size();
      if (length > buffer_size)
        ELECTRONEUM_THROW(net::error::invalid_tor_address, "Tor address too long");
 
      char host[buffer_size] = {0};
      a.load_binary(host, length);
      host[sizeof(host) - 1] = 0;
 
      if (std::strcmp(host, net::tor_address::unknown_str()) == 0)
        na = net::tor_address::unknown();
      else
        na = ELECTRONEUM_UNWRAP(net::tor_address::make(host, port));
    }

Here is the call graph for this function:

load() [3/5]

template<class Archive, class h_key, class hval>

void boost::serialization::load ( Archive & a, std::unordered_map< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 55 of file unordered_containers_boost_serialization.h.

    {
      x.clear();
      size_t s = 0;
      a >> s;
      for(size_t i = 0; i != s; i++)
      {
        h_key k;
        hval v;
        a >> k;
        a >> v;
        x.insert(std::pair<h_key, hval>(k, v));
      }
    }

Here is the caller graph for this function:

load() [4/5]

template<class Archive, class h_key, class hval>

void boost::serialization::load ( Archive & a, std::unordered_multimap< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 84 of file unordered_containers_boost_serialization.h.

    {
      x.clear();
      size_t s = 0;
      a >> s;
      for(size_t i = 0; i != s; i++)
      {
        h_key k;
        hval v;
        a >> k;
        a >> v;
        x.emplace(k, v);
      }
    }

load() [5/5]

template<class Archive, class hval>

void boost::serialization::load ( Archive & a, std::unordered_set< hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 112 of file unordered_containers_boost_serialization.h.

    {
      x.clear();
      size_t s = 0;
      a >> s;
      for(size_t i = 0; i != s; i++)
      {
        hval v;
        a >> v;
        x.insert(v);
      }
    }

save() [1/5]

template<class Archive, class ver_type>

void boost::serialization::save ( Archive & a, const net::i2p_address & na, const ver_type  )

inline

Definition at line 117 of file net_peerlist_boost_serialization.h.

    {
      const size_t length = std::strlen(na.host_str());
      if (length > 255)
        ELECTRONEUM_THROW(net::error::invalid_i2p_address, "i2p address too long");
 
      const uint16_t port{na.port()};
      const uint8_t len = length;
      a & port;
      a & len;
      a.save_binary(na.host_str(), length);
    }

Here is the call graph for this function:

save() [2/5]

template<class Archive, class ver_type>

void boost::serialization::save ( Archive & a, const net::tor_address & na, const ver_type  )

inline

Definition at line 103 of file net_peerlist_boost_serialization.h.

    {
      const size_t length = std::strlen(na.host_str());
      if (length > 255)
        ELECTRONEUM_THROW(net::error::invalid_tor_address, "Tor address too long");
 
      const uint16_t port{na.port()};
      const uint8_t len = length;
      a & port;
      a & len;
      a.save_binary(na.host_str(), length);
    }

Here is the call graph for this function:

save() [3/5]

template<class Archive, class h_key, class hval>

void boost::serialization::save ( Archive & a, const std::unordered_map< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 43 of file unordered_containers_boost_serialization.h.

    {
      size_t s = x.size();
      a << s;
      for(auto& v: x)
      {
        a << v.first;
        a << v.second;
      }
    }

Here is the caller graph for this function:

save() [4/5]

template<class Archive, class h_key, class hval>

void boost::serialization::save ( Archive & a, const std::unordered_multimap< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 72 of file unordered_containers_boost_serialization.h.

    {
      size_t s = x.size();
      a << s;
      for(auto& v: x)
      {
        a << v.first;
        a << v.second;
      }
    }

save() [5/5]

template<class Archive, class hval>

void boost::serialization::save ( Archive & a, const std::unordered_set< hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 101 of file unordered_containers_boost_serialization.h.

    {
      size_t s = x.size();
      a << s;
      for(auto& v: x)
      {
        a << v;
      }
    }

serialize() [1/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::chacha_iv & x, const boost::serialization::version_type ver )

inline

Definition at line 415 of file message_store.h.

    {
      a & x.data;
    }

serialize() [2/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::hash & x, const boost::serialization::version_type ver )

inline

Definition at line 85 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::hash)]>(x);
  }

serialize() [3/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::hash8 & x, const boost::serialization::version_type ver )

inline

Definition at line 90 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::hash8)]>(x);
  }

serialize() [4/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::key_derivation & x, const boost::serialization::version_type ver )

inline

Definition at line 68 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::key_derivation)]>(x);
  }

serialize() [5/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::key_image & x, const boost::serialization::version_type ver )

inline

Definition at line 73 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::key_image)]>(x);
  }

serialize() [6/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::public_key & x, const boost::serialization::version_type ver )

inline

Definition at line 58 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::public_key)]>(x);
  }

serialize() [7/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::secret_key & x, const boost::serialization::version_type ver )

inline

Definition at line 63 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::secret_key)]>(x);
  }

serialize() [8/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, crypto::signature & x, const boost::serialization::version_type ver )

inline

Definition at line 79 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(crypto::signature)]>(x);
  }

serialize() [9/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::account_keys & x, const boost::serialization::version_type ver )

inline

Definition at line 43 of file account_boost_serialization.h.

    {
      a & x.m_account_address;
      a & x.m_spend_secret_key;
      a & x.m_view_secret_key;
    }

serialize() [10/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::account_public_address & x, const boost::serialization::version_type ver )

inline

Definition at line 117 of file cryptonote_boost_serialization.h.

  {
    a & x.m_spend_public_key;
    a & x.m_view_public_key;
  }

serialize() [11/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::block & b, const boost::serialization::version_type ver )

inline

Definition at line 207 of file cryptonote_boost_serialization.h.

  {
    a & b.major_version;
    a & b.minor_version;
    a & b.timestamp;
    a & b.prev_id;
    a & b.nonce;
    //------------------
    a & b.miner_tx;
    a & b.tx_hashes;
  }

serialize() [12/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::difficulty_type & x, const boost::serialization::version_type ver )

inline

Definition at line 376 of file cryptonote_boost_serialization.h.

  {
    if (Archive::is_loading::value)
    {
      // load high part
      uint64_t v = 0;
      a & v;
      x = v;
      // load low part
      x = x << 64;
      a & v;
      x += v;
    }
    else
    {
      // store high part
      cryptonote::difficulty_type x_ = (x >> 64) & 0xffffffffffffffff;
      uint64_t v = x_.convert_to<uint64_t>();
      a & v;
      // store low part
      x_ = x & 0xffffffffffffffff;
      v = x_.convert_to<uint64_t>();
      a & v;
    }
  }

serialize() [13/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::subaddress_index & x, const boost::serialization::version_type ver )

inline

Definition at line 96 of file subaddress_index.h.

    {
      a & x.major;
      a & x.minor;
    }

serialize() [14/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::transaction & x, const boost::serialization::version_type ver )

inline

Definition at line 187 of file cryptonote_boost_serialization.h.

  {
    a & x.version;
    a & x.unlock_time;
    a & x.vin;
    a & x.vout;
    a & x.extra;
    if (x.version == 1)
    {
      a & x.signatures;
    }
    else
    {
      a & (rct::rctSigBase&)x.rct_signatures;
      if (x.rct_signatures.type != rct::RCTTypeNull)
        a & x.rct_signatures.p;
    }
  }

serialize() [15/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::transaction_prefix & x, const boost::serialization::version_type ver )

inline

Definition at line 177 of file cryptonote_boost_serialization.h.

  {
    a & x.version;
    a & x.unlock_time;
    a & x.vin;
    a & x.vout;
    a & x.extra;
  }

serialize() [16/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::tx_destination_entry & x, const boost::serialization::version_type ver )

inline

Definition at line 158 of file cryptonote_tx_utils.h.

    {
      a & x.amount;
      a & x.addr;
      if (ver < 1)
        return;
      a & x.is_subaddress;
      if (ver < 2)
      {
        x.is_integrated = false;
        return;
      }
      a & x.original;
      a & x.is_integrated;
    }

serialize() [17/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::tx_out & x, const boost::serialization::version_type ver )

inline

Definition at line 169 of file cryptonote_boost_serialization.h.

  {
    a & x.amount;
    a & x.target;
  }

serialize() [18/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::tx_source_entry & x, const boost::serialization::version_type ver )

inline

Definition at line 138 of file cryptonote_tx_utils.h.

    {
      a & x.outputs;
      a & x.real_output;
      a & x.real_out_tx_key;
      a & x.real_output_in_tx_index;
      a & x.amount;
      a & x.rct;
      a & x.mask;
      if (ver < 1)
        return;
      a & x.multisig_kLRki;
      a & x.real_out_additional_tx_keys;
      if (ver < 2)
        return;
      a & x.tx_hash;
      a & x.subaddr_index;
    }

serialize() [19/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txin_gen & x, const boost::serialization::version_type ver )

inline

Definition at line 130 of file cryptonote_boost_serialization.h.

  {
    a & x.height;
  }

serialize() [20/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txin_to_key & x, const boost::serialization::version_type ver )

inline

Definition at line 153 of file cryptonote_boost_serialization.h.

  {
    a & x.amount;
    a & x.key_offsets;
    a & x.k_image;
  }

serialize() [21/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txin_to_key_public & x, const boost::serialization::version_type ver )

inline

Definition at line 161 of file cryptonote_boost_serialization.h.

  {
      a & x.amount;
      a & x.relative_offset;
      a & x.tx_hash;
  }

serialize() [22/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txin_to_script & x, const boost::serialization::version_type ver )

inline

Definition at line 136 of file cryptonote_boost_serialization.h.

  {
    a & x.prev;
    a & x.prevout;
    a & x.sigset;
  }

serialize() [23/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txin_to_scripthash & x, const boost::serialization::version_type ver )

inline

Definition at line 144 of file cryptonote_boost_serialization.h.

  {
    a & x.prev;
    a & x.prevout;
    a & x.script;
    a & x.sigset;
  }

serialize() [24/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txout_to_key & x, const boost::serialization::version_type ver )

inline

Definition at line 104 of file cryptonote_boost_serialization.h.

  {
    a & x.key;
  }

serialize() [25/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txout_to_key_public & x, const boost::serialization::version_type ver )

inline

Definition at line 110 of file cryptonote_boost_serialization.h.

  {
    a & x.m_address_prefix;
    a & x.address;
  }

serialize() [26/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txout_to_script & x, const boost::serialization::version_type ver )

inline

Definition at line 96 of file cryptonote_boost_serialization.h.

  {
    a & x.keys;
    a & x.script;
  }

serialize() [27/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, cryptonote::txout_to_scripthash & x, const boost::serialization::version_type ver )

inline

Definition at line 124 of file cryptonote_boost_serialization.h.

  {
    a & x.hash;
  }

serialize() [28/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, epee::net_utils::ipv4_network_address & na, const ver_type ver )

inline

Definition at line 92 of file net_peerlist_boost_serialization.h.

    {
      uint32_t ip{na.ip()};
      uint16_t port{na.port()};
      a & ip;
      a & port;
      if (!typename Archive::is_saving())
        na = epee::net_utils::ipv4_network_address{ip, port};
    }

Here is the call graph for this function:

serialize() [29/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, epee::net_utils::network_address & na, const ver_type ver )

inline

Definition at line 67 of file net_peerlist_boost_serialization.h.

    {
      static constexpr const typename Archive::is_saving is_saving{};
 
      uint8_t type;
      if (is_saving)
        type = uint8_t(na.get_type_id());
      a & type;
      switch (epee::net_utils::address_type(type))
      {
        case epee::net_utils::ipv4_network_address::get_type_id():
          do_serialize<epee::net_utils::ipv4_network_address>(is_saving, a, na);
          break;
        case net::tor_address::get_type_id():
          do_serialize<net::tor_address>(is_saving, a, na);
          break;
        case net::i2p_address::get_type_id():
          do_serialize<net::i2p_address>(is_saving, a, na);
          break;
        case epee::net_utils::address_type::invalid:
        default:
          throw std::runtime_error("Unsupported network address type");
      }
    }

Here is the call graph for this function:

serialize() [30/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, mms::authorized_signer & x, const boost::serialization::version_type ver )

inline

Definition at line 378 of file message_store.h.

    {
      a & x.label;
      a & x.transport_address;
      a & x.etn_address_known;
      a & x.etn_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;  
    }

serialize() [31/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, mms::auto_config_data & x, const boost::serialization::version_type ver )

inline

Definition at line 398 of file message_store.h.

    {
      a & x.label;
      a & x.transport_address;
      a & x.etn_address;
    }

serialize() [32/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, mms::file_data & x, const boost::serialization::version_type ver )

inline

Definition at line 350 of file message_store.h.

    {
      a & x.magic_string;
      a & x.file_version;
      a & x.iv;
      a & x.encrypted_data;
    }

serialize() [33/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, mms::file_transport_message & x, const boost::serialization::version_type ver )

inline

Definition at line 406 of file message_store.h.

    {
      a & x.sender_address;
      a & x.iv;
      a & x.encryption_public_key;
      a & x.internal_message;
    }

serialize() [34/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, mms::message & x, const boost::serialization::version_type ver )

inline

Definition at line 359 of file message_store.h.

    {
      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;
    }

serialize() [35/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, net::i2p_address & na, const ver_type ver )

inline

Definition at line 181 of file net_peerlist_boost_serialization.h.

    {
      boost::serialization::split_free(a, na, ver);
    }

serialize() [36/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, net::tor_address & na, const ver_type ver )

inline

Definition at line 175 of file net_peerlist_boost_serialization.h.

    {
      boost::serialization::split_free(a, na, ver);
    }

serialize() [37/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, nodetool::anchor_peerlist_entry & pl, const ver_type ver )

inline

Definition at line 215 of file net_peerlist_boost_serialization.h.

    {
      a & pl.adr;
      a & pl.id;
      a & pl.first_seen;
    }

serialize() [38/72]

template<class Archive, class ver_type>

void boost::serialization::serialize ( Archive & a, nodetool::peerlist_entry & pl, const ver_type ver )

inline

Definition at line 187 of file net_peerlist_boost_serialization.h.

    {
      a & pl.adr;
      a & pl.id;
      a & pl.last_seen;
      if (ver < 1)
      {
        if (!typename Archive::is_saving())
          pl.pruning_seed = 0;
        return;
      }
      a & pl.pruning_seed;
#ifdef CRYPTONOTE_PRUNING_DEBUG_SPOOF_SEED
      if (!typename Archive::is_saving())
      {
        pl.pruning_seed = tools::make_pruning_seed(1+pl.adr.as<epee::net_utils::ipv4_network_address>().ip() % (1<<CRYPTONOTE_PRUNING_LOG_STRIPES), CRYPTONOTE_PRUNING_LOG_STRIPES);
      }
#endif
      if (ver < 2)
      {
        if (!typename Archive::is_saving())
          pl.rpc_port = 0;
        return;
      }
      a & pl.rpc_port;
    }

Here is the call graph for this function:

serialize() [39/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::boroSig & x, const boost::serialization::version_type ver )

inline

Definition at line 257 of file cryptonote_boost_serialization.h.

  {
    a & x.s0;
    a & x.s1;
    a & x.ee;
  }

serialize() [40/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::Bulletproof & x, const boost::serialization::version_type ver )

inline

Definition at line 240 of file cryptonote_boost_serialization.h.

  {
    a & x.V;
    a & x.A;
    a & x.S;
    a & x.T1;
    a & x.T2;
    a & x.taux;
    a & x.mu;
    a & x.L;
    a & x.R;
    a & x.a;
    a & x.b;
    a & x.t;
  }

serialize() [41/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::ctkey & x, const boost::serialization::version_type ver )

inline

Definition at line 226 of file cryptonote_boost_serialization.h.

  {
    a & x.dest;
    a & x.mask;
  }

serialize() [42/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::ecdhTuple & x, const boost::serialization::version_type ver )

inline

Definition at line 273 of file cryptonote_boost_serialization.h.

  {
    a & x.mask;
    a & x.amount;
  }

serialize() [43/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::key & x, const boost::serialization::version_type ver )

inline

Definition at line 220 of file cryptonote_boost_serialization.h.

  {
    a & reinterpret_cast<char (&)[sizeof(rct::key)]>(x);
  }

serialize() [44/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::mgSig & x, const boost::serialization::version_type ver )

inline

Definition at line 265 of file cryptonote_boost_serialization.h.

  {
    a & x.ss;
    a & x.cc;
    // a & x.II; // not serialized, we can recover it from the tx vin
  }

serialize() [45/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::multisig_kLRki & x, const boost::serialization::version_type ver )

inline

Definition at line 280 of file cryptonote_boost_serialization.h.

  {
    a & x.k;
    a & x.L;
    a & x.R;
    a & x.ki;
  }

serialize() [46/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::multisig_out & x, const boost::serialization::version_type ver )

inline

Definition at line 289 of file cryptonote_boost_serialization.h.

  {
    a & x.c;
  }

serialize() [47/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::rangeSig & x, const boost::serialization::version_type ver )

inline

Definition at line 233 of file cryptonote_boost_serialization.h.

  {
    a & x.asig;
    a & x.Ci;
  }

serialize() [48/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::RCTConfig & x, const boost::serialization::version_type ver )

inline

Definition at line 369 of file cryptonote_boost_serialization.h.

  {
    a & x.range_proof_type;
    a & x.bp_version;
  }

serialize() [49/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::rctSig & x, const boost::serialization::version_type ver )

inline

Definition at line 345 of file cryptonote_boost_serialization.h.

  {
    a & x.type;
    if (x.type == rct::RCTTypeNull)
      return;
    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2)
      throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
    // a & x.message; message is not serialized, as it can be reconstructed from the tx data
    // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
    if (x.type == rct::RCTTypeSimple)
      a & x.pseudoOuts;
    a & x.ecdhInfo;
    serializeOutPk(a, x.outPk, ver);
    a & x.txnFee;
    //--------------
    a & x.p.rangeSigs;
    if (x.p.rangeSigs.empty())
      a & x.p.bulletproofs;
    a & x.p.MGs;
    if (x.type == rct::RCTTypeBulletproof || x.type == rct::RCTTypeBulletproof2)
      a & x.p.pseudoOuts;
  }

Here is the call graph for this function:

serialize() [50/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::rctSigBase & x, const boost::serialization::version_type ver )

inline

Definition at line 317 of file cryptonote_boost_serialization.h.

  {
    a & x.type;
    if (x.type == rct::RCTTypeNull)
      return;
    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2)
      throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
    // a & x.message; message is not serialized, as it can be reconstructed from the tx data
    // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
    if (x.type == rct::RCTTypeSimple) // moved to prunable with bulletproofs
      a & x.pseudoOuts;
    a & x.ecdhInfo;
    serializeOutPk(a, x.outPk, ver);
    a & x.txnFee;
  }

Here is the call graph for this function:

serialize() [51/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, rct::rctSigPrunable & x, const boost::serialization::version_type ver )

inline

Definition at line 334 of file cryptonote_boost_serialization.h.

  {
    a & x.rangeSigs;
    if (x.rangeSigs.empty())
      a & x.bulletproofs;
    a & x.MGs;
    if (x.rangeSigs.empty())
      a & x.pseudoOuts;
  }

serialize() [52/72]

template<class Archive, class h_key, class hval>

void boost::serialization::serialize ( Archive & a, std::unordered_map< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 127 of file unordered_containers_boost_serialization.h.

    {
      split_free(a, x, ver);
    }

serialize() [53/72]

template<class Archive, class h_key, class hval>

void boost::serialization::serialize ( Archive & a, std::unordered_multimap< h_key, hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 133 of file unordered_containers_boost_serialization.h.

    {
      split_free(a, x, ver);
    }

serialize() [54/72]

template<class Archive, class hval>

void boost::serialization::serialize ( Archive & a, std::unordered_set< hval > & x, const boost::serialization::version_type ver )

inline

Definition at line 139 of file unordered_containers_boost_serialization.h.

    {
      split_free(a, x, ver);
    }

serialize() [55/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::address_book_row & x, const boost::serialization::version_type ver )

inline

Definition at line 1955 of file wallet2.h.

    {
      a & x.m_address;
      a & x.m_payment_id;
      a & x.m_description;
      if (ver < 17)
      {
        x.m_is_subaddress = false;
        return;
      }
      a & x.m_is_subaddress;
    }

serialize() [56/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::confirmed_transfer_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1862 of file wallet2.h.

    {
      a & x.m_amount_in;
      a & x.m_amount_out;
      a & x.m_change;
      a & x.m_block_height;
      if (ver < 1)
        return;
      a & x.m_dests;
      a & x.m_payment_id;
      if (ver < 2)
        return;
      a & x.m_timestamp;
      if (ver < 3)
      {
        // v<3 may not have change accumulated in m_amount_out, which is a pain,
        // as it's readily understood to be sum of outputs. Whether it got added
        // or not depends on whether it came from a unconfirmed_transfer_details
        // (not included) or not (included). We can't reliably tell here, so we
        // check whether either yields a "negative" fee, or use the other if so.
        // We convert it to include change from v3
        if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
        {
          if (x.m_amount_in > (x.m_amount_out + x.m_change))
            x.m_amount_out += x.m_change;
        }
      }
      if (ver < 4)
      {
        if (!typename Archive::is_saving())
          x.m_unlock_time = 0;
        return;
      }
      a & x.m_unlock_time;
      if (ver < 5)
      {
        x.m_subaddr_account = 0;
        return;
      }
      a & x.m_subaddr_account;
      a & x.m_subaddr_indices;
      if (ver < 6)
        return;
      a & x.m_rings;
      if(ver < 7)
        return;
      a & x.m_is_migration;
      if(ver < 8)
          return;
      a & x.m_is_sc_migration;
    }

serialize() [57/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::multisig_info & x, const boost::serialization::version_type ver )

inline

Definition at line 1798 of file wallet2.h.

    {
      a & x.m_signer;
      a & x.m_LR;
      a & x.m_partial_key_images;
    }

serialize() [58/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::multisig_info::LR & x, const boost::serialization::version_type ver )

inline

Definition at line 1791 of file wallet2.h.

    {
      a & x.m_L;
      a & x.m_R;
    }

serialize() [59/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::multisig_sig & x, const boost::serialization::version_type ver )

inline

Definition at line 2048 of file wallet2.h.

    {
      a & x.sigs;
      a & x.ignore;
      a & x.used_L;
      a & x.signing_keys;
      a & x.msout;
    }

serialize() [60/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::multisig_tx_set & x, const boost::serialization::version_type ver )

inline

Definition at line 1806 of file wallet2.h.

    {
      a & x.m_ptx;
      a & x.m_signers;
    }

serialize() [61/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::payment_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1915 of file wallet2.h.

    {
      a & x.m_tx_hash;
      a & x.m_amount;
      a & x.m_block_height;
      a & x.m_unlock_time;
      if (ver < 1)
        return;
      a & x.m_timestamp;
      if (ver < 2)
      {
        x.m_coinbase = false;
        x.m_subaddr_index = {};
        return;
      }
      a & x.m_subaddr_index;
      if (ver < 3)
      {
        x.m_coinbase = false;
        x.m_fee = 0;
        return;
      }
      a & x.m_fee;
      if (ver < 4)
      {
        x.m_coinbase = false;
        return;
      }
      a & x.m_coinbase;
    }

serialize() [62/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::pending_tx & x, const boost::serialization::version_type ver )

inline

Definition at line 2058 of file wallet2.h.

    {
      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;
    }

serialize() [63/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::pool_payment_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1947 of file wallet2.h.

    {
      a & x.m_pd;
      a & x.m_double_spend_seen;
      a & x.m_nonexistent_utxo_seen;
    }

serialize() [64/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::reserve_proof_entry & x, const boost::serialization::version_type ver )

inline

Definition at line 1969 of file wallet2.h.

    {
      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;
    }

serialize() [65/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::signed_tx_set & x, const boost::serialization::version_type ver )

inline

Definition at line 1987 of file wallet2.h.

    {
      a & x.ptx;
      a & x.key_images;
      if (ver < 1)
        return;
      a & x.tx_key_images;
    }

serialize() [66/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::transfer_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1692 of file wallet2.h.

    {
      a & x.m_block_height;
      a & x.m_global_output_index;
      a & x.m_internal_output_index;
      if (ver < 3)
      {
        cryptonote::transaction tx;
        a & tx;
        x.m_tx = (const cryptonote::transaction_prefix&)tx;
        x.m_txid = cryptonote::get_transaction_hash(tx);
      }
      else
      {
        a & x.m_tx;
      }
      a & x.m_spent;
      a & x.m_key_image;
      if (ver < 1)
      {
        // ensure mask and amount are set
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_mask;
      a & x.m_amount;
      if (ver < 2)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_spent_height;
      if (ver < 3)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_txid;
      if (ver < 4)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_rct;
      if (ver < 5)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      if (ver < 6)
      {
        // v5 did not properly initialize
        uint8_t u;
        a & u;
        x.m_key_image_known = true;
        return;
      }
      a & x.m_key_image_known;
      if (ver < 7)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_pk_index;
      if (ver < 8)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_subaddr_index;
      if (ver < 9)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_multisig_info;
      a & x.m_multisig_k;
      a & x.m_key_image_partial;
      if (ver < 10)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_key_image_request;
      if (ver < 11)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_uses;
      if (ver < 12)
      {
        initialize_transfer_details(a, x, ver);
        return;
      }
      a & x.m_frozen;
    }

Here is the call graph for this function:

serialize() [67/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::tx_construction_data & x, const boost::serialization::version_type ver )

inline

Definition at line 1997 of file wallet2.h.

    {
      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::RangeProofBulletproof : rct::RangeProofBorromean, 0 };
        return;
      }
      a & x.rct_config;
    }

serialize() [68/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::unconfirmed_transfer_details & x, const boost::serialization::version_type ver )

inline

Definition at line 1813 of file wallet2.h.

    {
      a & x.m_change;
      a & x.m_sent_time;
      if (ver < 5)
      {
        cryptonote::transaction tx;
        a & tx;
        x.m_tx = (const cryptonote::transaction_prefix&)tx;
      }
      else
      {
        a & x.m_tx;
      }
      if (ver < 1)
        return;
      a & x.m_dests;
      a & x.m_payment_id;
      if (ver < 2)
        return;
      a & x.m_state;
      if (ver < 3)
        return;
      a & x.m_timestamp;
      if (ver < 4)
        return;
      a & x.m_amount_in;
      a & x.m_amount_out;
      if (ver < 6)
      {
        // v<6 may not have change accumulated in m_amount_out, which is a pain,
        // as it's readily understood to be sum of outputs.
        // We convert it to include change from v6
        if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
          x.m_amount_out += x.m_change;
      }
      if (ver < 7)
      {
        x.m_subaddr_account = 0;
        return;
      }
      a & x.m_subaddr_account;
      a & x.m_subaddr_indices;
      if (ver < 8)
        return;
      a & x.m_rings;
    }

serialize() [69/72]

template<class Archive>

void boost::serialization::serialize ( Archive & a, tools::wallet2::unsigned_tx_set & x, const boost::serialization::version_type ver )

inline

Definition at line 1980 of file wallet2.h.

    {
      a & x.txes;
      a & x.transfers;
    }

serialize() [70/72]

template<class archive_t>

void boost::serialization::serialize	(	archive_t &	ar,
		cryptonote::blockchain_storage::block_extended_info &	ei,
		const unsigned int	version )

Definition at line 50 of file blockchain_storage_boost_serialization.h.

    {
      ar & ei.bl;
      ar & ei.height;
      ar & ei.cumulative_difficulty;
      ar & ei.block_cumulative_size;
      ar & ei.already_generated_coins;
    }

serialize() [71/72]

template<class archive_t>

void boost::serialization::serialize	(	archive_t &	ar,
		cryptonote::blockchain_storage::transaction_chain_entry &	te,
		const unsigned int	version )

Definition at line 41 of file blockchain_storage_boost_serialization.h.

    {
      ar & te.tx;
      ar & te.m_keeper_block_height;
      ar & te.m_blob_size;
      ar & te.m_global_output_indexes;
    }

serialize() [72/72]

template<class archive_t>

void boost::serialization::serialize	(	archive_t &	ar,
		cryptonote::tx_memory_pool::tx_details &	td,
		const unsigned int	version )

Definition at line 636 of file tx_pool.h.

    {
      ar & td.blob_size;
      ar & td.fee;
      ar & td.tx;
      ar & td.max_used_block_height;
      ar & td.max_used_block_id;
      ar & td.last_failed_height;
      ar & td.last_failed_id;
      ar & td.receive_time;
      ar & td.last_relayed_time;
      ar & td.relayed;
      if (version < 11)
        return;
      ar & td.kept_by_block;
      if (version < 12)
        return;
      ar & td.do_not_relay;
      if (version < 13)
        return;
      ar & td.weight;
    }

serializeOutPk() [1/2]

template<class Archive>

std::enable_if< Archive::is_saving::value, void >::type boost::serialization::serializeOutPk ( Archive & a, rct::ctkeyV & outPk_, const boost::serialization::version_type ver )

inline

Definition at line 308 of file cryptonote_boost_serialization.h.

  {
    rct::keyV outPk(outPk_.size());
    for (size_t n = 0; n < outPk_.size(); ++n)
      outPk[n] = outPk_[n].mask;
    a & outPk;
  }

serializeOutPk() [2/2]

template<class Archive>

std::enable_if< Archive::is_loading::value, void >::type boost::serialization::serializeOutPk ( Archive & a, rct::ctkeyV & outPk_, const boost::serialization::version_type ver )

inline

Definition at line 295 of file cryptonote_boost_serialization.h.

  {
    rct::keyV outPk;
    a & outPk;
    outPk_.resize(outPk.size());
    for (size_t n = 0; n < outPk_.size(); ++n)
    {
      outPk_[n].dest = rct::identity();
      outPk_[n].mask = outPk[n];
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function: