Monero
Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
rct Namespace Reference

Classes

struct  proof_data_t
struct  bp_plus_proof_data_t
struct  straus_cached_data
struct  pippenger_cached_data
struct  MultiexpData
struct  key
struct  ctkey
struct  multisig_kLRki
struct  multisig_out
struct  ecdhTuple
struct  boroSig
struct  geDsmp
struct  mgSig
struct  clsag
struct  rangeSig
struct  Bulletproof
struct  BulletproofPlus
struct  RCTConfig
struct  rctSigBase
struct  rctSigPrunable
struct  rctSig

Typedefs

typedef unsigned char * Bytes
typedef std::vector< key > keyV
typedef std::vector< keyV > keyM
typedef std::vector< ctkey > ctkeyV
typedef std::vector< ctkeyV > ctkeyM
typedef uint64_t xmr_amount
typedef unsigned int bits[ATOMS]
typedef key key64[64]

Enumerations

enum  {
  RCTTypeNull = 0 , RCTTypeFull = 1 , RCTTypeSimple = 2 , RCTTypeBulletproof = 3 ,
  RCTTypeBulletproof2 = 4 , RCTTypeCLSAG = 5 , RCTTypeBulletproofPlus = 6
}
enum  RangeProofType { RangeProofBorromean , RangeProofBulletproof , RangeProofMultiOutputBulletproof , RangeProofPaddedBulletproof }

Functions

static rct::key vector_exponent (const rct::keyV &a, const rct::keyV &b)
static rct::keyV vector_powers (const rct::key &x, size_t n)
static rct::keyV vector_dup (const rct::key &x, size_t n)
static rct::key inner_product (const rct::keyV &a, const rct::keyV &b)
static rct::key multiexp (const std::vector< MultiexpData > &data, size_t HiGi_size)
static bool is_reduced (const rct::key &scalar)
static rct::key get_exponent (const rct::key &base, size_t idx)
static void init_exponents ()
static rct::key cross_vector_exponent8 (size_t size, const std::vector< ge_p3 > &A, size_t Ao, const std::vector< ge_p3 > &B, size_t Bo, const rct::keyV &a, size_t ao, const rct::keyV &b, size_t bo, const rct::keyV *scale, const ge_p3 *extra_point, const rct::key *extra_scalar)
static rct::key vector_power_sum (rct::key x, size_t n)
static rct::key inner_product (const epee::span< const rct::key > &a, const epee::span< const rct::key > &b)
static rct::keyV hadamard (const rct::keyV &a, const rct::keyV &b)
static void hadamard_fold (std::vector< ge_p3 > &v, const rct::keyV *scale, const rct::key &a, const rct::key &b)
static rct::keyV vector_add (const rct::keyV &a, const rct::keyV &b)
static rct::keyV vector_add (const rct::keyV &a, const rct::key &b)
static rct::keyV vector_subtract (const rct::keyV &a, const rct::key &b)
static rct::keyV vector_scalar (const epee::span< const rct::key > &a, const rct::key &x)
static rct::keyV vector_scalar (const rct::keyV &a, const rct::key &x)
static rct::key sm (rct::key y, int n, const rct::key &x)
static rct::key invert (const rct::key &x)
static rct::keyV invert (rct::keyV x)
static epee::span< const rct::key > slice (const rct::keyV &a, size_t start, size_t stop)
static rct::key hash_cache_mash (rct::key &hash_cache, const rct::key &mash0, const rct::key &mash1)
static rct::key hash_cache_mash (rct::key &hash_cache, const rct::key &mash0, const rct::key &mash1, const rct::key &mash2)
static rct::key hash_cache_mash (rct::key &hash_cache, const rct::key &mash0, const rct::key &mash1, const rct::key &mash2, const rct::key &mash3)
Bulletproof bulletproof_PROVE (const rct::key &sv, const rct::key &gamma)
Bulletproof bulletproof_PROVE (uint64_t v, const rct::key &gamma)
Bulletproof bulletproof_PROVE (const rct::keyV &sv, const rct::keyV &gamma)
Bulletproof bulletproof_PROVE (const std::vector< uint64_t > &v, const rct::keyV &gamma)
bool bulletproof_VERIFY (const std::vector< const Bulletproof * > &proofs)
bool bulletproof_VERIFY (const std::vector< Bulletproof > &proofs)
bool bulletproof_VERIFY (const Bulletproof &proof)
static rct::key vector_exponent (const rct::keyV &a, const rct::keyV &b)
static rct::keyV vector_of_scalar_powers (const rct::key &x, size_t n)
static rct::key multiexp (const std::vector< MultiexpData > &data, size_t HiGi_size)
static bool is_reduced (const rct::key &scalar)
static ge_p3 get_exponent (const rct::key &base, size_t idx)
static void init_exponents ()
static rct::key compute_LR (size_t size, const rct::key &y, const std::vector< ge_p3 > &G, size_t G0, const std::vector< ge_p3 > &H, size_t H0, const rct::keyV &a, size_t a0, const rct::keyV &b, size_t b0, const rct::key &c, const rct::key &d)
static rct::key sum_of_even_powers (const rct::key &x, size_t n)
static rct::key sum_of_scalar_powers (const rct::key &x, size_t n)
static rct::key weighted_inner_product (const epee::span< const rct::key > &a, const epee::span< const rct::key > &b, const rct::key &y)
static rct::key weighted_inner_product (const rct::keyV &a, const epee::span< const rct::key > &b, const rct::key &y)
static void hadamard_fold (std::vector< ge_p3 > &v, const rct::key &a, const rct::key &b)
static rct::keyV vector_add (const rct::keyV &a, const rct::keyV &b)
static rct::keyV vector_add (const rct::keyV &a, const rct::key &b)
static rct::keyV vector_subtract (const rct::keyV &a, const rct::key &b)
static rct::keyV vector_scalar (const epee::span< const rct::key > &a, const rct::key &x)
static rct::key sm (rct::key y, int n, const rct::key &x)
static rct::key invert (const rct::key &x)
static rct::keyV invert (rct::keyV x)
static epee::span< const rct::key > slice (const rct::keyV &a, size_t start, size_t stop)
static rct::key transcript_update (rct::key &transcript, const rct::key &update_0)
static rct::key transcript_update (rct::key &transcript, const rct::key &update_0, const rct::key &update_1)
BulletproofPlus bulletproof_plus_PROVE (const rct::key &sv, const rct::key &gamma)
BulletproofPlus bulletproof_plus_PROVE (uint64_t v, const rct::key &gamma)
BulletproofPlus bulletproof_plus_PROVE (const rct::keyV &sv, const rct::keyV &gamma)
BulletproofPlus bulletproof_plus_PROVE (const std::vector< uint64_t > &v, const rct::keyV &gamma)
bool bulletproof_plus_VERIFY (const std::vector< const BulletproofPlus * > &proofs)
bool bulletproof_plus_VERIFY (const std::vector< BulletproofPlus > &proofs)
bool bulletproof_plus_VERIFY (const BulletproofPlus &proof)
static bool operator< (const rct::key &k0, const rct::key &k1)
static rct::key div2 (const rct::key &k)
static rct::key pow2 (size_t n)
static int test (const rct::key &k, size_t n)
static void add (ge_p3 &p3, const ge_cached &other)
static void add (ge_p3 &p3, const ge_p3 &other)
rct::key bos_coster_heap_conv (std::vector< MultiexpData > data)
rct::key bos_coster_heap_conv_robust (std::vector< MultiexpData > data)
std::shared_ptr< straus_cached_data > straus_init_cache (const std::vector< MultiexpData > &data, size_t N)
size_t straus_get_cache_size (const std::shared_ptr< straus_cached_data > &cache)
rct::key straus (const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache, size_t STEP)
size_t get_pippenger_c (size_t N)
std::shared_ptr< pippenger_cached_data > pippenger_init_cache (const std::vector< MultiexpData > &data, size_t start_offset, size_t N)
size_t pippenger_get_cache_size (const std::shared_ptr< pippenger_cached_data > &cache)
rct::key pippenger (const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache, size_t cache_size, size_t c)
keyM keyMInit (size_t rows, size_t cols)
bool toPointCheckOrder (ge_p3 *P, const unsigned char *data)
void skGen (key &sk)
key skGen ()
keyV skvGen (size_t rows)
key pkGen ()
void skpkGen (key &sk, key &pk)
tuple< key, key > skpkGen ()
void genC (key &C, const key &a, xmr_amount amount)
tuple< ctkey, ctkey > ctskpkGen (xmr_amount amount)
tuple< ctkey, ctkey > ctskpkGen (const key &bH)
key zeroCommit (xmr_amount amount)
key commit (xmr_amount amount, const key &mask)
xmr_amount randXmrAmount (xmr_amount upperlimit)
void scalarmultBase (key &aG, const key &a)
key scalarmultBase (const key &a)
void scalarmultKey (key &aP, const key &P, const key &a)
key scalarmultKey (const key &P, const key &a)
key scalarmultH (const key &a)
key scalarmult8 (const key &P)
void scalarmult8 (ge_p3 &res, const key &P)
bool isInMainSubgroup (const key &A)
void addKeys (key &AB, const key &A, const key &B)
rct::key addKeys (const key &A, const key &B)
rct::key addKeys (const keyV &A)
void addKeys1 (key &aGB, const key &a, const key &B)
void addKeys2 (key &aGbB, const key &a, const key &b, const key &B)
void precomp (ge_dsmp rv, const key &B)
void addKeys3 (key &aAbB, const key &a, const key &A, const key &b, const ge_dsmp B)
void addKeys3 (key &aAbB, const key &a, const ge_dsmp A, const key &b, const ge_dsmp B)
void addKeys_aGbBcC (key &aGbBcC, const key &a, const key &b, const ge_dsmp B, const key &c, const ge_dsmp C)
void addKeys_aAbBcC (key &aAbBcC, const key &a, const ge_dsmp A, const key &b, const ge_dsmp B, const key &c, const ge_dsmp C)
void subKeys (key &AB, const key &A, const key &B)
bool equalKeys (const key &a, const key &b)
void cn_fast_hash (key &hash, const void *data, const std::size_t l)
void hash_to_scalar (key &hash, const void *data, const std::size_t l)
void cn_fast_hash (key &hash, const key &in)
void hash_to_scalar (key &hash, const key &in)
key cn_fast_hash (const key &in)
key hash_to_scalar (const key &in)
key cn_fast_hash128 (const void *in)
key hash_to_scalar128 (const void *in)
key cn_fast_hash (const ctkeyV &PC)
key hash_to_scalar (const ctkeyV &PC)
key cn_fast_hash (const keyV &keys)
key hash_to_scalar (const keyV &keys)
key cn_fast_hash (const key64 keys)
key hash_to_scalar (const key64 keys)
void hash_to_p3 (ge_p3 &hash8_p3, const key &k)
void sumKeys (key &Csum, const keyV &Cis)
static key ecdhHash (const key &k)
static void xor8 (key &v, const key &k)
key genCommitmentMask (const key &sk)
void ecdhEncode (ecdhTuple &unmasked, const key &sharedSec, bool v2)
void ecdhDecode (ecdhTuple &masked, const key &sharedSec, bool v2)
key zero ()
void zero (key &z)
key identity ()
void identity (key &Id)
key curveOrder ()
void curveOrder (key &l)
void copy (key &AA, const key &A)
key copy (const key &A)
bool toPointCheckOrder (ge_p3 *P, const unsigned char *data)
void scalarmult8 (ge_p3 &res, const key &P)
void cn_fast_hash (key &hash, const void *data, const size_t l)
void hash_to_scalar (key &hash, const void *data, const size_t l)
void hash_to_p3 (ge_p3 &hash8_p3, const key &k)
void sumKeys (key &Csum, const key &Cis)
void ecdhEncode (ecdhTuple &unmasked, const key &sharedSec, bool v2)
void ecdhDecode (ecdhTuple &masked, const key &sharedSec, bool v2)
Bulletproof proveRangeBulletproof (keyV &C, keyV &masks, const std::vector< uint64_t > &amounts, epee::span< const key > sk, hw::device &hwdev)
bool verBulletproof (const Bulletproof &proof)
bool verBulletproof (const std::vector< const Bulletproof * > &proofs)
BulletproofPlus proveRangeBulletproofPlus (keyV &C, keyV &masks, const std::vector< uint64_t > &amounts, epee::span< const key > sk, hw::device &hwdev)
bool verBulletproofPlus (const BulletproofPlus &proof)
bool verBulletproofPlus (const std::vector< const BulletproofPlus * > &proofs)
boroSig genBorromean (const key64 x, const key64 P1, const key64 P2, const bits indices)
bool verifyBorromean (const boroSig &bb, const ge_p3 P1[64], const ge_p3 P2[64])
bool verifyBorromean (const boroSig &bb, const key64 P1, const key64 P2)
clsag CLSAG_Gen (const key &message, const keyV &P, const key &p, const keyV &C, const key &z, const keyV &C_nonzero, const key &C_offset, const unsigned int l, hw::device &hwdev)
clsag CLSAG_Gen (const key &message, const keyV &P, const key &p, const keyV &C, const key &z, const keyV &C_nonzero, const key &C_offset, const unsigned int l)
mgSig MLSAG_Gen (const key &message, const keyM &pk, const keyV &xx, const unsigned int index, size_t dsRows, hw::device &hwdev)
bool MLSAG_Ver (const key &message, const keyM &pk, const mgSig &rv, size_t dsRows)
rangeSig proveRange (key &C, key &mask, const xmr_amount &amount)
bool verRange (const key &C, const rangeSig &as)
key get_pre_mlsag_hash (const rctSig &rv, hw::device &hwdev)
mgSig proveRctMG (const key &message, const ctkeyM &pubs, const ctkeyV &inSk, const ctkeyV &outSk, const ctkeyV &outPk, unsigned int index, const key &txnFeeKey, hw::device &hwdev)
mgSig proveRctMGSimple (const key &message, const ctkeyV &pubs, const ctkey &inSk, const key &a, const key &Cout, unsigned int index, hw::device &hwdev)
clsag proveRctCLSAGSimple (const key &message, const ctkeyV &pubs, const ctkey &inSk, const key &a, const key &Cout, unsigned int index, hw::device &hwdev)
bool verRctMG (const mgSig &mg, const ctkeyM &pubs, const ctkeyV &outPk, const key &txnFeeKey, const key &message)
bool verRctMGSimple (const key &message, const mgSig &mg, const ctkeyV &pubs, const key &C)
bool verRctCLSAGSimple (const key &message, const clsag &sig, const ctkeyV &pubs, const key &C_offset)
void getKeyFromBlockchain (ctkey &a, size_t reference_index)
tuple< ctkeyM, xmr_amount > populateFromBlockchain (ctkeyV inPk, int mixin)
xmr_amount populateFromBlockchainSimple (ctkeyV &mixRing, const ctkey &inPk, int mixin)
rctSig genRct (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< xmr_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRct (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< xmr_amount > &amounts, const keyV &amount_keys, const int mixin, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRctSimple (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< xmr_amount > &inamounts, const vector< xmr_amount > &outamounts, xmr_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRctSimple (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< xmr_amount > &inamounts, const vector< xmr_amount > &outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev)
bool verRct (const rctSig &rv, bool semantics)
bool verRctSemanticsSimple (const std::vector< const rctSig * > &rvv)
bool verRctSemanticsSimple (const rctSig &rv)
bool verRctNonSemanticsSimple (const rctSig &rv)
xmr_amount decodeRct (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
xmr_amount decodeRct (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
xmr_amount decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
xmr_amount decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
mgSig proveRctMG (const ctkeyM &pubs, const ctkeyV &inSk, const keyV &outMasks, const ctkeyV &outPk, unsigned int index, const key &txnFee, const key &message, hw::device &hwdev)
rctSig genRct (const key &message, const ctkeyV &inSk, const keyV &destinations, const std::vector< xmr_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRct (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const std::vector< xmr_amount > &amounts, const keyV &amount_keys, const int mixin, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRctSimple (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const std::vector< xmr_amount > &inamounts, const std::vector< xmr_amount > &outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev)
rctSig genRctSimple (const key &message, const ctkeyV &inSk, const keyV &destinations, const std::vector< xmr_amount > &inamounts, const std::vector< xmr_amount > &outamounts, xmr_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
bool verRct (const rctSig &rv, bool semantics)
static bool verRct (const rctSig &rv)
static bool verRctSimple (const rctSig &rv)
void dp (key a)
void dp (bool a)
void dp (const char *a, int l)
void dp (keyV a)
void dp (keyM a)
void dp (xmr_amount vali)
void dp (bits amountb)
void dp (const char *st)
void d2h (key &amounth, const xmr_amount in)
key d2h (const xmr_amount in)
void d2b (bits amountb, xmr_amount val)
xmr_amount h2d (const key &test)
void h2b (bits amountb2, const key &test)
void b2h (key &amountdh, const bits amountb2)
xmr_amount b2d (bits amountb)
bool is_rct_simple (int type)
bool is_rct_bulletproof (int type)
bool is_rct_bulletproof_plus (int type)
bool is_rct_borromean (int type)
bool is_rct_clsag (int type)
static size_t n_bulletproof_amounts_base (const size_t L_size, const size_t R_size, const size_t V_size, const size_t max_outputs)
size_t n_bulletproof_amounts (const Bulletproof &proof)
size_t n_bulletproof_plus_amounts (const BulletproofPlus &proof)
size_t n_bulletproof_amounts (const std::vector< Bulletproof > &proofs)
size_t n_bulletproof_plus_amounts (const std::vector< BulletproofPlus > &proofs)
static size_t n_bulletproof_max_amounts_base (size_t L_size, size_t R_size, size_t max_outputs)
size_t n_bulletproof_max_amounts (const Bulletproof &proof)
size_t n_bulletproof_plus_max_amounts (const BulletproofPlus &proof)
size_t n_bulletproof_max_amounts (const std::vector< Bulletproof > &proofs)
size_t n_bulletproof_plus_max_amounts (const std::vector< BulletproofPlus > &proofs)
void dp (bool a)
static const rct::key & pk2rct (const crypto::public_key &pk)
static const rct::key & sk2rct (const crypto::secret_key &sk)
static const rct::key & ki2rct (const crypto::key_image &ki)
static const rct::key & hash2rct (const crypto::hash &h)
static const crypto::public_key & rct2pk (const rct::key &k)
static const crypto::secret_key & rct2sk (const rct::key &k)
static const crypto::key_image & rct2ki (const rct::key &k)
static const crypto::hash & rct2hash (const rct::key &k)
static bool operator== (const rct::key &k0, const crypto::public_key &k1)
static bool operator!= (const rct::key &k0, const crypto::public_key &k1)
std::ostream & operator<< (std::ostream &o, const rct::key &v)

Variables

static constexpr size_t maxN = 64
static constexpr size_t maxM = BULLETPROOF_MAX_OUTPUTS
static ge_p3 Hi_p3 [maxN *maxM]
static ge_p3 Gi_p3 [maxN *maxM]
static std::shared_ptr< straus_cached_data > straus_HiGi_cache
static std::shared_ptr< pippenger_cached_data > pippenger_HiGi_cache
static const constexpr rct::key TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const constexpr rct::key MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
static const constexpr rct::key MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } }
static const rct::keyV oneN = vector_dup(rct::identity(), maxN)
static const rct::keyV twoN = vector_powers(TWO, maxN)
static const rct::key ip12 = inner_product(oneN, twoN)
static boost::mutex init_mutex
static constexpr size_t maxN = 64
static constexpr size_t maxM = BULLETPROOF_PLUS_MAX_OUTPUTS
static ge_p3 Hi_p3 [maxN *maxM]
static ge_p3 Gi_p3 [maxN *maxM]
static std::shared_ptr< straus_cached_data > straus_HiGi_cache
static std::shared_ptr< pippenger_cached_data > pippenger_HiGi_cache
static const constexpr rct::key ZERO = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const constexpr rct::key ONE = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const constexpr rct::key TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const constexpr rct::key MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
static const constexpr rct::key MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } }
static rct::key TWO_SIXTY_FOUR_MINUS_ONE
static rct::key initial_transcript
static boost::mutex init_mutex
static const key Z = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const key I = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const key L = { {0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
static const key G = { {0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66 } }
static const key EIGHT = { {0x08, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const key INV_EIGHT = { { 0x79, 0x2f, 0xdc, 0xe2, 0x29, 0xe5, 0x06, 0x61, 0xd0, 0xda, 0x1c, 0x7d, 0xb3, 0x9d, 0xd3, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06 } }
static const key H = { {0x8b, 0x65, 0x59, 0x70, 0x15, 0x37, 0x99, 0xaf, 0x2a, 0xea, 0xdc, 0x9f, 0xf1, 0xad, 0xd0, 0xea, 0x6c, 0x72, 0x51, 0xd5, 0x41, 0x54, 0xcf, 0xa9, 0x2c, 0x17, 0x3a, 0x0d, 0xd3, 0x9c, 0x1f, 0x94} }
static const key64 H2

Typedef Documentation

◆ bits

typedef unsigned int rct::bits[ATOMS]

◆ Bytes

typedef unsigned char* rct::Bytes

◆ ctkeyM

typedef std::vector<ctkeyV> rct::ctkeyM

◆ ctkeyV

typedef std::vector<ctkey> rct::ctkeyV

◆ key64

typedef key rct::key64[64]

◆ keyM

typedef std::vector<keyV> rct::keyM

◆ keyV

typedef std::vector<key> rct::keyV

◆ xmr_amount

typedef uint64_t rct::xmr_amount

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
RCTTypeNull 
RCTTypeFull 
RCTTypeSimple 
RCTTypeBulletproof 
RCTTypeBulletproof2 
RCTTypeCLSAG 
RCTTypeBulletproofPlus 

◆ RangeProofType

enum rct::RangeProofType
Enumerator
RangeProofBorromean 
RangeProofBulletproof 
RangeProofMultiOutputBulletproof 
RangeProofPaddedBulletproof 

Function Documentation

◆ add() [1/2]

void rct::add ( ge_p3 & p3,
const ge_cached & other )
inlinestatic

◆ add() [2/2]

void rct::add ( ge_p3 & p3,
const ge_p3 & other )
inlinestatic

◆ addKeys() [1/3]

rct::key rct::addKeys ( const key & A,
const key & B )

◆ addKeys() [2/3]

rct::key rct::addKeys ( const keyV & A)

◆ addKeys() [3/3]

void rct::addKeys ( key & AB,
const key & A,
const key & B )

◆ addKeys1()

void rct::addKeys1 ( key & aGB,
const key & a,
const key & B )

◆ addKeys2()

void rct::addKeys2 ( key & aGbB,
const key & a,
const key & b,
const key & B )

◆ addKeys3() [1/2]

void rct::addKeys3 ( key & aAbB,
const key & a,
const ge_dsmp A,
const key & b,
const ge_dsmp B )

◆ addKeys3() [2/2]

void rct::addKeys3 ( key & aAbB,
const key & a,
const key & A,
const key & b,
const ge_dsmp B )

◆ addKeys_aAbBcC()

void rct::addKeys_aAbBcC ( key & aAbBcC,
const key & a,
const ge_dsmp A,
const key & b,
const ge_dsmp B,
const key & c,
const ge_dsmp C )

◆ addKeys_aGbBcC()

void rct::addKeys_aGbBcC ( key & aGbBcC,
const key & a,
const key & b,
const ge_dsmp B,
const key & c,
const ge_dsmp C )

◆ b2d()

xmr_amount rct::b2d ( bits amountb)

◆ b2h()

void rct::b2h ( key & amountdh,
const bits amountb2 )

◆ bos_coster_heap_conv()

rct::key rct::bos_coster_heap_conv ( std::vector< MultiexpData > data)

◆ bos_coster_heap_conv_robust()

rct::key rct::bos_coster_heap_conv_robust ( std::vector< MultiexpData > data)

◆ bulletproof_plus_PROVE() [1/4]

BulletproofPlus rct::bulletproof_plus_PROVE ( const rct::key & sv,
const rct::key & gamma )

◆ bulletproof_plus_PROVE() [2/4]

BulletproofPlus rct::bulletproof_plus_PROVE ( const rct::keyV & sv,
const rct::keyV & gamma )

◆ bulletproof_plus_PROVE() [3/4]

BulletproofPlus rct::bulletproof_plus_PROVE ( const std::vector< uint64_t > & v,
const rct::keyV & gamma )

◆ bulletproof_plus_PROVE() [4/4]

BulletproofPlus rct::bulletproof_plus_PROVE ( uint64_t v,
const rct::key & gamma )

◆ bulletproof_plus_VERIFY() [1/3]

bool rct::bulletproof_plus_VERIFY ( const BulletproofPlus & proof)

◆ bulletproof_plus_VERIFY() [2/3]

bool rct::bulletproof_plus_VERIFY ( const std::vector< BulletproofPlus > & proofs)

◆ bulletproof_plus_VERIFY() [3/3]

bool rct::bulletproof_plus_VERIFY ( const std::vector< const BulletproofPlus * > & proofs)

◆ bulletproof_PROVE() [1/4]

Bulletproof rct::bulletproof_PROVE ( const rct::key & sv,
const rct::key & gamma )

◆ bulletproof_PROVE() [2/4]

Bulletproof rct::bulletproof_PROVE ( const rct::keyV & sv,
const rct::keyV & gamma )

◆ bulletproof_PROVE() [3/4]

Bulletproof rct::bulletproof_PROVE ( const std::vector< uint64_t > & v,
const rct::keyV & gamma )

◆ bulletproof_PROVE() [4/4]

Bulletproof rct::bulletproof_PROVE ( uint64_t v,
const rct::key & gamma )

◆ bulletproof_VERIFY() [1/3]

bool rct::bulletproof_VERIFY ( const Bulletproof & proof)

◆ bulletproof_VERIFY() [2/3]

bool rct::bulletproof_VERIFY ( const std::vector< Bulletproof > & proofs)

◆ bulletproof_VERIFY() [3/3]

bool rct::bulletproof_VERIFY ( const std::vector< const Bulletproof * > & proofs)

◆ CLSAG_Gen() [1/2]

clsag rct::CLSAG_Gen ( const key & message,
const keyV & P,
const key & p,
const keyV & C,
const key & z,
const keyV & C_nonzero,
const key & C_offset,
const unsigned int l )

◆ CLSAG_Gen() [2/2]

clsag rct::CLSAG_Gen ( const key & message,
const keyV & P,
const key & p,
const keyV & C,
const key & z,
const keyV & C_nonzero,
const key & C_offset,
const unsigned int l,
hw::device & hwdev )

◆ cn_fast_hash() [1/7]

key rct::cn_fast_hash ( const ctkeyV & PC)

◆ cn_fast_hash() [2/7]

key rct::cn_fast_hash ( const key & in)

◆ cn_fast_hash() [3/7]

key rct::cn_fast_hash ( const key64 keys)

◆ cn_fast_hash() [4/7]

key rct::cn_fast_hash ( const keyV & keys)

◆ cn_fast_hash() [5/7]

void rct::cn_fast_hash ( key & hash,
const key & in )

◆ cn_fast_hash() [6/7]

void rct::cn_fast_hash ( key & hash,
const void * data,
const size_t l )

◆ cn_fast_hash() [7/7]

void rct::cn_fast_hash ( key & hash,
const void * data,
const std::size_t l )

◆ cn_fast_hash128()

key rct::cn_fast_hash128 ( const void * in)

◆ commit()

key rct::commit ( xmr_amount amount,
const key & mask )

◆ compute_LR()

rct::key rct::compute_LR ( size_t size,
const rct::key & y,
const std::vector< ge_p3 > & G,
size_t G0,
const std::vector< ge_p3 > & H,
size_t H0,
const rct::keyV & a,
size_t a0,
const rct::keyV & b,
size_t b0,
const rct::key & c,
const rct::key & d )
static

◆ copy() [1/2]

key rct::copy ( const key & A)
inline

◆ copy() [2/2]

void rct::copy ( key & AA,
const key & A )
inline

◆ cross_vector_exponent8()

rct::key rct::cross_vector_exponent8 ( size_t size,
const std::vector< ge_p3 > & A,
size_t Ao,
const std::vector< ge_p3 > & B,
size_t Bo,
const rct::keyV & a,
size_t ao,
const rct::keyV & b,
size_t bo,
const rct::keyV * scale,
const ge_p3 * extra_point,
const rct::key * extra_scalar )
static

◆ ctskpkGen() [1/2]

std::tuple< ctkey, ctkey > rct::ctskpkGen ( const key & bH)

◆ ctskpkGen() [2/2]

std::tuple< ctkey, ctkey > rct::ctskpkGen ( xmr_amount amount)

◆ curveOrder() [1/2]

key rct::curveOrder ( )
inline

◆ curveOrder() [2/2]

void rct::curveOrder ( key & l)
inline

◆ d2b()

void rct::d2b ( bits amountb,
xmr_amount val )

◆ d2h() [1/2]

key rct::d2h ( const xmr_amount in)

◆ d2h() [2/2]

void rct::d2h ( key & amounth,
const xmr_amount in )

◆ decodeRct() [1/2]

xmr_amount rct::decodeRct ( const rctSig & rv,
const key & sk,
unsigned int i,
hw::device & hwdev )

◆ decodeRct() [2/2]

xmr_amount rct::decodeRct ( const rctSig & rv,
const key & sk,
unsigned int i,
key & mask,
hw::device & hwdev )

◆ decodeRctSimple() [1/2]

xmr_amount rct::decodeRctSimple ( const rctSig & rv,
const key & sk,
unsigned int i,
hw::device & hwdev )

◆ decodeRctSimple() [2/2]

xmr_amount rct::decodeRctSimple ( const rctSig & rv,
const key & sk,
unsigned int i,
key & mask,
hw::device & hwdev )

◆ div2()

rct::key rct::div2 ( const rct::key & k)
inlinestatic

◆ dp() [1/9]

void rct::dp ( bits amountb)

◆ dp() [2/9]

void rct::dp ( bool a)

◆ dp() [3/9]

void rct::dp ( bool a)

◆ dp() [4/9]

void rct::dp ( const char * a,
int l )

◆ dp() [5/9]

void rct::dp ( const char * st)

◆ dp() [6/9]

void rct::dp ( key a)

◆ dp() [7/9]

void rct::dp ( keyM a)

◆ dp() [8/9]

void rct::dp ( keyV a)

◆ dp() [9/9]

void rct::dp ( xmr_amount vali)

◆ ecdhDecode() [1/2]

void rct::ecdhDecode ( ecdhTuple & masked,
const key & sharedSec,
bool v2 )

◆ ecdhDecode() [2/2]

void rct::ecdhDecode ( ecdhTuple & masked,
const key & sharedSec,
bool v2 )

◆ ecdhEncode() [1/2]

void rct::ecdhEncode ( ecdhTuple & unmasked,
const key & sharedSec,
bool v2 )

◆ ecdhEncode() [2/2]

void rct::ecdhEncode ( ecdhTuple & unmasked,
const key & sharedSec,
bool v2 )

◆ ecdhHash()

key rct::ecdhHash ( const key & k)
static

◆ equalKeys()

bool rct::equalKeys ( const key & a,
const key & b )

◆ genBorromean()

boroSig rct::genBorromean ( const key64 x,
const key64 P1,
const key64 P2,
const bits indices )

◆ genC()

void rct::genC ( key & C,
const key & a,
xmr_amount amount )

◆ genCommitmentMask()

key rct::genCommitmentMask ( const key & sk)

◆ genRct() [1/4]

rctSig rct::genRct ( const key & message,
const ctkeyV & inSk,
const ctkeyV & inPk,
const keyV & destinations,
const std::vector< xmr_amount > & amounts,
const keyV & amount_keys,
const int mixin,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRct() [2/4]

rctSig rct::genRct ( const key & message,
const ctkeyV & inSk,
const ctkeyV & inPk,
const keyV & destinations,
const vector< xmr_amount > & amounts,
const keyV & amount_keys,
const int mixin,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRct() [3/4]

rctSig rct::genRct ( const key & message,
const ctkeyV & inSk,
const keyV & destinations,
const std::vector< xmr_amount > & amounts,
const ctkeyM & mixRing,
const keyV & amount_keys,
unsigned int index,
ctkeyV & outSk,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRct() [4/4]

rctSig rct::genRct ( const key & message,
const ctkeyV & inSk,
const keyV & destinations,
const vector< xmr_amount > & amounts,
const ctkeyM & mixRing,
const keyV & amount_keys,
unsigned int index,
ctkeyV & outSk,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRctSimple() [1/4]

rctSig rct::genRctSimple ( const key & message,
const ctkeyV & inSk,
const ctkeyV & inPk,
const keyV & destinations,
const std::vector< xmr_amount > & inamounts,
const std::vector< xmr_amount > & outamounts,
const keyV & amount_keys,
xmr_amount txnFee,
unsigned int mixin,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRctSimple() [2/4]

rctSig rct::genRctSimple ( const key & message,
const ctkeyV & inSk,
const ctkeyV & inPk,
const keyV & destinations,
const vector< xmr_amount > & inamounts,
const vector< xmr_amount > & outamounts,
const keyV & amount_keys,
xmr_amount txnFee,
unsigned int mixin,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRctSimple() [3/4]

rctSig rct::genRctSimple ( const key & message,
const ctkeyV & inSk,
const keyV & destinations,
const std::vector< xmr_amount > & inamounts,
const std::vector< xmr_amount > & outamounts,
xmr_amount txnFee,
const ctkeyM & mixRing,
const keyV & amount_keys,
const std::vector< unsigned int > & index,
ctkeyV & outSk,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ genRctSimple() [4/4]

rctSig rct::genRctSimple ( const key & message,
const ctkeyV & inSk,
const keyV & destinations,
const vector< xmr_amount > & inamounts,
const vector< xmr_amount > & outamounts,
xmr_amount txnFee,
const ctkeyM & mixRing,
const keyV & amount_keys,
const std::vector< unsigned int > & index,
ctkeyV & outSk,
const RCTConfig & rct_config,
hw::device & hwdev )

◆ get_exponent() [1/2]

rct::key rct::get_exponent ( const rct::key & base,
size_t idx )
static

◆ get_exponent() [2/2]

ge_p3 rct::get_exponent ( const rct::key & base,
size_t idx )
static

◆ get_pippenger_c()

size_t rct::get_pippenger_c ( size_t N)

◆ get_pre_mlsag_hash()

key rct::get_pre_mlsag_hash ( const rctSig & rv,
hw::device & hwdev )

◆ getKeyFromBlockchain()

void rct::getKeyFromBlockchain ( ctkey & a,
size_t reference_index )

◆ h2b()

void rct::h2b ( bits amountb2,
const key & test )

◆ h2d()

xmr_amount rct::h2d ( const key & test)

◆ hadamard()

rct::keyV rct::hadamard ( const rct::keyV & a,
const rct::keyV & b )
static

◆ hadamard_fold() [1/2]

void rct::hadamard_fold ( std::vector< ge_p3 > & v,
const rct::key & a,
const rct::key & b )
static

◆ hadamard_fold() [2/2]

void rct::hadamard_fold ( std::vector< ge_p3 > & v,
const rct::keyV * scale,
const rct::key & a,
const rct::key & b )
static

◆ hash2rct()

const rct::key & rct::hash2rct ( const crypto::hash & h)
inlinestatic

◆ hash_cache_mash() [1/3]

rct::key rct::hash_cache_mash ( rct::key & hash_cache,
const rct::key & mash0,
const rct::key & mash1 )
static

◆ hash_cache_mash() [2/3]

rct::key rct::hash_cache_mash ( rct::key & hash_cache,
const rct::key & mash0,
const rct::key & mash1,
const rct::key & mash2 )
static

◆ hash_cache_mash() [3/3]

rct::key rct::hash_cache_mash ( rct::key & hash_cache,
const rct::key & mash0,
const rct::key & mash1,
const rct::key & mash2,
const rct::key & mash3 )
static

◆ hash_to_p3() [1/2]

void rct::hash_to_p3 ( ge_p3 & hash8_p3,
const key & k )

◆ hash_to_p3() [2/2]

void rct::hash_to_p3 ( ge_p3 & hash8_p3,
const key & k )

◆ hash_to_scalar() [1/7]

key rct::hash_to_scalar ( const ctkeyV & PC)

◆ hash_to_scalar() [2/7]

key rct::hash_to_scalar ( const key & in)

◆ hash_to_scalar() [3/7]

key rct::hash_to_scalar ( const key64 keys)

◆ hash_to_scalar() [4/7]

key rct::hash_to_scalar ( const keyV & keys)

◆ hash_to_scalar() [5/7]

void rct::hash_to_scalar ( key & hash,
const key & in )

◆ hash_to_scalar() [6/7]

void rct::hash_to_scalar ( key & hash,
const void * data,
const size_t l )

◆ hash_to_scalar() [7/7]

void rct::hash_to_scalar ( key & hash,
const void * data,
const std::size_t l )

◆ hash_to_scalar128()

key rct::hash_to_scalar128 ( const void * in)

◆ identity() [1/2]

key rct::identity ( )
inline

◆ identity() [2/2]

void rct::identity ( key & Id)
inline

◆ init_exponents() [1/2]

void rct::init_exponents ( )
static

◆ init_exponents() [2/2]

void rct::init_exponents ( )
static

◆ inner_product() [1/2]

rct::key rct::inner_product ( const epee::span< const rct::key > & a,
const epee::span< const rct::key > & b )
static

◆ inner_product() [2/2]

rct::key rct::inner_product ( const rct::keyV & a,
const rct::keyV & b )
static

◆ invert() [1/4]

rct::key rct::invert ( const rct::key & x)
static

◆ invert() [2/4]

rct::key rct::invert ( const rct::key & x)
static

◆ invert() [3/4]

rct::keyV rct::invert ( rct::keyV x)
static

◆ invert() [4/4]

rct::keyV rct::invert ( rct::keyV x)
static

◆ is_rct_borromean()

bool rct::is_rct_borromean ( int type)

◆ is_rct_bulletproof()

bool rct::is_rct_bulletproof ( int type)

◆ is_rct_bulletproof_plus()

bool rct::is_rct_bulletproof_plus ( int type)

◆ is_rct_clsag()

bool rct::is_rct_clsag ( int type)

◆ is_rct_simple()

bool rct::is_rct_simple ( int type)

◆ is_reduced() [1/2]

bool rct::is_reduced ( const rct::key & scalar)
inlinestatic

◆ is_reduced() [2/2]

bool rct::is_reduced ( const rct::key & scalar)
inlinestatic

◆ isInMainSubgroup()

bool rct::isInMainSubgroup ( const key & A)

◆ keyMInit()

keyM rct::keyMInit ( size_t rows,
size_t cols )

◆ ki2rct()

const rct::key & rct::ki2rct ( const crypto::key_image & ki)
inlinestatic

◆ MLSAG_Gen()

mgSig rct::MLSAG_Gen ( const key & message,
const keyM & pk,
const keyV & xx,
const unsigned int index,
size_t dsRows,
hw::device & hwdev )

◆ MLSAG_Ver()

bool rct::MLSAG_Ver ( const key & message,
const keyM & pk,
const mgSig & rv,
size_t dsRows )

◆ multiexp() [1/2]

rct::key rct::multiexp ( const std::vector< MultiexpData > & data,
size_t HiGi_size )
inlinestatic

◆ multiexp() [2/2]

rct::key rct::multiexp ( const std::vector< MultiexpData > & data,
size_t HiGi_size )
inlinestatic

◆ n_bulletproof_amounts() [1/2]

size_t rct::n_bulletproof_amounts ( const Bulletproof & proof)

◆ n_bulletproof_amounts() [2/2]

size_t rct::n_bulletproof_amounts ( const std::vector< Bulletproof > & proofs)

◆ n_bulletproof_amounts_base()

size_t rct::n_bulletproof_amounts_base ( const size_t L_size,
const size_t R_size,
const size_t V_size,
const size_t max_outputs )
static

◆ n_bulletproof_max_amounts() [1/2]

size_t rct::n_bulletproof_max_amounts ( const Bulletproof & proof)

◆ n_bulletproof_max_amounts() [2/2]

size_t rct::n_bulletproof_max_amounts ( const std::vector< Bulletproof > & proofs)

◆ n_bulletproof_max_amounts_base()

size_t rct::n_bulletproof_max_amounts_base ( size_t L_size,
size_t R_size,
size_t max_outputs )
static

◆ n_bulletproof_plus_amounts() [1/2]

size_t rct::n_bulletproof_plus_amounts ( const BulletproofPlus & proof)

◆ n_bulletproof_plus_amounts() [2/2]

size_t rct::n_bulletproof_plus_amounts ( const std::vector< BulletproofPlus > & proofs)

◆ n_bulletproof_plus_max_amounts() [1/2]

size_t rct::n_bulletproof_plus_max_amounts ( const BulletproofPlus & proof)

◆ n_bulletproof_plus_max_amounts() [2/2]

size_t rct::n_bulletproof_plus_max_amounts ( const std::vector< BulletproofPlus > & proofs)

◆ operator!=()

bool rct::operator!= ( const rct::key & k0,
const crypto::public_key & k1 )
inlinestatic

◆ operator<()

bool rct::operator< ( const rct::key & k0,
const rct::key & k1 )
inlinestatic

◆ operator<<()

std::ostream & rct::operator<< ( std::ostream & o,
const rct::key & v )
inline

◆ operator==()

bool rct::operator== ( const rct::key & k0,
const crypto::public_key & k1 )
inlinestatic

◆ pippenger()

rct::key rct::pippenger ( const std::vector< MultiexpData > & data,
const std::shared_ptr< pippenger_cached_data > & cache,
size_t cache_size,
size_t c )

◆ pippenger_get_cache_size()

size_t rct::pippenger_get_cache_size ( const std::shared_ptr< pippenger_cached_data > & cache)

◆ pippenger_init_cache()

std::shared_ptr< pippenger_cached_data > rct::pippenger_init_cache ( const std::vector< MultiexpData > & data,
size_t start_offset,
size_t N )

◆ pk2rct()

const rct::key & rct::pk2rct ( const crypto::public_key & pk)
inlinestatic

◆ pkGen()

key rct::pkGen ( )

◆ populateFromBlockchain()

std::tuple< ctkeyM, xmr_amount > rct::populateFromBlockchain ( ctkeyV inPk,
int mixin )

◆ populateFromBlockchainSimple()

xmr_amount rct::populateFromBlockchainSimple ( ctkeyV & mixRing,
const ctkey & inPk,
int mixin )

◆ pow2()

rct::key rct::pow2 ( size_t n)
inlinestatic

◆ precomp()

void rct::precomp ( ge_dsmp rv,
const key & B )

◆ proveRange()

rangeSig rct::proveRange ( key & C,
key & mask,
const xmr_amount & amount )

◆ proveRangeBulletproof()

Bulletproof rct::proveRangeBulletproof ( keyV & C,
keyV & masks,
const std::vector< uint64_t > & amounts,
epee::span< const key > sk,
hw::device & hwdev )

◆ proveRangeBulletproofPlus()

BulletproofPlus rct::proveRangeBulletproofPlus ( keyV & C,
keyV & masks,
const std::vector< uint64_t > & amounts,
epee::span< const key > sk,
hw::device & hwdev )

◆ proveRctCLSAGSimple()

clsag rct::proveRctCLSAGSimple ( const key & message,
const ctkeyV & pubs,
const ctkey & inSk,
const key & a,
const key & Cout,
unsigned int index,
hw::device & hwdev )

◆ proveRctMG() [1/2]

mgSig rct::proveRctMG ( const ctkeyM & pubs,
const ctkeyV & inSk,
const keyV & outMasks,
const ctkeyV & outPk,
unsigned int index,
const key & txnFee,
const key & message,
hw::device & hwdev )

◆ proveRctMG() [2/2]

mgSig rct::proveRctMG ( const key & message,
const ctkeyM & pubs,
const ctkeyV & inSk,
const ctkeyV & outSk,
const ctkeyV & outPk,
unsigned int index,
const key & txnFeeKey,
hw::device & hwdev )

◆ proveRctMGSimple()

mgSig rct::proveRctMGSimple ( const key & message,
const ctkeyV & pubs,
const ctkey & inSk,
const key & a,
const key & Cout,
unsigned int index,
hw::device & hwdev )

◆ randXmrAmount()

xmr_amount rct::randXmrAmount ( xmr_amount upperlimit)

◆ rct2hash()

const crypto::hash & rct::rct2hash ( const rct::key & k)
inlinestatic

◆ rct2ki()

const crypto::key_image & rct::rct2ki ( const rct::key & k)
inlinestatic

◆ rct2pk()

const crypto::public_key & rct::rct2pk ( const rct::key & k)
inlinestatic

◆ rct2sk()

const crypto::secret_key & rct::rct2sk ( const rct::key & k)
inlinestatic

◆ scalarmult8() [1/3]

key rct::scalarmult8 ( const key & P)

◆ scalarmult8() [2/3]

void rct::scalarmult8 ( ge_p3 & res,
const key & P )

◆ scalarmult8() [3/3]

void rct::scalarmult8 ( ge_p3 & res,
const key & P )

◆ scalarmultBase() [1/2]

key rct::scalarmultBase ( const key & a)

◆ scalarmultBase() [2/2]

void rct::scalarmultBase ( key & aG,
const key & a )

◆ scalarmultH()

key rct::scalarmultH ( const key & a)

◆ scalarmultKey() [1/2]

key rct::scalarmultKey ( const key & P,
const key & a )

◆ scalarmultKey() [2/2]

void rct::scalarmultKey ( key & aP,
const key & P,
const key & a )

◆ sk2rct()

const rct::key & rct::sk2rct ( const crypto::secret_key & sk)
inlinestatic

◆ skGen() [1/2]

key rct::skGen ( )

◆ skGen() [2/2]

void rct::skGen ( key & sk)

◆ skpkGen() [1/2]

std::tuple< key, key > rct::skpkGen ( )

◆ skpkGen() [2/2]

void rct::skpkGen ( key & sk,
key & pk )

◆ skvGen()

keyV rct::skvGen ( size_t rows)

◆ slice() [1/2]

epee::span< const rct::key > rct::slice ( const rct::keyV & a,
size_t start,
size_t stop )
static

◆ slice() [2/2]

epee::span< const rct::key > rct::slice ( const rct::keyV & a,
size_t start,
size_t stop )
static

◆ sm() [1/2]

rct::key rct::sm ( rct::key y,
int n,
const rct::key & x )
static

◆ sm() [2/2]

rct::key rct::sm ( rct::key y,
int n,
const rct::key & x )
static

◆ straus()

rct::key rct::straus ( const std::vector< MultiexpData > & data,
const std::shared_ptr< straus_cached_data > & cache,
size_t STEP )

◆ straus_get_cache_size()

size_t rct::straus_get_cache_size ( const std::shared_ptr< straus_cached_data > & cache)

◆ straus_init_cache()

std::shared_ptr< straus_cached_data > rct::straus_init_cache ( const std::vector< MultiexpData > & data,
size_t N )

◆ subKeys()

void rct::subKeys ( key & AB,
const key & A,
const key & B )

◆ sum_of_even_powers()

rct::key rct::sum_of_even_powers ( const rct::key & x,
size_t n )
static

◆ sum_of_scalar_powers()

rct::key rct::sum_of_scalar_powers ( const rct::key & x,
size_t n )
static

◆ sumKeys() [1/2]

void rct::sumKeys ( key & Csum,
const key & Cis )

◆ sumKeys() [2/2]

void rct::sumKeys ( key & Csum,
const keyV & Cis )

◆ test()

int rct::test ( const rct::key & k,
size_t n )
inlinestatic

◆ toPointCheckOrder() [1/2]

bool rct::toPointCheckOrder ( ge_p3 * P,
const unsigned char * data )

◆ toPointCheckOrder() [2/2]

bool rct::toPointCheckOrder ( ge_p3 * P,
const unsigned char * data )

◆ transcript_update() [1/2]

rct::key rct::transcript_update ( rct::key & transcript,
const rct::key & update_0 )
static

◆ transcript_update() [2/2]

rct::key rct::transcript_update ( rct::key & transcript,
const rct::key & update_0,
const rct::key & update_1 )
static

◆ vector_add() [1/4]

rct::keyV rct::vector_add ( const rct::keyV & a,
const rct::key & b )
static

◆ vector_add() [2/4]

rct::keyV rct::vector_add ( const rct::keyV & a,
const rct::key & b )
static

◆ vector_add() [3/4]

rct::keyV rct::vector_add ( const rct::keyV & a,
const rct::keyV & b )
static

◆ vector_add() [4/4]

rct::keyV rct::vector_add ( const rct::keyV & a,
const rct::keyV & b )
static

◆ vector_dup()

rct::keyV rct::vector_dup ( const rct::key & x,
size_t n )
static

◆ vector_exponent() [1/2]

rct::key rct::vector_exponent ( const rct::keyV & a,
const rct::keyV & b )
static

◆ vector_exponent() [2/2]

rct::key rct::vector_exponent ( const rct::keyV & a,
const rct::keyV & b )
static

◆ vector_of_scalar_powers()

rct::keyV rct::vector_of_scalar_powers ( const rct::key & x,
size_t n )
static

◆ vector_power_sum()

rct::key rct::vector_power_sum ( rct::key x,
size_t n )
static

◆ vector_powers()

rct::keyV rct::vector_powers ( const rct::key & x,
size_t n )
static

◆ vector_scalar() [1/3]

rct::keyV rct::vector_scalar ( const epee::span< const rct::key > & a,
const rct::key & x )
static

◆ vector_scalar() [2/3]

rct::keyV rct::vector_scalar ( const epee::span< const rct::key > & a,
const rct::key & x )
static

◆ vector_scalar() [3/3]

rct::keyV rct::vector_scalar ( const rct::keyV & a,
const rct::key & x )
static

◆ vector_subtract() [1/2]

rct::keyV rct::vector_subtract ( const rct::keyV & a,
const rct::key & b )
static

◆ vector_subtract() [2/2]

rct::keyV rct::vector_subtract ( const rct::keyV & a,
const rct::key & b )
static

◆ verBulletproof() [1/2]

bool rct::verBulletproof ( const Bulletproof & proof)

◆ verBulletproof() [2/2]

bool rct::verBulletproof ( const std::vector< const Bulletproof * > & proofs)

◆ verBulletproofPlus() [1/2]

bool rct::verBulletproofPlus ( const BulletproofPlus & proof)

◆ verBulletproofPlus() [2/2]

bool rct::verBulletproofPlus ( const std::vector< const BulletproofPlus * > & proofs)

◆ verifyBorromean() [1/2]

bool rct::verifyBorromean ( const boroSig & bb,
const ge_p3 P1[64],
const ge_p3 P2[64] )

◆ verifyBorromean() [2/2]

bool rct::verifyBorromean ( const boroSig & bb,
const key64 P1,
const key64 P2 )

◆ verRange()

bool rct::verRange ( const key & C,
const rangeSig & as )

◆ verRct() [1/3]

bool rct::verRct ( const rctSig & rv)
inlinestatic

◆ verRct() [2/3]

bool rct::verRct ( const rctSig & rv,
bool semantics )

◆ verRct() [3/3]

bool rct::verRct ( const rctSig & rv,
bool semantics )

◆ verRctCLSAGSimple()

bool rct::verRctCLSAGSimple ( const key & message,
const clsag & sig,
const ctkeyV & pubs,
const key & C_offset )

◆ verRctMG()

bool rct::verRctMG ( const mgSig & mg,
const ctkeyM & pubs,
const ctkeyV & outPk,
const key & txnFeeKey,
const key & message )

◆ verRctMGSimple()

bool rct::verRctMGSimple ( const key & message,
const mgSig & mg,
const ctkeyV & pubs,
const key & C )

◆ verRctNonSemanticsSimple()

bool rct::verRctNonSemanticsSimple ( const rctSig & rv)

◆ verRctSemanticsSimple() [1/2]

bool rct::verRctSemanticsSimple ( const rctSig & rv)

◆ verRctSemanticsSimple() [2/2]

bool rct::verRctSemanticsSimple ( const std::vector< const rctSig * > & rvv)

◆ verRctSimple()

bool rct::verRctSimple ( const rctSig & rv)
inlinestatic

◆ weighted_inner_product() [1/2]

rct::key rct::weighted_inner_product ( const epee::span< const rct::key > & a,
const epee::span< const rct::key > & b,
const rct::key & y )
static

◆ weighted_inner_product() [2/2]

rct::key rct::weighted_inner_product ( const rct::keyV & a,
const epee::span< const rct::key > & b,
const rct::key & y )
static

◆ xor8()

void rct::xor8 ( key & v,
const key & k )
static

◆ zero() [1/2]

key rct::zero ( )
inline

◆ zero() [2/2]

void rct::zero ( key & z)
inline

◆ zeroCommit()

key rct::zeroCommit ( xmr_amount amount)

Variable Documentation

◆ EIGHT

const key rct::EIGHT = { {0x08, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static

◆ G

const key rct::G = { {0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66 } }
static

◆ Gi_p3 [1/2]

ge_p3 rct::Gi_p3[maxN *maxM]
static

◆ Gi_p3 [2/2]

ge_p3 rct::Gi_p3[maxN *maxM]
static

◆ H

const key rct::H = { {0x8b, 0x65, 0x59, 0x70, 0x15, 0x37, 0x99, 0xaf, 0x2a, 0xea, 0xdc, 0x9f, 0xf1, 0xad, 0xd0, 0xea, 0x6c, 0x72, 0x51, 0xd5, 0x41, 0x54, 0xcf, 0xa9, 0x2c, 0x17, 0x3a, 0x0d, 0xd3, 0x9c, 0x1f, 0x94} }
static

◆ H2

const key64 rct::H2
static

◆ Hi_p3 [1/2]

ge_p3 rct::Hi_p3[maxN *maxM]
static

◆ Hi_p3 [2/2]

ge_p3 rct::Hi_p3[maxN *maxM]
static

◆ I

const key rct::I = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static

◆ init_mutex [1/2]

boost::mutex rct::init_mutex
static

◆ init_mutex [2/2]

boost::mutex rct::init_mutex
static

◆ initial_transcript

rct::key rct::initial_transcript
static

◆ INV_EIGHT

const key rct::INV_EIGHT = { { 0x79, 0x2f, 0xdc, 0xe2, 0x29, 0xe5, 0x06, 0x61, 0xd0, 0xda, 0x1c, 0x7d, 0xb3, 0x9d, 0xd3, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06 } }
static

◆ ip12

const rct::key rct::ip12 = inner_product(oneN, twoN)
static

◆ L

const key rct::L = { {0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
static

◆ maxM [1/2]

size_t rct::maxM = BULLETPROOF_MAX_OUTPUTS
staticconstexpr

◆ maxM [2/2]

size_t rct::maxM = BULLETPROOF_PLUS_MAX_OUTPUTS
staticconstexpr

◆ maxN [1/2]

size_t rct::maxN = 64
staticconstexpr

◆ maxN [2/2]

size_t rct::maxN = 64
staticconstexpr

◆ MINUS_INV_EIGHT [1/2]

const constexpr rct::key rct::MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } }
staticconstexpr

◆ MINUS_INV_EIGHT [2/2]

const constexpr rct::key rct::MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } }
staticconstexpr

◆ MINUS_ONE [1/2]

const constexpr rct::key rct::MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
staticconstexpr

◆ MINUS_ONE [2/2]

const constexpr rct::key rct::MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
staticconstexpr

◆ ONE

const constexpr rct::key rct::ONE = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
staticconstexpr

◆ oneN

const rct::keyV rct::oneN = vector_dup(rct::identity(), maxN)
static

◆ pippenger_HiGi_cache [1/2]

std::shared_ptr<pippenger_cached_data> rct::pippenger_HiGi_cache
static

◆ pippenger_HiGi_cache [2/2]

std::shared_ptr<pippenger_cached_data> rct::pippenger_HiGi_cache
static

◆ straus_HiGi_cache [1/2]

std::shared_ptr<straus_cached_data> rct::straus_HiGi_cache
static

◆ straus_HiGi_cache [2/2]

std::shared_ptr<straus_cached_data> rct::straus_HiGi_cache
static

◆ TWO [1/2]

const constexpr rct::key rct::TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
staticconstexpr

◆ TWO [2/2]

const constexpr rct::key rct::TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
staticconstexpr

◆ TWO_SIXTY_FOUR_MINUS_ONE

rct::key rct::TWO_SIXTY_FOUR_MINUS_ONE
static

◆ twoN

const rct::keyV rct::twoN = vector_powers(TWO, maxN)
static

◆ Z

const key rct::Z = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static

◆ ZERO

const constexpr rct::key rct::ZERO = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
staticconstexpr
Generated on for Monero by doxygen 1.16.1