rct::rctSigPrunable Struct Reference

#include <rctTypes.h>

Collaboration diagram for rct::rctSigPrunable:

Public Member Functions
template<bool W, template< bool > class Archive>
bool	serialize_rctsig_prunable (Archive< W > &ar, uint8_t type, size_t inputs, size_t outputs, size_t mixin)

Public Attributes
std::vector< rangeSig >	rangeSigs
std::vector< Bulletproof >	bulletproofs
std::vector< mgSig >	MGs
keyV	pseudoOuts

Detailed Description

Definition at line 318 of file rctTypes.h.

Member Function Documentation

serialize_rctsig_prunable()

template<bool W, template< bool > class Archive>

bool rct::rctSigPrunable::serialize_rctsig_prunable ( Archive< W > & ar, uint8_t type, size_t inputs, size_t outputs, size_t mixin )

inline

Definition at line 325 of file rctTypes.h.

        {
          if (type == RCTTypeNull)
            return ar.stream().good();
          if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2)
            return false;
          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2)
          {
            uint32_t nbp = bulletproofs.size();
            if (type == RCTTypeBulletproof2)
              VARINT_FIELD(nbp)
            else
              FIELD(nbp)
            ar.tag("bp");
            ar.begin_array();
            if (nbp > outputs)
              return false;
            PREPARE_CUSTOM_VECTOR_SERIALIZATION(nbp, bulletproofs);
            for (size_t i = 0; i < nbp; ++i)
            {
              FIELDS(bulletproofs[i])
              if (nbp - i > 1)
                ar.delimit_array();
            }
            if (n_bulletproof_max_amounts(bulletproofs) < outputs)
              return false;
            ar.end_array();
          }
          else
          {
            ar.tag("rangeSigs");
            ar.begin_array();
            PREPARE_CUSTOM_VECTOR_SERIALIZATION(outputs, rangeSigs);
            if (rangeSigs.size() != outputs)
              return false;
            for (size_t i = 0; i < outputs; ++i)
            {
              FIELDS(rangeSigs[i])
              if (outputs - i > 1)
                ar.delimit_array();
            }
            ar.end_array();
          }
 
          ar.tag("MGs");
          ar.begin_array();
          // we keep a byte for size of MGs, because we don't know whether this is
          // a simple or full rct signature, and it's starting to annoy the hell out of me
          size_t mg_elements = (type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2) ? inputs : 1;
          PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_elements, MGs);
          if (MGs.size() != mg_elements)
            return false;
          for (size_t i = 0; i < mg_elements; ++i)
          {
            // we save the MGs contents directly, because we want it to save its
            // arrays and matrices without the size prefixes, and the load can't
            // know what size to expect if it's not in the data
            ar.begin_object();
            ar.tag("ss");
            ar.begin_array();
            PREPARE_CUSTOM_VECTOR_SERIALIZATION(mixin + 1, MGs[i].ss);
            if (MGs[i].ss.size() != mixin + 1)
              return false;
            for (size_t j = 0; j < mixin + 1; ++j)
            {
              ar.begin_array();
              size_t mg_ss2_elements = ((type == RCTTypeSimple || type == RCTTypeBulletproof || type == RCTTypeBulletproof2) ? 1 : inputs) + 1;
              PREPARE_CUSTOM_VECTOR_SERIALIZATION(mg_ss2_elements, MGs[i].ss[j]);
              if (MGs[i].ss[j].size() != mg_ss2_elements)
                return false;
              for (size_t k = 0; k < mg_ss2_elements; ++k)
              {
                FIELDS(MGs[i].ss[j][k])
                if (mg_ss2_elements - k > 1)
                  ar.delimit_array();
              }
              ar.end_array();
 
              if (mixin + 1 - j > 1)
                ar.delimit_array();
            }
            ar.end_array();
 
            ar.tag("cc");
            FIELDS(MGs[i].cc)
            // MGs[i].II not saved, it can be reconstructed
            ar.end_object();
 
            if (mg_elements - i > 1)
               ar.delimit_array();
          }
          ar.end_array();
          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2)
          {
            ar.tag("pseudoOuts");
            ar.begin_array();
            PREPARE_CUSTOM_VECTOR_SERIALIZATION(inputs, pseudoOuts);
            if (pseudoOuts.size() != inputs)
              return false;
            for (size_t i = 0; i < inputs; ++i)
            {
              FIELDS(pseudoOuts[i])
              if (inputs - i > 1)
                ar.delimit_array();
            }
            ar.end_array();
          }
          return ar.stream().good();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bulletproofs

std::vector<Bulletproof> rct::rctSigPrunable::bulletproofs

Definition at line 320 of file rctTypes.h.

MGs

std::vector<mgSig> rct::rctSigPrunable::MGs

Definition at line 321 of file rctTypes.h.

pseudoOuts

keyV rct::rctSigPrunable::pseudoOuts

Definition at line 322 of file rctTypes.h.

rangeSigs

std::vector<rangeSig> rct::rctSigPrunable::rangeSigs

Definition at line 319 of file rctTypes.h.

---

The documentation for this struct was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/ringct/rctTypes.h