Electroneum
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.

54  {
55  T addr{};
56  a & addr;
57  na = std::move(addr);
58  }
const uint32_t T[512]
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
const T & move(const T &t)
Definition: gtest-port.h:1317
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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.

62  {
63  a & na.as<T>();
64  }
const uint32_t T[512]
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
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 1644 of file wallet2.h.

1645  {
1646  }

◆ 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 1648 of file wallet2.h.

1649  {
1650  if (ver < 1)
1651  {
1652  x.m_mask = rct::identity();
1653  x.m_amount = x.m_tx.vout[x.m_internal_output_index].amount;
1654  }
1655  if (ver < 2)
1656  {
1657  x.m_spent_height = 0;
1658  }
1659  if (ver < 4)
1660  {
1661  x.m_rct = x.m_tx.vout[x.m_internal_output_index].amount == 0;
1662  }
1663  if (ver < 6)
1664  {
1665  x.m_key_image_known = true;
1666  }
1667  if (ver < 7)
1668  {
1669  x.m_pk_index = 0;
1670  }
1671  if (ver < 8)
1672  {
1673  x.m_subaddr_index = {};
1674  }
1675  if (ver < 9)
1676  {
1677  x.m_key_image_partial = false;
1678  x.m_multisig_k.clear();
1679  x.m_multisig_info.clear();
1680  }
1681  if (ver < 10)
1682  {
1683  x.m_key_image_request = false;
1684  }
1685  if (ver < 12)
1686  {
1687  x.m_frozen = false;
1688  }
1689  }
cryptonote::subaddress_index m_subaddr_index
Definition: wallet2.h:318
std::vector< rct::key > m_multisig_k
Definition: wallet2.h:320
cryptonote::transaction_prefix m_tx
Definition: wallet2.h:304
key identity()
Definition: rctOps.h:73
std::vector< multisig_info > m_multisig_info
Definition: wallet2.h:321
Here is the call graph for this function:
Here is the caller graph for this function:

◆ load() [1/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.

56  {
57  x.clear();
58  size_t s = 0;
59  a >> s;
60  for(size_t i = 0; i != s; i++)
61  {
62  h_key k;
63  hval v;
64  a >> k;
65  a >> v;
66  x.insert(std::pair<h_key, hval>(k, v));
67  }
68  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
Here is the caller graph for this function:

◆ load() [2/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.

85  {
86  x.clear();
87  size_t s = 0;
88  a >> s;
89  for(size_t i = 0; i != s; i++)
90  {
91  h_key k;
92  hval v;
93  a >> k;
94  a >> v;
95  x.emplace(k, v);
96  }
97  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ load() [3/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.

113  {
114  x.clear();
115  size_t s = 0;
116  a >> s;
117  for(size_t i = 0; i != s; i++)
118  {
119  hval v;
120  a >> v;
121  x.insert(v);
122  }
123  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ load() [4/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.

132  {
133  uint16_t port = 0;
134  uint8_t length = 0;
135  a & port;
136  a & length;
137 
138  const size_t buffer_size = net::tor_address::buffer_size();
139  if (length > buffer_size)
140  ELECTRONEUM_THROW(net::error::invalid_tor_address, "Tor address too long");
141 
142  char host[buffer_size] = {0};
143  a.load_binary(host, length);
144  host[sizeof(host) - 1] = 0;
145 
146  if (std::strcmp(host, net::tor_address::unknown_str()) == 0)
148  else
150  }
static constexpr std::size_t buffer_size() noexcept
Definition: tor_address.h:61
static const char * unknown_str() noexcept
Definition: tor_address.cpp:95
unsigned short uint16_t
Definition: stdint.h:125
static tor_address unknown() noexcept
Definition: tor_address.h:70
unsigned char uint8_t
Definition: stdint.h:124
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define ELECTRONEUM_UNWRAP(...)
Definition: expect.h:60
Invalid base32 or length.
#define ELECTRONEUM_THROW(code, msg)
Definition: expect.h:66
static expect< tor_address > make(boost::string_ref address, std::uint16_t default_port=0)
Here is the call graph for this function:

◆ load() [5/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.

154  {
155  uint16_t port = 0;
156  uint8_t length = 0;
157  a & port;
158  a & length;
159 
160  const size_t buffer_size = net::i2p_address::buffer_size();
161  if (length > buffer_size)
162  ELECTRONEUM_THROW(net::error::invalid_i2p_address, "i2p address too long");
163 
164  char host[buffer_size] = {0};
165  a.load_binary(host, length);
166  host[sizeof(host) - 1] = 0;
167 
168  if (std::strcmp(host, net::i2p_address::unknown_str()) == 0)
170  else
172  }
static const char * unknown_str() noexcept
Definition: i2p_address.cpp:94
static i2p_address unknown() noexcept
Definition: i2p_address.h:70
unsigned short uint16_t
Definition: stdint.h:125
unsigned char uint8_t
Definition: stdint.h:124
static constexpr std::size_t buffer_size() noexcept
Definition: i2p_address.h:61
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define ELECTRONEUM_UNWRAP(...)
Definition: expect.h:60
static expect< i2p_address > make(boost::string_ref address, std::uint16_t default_port=0)
#define ELECTRONEUM_THROW(code, msg)
Definition: expect.h:66
Here is the call graph for this function:

◆ save() [1/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.

44  {
45  size_t s = x.size();
46  a << s;
47  for(auto& v: x)
48  {
49  a << v.first;
50  a << v.second;
51  }
52  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
Here is the caller graph for this function:

◆ save() [2/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.

73  {
74  size_t s = x.size();
75  a << s;
76  for(auto& v: x)
77  {
78  a << v.first;
79  a << v.second;
80  }
81  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ save() [3/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.

102  {
103  size_t s = x.size();
104  a << s;
105  for(auto& v: x)
106  {
107  a << v;
108  }
109  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ save() [4/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.

104  {
105  const size_t length = std::strlen(na.host_str());
106  if (length > 255)
107  ELECTRONEUM_THROW(net::error::invalid_tor_address, "Tor address too long");
108 
109  const uint16_t port{na.port()};
110  const uint8_t len = length;
111  a & port;
112  a & len;
113  a.save_binary(na.host_str(), length);
114  }
unsigned short uint16_t
Definition: stdint.h:125
unsigned char uint8_t
Definition: stdint.h:124
const char * host_str() const noexcept
Definition: tor_address.h:104
std::uint16_t port() const noexcept
Definition: tor_address.h:107
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
Invalid base32 or length.
#define ELECTRONEUM_THROW(code, msg)
Definition: expect.h:66
Here is the call graph for this function:

◆ save() [5/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.

118  {
119  const size_t length = std::strlen(na.host_str());
120  if (length > 255)
121  ELECTRONEUM_THROW(net::error::invalid_i2p_address, "i2p address too long");
122 
123  const uint16_t port{na.port()};
124  const uint8_t len = length;
125  a & port;
126  a & len;
127  a.save_binary(na.host_str(), length);
128  }
unsigned short uint16_t
Definition: stdint.h:125
unsigned char uint8_t
Definition: stdint.h:124
const char * host_str() const noexcept
Definition: i2p_address.h:104
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define ELECTRONEUM_THROW(code, msg)
Definition: expect.h:66
std::uint16_t port() const noexcept
Definition: i2p_address.h:107
Here is the call graph for this function:

◆ serialize() [1/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.

42  {
43  ar & te.tx;
44  ar & te.m_keeper_block_height;
45  ar & te.m_blob_size;
46  ar & te.m_global_output_indexes;
47  }

◆ serialize() [2/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.

44  {
45  a & x.m_account_address;
47  a & x.m_view_secret_key;
48  }
crypto::secret_key m_view_secret_key
Definition: account.h:45
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
account_public_address m_account_address
Definition: account.h:43
crypto::secret_key m_spend_secret_key
Definition: account.h:44

◆ serialize() [3/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.

51  {
52  ar & ei.bl;
53  ar & ei.height;
54  ar & ei.cumulative_difficulty;
55  ar & ei.block_cumulative_size;
56  ar & ei.already_generated_coins;
57  }

◆ serialize() [4/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.

59  {
60  a & reinterpret_cast<char (&)[sizeof(crypto::public_key)]>(x);
61  }
POD_CLASS public_key
Definition: crypto.h:76
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [5/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.

64  {
65  a & reinterpret_cast<char (&)[sizeof(crypto::secret_key)]>(x);
66  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [6/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.

68  {
69  static constexpr const typename Archive::is_saving is_saving{};
70 
71  uint8_t type;
72  if (is_saving)
73  type = uint8_t(na.get_type_id());
74  a & type;
75  switch (epee::net_utils::address_type(type))
76  {
78  do_serialize<epee::net_utils::ipv4_network_address>(is_saving, a, na);
79  break;
81  do_serialize<net::tor_address>(is_saving, a, na);
82  break;
84  do_serialize<net::i2p_address>(is_saving, a, na);
85  break;
87  default:
88  throw std::runtime_error("Unsupported network address type");
89  }
90  }
unsigned char uint8_t
Definition: stdint.h:124
address_type get_type_id() const
static constexpr address_type get_type_id() noexcept
static constexpr epee::net_utils::address_type get_type_id() noexcept
Definition: tor_address.h:112
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
static constexpr epee::net_utils::address_type get_type_id() noexcept
Definition: i2p_address.h:112
void do_serialize(boost::mpl::true_, Archive &a, const epee::net_utils::network_address &na)
Here is the call graph for this function:

◆ serialize() [7/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.

69  {
70  a & reinterpret_cast<char (&)[sizeof(crypto::key_derivation)]>(x);
71  }
POD_CLASS key_derivation
Definition: crypto.h:98
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [8/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.

74  {
75  a & reinterpret_cast<char (&)[sizeof(crypto::key_image)]>(x);
76  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
POD_CLASS key_image
Definition: crypto.h:102

◆ serialize() [9/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.

80  {
81  a & reinterpret_cast<char (&)[sizeof(crypto::signature)]>(x);
82  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
POD_CLASS signature
Definition: crypto.h:108

◆ serialize() [10/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.

86  {
87  a & reinterpret_cast<char (&)[sizeof(crypto::hash)]>(x);
88  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
POD_CLASS hash
Definition: hash.h:50

◆ serialize() [11/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.

91  {
92  a & reinterpret_cast<char (&)[sizeof(crypto::hash8)]>(x);
93  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
POD_CLASS hash8
Definition: hash.h:53

◆ serialize() [12/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.

93  {
94  uint32_t ip{na.ip()};
95  uint16_t port{na.port()};
96  a & ip;
97  a & port;
98  if (!typename Archive::is_saving())
100  }
constexpr uint16_t port() const noexcept
unsigned short uint16_t
Definition: stdint.h:125
constexpr uint32_t ip() const noexcept
unsigned int uint32_t
Definition: stdint.h:126
boost::endian::big_uint32_t ip
Definition: socks.cpp:61
boost::endian::big_uint16_t port
Definition: socks.cpp:60
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
Here is the call graph for this function:

◆ serialize() [13/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.

97  {
98  a & x.keys;
99  a & x.script;
100  }
std::vector< uint8_t > script
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< crypto::public_key > keys

◆ serialize() [14/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.

97  {
98  a & x.major;
99  a & x.minor;
100  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [15/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.

105  {
106  a & x.key;
107  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::public_key key

◆ serialize() [16/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.

111  {
112  a & x.m_address_prefix;
113  a & x.address;
114  }
cryptonote::account_public_address address
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [17/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.

118  {
119  a & x.m_spend_public_key;
120  a & x.m_view_public_key;
121  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [18/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.

125  {
126  a & x.hash;
127  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [19/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.

128  {
129  split_free(a, x, ver);
130  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [20/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.

131  {
132  a & x.height;
133  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [21/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.

134  {
135  split_free(a, x, ver);
136  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ 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.

137  {
138  a & x.prev;
139  a & x.prevout;
140  a & x.sigset;
141  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< uint8_t > sigset

◆ serialize() [23/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.

139  {
140  a & x.outputs;
141  a & x.real_output;
142  a & x.real_out_tx_key;
144  a & x.amount;
145  a & x.rct;
146  a & x.mask;
147  if (ver < 1)
148  return;
149  a & x.multisig_kLRki;
151  if (ver < 2)
152  return;
153  a & x.tx_hash;
154  a & x.subaddr_index;
155  }
crypto::public_key real_out_tx_key
bool rct
uint64_t amount
size_t real_output
crypto::hash tx_hash
rct::multisig_kLRki multisig_kLRki
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< crypto::public_key > real_out_additional_tx_keys
size_t real_output_in_tx_index
std::vector< output_entry > outputs
subaddress_index subaddr_index
rct::key mask

◆ serialize() [24/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.

140  {
141  split_free(a, x, ver);
142  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [25/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.

145  {
146  a & x.prev;
147  a & x.prevout;
148  a & x.script;
149  a & x.sigset;
150  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< uint8_t > sigset

◆ serialize() [26/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.

154  {
155  a & x.amount;
156  a & x.key_offsets;
157  a & x.k_image;
158  }
std::vector< uint64_t > key_offsets
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::key_image k_image

◆ serialize() [27/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.

159  {
160  a & x.amount;
161  a & x.addr;
162  if (ver < 1)
163  return;
164  a & x.is_subaddress;
165  if (ver < 2)
166  {
167  x.is_integrated = false;
168  return;
169  }
170  a & x.original;
171  a & x.is_integrated;
172  }
uint64_t amount
bool is_subaddress
bool is_integrated
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
account_public_address addr
std::string original

◆ serialize() [28/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.

162  {
163  a & x.amount;
164  a & x.relative_offset;
165  a & x.tx_hash;
166  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [29/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.

170  {
171  a & x.amount;
172  a & x.target;
173  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
txout_target_v target

◆ serialize() [30/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.

176  {
177  boost::serialization::split_free(a, na, ver);
178  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [31/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.

178  {
179  a & x.version;
180  a & x.unlock_time;
181  a & x.vin;
182  a & x.vout;
183  a & x.extra;
184  }
std::vector< uint8_t > extra
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [32/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.

182  {
183  boost::serialization::split_free(a, na, ver);
184  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [33/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.

188  {
189  a & pl.adr;
190  a & pl.id;
191  a & pl.last_seen;
192  if (ver < 1)
193  {
194  if (!typename Archive::is_saving())
195  pl.pruning_seed = 0;
196  return;
197  }
198  a & pl.pruning_seed;
199 #ifdef CRYPTONOTE_PRUNING_DEBUG_SPOOF_SEED
200  if (!typename Archive::is_saving())
201  {
203  }
204 #endif
205  if (ver < 2)
206  {
207  if (!typename Archive::is_saving())
208  pl.rpc_port = 0;
209  return;
210  }
211  a & pl.rpc_port;
212  }
int64_t last_seen
uint16_t rpc_port
AddressType adr
#define CRYPTONOTE_PRUNING_LOG_STRIPES
uint32_t pruning_seed
peerid_type id
constexpr uint32_t ip() const noexcept
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
uint32_t make_pruning_seed(uint32_t stripe, uint32_t log_stripes)
Definition: pruning.cpp:37
Here is the call graph for this function:

◆ serialize() [34/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.

188  {
189  a & x.version;
190  a & x.unlock_time;
191  a & x.vin;
192  a & x.vout;
193  a & x.extra;
194  if (x.version == 1)
195  {
196  a & x.signatures;
197  }
198  else
199  {
202  a & x.rct_signatures.p;
203  }
204  }
uint8_t type
Definition: rctTypes.h:241
std::vector< uint8_t > extra
rctSigPrunable p
Definition: rctTypes.h:437
std::vector< std::vector< crypto::signature > > signatures
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
else if(0==res)
Here is the call graph for this function:

◆ serialize() [35/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.

208  {
209  a & b.major_version;
210  a & b.minor_version;
211  a & b.timestamp;
212  a & b.prev_id;
213  a & b.nonce;
214  //------------------
215  a & b.miner_tx;
216  a & b.tx_hashes;
217  }
std::vector< crypto::hash > tx_hashes
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [36/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.

216  {
217  a & pl.adr;
218  a & pl.id;
219  a & pl.first_seen;
220  }
AddressType adr
int64_t first_seen
peerid_type id
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [37/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.

221  {
222  a & reinterpret_cast<char (&)[sizeof(rct::key)]>(x);
223  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [38/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.

227  {
228  a & x.dest;
229  a & x.mask;
230  }
key dest
Definition: rctTypes.h:97
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
key mask
Definition: rctTypes.h:98

◆ serialize() [39/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.

234  {
235  a & x.asig;
236  a & x.Ci;
237  }
boroSig asig
Definition: rctTypes.h:170
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ 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.

241  {
242  a & x.V;
243  a & x.A;
244  a & x.S;
245  a & x.T1;
246  a & x.T2;
247  a & x.taux;
248  a & x.mu;
249  a & x.L;
250  a & x.R;
251  a & x.a;
252  a & x.b;
253  a & x.t;
254  }
rct::key b
Definition: rctTypes.h:185
rct::key S
Definition: rctTypes.h:182
rct::key taux
Definition: rctTypes.h:183
rct::key mu
Definition: rctTypes.h:183
rct::key T2
Definition: rctTypes.h:182
rct::keyV R
Definition: rctTypes.h:184
rct::key A
Definition: rctTypes.h:182
rct::key a
Definition: rctTypes.h:185
rct::keyV L
Definition: rctTypes.h:184
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
rct::key T1
Definition: rctTypes.h:182
rct::key t
Definition: rctTypes.h:185
rct::keyV V
Definition: rctTypes.h:181

◆ serialize() [41/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.

258  {
259  a & x.s0;
260  a & x.s1;
261  a & x.ee;
262  }
key64 s0
Definition: rctTypes.h:140
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
key64 s1
Definition: rctTypes.h:141

◆ serialize() [42/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.

266  {
267  a & x.ss;
268  a & x.cc;
269  // a & x.II; // not serialized, we can recover it from the tx vin
270  }
keyM ss
Definition: rctTypes.h:153
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [43/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.

274  {
275  a & x.mask;
276  a & x.amount;
277  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [44/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.

281  {
282  a & x.k;
283  a & x.L;
284  a & x.R;
285  a & x.ki;
286  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [45/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.

290  {
291  a & x.c;
292  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< key > c
Definition: rctTypes.h:112

◆ serialize() [46/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.

318  {
319  a & x.type;
320  if (x.type == rct::RCTTypeNull)
321  return;
323  throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
324  // a & x.message; message is not serialized, as it can be reconstructed from the tx data
325  // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
326  if (x.type == rct::RCTTypeSimple) // moved to prunable with bulletproofs
327  a & x.pseudoOuts;
328  a & x.ecdhInfo;
329  serializeOutPk(a, x.outPk, ver);
330  a & x.txnFee;
331  }
etn_amount txnFee
Definition: rctTypes.h:248
uint8_t type
Definition: rctTypes.h:241
std::vector< ecdhTuple > ecdhInfo
Definition: rctTypes.h:246
std::enable_if< Archive::is_saving::value, void >::type serializeOutPk(Archive &a, rct::ctkeyV &outPk_, const boost::serialization::version_type ver)
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
ctkeyV outPk
Definition: rctTypes.h:247
Here is the call graph for this function:

◆ serialize() [47/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.

335  {
336  a & x.rangeSigs;
337  if (x.rangeSigs.empty())
338  a & x.bulletproofs;
339  a & x.MGs;
340  if (x.rangeSigs.empty())
341  a & x.pseudoOuts;
342  }
std::vector< mgSig > MGs
Definition: rctTypes.h:321
std::vector< rangeSig > rangeSigs
Definition: rctTypes.h:319
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
else if(0==res)
std::vector< Bulletproof > bulletproofs
Definition: rctTypes.h:320
Here is the call graph for this function:

◆ serialize() [48/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.

346  {
347  a & x.type;
348  if (x.type == rct::RCTTypeNull)
349  return;
351  throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
352  // a & x.message; message is not serialized, as it can be reconstructed from the tx data
353  // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
354  if (x.type == rct::RCTTypeSimple)
355  a & x.pseudoOuts;
356  a & x.ecdhInfo;
357  serializeOutPk(a, x.outPk, ver);
358  a & x.txnFee;
359  //--------------
360  a & x.p.rangeSigs;
361  if (x.p.rangeSigs.empty())
362  a & x.p.bulletproofs;
363  a & x.p.MGs;
365  a & x.p.pseudoOuts;
366  }
etn_amount txnFee
Definition: rctTypes.h:248
std::vector< mgSig > MGs
Definition: rctTypes.h:321
std::vector< rangeSig > rangeSigs
Definition: rctTypes.h:319
uint8_t type
Definition: rctTypes.h:241
std::vector< ecdhTuple > ecdhInfo
Definition: rctTypes.h:246
std::enable_if< Archive::is_saving::value, void >::type serializeOutPk(Archive &a, rct::ctkeyV &outPk_, const boost::serialization::version_type ver)
rctSigPrunable p
Definition: rctTypes.h:437
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
ctkeyV outPk
Definition: rctTypes.h:247
else if(0==res)
std::vector< Bulletproof > bulletproofs
Definition: rctTypes.h:320
Here is the call graph for this function:

◆ serialize() [49/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.

351  {
352  a & x.magic_string;
353  a & x.file_version;
354  a & x.iv;
355  a & x.encrypted_data;
356  }
std::string magic_string
crypto::chacha_iv iv
std::string encrypted_data
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
uint32_t file_version

◆ serialize() [50/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.

360  {
361  a & x.id;
362  a & x.type;
363  a & x.direction;
364  a & x.content;
365  a & x.created;
366  a & x.modified;
367  a & x.sent;
368  a & x.signer_index;
369  a & x.hash;
370  a & x.state;
371  a & x.wallet_height;
372  a & x.round;
373  a & x.signature_count;
374  a & x.transport_id;
375  }
uint64_t modified
message_type type
uint32_t signer_index
std::string transport_id
uint32_t wallet_height
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::string content
uint32_t signature_count
uint64_t created
crypto::hash hash
message_state state
uint32_t round
message_direction direction
uint64_t sent

◆ serialize() [51/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.

370  {
371  a & x.range_proof_type;
372  a & x.bp_version;
373  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
RangeProofType range_proof_type
Definition: rctTypes.h:237

◆ serialize() [52/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.

377  {
379  {
380  // load high part
381  uint64_t v = 0;
382  a & v;
383  x = v;
384  // load low part
385  x = x << 64;
386  a & v;
387  x += v;
388  }
389  else
390  {
391  // store high part
392  cryptonote::difficulty_type x_ = (x >> 64) & 0xffffffffffffffff;
393  uint64_t v = x_.convert_to<uint64_t>();
394  a & v;
395  // store low part
396  x_ = x & 0xffffffffffffffff;
397  v = x_.convert_to<uint64_t>();
398  a & v;
399  }
400  }
unsigned __int64 uint64_t
Definition: stdint.h:136
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
boost::multiprecision::uint128_t difficulty_type
Definition: difficulty.h:43
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225

◆ serialize() [53/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.

379  {
380  a & x.label;
381  a & x.transport_address;
382  a & x.etn_address_known;
383  a & x.etn_address;
384  a & x.me;
385  a & x.index;
386  if (ver < 1)
387  {
388  return;
389  }
390  a & x.auto_config_token;
394  a & x.auto_config_running;
395  }
crypto::secret_key auto_config_secret_key
std::string auto_config_transport_address
std::string transport_address
cryptonote::account_public_address etn_address
std::string auto_config_token
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::public_key auto_config_public_key

◆ serialize() [54/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.

399  {
400  a & x.label;
401  a & x.transport_address;
402  a & x.etn_address;
403  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
cryptonote::account_public_address etn_address
std::string transport_address

◆ serialize() [55/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.

407  {
408  a & x.sender_address;
409  a & x.iv;
411  a & x.internal_message;
412  }
cryptonote::account_public_address sender_address
crypto::public_key encryption_public_key
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [56/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.

416  {
417  a & x.data;
418  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [57/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.

637  {
638  ar & td.blob_size;
639  ar & td.fee;
640  ar & td.tx;
641  ar & td.max_used_block_height;
642  ar & td.max_used_block_id;
643  ar & td.last_failed_height;
644  ar & td.last_failed_id;
645  ar & td.receive_time;
646  ar & td.last_relayed_time;
647  ar & td.relayed;
648  if (version < 11)
649  return;
650  ar & td.kept_by_block;
651  if (version < 12)
652  return;
653  ar & td.do_not_relay;
654  if (version < 13)
655  return;
656  ar & td.weight;
657  }
bool relayed
whether or not the transaction has been relayed to the network
Definition: tx_pool.h:435
crypto::hash max_used_block_id
the hash of the highest block referenced by an input
Definition: tx_pool.h:409
crypto::hash last_failed_id
the hash of the highest block the transaction referenced when last checking it failed ...
Definition: tx_pool.h:430
uint64_t max_used_block_height
the height of the highest block referenced by an input
Definition: tx_pool.h:410
transaction tx
the transaction
Definition: tx_pool.h:405
bool do_not_relay
to avoid relay this transaction to the network
Definition: tx_pool.h:436
time_t receive_time
the time when the transaction entered the pool
Definition: tx_pool.h:432
size_t blob_size
the transaction&#39;s size
Definition: tx_pool.h:406
uint64_t last_failed_height
the highest block the transaction referenced when last checking it failed
Definition: tx_pool.h:423
uint64_t fee
the transaction&#39;s fee amount
Definition: tx_pool.h:408
version
Supported socks variants.
Definition: socks.h:57
size_t weight
the transaction&#39;s weight
Definition: tx_pool.h:407
bool kept_by_block
whether or not the transaction has been in a block before
Definition: tx_pool.h:416
time_t last_relayed_time
the last time the transaction was relayed to the network
Definition: tx_pool.h:434

◆ serialize() [58/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.

1693  {
1694  a & x.m_block_height;
1697  if (ver < 3)
1698  {
1700  a & tx;
1701  x.m_tx = (const cryptonote::transaction_prefix&)tx;
1703  }
1704  else
1705  {
1706  a & x.m_tx;
1707  }
1708  a & x.m_spent;
1709  a & x.m_key_image;
1710  if (ver < 1)
1711  {
1712  // ensure mask and amount are set
1713  initialize_transfer_details(a, x, ver);
1714  return;
1715  }
1716  a & x.m_mask;
1717  a & x.m_amount;
1718  if (ver < 2)
1719  {
1720  initialize_transfer_details(a, x, ver);
1721  return;
1722  }
1723  a & x.m_spent_height;
1724  if (ver < 3)
1725  {
1726  initialize_transfer_details(a, x, ver);
1727  return;
1728  }
1729  a & x.m_txid;
1730  if (ver < 4)
1731  {
1732  initialize_transfer_details(a, x, ver);
1733  return;
1734  }
1735  a & x.m_rct;
1736  if (ver < 5)
1737  {
1738  initialize_transfer_details(a, x, ver);
1739  return;
1740  }
1741  if (ver < 6)
1742  {
1743  // v5 did not properly initialize
1744  uint8_t u;
1745  a & u;
1746  x.m_key_image_known = true;
1747  return;
1748  }
1749  a & x.m_key_image_known;
1750  if (ver < 7)
1751  {
1752  initialize_transfer_details(a, x, ver);
1753  return;
1754  }
1755  a & x.m_pk_index;
1756  if (ver < 8)
1757  {
1758  initialize_transfer_details(a, x, ver);
1759  return;
1760  }
1761  a & x.m_subaddr_index;
1762  if (ver < 9)
1763  {
1764  initialize_transfer_details(a, x, ver);
1765  return;
1766  }
1767  a & x.m_multisig_info;
1768  a & x.m_multisig_k;
1769  a & x.m_key_image_partial;
1770  if (ver < 10)
1771  {
1772  initialize_transfer_details(a, x, ver);
1773  return;
1774  }
1775  a & x.m_key_image_request;
1776  if (ver < 11)
1777  {
1778  initialize_transfer_details(a, x, ver);
1779  return;
1780  }
1781  a & x.m_uses;
1782  if (ver < 12)
1783  {
1784  initialize_transfer_details(a, x, ver);
1785  return;
1786  }
1787  a & x.m_frozen;
1788  }
cryptonote::subaddress_index m_subaddr_index
Definition: wallet2.h:318
std::vector< rct::key > m_multisig_k
Definition: wallet2.h:320
std::vector< std::pair< uint64_t, crypto::hash > > m_uses
Definition: wallet2.h:322
unsigned char uint8_t
Definition: stdint.h:124
cryptonote::transaction_prefix m_tx
Definition: wallet2.h:304
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::hash get_transaction_hash(const transaction &t)
crypto::key_image m_key_image
Definition: wallet2.h:311
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)
Definition: wallet2.h:1648
std::vector< multisig_info > m_multisig_info
Definition: wallet2.h:321
Here is the call graph for this function:

◆ serialize() [59/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.

1792  {
1793  a & x.m_L;
1794  a & x.m_R;
1795  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [60/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.

1799  {
1800  a & x.m_signer;
1801  a & x.m_LR;
1802  a & x.m_partial_key_images;
1803  }
std::vector< LR > m_LR
Definition: wallet2.h:278
std::vector< crypto::key_image > m_partial_key_images
Definition: wallet2.h:279
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::public_key m_signer
Definition: wallet2.h:277

◆ serialize() [61/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.

1807  {
1808  a & x.m_ptx;
1809  a & x.m_signers;
1810  }
std::unordered_set< crypto::public_key > m_signers
Definition: wallet2.h:513
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< pending_tx > m_ptx
Definition: wallet2.h:512

◆ serialize() [62/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.

1814  {
1815  a & x.m_change;
1816  a & x.m_sent_time;
1817  if (ver < 5)
1818  {
1820  a & tx;
1821  x.m_tx = (const cryptonote::transaction_prefix&)tx;
1822  }
1823  else
1824  {
1825  a & x.m_tx;
1826  }
1827  if (ver < 1)
1828  return;
1829  a & x.m_dests;
1830  a & x.m_payment_id;
1831  if (ver < 2)
1832  return;
1833  a & x.m_state;
1834  if (ver < 3)
1835  return;
1836  a & x.m_timestamp;
1837  if (ver < 4)
1838  return;
1839  a & x.m_amount_in;
1840  a & x.m_amount_out;
1841  if (ver < 6)
1842  {
1843  // v<6 may not have change accumulated in m_amount_out, which is a pain,
1844  // as it's readily understood to be sum of outputs.
1845  // We convert it to include change from v6
1846  if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
1847  x.m_amount_out += x.m_change;
1848  }
1849  if (ver < 7)
1850  {
1851  x.m_subaddr_account = 0;
1852  return;
1853  }
1854  a & x.m_subaddr_account;
1855  a & x.m_subaddr_indices;
1856  if (ver < 8)
1857  return;
1858  a & x.m_rings;
1859  }
enum tools::wallet2::unconfirmed_transfer_details::@63 m_state
std::vector< cryptonote::tx_destination_entry > m_dests
Definition: wallet2.h:385
unsigned __int64 uint64_t
Definition: stdint.h:136
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
cryptonote::transaction_prefix m_tx
Definition: wallet2.h:380
std::vector< std::pair< crypto::key_image, std::vector< uint64_t > > > m_rings
Definition: wallet2.h:391

◆ serialize() [63/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.

1863  {
1864  a & x.m_amount_in;
1865  a & x.m_amount_out;
1866  a & x.m_change;
1867  a & x.m_block_height;
1868  if (ver < 1)
1869  return;
1870  a & x.m_dests;
1871  a & x.m_payment_id;
1872  if (ver < 2)
1873  return;
1874  a & x.m_timestamp;
1875  if (ver < 3)
1876  {
1877  // v<3 may not have change accumulated in m_amount_out, which is a pain,
1878  // as it's readily understood to be sum of outputs. Whether it got added
1879  // or not depends on whether it came from a unconfirmed_transfer_details
1880  // (not included) or not (included). We can't reliably tell here, so we
1881  // check whether either yields a "negative" fee, or use the other if so.
1882  // We convert it to include change from v3
1883  if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
1884  {
1885  if (x.m_amount_in > (x.m_amount_out + x.m_change))
1886  x.m_amount_out += x.m_change;
1887  }
1888  }
1889  if (ver < 4)
1890  {
1891  if (!typename Archive::is_saving())
1892  x.m_unlock_time = 0;
1893  return;
1894  }
1895  a & x.m_unlock_time;
1896  if (ver < 5)
1897  {
1898  x.m_subaddr_account = 0;
1899  return;
1900  }
1901  a & x.m_subaddr_account;
1902  a & x.m_subaddr_indices;
1903  if (ver < 6)
1904  return;
1905  a & x.m_rings;
1906  if(ver < 7)
1907  return;
1908  a & x.m_is_migration;
1909  if(ver < 8)
1910  return;
1911  a & x.m_is_sc_migration;
1912  }
std::vector< cryptonote::tx_destination_entry > m_dests
Definition: wallet2.h:400
unsigned __int64 uint64_t
Definition: stdint.h:136
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::set< uint32_t > m_subaddr_indices
Definition: wallet2.h:405
std::vector< std::pair< crypto::key_image, std::vector< uint64_t > > > m_rings
Definition: wallet2.h:406

◆ serialize() [64/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.

1916  {
1917  a & x.m_tx_hash;
1918  a & x.m_amount;
1919  a & x.m_block_height;
1920  a & x.m_unlock_time;
1921  if (ver < 1)
1922  return;
1923  a & x.m_timestamp;
1924  if (ver < 2)
1925  {
1926  x.m_coinbase = false;
1927  x.m_subaddr_index = {};
1928  return;
1929  }
1930  a & x.m_subaddr_index;
1931  if (ver < 3)
1932  {
1933  x.m_coinbase = false;
1934  x.m_fee = 0;
1935  return;
1936  }
1937  a & x.m_fee;
1938  if (ver < 4)
1939  {
1940  x.m_coinbase = false;
1941  return;
1942  }
1943  a & x.m_coinbase;
1944  }
cryptonote::subaddress_index m_subaddr_index
Definition: wallet2.h:362
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [65/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.

1948  {
1949  a & x.m_pd;
1950  a & x.m_double_spend_seen;
1952  }
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [66/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.

1956  {
1957  a & x.m_address;
1958  a & x.m_payment_id;
1959  a & x.m_description;
1960  if (ver < 17)
1961  {
1962  x.m_is_subaddress = false;
1963  return;
1964  }
1965  a & x.m_is_subaddress;
1966  }
cryptonote::account_public_address m_address
Definition: wallet2.h:546
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [67/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.

1970  {
1971  a & x.txid;
1972  a & x.index_in_tx;
1973  a & x.shared_secret;
1974  a & x.key_image;
1975  a & x.shared_secret_sig;
1976  a & x.key_image_sig;
1977  }
crypto::public_key shared_secret
Definition: wallet2.h:556
uint64_t index_in_tx
Definition: wallet2.h:555
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
crypto::signature shared_secret_sig
Definition: wallet2.h:558
crypto::signature key_image_sig
Definition: wallet2.h:559
crypto::hash txid
Definition: wallet2.h:554
crypto::key_image key_image
Definition: wallet2.h:557

◆ serialize() [68/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.

1981  {
1982  a & x.txes;
1983  a & x.transfers;
1984  }
std::vector< tx_construction_data > txes
Definition: wallet2.h:499
std::pair< size_t, wallet2::transfer_container > transfers
Definition: wallet2.h:500
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [69/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.

1988  {
1989  a & x.ptx;
1990  a & x.key_images;
1991  if (ver < 1)
1992  return;
1993  a & x.tx_key_images;
1994  }
std::unordered_map< crypto::public_key, crypto::key_image > tx_key_images
Definition: wallet2.h:507
std::vector< crypto::key_image > key_images
Definition: wallet2.h:506
std::vector< pending_tx > ptx
Definition: wallet2.h:505
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124

◆ serialize() [70/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.

1998  {
1999  a & x.sources;
2000  a & x.change_dts;
2001  a & x.splitted_dsts;
2002  if (ver < 2)
2003  {
2004  // load list to vector
2005  std::list<size_t> selected_transfers;
2006  a & selected_transfers;
2007  x.selected_transfers.clear();
2008  x.selected_transfers.reserve(selected_transfers.size());
2009  for (size_t t: selected_transfers)
2010  x.selected_transfers.push_back(t);
2011  }
2012  a & x.extra;
2013  a & x.unlock_time;
2014  a & x.use_rct;
2015  a & x.dests;
2016  if (ver < 1)
2017  {
2018  x.subaddr_account = 0;
2019  return;
2020  }
2021  a & x.subaddr_account;
2022  a & x.subaddr_indices;
2023  if (ver < 2)
2024  {
2025  if (!typename Archive::is_saving())
2027  return;
2028  }
2029  a & x.selected_transfers;
2030  if (ver < 3)
2031  {
2032  if (!typename Archive::is_saving())
2034  return;
2035  }
2036  if (ver < 4)
2037  {
2038  bool use_bulletproofs = x.rct_config.range_proof_type != rct::RangeProofBorromean;
2039  a & use_bulletproofs;
2040  if (!typename Archive::is_saving())
2041  x.rct_config = { use_bulletproofs ? rct::RangeProofBulletproof : rct::RangeProofBorromean, 0 };
2042  return;
2043  }
2044  a & x.rct_config;
2045  }
cryptonote::tx_destination_entry change_dts
Definition: wallet2.h:423
std::vector< cryptonote::tx_source_entry > sources
Definition: wallet2.h:422
std::set< uint32_t > subaddr_indices
Definition: wallet2.h:432
std::vector< cryptonote::tx_destination_entry > splitted_dsts
Definition: wallet2.h:424
std::vector< uint8_t > extra
Definition: wallet2.h:426
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
std::vector< cryptonote::tx_destination_entry > dests
Definition: wallet2.h:430
RangeProofType range_proof_type
Definition: rctTypes.h:237
std::vector< size_t > selected_transfers
Definition: wallet2.h:425

◆ serialize() [71/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.

2049  {
2050  a & x.sigs;
2051  a & x.ignore;
2052  a & x.used_L;
2053  a & x.signing_keys;
2054  a & x.msout;
2055  }
std::unordered_set< crypto::public_key > signing_keys
Definition: wallet2.h:457
std::unordered_set< rct::key > used_L
Definition: wallet2.h:456
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
rct::multisig_out msout
Definition: wallet2.h:458
std::unordered_set< crypto::public_key > ignore
Definition: wallet2.h:455

◆ serialize() [72/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.

2059  {
2060  a & x.tx;
2061  a & x.dust;
2062  a & x.fee;
2063  a & x.dust_added_to_fee;
2064  a & x.change_dts;
2065  if (ver < 2)
2066  {
2067  // load list to vector
2068  std::list<size_t> selected_transfers;
2069  a & selected_transfers;
2070  x.selected_transfers.clear();
2071  x.selected_transfers.reserve(selected_transfers.size());
2072  for (size_t t: selected_transfers)
2073  x.selected_transfers.push_back(t);
2074  }
2075  a & x.key_images;
2076  a & x.tx_key;
2077  a & x.dests;
2078  a & x.construction_data;
2079  if (ver < 1)
2080  return;
2081  a & x.additional_tx_keys;
2082  if (ver < 2)
2083  return;
2084  a & x.selected_transfers;
2085  if (ver < 3)
2086  return;
2087  a & x.multisig_sigs;
2088  }
cryptonote::transaction tx
Definition: wallet2.h:466
std::vector< crypto::secret_key > additional_tx_keys
Definition: wallet2.h:473
std::vector< cryptonote::tx_destination_entry > dests
Definition: wallet2.h:474
std::vector< size_t > selected_transfers
Definition: wallet2.h:470
std::string key_images
Definition: wallet2.h:471
std::vector< multisig_sig > multisig_sigs
Definition: wallet2.h:475
tx_construction_data construction_data
Definition: wallet2.h:477
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
cryptonote::tx_destination_entry change_dts
Definition: wallet2.h:469
crypto::secret_key tx_key
Definition: wallet2.h:472

◆ serializeOutPk() [1/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.

296  {
297  rct::keyV outPk;
298  a & outPk;
299  outPk_.resize(outPk.size());
300  for (size_t n = 0; n < outPk_.size(); ++n)
301  {
302  outPk_[n].dest = rct::identity();
303  outPk_[n].mask = outPk[n];
304  }
305  }
std::vector< key > keyV
Definition: rctTypes.h:88
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
key identity()
Definition: rctOps.h:73
Here is the call graph for this function:
Here is the caller graph for this function:

◆ serializeOutPk() [2/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.

309  {
310  rct::keyV outPk(outPk_.size());
311  for (size_t n = 0; n < outPk_.size(); ++n)
312  outPk[n] = outPk_[n].mask;
313  a & outPk;
314  }
std::vector< key > keyV
Definition: rctTypes.h:88
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124