rct Namespace Reference

Classes
struct	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	rangeSig
struct	Bulletproof
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	etn_amount
typedef unsigned int	bits[ATOMS]
typedef key	key64[64]

Enumerations
enum	{   RCTTypeNull = 0 , RCTTypeFull = 1 , RCTTypeSimple = 2 , RCTTypeBulletproof = 3 ,   RCTTypeBulletproof2 = 4 }
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 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, etn_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (etn_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (const key &bH)
key	zeroCommit (etn_amount amount)
key	commit (etn_amount amount, const key &mask)
etn_amount	randEtnAmount (etn_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)
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	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)
key	hashToPointSimple (const key &hh)
key	hashToPoint (const key &hh)
void	hashToPoint (key &pointk, const key &hh)
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)
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	sumKeys (key &Csum, const key &Cis)
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)
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)
mgSig	MLSAG_Gen (const key &message, const keyM &pk, const keyV &xx, const multisig_kLRki *kLRki, key *mscout, 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 etn_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, const multisig_kLRki *kLRki, key *mscout, 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, const multisig_kLRki *kLRki, key *mscout, 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)
void	getKeyFromBlockchain (ctkey &a, size_t reference_index)
tuple< ctkeyM, etn_amount >	populateFromBlockchain (ctkeyV inPk, int mixin)
etn_amount	populateFromBlockchainSimple (ctkeyV &mixRing, const ctkey &inPk, int mixin)
rctSig	genRct (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, 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< etn_amount > &amounts, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, const int mixin, const RCTConfig &rct_config, hw::device &hwdev)
rctSig	genRctSimple (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &inamounts, const vector< etn_amount > &outamounts, etn_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, 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< etn_amount > &inamounts, const vector< etn_amount > &outamounts, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, etn_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)
etn_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
etn_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
etn_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
etn_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, hw::device &hwdev)
bool	signMultisig (rctSig &rv, const std::vector< unsigned int > &indices, const keyV &k, const multisig_out &msout, const key &secret_key)
mgSig	proveRctMG (const ctkeyM &pubs, const ctkeyV &inSk, const keyV &outMasks, const ctkeyV &outPk, const multisig_kLRki *kLRki, key *mscout, 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< etn_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, 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< etn_amount > &amounts, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, 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< etn_amount > &inamounts, const std::vector< etn_amount > &outamounts, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, etn_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< etn_amount > &inamounts, const std::vector< etn_amount > &outamounts, etn_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
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 (etn_amount vali)
void	dp (bits amountb)
void	dp (const char *st)
void	d2h (key &amounth, const etn_amount in)
key	d2h (const etn_amount in)
void	d2b (bits amountb, etn_amount val)
etn_amount	h2d (const key &test)
void	h2b (bits amountb2, const key &test)
void	b2h (key &amountdh, const bits amountb2)
etn_amount	b2d (bits amountb)
bool	is_rct_simple (int type)
bool	is_rct_bulletproof (int type)
bool	is_rct_borromean (int type)
size_t	n_bulletproof_amounts (const Bulletproof &proof)
size_t	n_bulletproof_amounts (const std::vector< Bulletproof > &proofs)
size_t	n_bulletproof_max_amounts (const Bulletproof &proof)
size_t	n_bulletproof_max_amounts (const std::vector< Bulletproof > &proofs)
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 rct::key	Hi [maxN *maxM]
static rct::key	Gi [maxN *maxM]
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 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 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 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 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

etn_amount

typedef uint64_t rct::etn_amount

key64

typedef key rct::key64[64]

keyM

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

keyV

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

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RCTTypeNull
RCTTypeFull
RCTTypeSimple
RCTTypeBulletproof
RCTTypeBulletproof2

RangeProofType

enum rct::RangeProofType

Enumerator
RangeProofBorromean
RangeProofBulletproof
RangeProofMultiOutputBulletproof
RangeProofPaddedBulletproof

Function Documentation

add() [1/2]

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

inlinestatic

add() [2/2]

static 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
	)

b2d()

etn_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_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

)

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	(	etn_amount	amount,
		const key &	mask
	)

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()

static 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

(

etn_amount

amount

)

curveOrder() [1/2]

key rct::curveOrder ( )

inline

curveOrder() [2/2]

void rct::curveOrder ( key &  l )

inline

d2b()

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

d2h() [1/2]

key rct::d2h

(

const etn_amount

in

)

d2h() [2/2]

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

decodeRct() [1/2]

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

decodeRct() [2/2]

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

decodeRctSimple() [1/2]

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

decodeRctSimple() [2/2]

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

div2()

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

inlinestatic

dp() [1/8]

void rct::dp

(

bits

amountb

)

dp() [2/8]

void rct::dp

(

bool

a

)

dp() [3/8]

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

dp() [4/8]

void rct::dp

(

const char *

st

)

dp() [5/8]

void rct::dp

(

etn_amount

vali

)

dp() [6/8]

void rct::dp

(

key

a

)

dp() [7/8]

void rct::dp

(

keyM

a

)

dp() [8/8]

void rct::dp

(

keyV

a

)

ecdhDecode()

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

ecdhEncode()

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

ecdhHash()

static 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,
		etn_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< etn_amount > &	amounts,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		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< etn_amount > &	amounts,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		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< etn_amount > &	amounts,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		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< etn_amount > &	amounts,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const multisig_kLRki *	kLRki,
		multisig_out *	msout,
		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< etn_amount > &	inamounts,
		const std::vector< etn_amount > &	outamounts,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		etn_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< etn_amount > &	inamounts,
		const vector< etn_amount > &	outamounts,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		etn_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< etn_amount > &	inamounts,
		const std::vector< etn_amount > &	outamounts,
		etn_amount	txnFee,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		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< etn_amount > &	inamounts,
		const vector< etn_amount > &	outamounts,
		etn_amount	txnFee,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const std::vector< multisig_kLRki > *	kLRki,
		multisig_out *	msout,
		const std::vector< unsigned int > &	index,
		ctkeyV &	outSk,
		const RCTConfig &	rct_config,
		hw::device &	hwdev
	)

get_exponent()

static rct::key 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()

etn_amount rct::h2d

(

const key &

test

)

hadamard()

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

static

hadamard_fold()

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

static

hash2rct()

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

inlinestatic

hash_cache_mash() [1/3]

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

static

hash_cache_mash() [2/3]

static 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]

static 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_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

)

hashToPoint() [1/2]

key rct::hashToPoint

(

const key &

hh

)

hashToPoint() [2/2]

void rct::hashToPoint	(	key &	pointk,
		const key &	hh
	)

hashToPointSimple()

key rct::hashToPointSimple

(

const key &

hh

)

identity() [1/2]

key rct::identity ( )

inline

identity() [2/2]

void rct::identity ( key &  Id )

inline

init_exponents()

static void rct::init_exponents ( )

static

inner_product() [1/2]

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

static

inner_product() [2/2]

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

static

invert() [1/2]

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

static

invert() [2/2]

static 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_simple()

bool rct::is_rct_simple

(

int

type

)

is_reduced()

static 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()

static 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 multisig_kLRki *	kLRki,
		key *	mscout,
		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()

static 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_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

)

operator!=()

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

inlinestatic

operator<()

static 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==()

static 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()

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

inlinestatic

pkGen()

key rct::pkGen

(

)

populateFromBlockchain()

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

populateFromBlockchainSimple()

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

pow2()

static 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 etn_amount &	amount
	)

proveRangeBulletproof()

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

proveRctMG() [1/2]

mgSig rct::proveRctMG	(	const ctkeyM &	pubs,
		const ctkeyV &	inSk,
		const keyV &	outMasks,
		const ctkeyV &	outPk,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		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,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		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,
		const multisig_kLRki *	kLRki,
		key *	mscout,
		unsigned int	index,
		hw::device &	hwdev
	)

randEtnAmount()

etn_amount rct::randEtnAmount

(

etn_amount

upperlimit

)

rct2hash()

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

inlinestatic

rct2ki()

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

inlinestatic

rct2pk()

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

inlinestatic

rct2sk()

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

inlinestatic

scalarmult8()

key rct::scalarmult8

(

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
	)

signMultisig()

bool rct::signMultisig	(	rctSig &	rv,
		const std::vector< unsigned int > &	indices,
		const keyV &	k,
		const multisig_out &	msout,
		const key &	secret_key
	)

sk2rct()

static 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()

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

static

sm()

static 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
	)

sumKeys() [1/2]

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

sumKeys() [2/2]

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

test()

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

inlinestatic

toPointCheckOrder()

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

vector_add() [1/2]

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

static

vector_add() [2/2]

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

static

vector_dup()

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

static

vector_exponent()

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

static

vector_power_sum()

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

static

vector_powers()

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

static

vector_scalar() [1/2]

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

static

vector_scalar() [2/2]

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

static

vector_subtract()

static 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

)

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/2]

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

inlinestatic

verRct() [2/2]

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

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()

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

inlinestatic

xor8()

static 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

(

etn_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

rct::key rct::Gi[maxN *maxM]

static

Gi_p3

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

rct::key rct::Hi[maxN *maxM]

static

Hi_p3

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

boost::mutex rct::init_mutex

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

constexpr size_t rct::maxM = BULLETPROOF_MAX_OUTPUTS

staticconstexpr

maxN

constexpr size_t rct::maxN = 64

staticconstexpr

MINUS_INV_EIGHT

const 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 } }

static

MINUS_ONE

const 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 } }

static

oneN

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

static

pippenger_HiGi_cache

std::shared_ptr<pippenger_cached_data> rct::pippenger_HiGi_cache

static

straus_HiGi_cache

std::shared_ptr<straus_cached_data> rct::straus_HiGi_cache

static

TWO

const 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 } }

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