Namespaces
namespace	coins

namespace	ct

namespace	detail

namespace	fast

namespace	hash

namespace	test

namespace	zk

Classes
struct	AffinePointData

struct	Bech32DecodeResult

struct	Bip143Preimage

class	Bip324Cipher

class	Bip324Session

struct	Bip39Entropy

struct	CurveContext

struct	ECDSAAdaptorSig

struct	ECDSABatchEntry

struct	ECDSASignature

struct	ExtendedKey

struct	FieldElementData

struct	FrostCommitment

struct	FrostKeyPackage

struct	FrostNonce

struct	FrostNonceCommitment

struct	FrostPartialSig

struct	FrostShare

struct	JacobianPointData

struct	MidFieldElementData

struct	MuSig2AggNonce

struct	MuSig2KeyAggCtx

struct	MuSig2PubNonce

struct	MuSig2SecNonce

struct	MuSig2Session

struct	Outpoint

struct	PedersenCommitment

class	PrivateKey

struct	RecoverableSignature

struct	ScalarData

struct	ScanMatch

struct	ScanTx

struct	ScanTxRaw

struct	SchnorrAdaptorSig

struct	SchnorrBatchCachedEntry

struct	SchnorrBatchEntry

struct	SchnorrKeypair

struct	SchnorrSignature

struct	SchnorrXonlyPubkey

class	SHA256

class	SHA512

struct	SilentPaymentAddress

struct	TapSighashTxData

struct	TxInput

struct	TxOut

struct	TxOutput

struct	WIFDecodeResult

struct	WitnessProgram

struct	WitnessTx

Typedefs
using	WitnessItem = std::vector< std::uint8_t >

using	WitnessStack = std::vector< WitnessItem >

using	ParticipantId = std::uint32_t

Enumerations
enum class	Network : std::uint8_t { Mainnet = 0 , Testnet = 1 }

enum class	Bech32Encoding { BECH32 , BECH32M }

enum class	SighashType : std::uint32_t { ALL = 0x01 , NONE = 0x02 , SINGLE = 0x03 , ANYONECANPAY = 0x80 }

enum class	WitnessProgramType : std::uint8_t { NONE = 0 , P2WPKH = 1 , P2WSH = 2 , P2TR = 3 , UNKNOWN = 4 }

Functions
SchnorrAdaptorSig	schnorr_adaptor_sign (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg, const fast::Point &adaptor_point, const std::array< std::uint8_t, 32 > &aux_rand)

bool	schnorr_adaptor_verify (const SchnorrAdaptorSig &pre_sig, const std::array< std::uint8_t, 32 > &pubkey_x, const std::array< std::uint8_t, 32 > &msg, const fast::Point &adaptor_point)

SchnorrSignature	schnorr_adaptor_adapt (const SchnorrAdaptorSig &pre_sig, const fast::Scalar &adaptor_secret)

std::pair< fast::Scalar, bool >	schnorr_adaptor_extract (const SchnorrAdaptorSig &pre_sig, const SchnorrSignature &sig)

ECDSAAdaptorSig	ecdsa_adaptor_sign (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg_hash, const fast::Point &adaptor_point)

bool	ecdsa_adaptor_verify (const ECDSAAdaptorSig &pre_sig, const fast::Point &public_key, const std::array< std::uint8_t, 32 > &msg_hash, const fast::Point &adaptor_point)

ECDSASignature	ecdsa_adaptor_adapt (const ECDSAAdaptorSig &pre_sig, const fast::Scalar &adaptor_secret)

std::pair< fast::Scalar, bool >	ecdsa_adaptor_extract (const ECDSAAdaptorSig &pre_sig, const ECDSASignature &sig)

std::string	base58check_encode (const std::uint8_t *data, std::size_t len)

std::pair< std::vector< std::uint8_t >, bool >	base58check_decode (const std::string &encoded)

std::string	bech32_encode (const std::string &hrp, std::uint8_t witness_version, const std::uint8_t *witness_program, std::size_t prog_len)

Bech32DecodeResult	bech32_decode (const std::string &addr)

std::array< std::uint8_t, 20 >	hash160 (const std::uint8_t *data, std::size_t len)

std::string	address_p2pkh (const fast::Point &pubkey, Network net=Network::Mainnet)

std::string	address_p2wpkh (const fast::Point &pubkey, Network net=Network::Mainnet)

std::string	address_p2tr (const fast::Point &internal_key, Network net=Network::Mainnet)

std::string	address_p2tr_raw (const std::array< std::uint8_t, 32 > &output_key_x, Network net=Network::Mainnet)

std::string	address_p2sh_p2wpkh (const fast::Point &pubkey, Network net=Network::Mainnet)

std::string	address_p2sh (const std::array< std::uint8_t, 20 > &script_hash, Network net=Network::Mainnet)

std::string	address_p2wsh (const std::array< std::uint8_t, 32 > &witness_script_hash, Network net=Network::Mainnet)

std::string	cashaddr_encode (const std::array< std::uint8_t, 20 > &hash, const std::string &prefix, std::uint8_t type=0)

std::string	address_cashaddr (const fast::Point &pubkey, const std::string &prefix="bitcoincash")

std::string	wif_encode (const fast::Scalar &private_key, bool compressed=true, Network net=Network::Mainnet)

WIFDecodeResult	wif_decode (const std::string &wif)

SilentPaymentAddress	silent_payment_address (const fast::Scalar &scan_privkey, const fast::Scalar &spend_privkey)

std::pair< fast::Point, fast::Scalar >	silent_payment_create_output (const std::vector< fast::Scalar > &input_privkeys, const SilentPaymentAddress &recipient, std::uint32_t k=0)

std::vector< std::pair< std::uint32_t, fast::Scalar > >	silent_payment_scan (const fast::Scalar &scan_privkey, const fast::Scalar &spend_privkey, const std::vector< fast::Point > &input_pubkeys, const std::vector< std::array< std::uint8_t, 32 > > &output_pubkeys)

ScanTx	compute_a_eff (const ScanTxRaw &raw)

std::vector< ScanMatch >	fast_scan_batch (const fast::Scalar &scan_privkey, const fast::Scalar &spend_privkey, const std::vector< ScanTx > &txs)

bool	schnorr_batch_verify (const SchnorrBatchEntry *entries, std::size_t n)

bool	schnorr_batch_verify (const std::vector< SchnorrBatchEntry > &entries)

bool	schnorr_batch_verify (const SchnorrBatchCachedEntry *entries, std::size_t n)

bool	schnorr_batch_verify (const std::vector< SchnorrBatchCachedEntry > &entries)

bool	ecdsa_batch_verify (const ECDSABatchEntry *entries, std::size_t n)

bool	ecdsa_batch_verify (const std::vector< ECDSABatchEntry > &entries)

void	schnorr_batch_identify_invalid (const SchnorrBatchEntry *entries, std::size_t n, std::vector< std::size_t > &invalid_out)

std::vector< std::size_t >	schnorr_batch_identify_invalid (const SchnorrBatchEntry *entries, std::size_t n)

void	schnorr_batch_identify_invalid (const SchnorrBatchCachedEntry *entries, std::size_t n, std::vector< std::size_t > &invalid_out)

std::vector< std::size_t >	schnorr_batch_identify_invalid (const SchnorrBatchCachedEntry *entries, std::size_t n)

void	ecdsa_batch_identify_invalid (const ECDSABatchEntry *entries, std::size_t n, std::vector< std::size_t > &invalid_out)

std::vector< std::size_t >	ecdsa_batch_identify_invalid (const ECDSABatchEntry *entries, std::size_t n)

std::array< std::uint8_t, 32 >	bip143_hash_prevouts (const Outpoint *outpoints, std::size_t count) noexcept

std::array< std::uint8_t, 32 >	bip143_hash_sequence (const std::uint32_t *sequences, std::size_t count) noexcept

std::array< std::uint8_t, 32 >	bip143_hash_outputs (const TxOutput *outputs, std::size_t count) noexcept

Bip143Preimage	bip143_build_preimage (std::uint32_t version, const Outpoint outpoints, std::size_t input_count, const std::uint32_t sequences, const TxOutput *outputs, std::size_t output_count, std::uint32_t locktime) noexcept

std::array< std::uint8_t, 32 >	bip143_sighash (const Bip143Preimage &preimage, const Outpoint &outpoint, const std::uint8_t *script_code, std::size_t script_code_len, std::uint64_t value, std::uint32_t sequence, std::uint32_t sighash_type) noexcept

std::array< std::uint8_t, 25 >	bip143_p2wpkh_script_code (const std::uint8_t pubkey_hash[20]) noexcept

std::vector< std::uint8_t >	witness_serialize (const WitnessTx &tx) noexcept

std::vector< std::uint8_t >	legacy_serialize (const WitnessTx &tx) noexcept

std::array< std::uint8_t, 32 >	compute_txid (const WitnessTx &tx) noexcept

std::array< std::uint8_t, 32 >	compute_wtxid (const WitnessTx &tx) noexcept

std::array< std::uint8_t, 32 >	witness_commitment (const std::array< std::uint8_t, 32 > &witness_root, const std::array< std::uint8_t, 32 > &witness_nonce) noexcept

bool	has_witness (const WitnessTx &tx) noexcept

std::uint64_t	tx_weight (const WitnessTx &tx) noexcept

std::uint64_t	tx_vsize (const WitnessTx &tx) noexcept

std::pair< ExtendedKey, bool >	bip32_master_key (const std::uint8_t *seed, std::size_t seed_len)

std::pair< ExtendedKey, bool >	bip32_derive_path (const ExtendedKey &master, const std::string &path)

std::array< std::uint8_t, 64 >	hmac_sha512 (const std::uint8_t key, std::size_t key_len, const std::uint8_t data, std::size_t data_len)

std::pair< std::string, bool >	bip39_generate (std::size_t entropy_bytes, const std::uint8_t *entropy_in=nullptr)

bool	bip39_validate (const std::string &mnemonic)

std::pair< std::array< std::uint8_t, 64 >, bool >	bip39_mnemonic_to_seed (const std::string &mnemonic, const std::string &passphrase="")

std::pair< Bip39Entropy, bool >	bip39_mnemonic_to_entropy (const std::string &mnemonic)

void	pbkdf2_hmac_sha512 (const std::uint8_t password, std::size_t password_len, const std::uint8_t salt, std::size_t salt_len, std::uint32_t iterations, std::uint8_t *output, std::size_t output_len)

const char const	bip39_wordlist_english ()

void	chacha20_crypt (const std::uint8_t key[32], const std::uint8_t nonce[12], std::uint32_t counter, std::uint8_t *data, std::size_t len) noexcept

void	chacha20_block (const std::uint8_t key[32], const std::uint8_t nonce[12], std::uint32_t counter, std::uint8_t out[64]) noexcept

std::array< std::uint8_t, 16 >	poly1305_mac (const std::uint8_t key[32], const std::uint8_t *data, std::size_t len) noexcept

void	aead_chacha20_poly1305_encrypt (const std::uint8_t key[32], const std::uint8_t nonce[12], const std::uint8_t aad, std::size_t aad_len, const std::uint8_t plaintext, std::size_t plaintext_len, std::uint8_t *out, std::uint8_t tag[16]) noexcept

bool	aead_chacha20_poly1305_decrypt (const std::uint8_t key[32], const std::uint8_t nonce[12], const std::uint8_t aad, std::size_t aad_len, const std::uint8_t ciphertext, std::size_t ciphertext_len, const std::uint8_t tag[16], std::uint8_t *out) noexcept

const fast::Point &	effective_generator (const CurveContext *ctx=nullptr)

fast::Point	derive_public_key (const fast::Scalar &private_key, const CurveContext *ctx=nullptr)

fast::Point	scalar_mul_G (const fast::Scalar &scalar, const CurveContext *ctx=nullptr)

std::array< std::uint8_t, 32 >	ecdh_compute (const Scalar &private_key, const Point &public_key)

std::array< std::uint8_t, 32 >	ecdh_compute_xonly (const Scalar &private_key, const Point &public_key)

std::array< std::uint8_t, 32 >	ecdh_compute_raw (const Scalar &private_key, const Point &public_key)

ECDSASignature	ecdsa_sign (const std::array< std::uint8_t, 32 > &msg_hash, const fast::Scalar &private_key)

ECDSASignature	ecdsa_sign_verified (const std::array< std::uint8_t, 32 > &msg_hash, const fast::Scalar &private_key)

ECDSASignature	ecdsa_sign_hedged (const std::array< std::uint8_t, 32 > &msg_hash, const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &aux_rand)

ECDSASignature	ecdsa_sign_hedged_verified (const std::array< std::uint8_t, 32 > &msg_hash, const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &aux_rand)

bool	ecdsa_verify (const std::uint8_t *msg_hash32, const fast::Point &public_key, const ECDSASignature &sig)

bool	ecdsa_verify (const std::array< std::uint8_t, 32 > &msg_hash, const fast::Point &public_key, const ECDSASignature &sig)

fast::Scalar	rfc6979_nonce (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg_hash)

fast::Scalar	rfc6979_nonce_hedged (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg_hash, const std::array< std::uint8_t, 32 > &aux_rand)

std::vector< std::uint8_t >	ecies_encrypt (const fast::Point &recipient_pubkey, const std::uint8_t *plaintext, std::size_t plaintext_len)

std::vector< std::uint8_t >	ecies_decrypt (const fast::Scalar &privkey, const std::uint8_t *envelope, std::size_t envelope_len)

FieldElement	ellswift_decode (const std::uint8_t encoding[64]) noexcept

std::array< std::uint8_t, 64 >	ellswift_create (const Scalar &privkey)

std::array< std::uint8_t, 64 >	ellswift_create (const Scalar &privkey, const std::uint8_t *auxrnd32)

std::array< std::uint8_t, 64 >	ellswift_create_fast (const Scalar &privkey)

std::array< std::uint8_t, 32 >	ellswift_xdh_fast (const std::uint8_t ell_a64[64], const std::uint8_t ell_b64[64], const Scalar &our_privkey, bool initiating) noexcept

std::array< std::uint8_t, 64 >	ellswift_encode_x (const FieldElement &x, const std::uint8_t rnd32[32])

std::array< std::uint8_t, 32 >	ellswift_xdh (const std::uint8_t ell_a64[64], const std::uint8_t ell_b64[64], const Scalar &our_privkey, bool initiating) noexcept

std::pair< FrostCommitment, std::vector< FrostShare > >	frost_keygen_begin (ParticipantId participant_id, std::uint32_t threshold, std::uint32_t num_participants, const std::array< std::uint8_t, 32 > &secret_seed)

std::pair< FrostKeyPackage, bool >	frost_keygen_finalize (ParticipantId participant_id, const std::vector< FrostCommitment > &commitments, const std::vector< FrostShare > &received_shares, std::uint32_t threshold, std::uint32_t num_participants)

std::pair< FrostNonce, FrostNonceCommitment >	frost_sign_nonce_gen (ParticipantId participant_id, const std::array< std::uint8_t, 32 > &nonce_seed)

FrostPartialSig	frost_sign (const FrostKeyPackage &key_pkg, FrostNonce &nonce, const std::array< std::uint8_t, 32 > &msg, const std::vector< FrostNonceCommitment > &nonce_commitments)

bool	frost_verify_partial (const FrostPartialSig &partial_sig, const FrostNonceCommitment &signer_commitment, const fast::Point &verification_share, const std::array< std::uint8_t, 32 > &msg, const std::vector< FrostNonceCommitment > &nonce_commitments, const fast::Point &group_public_key)

SchnorrSignature	frost_aggregate (const std::vector< FrostPartialSig > &partial_sigs, const std::vector< FrostNonceCommitment > &nonce_commitments, const fast::Point &group_public_key, const std::array< std::uint8_t, 32 > &msg)

fast::Scalar	frost_lagrange_coefficient (ParticipantId i, const std::vector< ParticipantId > &signer_ids)

std::array< std::uint8_t, 32 >	hmac_sha256 (const std::uint8_t key, std::size_t key_len, const std::uint8_t data, std::size_t data_len) noexcept

std::array< std::uint8_t, 32 >	hkdf_sha256_extract (const std::uint8_t salt, std::size_t salt_len, const std::uint8_t ikm, std::size_t ikm_len) noexcept

bool	hkdf_sha256_expand (const std::uint8_t prk[32], const std::uint8_t info, std::size_t info_len, std::uint8_t out, std::size_t out_len) noexcept

fast::Point	shamir_trick (const fast::Scalar &a, const fast::Point &P, const fast::Scalar &b, const fast::Point &Q)

fast::Point	multi_scalar_mul (const fast::Scalar scalars, const fast::Point points, std::size_t n)

fast::Point	multi_scalar_mul (const std::vector< fast::Scalar > &scalars, const std::vector< fast::Point > &points)

unsigned	strauss_optimal_window (std::size_t n)

MuSig2KeyAggCtx	musig2_key_agg (const std::vector< std::array< std::uint8_t, 33 > > &pubkeys)

std::pair< MuSig2SecNonce, MuSig2PubNonce >	musig2_nonce_gen (const fast::Scalar &secret_key, const std::array< std::uint8_t, 32 > &pub_key, const std::array< std::uint8_t, 32 > &agg_pub_key, const std::array< std::uint8_t, 32 > &msg, const std::uint8_t *extra_input=nullptr)

MuSig2AggNonce	musig2_nonce_agg (const std::vector< MuSig2PubNonce > &pub_nonces)

MuSig2Session	musig2_start_sign_session (const MuSig2AggNonce &agg_nonce, const MuSig2KeyAggCtx &key_agg_ctx, const std::array< std::uint8_t, 32 > &msg)

fast::Scalar	musig2_partial_sign (MuSig2SecNonce &sec_nonce, const fast::Scalar &secret_key, const MuSig2KeyAggCtx &key_agg_ctx, const MuSig2Session &session, std::size_t signer_index)

bool	musig2_partial_verify (const fast::Scalar &partial_sig, const MuSig2PubNonce &pub_nonce, const std::array< std::uint8_t, 32 > &pubkey, const MuSig2KeyAggCtx &key_agg_ctx, const MuSig2Session &session, std::size_t signer_index)

std::array< std::uint8_t, 64 >	musig2_partial_sig_agg (const std::vector< fast::Scalar > &partial_sigs, const MuSig2Session &session)

const fast::Point &	pedersen_generator_H ()

PedersenCommitment	pedersen_commit (const fast::Scalar &value, const fast::Scalar &blinding)

bool	pedersen_verify (const PedersenCommitment &commitment, const fast::Scalar &value, const fast::Scalar &blinding)

bool	pedersen_verify_sum (const PedersenCommitment commitments_pos, std::size_t n_pos, const PedersenCommitment commitments_neg, std::size_t n_neg)

fast::Scalar	pedersen_blind_sum (const fast::Scalar blinds_in, std::size_t n_in, const fast::Scalar blinds_out, std::size_t n_out)

const fast::Point &	pedersen_generator_J ()

PedersenCommitment	pedersen_switch_commit (const fast::Scalar &value, const fast::Scalar &blinding, const fast::Scalar &switch_blind)

fast::Point	pippenger_msm (const fast::Scalar scalars, const fast::Point points, std::size_t n)

fast::Point	pippenger_msm (const std::vector< fast::Scalar > &scalars, const std::vector< fast::Point > &points)

unsigned	pippenger_optimal_window (std::size_t n)

fast::Point	msm (const fast::Scalar scalars, const fast::Point points, std::size_t n)

fast::Point	msm (const std::vector< fast::Scalar > &scalars, const std::vector< fast::Point > &points)

bool	operator== (const PrivateKey &a, const PrivateKey &b) noexcept

RecoverableSignature	ecdsa_sign_recoverable (const std::array< std::uint8_t, 32 > &msg_hash, const Scalar &private_key)

std::pair< Point, bool >	ecdsa_recover (const std::array< std::uint8_t, 32 > &msg_hash, const ECDSASignature &sig, int recid)

std::array< std::uint8_t, 65 >	recoverable_to_compact (const RecoverableSignature &rsig, bool compressed=true)

std::pair< RecoverableSignature, bool >	recoverable_from_compact (const std::array< std::uint8_t, 65 > &data)

SchnorrKeypair	schnorr_keypair_create (const fast::Scalar &private_key)

SchnorrSignature	schnorr_sign (const SchnorrKeypair &kp, const std::array< std::uint8_t, 32 > &msg, const std::array< std::uint8_t, 32 > &aux_rand)

SchnorrSignature	schnorr_sign_verified (const SchnorrKeypair &kp, const std::array< std::uint8_t, 32 > &msg, const std::array< std::uint8_t, 32 > &aux_rand)

SchnorrSignature	schnorr_sign (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg, const std::array< std::uint8_t, 32 > &aux_rand)

SchnorrSignature	schnorr_sign_verified (const fast::Scalar &private_key, const std::array< std::uint8_t, 32 > &msg, const std::array< std::uint8_t, 32 > &aux_rand)

bool	schnorr_verify (const std::uint8_t pubkey_x32, const std::uint8_t msg32, const SchnorrSignature &sig)

bool	schnorr_verify (const std::array< std::uint8_t, 32 > &pubkey_x, const std::array< std::uint8_t, 32 > &msg, const SchnorrSignature &sig)

bool	schnorr_verify (const std::array< std::uint8_t, 32 > &pubkey_x, const std::uint8_t *msg32, const SchnorrSignature &sig)

bool	schnorr_xonly_pubkey_parse (SchnorrXonlyPubkey &out, const std::uint8_t *pubkey_x32)

bool	schnorr_xonly_pubkey_parse (SchnorrXonlyPubkey &out, const std::array< std::uint8_t, 32 > &pubkey_x)

SchnorrXonlyPubkey	schnorr_xonly_from_keypair (const SchnorrKeypair &kp)

bool	schnorr_verify (const SchnorrXonlyPubkey &pubkey, const std::array< std::uint8_t, 32 > &msg, const SchnorrSignature &sig)

bool	schnorr_verify (const SchnorrXonlyPubkey &pubkey, const std::uint8_t *msg32, const SchnorrSignature &sig)

std::array< std::uint8_t, 32 >	tagged_hash (const char tag, const void data, std::size_t len)

std::array< std::uint8_t, 32 >	schnorr_pubkey (const fast::Scalar &private_key)

std::array< std::uint8_t, 22 >	segwit_scriptpubkey_p2wpkh (const std::uint8_t pubkey_hash[20]) noexcept

std::array< std::uint8_t, 34 >	segwit_scriptpubkey_p2wsh (const std::uint8_t script_hash[32]) noexcept

std::array< std::uint8_t, 34 >	segwit_scriptpubkey_p2tr (const std::uint8_t output_key[32]) noexcept

std::vector< std::uint8_t >	segwit_scriptpubkey (std::uint8_t version, const std::uint8_t *program, std::size_t program_len) noexcept

bool	is_witness_program (const std::uint8_t *script, std::size_t script_len) noexcept

WitnessProgram	parse_witness_program (const std::uint8_t *script, std::size_t script_len) noexcept

std::array< std::uint8_t, 32 >	witness_script_hash (const std::uint8_t *script, std::size_t script_len) noexcept

std::array< std::uint8_t, 25 >	p2wpkh_script_code (const std::uint8_t pubkey_hash[20]) noexcept

bool	validate_p2wpkh_witness (const std::vector< std::vector< std::uint8_t > > &witness, const std::uint8_t program[20]) noexcept

bool	validate_p2wsh_witness (const std::vector< std::vector< std::uint8_t > > &witness, const std::uint8_t program[32]) noexcept

std::size_t	witness_weight (const std::vector< std::vector< std::uint8_t > > &witness) noexcept

std::array< std::uint8_t, 32 >	taproot_tweak_hash (const std::array< std::uint8_t, 32 > &internal_key_x, const std::uint8_t *merkle_root=nullptr, std::size_t merkle_root_len=0)

std::array< std::uint8_t, 32 >	taproot_leaf_hash (const std::uint8_t *script, std::size_t script_len, std::uint8_t leaf_version=0xC0)

std::array< std::uint8_t, 32 >	taproot_branch_hash (const std::array< std::uint8_t, 32 > &a, const std::array< std::uint8_t, 32 > &b)

std::pair< std::array< std::uint8_t, 32 >, int >	taproot_output_key (const std::array< std::uint8_t, 32 > &internal_key_x, const std::uint8_t *merkle_root=nullptr, std::size_t merkle_root_len=0)

Scalar	taproot_tweak_privkey (const Scalar &private_key, const std::uint8_t *merkle_root=nullptr, std::size_t merkle_root_len=0)

bool	taproot_verify_commitment (const std::array< std::uint8_t, 32 > &output_key_x, int output_key_parity, const std::array< std::uint8_t, 32 > &internal_key_x, const std::uint8_t *merkle_root=nullptr, std::size_t merkle_root_len=0)

std::array< std::uint8_t, 32 >	taproot_merkle_root_from_proof (const std::array< std::uint8_t, 32 > &leaf_hash, const std::vector< std::array< std::uint8_t, 32 > > &proof)

std::array< std::uint8_t, 32 >	taproot_merkle_root (const std::vector< std::array< std::uint8_t, 32 > > &leaf_hashes)

std::array< std::uint8_t, 32 >	tapscript_sighash (const TapSighashTxData &tx_data, std::size_t input_index, std::uint8_t hash_type, const std::array< std::uint8_t, 32 > &tapleaf_hash, std::uint8_t key_version, std::uint32_t code_separator_pos, const std::uint8_t *annex=nullptr, std::size_t annex_len=0) noexcept

std::array< std::uint8_t, 32 >	taproot_keypath_sighash (const TapSighashTxData &tx_data, std::size_t input_index, std::uint8_t hash_type, const std::uint8_t *annex=nullptr, std::size_t annex_len=0) noexcept

std::string	nfkd_normalize (const std::string &utf8)

FieldElementData *	fe_to_data (void *fe) noexcept

const FieldElementData *	fe_to_data (const void *fe) noexcept

ScalarData *	sc_to_data (void *sc) noexcept

const ScalarData *	sc_to_data (const void *sc) noexcept

Typedef Documentation

◆ ParticipantId

using secp256k1::ParticipantId = typedef std::uint32_t

Definition at line 39 of file frost.hpp.

◆ WitnessItem

using secp256k1::WitnessItem = typedef std::vector<std::uint8_t>

Definition at line 29 of file bip144.hpp.

◆ WitnessStack

using secp256k1::WitnessStack = typedef std::vector<WitnessItem>

Definition at line 32 of file bip144.hpp.

Enumeration Type Documentation

◆ Bech32Encoding

enum class secp256k1::Bech32Encoding

strong

Enumerator
BECH32
BECH32M

Definition at line 52 of file address.hpp.

◆ Network

enum class secp256k1::Network : std::uint8_t

strong

Enumerator
Mainnet
Testnet

Definition at line 36 of file address.hpp.

◆ SighashType

enum class secp256k1::SighashType : std::uint32_t

strong

Enumerator
ALL
NONE
SINGLE
ANYONECANPAY

Definition at line 31 of file bip143.hpp.

◆ WitnessProgramType

enum class secp256k1::WitnessProgramType : std::uint8_t

strong

Enumerator
NONE
P2WPKH
P2WSH
P2TR
UNKNOWN

Definition at line 35 of file segwit.hpp.

Function Documentation

◆ address_cashaddr()

std::string secp256k1::address_cashaddr	(	const fast::Point &	pubkey,
		const std::string &	prefix = `"bitcoincash"`
	)

◆ address_p2pkh()

std::string secp256k1::address_p2pkh	(	const fast::Point &	pubkey,
		Network	net = `Network::Mainnet`
	)

◆ address_p2sh()

std::string secp256k1::address_p2sh	(	const std::array< std::uint8_t, 20 > &	script_hash,
		Network	net = `Network::Mainnet`
	)

◆ address_p2sh_p2wpkh()

std::string secp256k1::address_p2sh_p2wpkh	(	const fast::Point &	pubkey,
		Network	net = `Network::Mainnet`
	)

◆ address_p2tr()

std::string secp256k1::address_p2tr	(	const fast::Point &	internal_key,
		Network	net = `Network::Mainnet`
	)

◆ address_p2tr_raw()

std::string secp256k1::address_p2tr_raw	(	const std::array< std::uint8_t, 32 > &	output_key_x,
		Network	net = `Network::Mainnet`
	)

◆ address_p2wpkh()

std::string secp256k1::address_p2wpkh	(	const fast::Point &	pubkey,
		Network	net = `Network::Mainnet`
	)

◆ address_p2wsh()

std::string secp256k1::address_p2wsh	(	const std::array< std::uint8_t, 32 > &	witness_script_hash,
		Network	net = `Network::Mainnet`
	)

◆ aead_chacha20_poly1305_decrypt()

bool secp256k1::aead_chacha20_poly1305_decrypt	(	const std::uint8_t	key[32],
		const std::uint8_t	nonce[12],
		const std::uint8_t *	aad,
		std::size_t	aad_len,
		const std::uint8_t *	ciphertext,
		std::size_t	ciphertext_len,
		const std::uint8_t	tag[16],
		std::uint8_t *	out
	)

noexcept

◆ aead_chacha20_poly1305_encrypt()

void secp256k1::aead_chacha20_poly1305_encrypt	(	const std::uint8_t	key[32],
		const std::uint8_t	nonce[12],
		const std::uint8_t *	aad,
		std::size_t	aad_len,
		const std::uint8_t *	plaintext,
		std::size_t	plaintext_len,
		std::uint8_t *	out,
		std::uint8_t	tag[16]
	)

noexcept

◆ base58check_decode()

std::pair< std::vector< std::uint8_t >, bool > secp256k1::base58check_decode ( const std::string & encoded )

◆ base58check_encode()

std::string secp256k1::base58check_encode	(	const std::uint8_t *	data,
		std::size_t	len
	)

◆ bech32_decode()

Bech32DecodeResult secp256k1::bech32_decode ( const std::string & addr )

◆ bech32_encode()

std::string secp256k1::bech32_encode	(	const std::string &	hrp,
		std::uint8_t	witness_version,
		const std::uint8_t *	witness_program,
		std::size_t	prog_len
	)

◆ bip143_build_preimage()

Bip143Preimage secp256k1::bip143_build_preimage	(	std::uint32_t	version,
		const Outpoint *	outpoints,
		std::size_t	input_count,
		const std::uint32_t *	sequences,
		const TxOutput *	outputs,
		std::size_t	output_count,
		std::uint32_t	locktime
	)

noexcept

◆ bip143_hash_outputs()

std::array< std::uint8_t, 32 > secp256k1::bip143_hash_outputs	(	const TxOutput *	outputs,
		std::size_t	count
	)

noexcept

◆ bip143_hash_prevouts()

std::array< std::uint8_t, 32 > secp256k1::bip143_hash_prevouts	(	const Outpoint *	outpoints,
		std::size_t	count
	)

noexcept

◆ bip143_hash_sequence()

std::array< std::uint8_t, 32 > secp256k1::bip143_hash_sequence	(	const std::uint32_t *	sequences,
		std::size_t	count
	)

noexcept

◆ bip143_p2wpkh_script_code()

std::array< std::uint8_t, 25 > secp256k1::bip143_p2wpkh_script_code ( const std::uint8_t pubkey_hash[20] )

noexcept

◆ bip143_sighash()

std::array< std::uint8_t, 32 > secp256k1::bip143_sighash	(	const Bip143Preimage &	preimage,
		const Outpoint &	outpoint,
		const std::uint8_t *	script_code,
		std::size_t	script_code_len,
		std::uint64_t	value,
		std::uint32_t	sequence,
		std::uint32_t	sighash_type
	)

noexcept

◆ bip32_derive_path()

std::pair< ExtendedKey, bool > secp256k1::bip32_derive_path	(	const ExtendedKey &	master,
		const std::string &	path
	)

◆ bip32_master_key()

std::pair< ExtendedKey, bool > secp256k1::bip32_master_key	(	const std::uint8_t *	seed,
		std::size_t	seed_len
	)

◆ bip39_generate()

std::pair< std::string, bool > secp256k1::bip39_generate	(	std::size_t	entropy_bytes,
		const std::uint8_t *	entropy_in = `nullptr`
	)

◆ bip39_mnemonic_to_entropy()

std::pair< Bip39Entropy, bool > secp256k1::bip39_mnemonic_to_entropy ( const std::string & mnemonic )

◆ bip39_mnemonic_to_seed()

std::pair< std::array< std::uint8_t, 64 >, bool > secp256k1::bip39_mnemonic_to_seed	(	const std::string &	mnemonic,
		const std::string &	passphrase = `""`
	)

◆ bip39_validate()

bool secp256k1::bip39_validate ( const std::string & mnemonic )

◆ bip39_wordlist_english()

const char *const * secp256k1::bip39_wordlist_english ( )

◆ cashaddr_encode()

std::string secp256k1::cashaddr_encode	(	const std::array< std::uint8_t, 20 > &	hash,
		const std::string &	prefix,
		std::uint8_t	type = `0`
	)

◆ chacha20_block()

void secp256k1::chacha20_block	(	const std::uint8_t	key[32],
		const std::uint8_t	nonce[12],
		std::uint32_t	counter,
		std::uint8_t	out[64]
	)

noexcept

◆ chacha20_crypt()

void secp256k1::chacha20_crypt	(	const std::uint8_t	key[32],
		const std::uint8_t	nonce[12],
		std::uint32_t	counter,
		std::uint8_t *	data,
		std::size_t	len
	)

noexcept

◆ compute_a_eff()

ScanTx secp256k1::compute_a_eff ( const ScanTxRaw & raw )

◆ compute_txid()

std::array< std::uint8_t, 32 > secp256k1::compute_txid ( const WitnessTx & tx )

noexcept

◆ compute_wtxid()

std::array< std::uint8_t, 32 > secp256k1::compute_wtxid ( const WitnessTx & tx )

noexcept

◆ derive_public_key()

fast::Point secp256k1::derive_public_key	(	const fast::Scalar &	private_key,
		const CurveContext *	ctx = `nullptr`
	)

inline

Definition at line 126 of file context.hpp.

References effective_generator(), and secp256k1::fast::Point::scalar_mul().

◆ ecdh_compute()

std::array< std::uint8_t, 32 > secp256k1::ecdh_compute	(	const Scalar &	private_key,
		const Point &	public_key
	)

◆ ecdh_compute_raw()

std::array< std::uint8_t, 32 > secp256k1::ecdh_compute_raw	(	const Scalar &	private_key,
		const Point &	public_key
	)

◆ ecdh_compute_xonly()

std::array< std::uint8_t, 32 > secp256k1::ecdh_compute_xonly	(	const Scalar &	private_key,
		const Point &	public_key
	)

◆ ecdsa_adaptor_adapt()

ECDSASignature secp256k1::ecdsa_adaptor_adapt	(	const ECDSAAdaptorSig &	pre_sig,
		const fast::Scalar &	adaptor_secret
	)

◆ ecdsa_adaptor_extract()

std::pair< fast::Scalar, bool > secp256k1::ecdsa_adaptor_extract	(	const ECDSAAdaptorSig &	pre_sig,
		const ECDSASignature &	sig
	)

◆ ecdsa_adaptor_sign()

ECDSAAdaptorSig secp256k1::ecdsa_adaptor_sign	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Point &	adaptor_point
	)

◆ ecdsa_adaptor_verify()

bool secp256k1::ecdsa_adaptor_verify	(	const ECDSAAdaptorSig &	pre_sig,
		const fast::Point &	public_key,
		const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Point &	adaptor_point
	)

◆ ecdsa_batch_identify_invalid() [1/2]

std::vector< std::size_t > secp256k1::ecdsa_batch_identify_invalid	(	const ECDSABatchEntry *	entries,
		std::size_t	n
	)

◆ ecdsa_batch_identify_invalid() [2/2]

void secp256k1::ecdsa_batch_identify_invalid	(	const ECDSABatchEntry *	entries,
		std::size_t	n,
		std::vector< std::size_t > &	invalid_out
	)

◆ ecdsa_batch_verify() [1/2]

bool secp256k1::ecdsa_batch_verify	(	const ECDSABatchEntry *	entries,
		std::size_t	n
	)

◆ ecdsa_batch_verify() [2/2]

bool secp256k1::ecdsa_batch_verify ( const std::vector< ECDSABatchEntry > & entries )

◆ ecdsa_recover()

std::pair< Point, bool > secp256k1::ecdsa_recover	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const ECDSASignature &	sig,
		int	recid
	)

◆ ecdsa_sign()

ECDSASignature secp256k1::ecdsa_sign	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Scalar &	private_key
	)

◆ ecdsa_sign_hedged()

ECDSASignature secp256k1::ecdsa_sign_hedged	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ ecdsa_sign_hedged_verified()

ECDSASignature secp256k1::ecdsa_sign_hedged_verified	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ ecdsa_sign_recoverable()

RecoverableSignature secp256k1::ecdsa_sign_recoverable	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const Scalar &	private_key
	)

◆ ecdsa_sign_verified()

ECDSASignature secp256k1::ecdsa_sign_verified	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Scalar &	private_key
	)

◆ ecdsa_verify() [1/2]

bool secp256k1::ecdsa_verify	(	const std::array< std::uint8_t, 32 > &	msg_hash,
		const fast::Point &	public_key,
		const ECDSASignature &	sig
	)

◆ ecdsa_verify() [2/2]

bool secp256k1::ecdsa_verify	(	const std::uint8_t *	msg_hash32,
		const fast::Point &	public_key,
		const ECDSASignature &	sig
	)

◆ ecies_decrypt()

std::vector< std::uint8_t > secp256k1::ecies_decrypt	(	const fast::Scalar &	privkey,
		const std::uint8_t *	envelope,
		std::size_t	envelope_len
	)

◆ ecies_encrypt()

std::vector< std::uint8_t > secp256k1::ecies_encrypt	(	const fast::Point &	recipient_pubkey,
		const std::uint8_t *	plaintext,
		std::size_t	plaintext_len
	)

◆ effective_generator()

const fast::Point & secp256k1::effective_generator ( const CurveContext * ctx = nullptr )

inline

Definition at line 117 of file context.hpp.

References secp256k1::CurveContext::generator, and secp256k1::fast::Point::generator().

Referenced by derive_public_key(), and scalar_mul_G().

◆ ellswift_create() [1/2]

std::array< std::uint8_t, 64 > secp256k1::ellswift_create ( const Scalar & privkey )

◆ ellswift_create() [2/2]

std::array< std::uint8_t, 64 > secp256k1::ellswift_create	(	const Scalar &	privkey,
		const std::uint8_t *	auxrnd32
	)

◆ ellswift_create_fast()

std::array< std::uint8_t, 64 > secp256k1::ellswift_create_fast ( const Scalar & privkey )

◆ ellswift_decode()

FieldElement secp256k1::ellswift_decode ( const std::uint8_t encoding[64] )

noexcept

◆ ellswift_encode_x()

std::array< std::uint8_t, 64 > secp256k1::ellswift_encode_x	(	const FieldElement &	x,
		const std::uint8_t	rnd32[32]
	)

◆ ellswift_xdh()

std::array< std::uint8_t, 32 > secp256k1::ellswift_xdh	(	const std::uint8_t	ell_a64[64],
		const std::uint8_t	ell_b64[64],
		const Scalar &	our_privkey,
		bool	initiating
	)

noexcept

◆ ellswift_xdh_fast()

std::array< std::uint8_t, 32 > secp256k1::ellswift_xdh_fast	(	const std::uint8_t	ell_a64[64],
		const std::uint8_t	ell_b64[64],
		const Scalar &	our_privkey,
		bool	initiating
	)

noexcept

◆ fast_scan_batch()

std::vector< ScanMatch > secp256k1::fast_scan_batch	(	const fast::Scalar &	scan_privkey,
		const fast::Scalar &	spend_privkey,
		const std::vector< ScanTx > &	txs
	)

◆ fe_to_data() [1/2]

const FieldElementData * secp256k1::fe_to_data ( const void * fe )

inlinenoexcept

Definition at line 108 of file types.hpp.

◆ fe_to_data() [2/2]

FieldElementData * secp256k1::fe_to_data ( void * fe )

inlinenoexcept

Definition at line 104 of file types.hpp.

◆ frost_aggregate()

SchnorrSignature secp256k1::frost_aggregate	(	const std::vector< FrostPartialSig > &	partial_sigs,
		const std::vector< FrostNonceCommitment > &	nonce_commitments,
		const fast::Point &	group_public_key,
		const std::array< std::uint8_t, 32 > &	msg
	)

◆ frost_keygen_begin()

std::pair< FrostCommitment, std::vector< FrostShare > > secp256k1::frost_keygen_begin	(	ParticipantId	participant_id,
		std::uint32_t	threshold,
		std::uint32_t	num_participants,
		const std::array< std::uint8_t, 32 > &	secret_seed
	)

◆ frost_keygen_finalize()

std::pair< FrostKeyPackage, bool > secp256k1::frost_keygen_finalize	(	ParticipantId	participant_id,
		const std::vector< FrostCommitment > &	commitments,
		const std::vector< FrostShare > &	received_shares,
		std::uint32_t	threshold,
		std::uint32_t	num_participants
	)

◆ frost_lagrange_coefficient()

fast::Scalar secp256k1::frost_lagrange_coefficient	(	ParticipantId	i,
		const std::vector< ParticipantId > &	signer_ids
	)

◆ frost_sign()

FrostPartialSig secp256k1::frost_sign	(	const FrostKeyPackage &	key_pkg,
		FrostNonce &	nonce,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::vector< FrostNonceCommitment > &	nonce_commitments
	)

◆ frost_sign_nonce_gen()

std::pair< FrostNonce, FrostNonceCommitment > secp256k1::frost_sign_nonce_gen	(	ParticipantId	participant_id,
		const std::array< std::uint8_t, 32 > &	nonce_seed
	)

◆ frost_verify_partial()

bool secp256k1::frost_verify_partial	(	const FrostPartialSig &	partial_sig,
		const FrostNonceCommitment &	signer_commitment,
		const fast::Point &	verification_share,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::vector< FrostNonceCommitment > &	nonce_commitments,
		const fast::Point &	group_public_key
	)

◆ has_witness()

bool secp256k1::has_witness ( const WitnessTx & tx )

noexcept

◆ hash160()

std::array< std::uint8_t, 20 > secp256k1::hash160	(	const std::uint8_t *	data,
		std::size_t	len
	)

◆ hkdf_sha256_expand()

bool secp256k1::hkdf_sha256_expand	(	const std::uint8_t	prk[32],
		const std::uint8_t *	info,
		std::size_t	info_len,
		std::uint8_t *	out,
		std::size_t	out_len
	)

noexcept

◆ hkdf_sha256_extract()

std::array< std::uint8_t, 32 > secp256k1::hkdf_sha256_extract	(	const std::uint8_t *	salt,
		std::size_t	salt_len,
		const std::uint8_t *	ikm,
		std::size_t	ikm_len
	)

noexcept

◆ hmac_sha256()

std::array< std::uint8_t, 32 > secp256k1::hmac_sha256	(	const std::uint8_t *	key,
		std::size_t	key_len,
		const std::uint8_t *	data,
		std::size_t	data_len
	)

noexcept

◆ hmac_sha512()

std::array< std::uint8_t, 64 > secp256k1::hmac_sha512	(	const std::uint8_t *	key,
		std::size_t	key_len,
		const std::uint8_t *	data,
		std::size_t	data_len
	)

◆ is_witness_program()

bool secp256k1::is_witness_program	(	const std::uint8_t *	script,
		std::size_t	script_len
	)

noexcept

◆ legacy_serialize()

std::vector< std::uint8_t > secp256k1::legacy_serialize ( const WitnessTx & tx )

noexcept

◆ msm() [1/2]

fast::Point secp256k1::msm	(	const fast::Scalar *	scalars,
		const fast::Point *	points,
		std::size_t	n
	)

◆ msm() [2/2]

fast::Point secp256k1::msm	(	const std::vector< fast::Scalar > &	scalars,
		const std::vector< fast::Point > &	points
	)

◆ multi_scalar_mul() [1/2]

fast::Point secp256k1::multi_scalar_mul	(	const fast::Scalar *	scalars,
		const fast::Point *	points,
		std::size_t	n
	)

◆ multi_scalar_mul() [2/2]

fast::Point secp256k1::multi_scalar_mul	(	const std::vector< fast::Scalar > &	scalars,
		const std::vector< fast::Point > &	points
	)

◆ musig2_key_agg()

MuSig2KeyAggCtx secp256k1::musig2_key_agg ( const std::vector< std::array< std::uint8_t, 33 > > & pubkeys )

◆ musig2_nonce_agg()

MuSig2AggNonce secp256k1::musig2_nonce_agg ( const std::vector< MuSig2PubNonce > & pub_nonces )

◆ musig2_nonce_gen()

std::pair< MuSig2SecNonce, MuSig2PubNonce > secp256k1::musig2_nonce_gen	(	const fast::Scalar &	secret_key,
		const std::array< std::uint8_t, 32 > &	pub_key,
		const std::array< std::uint8_t, 32 > &	agg_pub_key,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::uint8_t *	extra_input = `nullptr`
	)

◆ musig2_partial_sig_agg()

std::array< std::uint8_t, 64 > secp256k1::musig2_partial_sig_agg	(	const std::vector< fast::Scalar > &	partial_sigs,
		const MuSig2Session &	session
	)

◆ musig2_partial_sign()

fast::Scalar secp256k1::musig2_partial_sign	(	MuSig2SecNonce &	sec_nonce,
		const fast::Scalar &	secret_key,
		const MuSig2KeyAggCtx &	key_agg_ctx,
		const MuSig2Session &	session,
		std::size_t	signer_index
	)

◆ musig2_partial_verify()

bool secp256k1::musig2_partial_verify	(	const fast::Scalar &	partial_sig,
		const MuSig2PubNonce &	pub_nonce,
		const std::array< std::uint8_t, 32 > &	pubkey,
		const MuSig2KeyAggCtx &	key_agg_ctx,
		const MuSig2Session &	session,
		std::size_t	signer_index
	)

◆ musig2_start_sign_session()

MuSig2Session secp256k1::musig2_start_sign_session	(	const MuSig2AggNonce &	agg_nonce,
		const MuSig2KeyAggCtx &	key_agg_ctx,
		const std::array< std::uint8_t, 32 > &	msg
	)

◆ nfkd_normalize()

std::string secp256k1::nfkd_normalize ( const std::string & utf8 )

Returns the UTF-8 NFKD-normalized form of the input. For ASCII-only strings (all bytes 0x00-0x7F): returns unchanged (fast path). Covers Latin-1/Extended, Latin Extended-A/B, Greek Extended, compatibility forms (fi/fl/ff/ffi/ffl), superscripts, fractions, and letterlike symbols.

◆ operator==()

bool secp256k1::operator==	(	const PrivateKey &	a,
		const PrivateKey &	b
	)

inlinenoexcept

Definition at line 113 of file private_key.hpp.

◆ p2wpkh_script_code()

std::array< std::uint8_t, 25 > secp256k1::p2wpkh_script_code ( const std::uint8_t pubkey_hash[20] )

noexcept

◆ parse_witness_program()

WitnessProgram secp256k1::parse_witness_program	(	const std::uint8_t *	script,
		std::size_t	script_len
	)

noexcept

◆ pbkdf2_hmac_sha512()

void secp256k1::pbkdf2_hmac_sha512	(	const std::uint8_t *	password,
		std::size_t	password_len,
		const std::uint8_t *	salt,
		std::size_t	salt_len,
		std::uint32_t	iterations,
		std::uint8_t *	output,
		std::size_t	output_len
	)

◆ pedersen_blind_sum()

fast::Scalar secp256k1::pedersen_blind_sum	(	const fast::Scalar *	blinds_in,
		std::size_t	n_in,
		const fast::Scalar *	blinds_out,
		std::size_t	n_out
	)

◆ pedersen_commit()

PedersenCommitment secp256k1::pedersen_commit	(	const fast::Scalar &	value,
		const fast::Scalar &	blinding
	)

◆ pedersen_generator_H()

const fast::Point & secp256k1::pedersen_generator_H ( )

◆ pedersen_generator_J()

const fast::Point & secp256k1::pedersen_generator_J ( )

◆ pedersen_switch_commit()

PedersenCommitment secp256k1::pedersen_switch_commit	(	const fast::Scalar &	value,
		const fast::Scalar &	blinding,
		const fast::Scalar &	switch_blind
	)

◆ pedersen_verify()

bool secp256k1::pedersen_verify	(	const PedersenCommitment &	commitment,
		const fast::Scalar &	value,
		const fast::Scalar &	blinding
	)

◆ pedersen_verify_sum()

bool secp256k1::pedersen_verify_sum	(	const PedersenCommitment *	commitments_pos,
		std::size_t	n_pos,
		const PedersenCommitment *	commitments_neg,
		std::size_t	n_neg
	)

◆ pippenger_msm() [1/2]

fast::Point secp256k1::pippenger_msm	(	const fast::Scalar *	scalars,
		const fast::Point *	points,
		std::size_t	n
	)

◆ pippenger_msm() [2/2]

fast::Point secp256k1::pippenger_msm	(	const std::vector< fast::Scalar > &	scalars,
		const std::vector< fast::Point > &	points
	)

◆ pippenger_optimal_window()

unsigned secp256k1::pippenger_optimal_window ( std::size_t n )

◆ poly1305_mac()

std::array< std::uint8_t, 16 > secp256k1::poly1305_mac	(	const std::uint8_t	key[32],
		const std::uint8_t *	data,
		std::size_t	len
	)

noexcept

◆ recoverable_from_compact()

std::pair< RecoverableSignature, bool > secp256k1::recoverable_from_compact ( const std::array< std::uint8_t, 65 > & data )

◆ recoverable_to_compact()

std::array< std::uint8_t, 65 > secp256k1::recoverable_to_compact	(	const RecoverableSignature &	rsig,
		bool	compressed = `true`
	)

◆ rfc6979_nonce()

fast::Scalar secp256k1::rfc6979_nonce	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg_hash
	)

◆ rfc6979_nonce_hedged()

fast::Scalar secp256k1::rfc6979_nonce_hedged	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg_hash,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ sc_to_data() [1/2]

const ScalarData * secp256k1::sc_to_data ( const void * sc )

inlinenoexcept

Definition at line 116 of file types.hpp.

◆ sc_to_data() [2/2]

ScalarData * secp256k1::sc_to_data ( void * sc )

inlinenoexcept

Definition at line 112 of file types.hpp.

◆ scalar_mul_G()

fast::Point secp256k1::scalar_mul_G	(	const fast::Scalar &	scalar,
		const CurveContext *	ctx = `nullptr`
	)

inline

Definition at line 132 of file context.hpp.

References effective_generator(), and secp256k1::fast::Point::scalar_mul().

◆ schnorr_adaptor_adapt()

SchnorrSignature secp256k1::schnorr_adaptor_adapt	(	const SchnorrAdaptorSig &	pre_sig,
		const fast::Scalar &	adaptor_secret
	)

◆ schnorr_adaptor_extract()

std::pair< fast::Scalar, bool > secp256k1::schnorr_adaptor_extract	(	const SchnorrAdaptorSig &	pre_sig,
		const SchnorrSignature &	sig
	)

◆ schnorr_adaptor_sign()

SchnorrAdaptorSig secp256k1::schnorr_adaptor_sign	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg,
		const fast::Point &	adaptor_point,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ schnorr_adaptor_verify()

bool secp256k1::schnorr_adaptor_verify	(	const SchnorrAdaptorSig &	pre_sig,
		const std::array< std::uint8_t, 32 > &	pubkey_x,
		const std::array< std::uint8_t, 32 > &	msg,
		const fast::Point &	adaptor_point
	)

◆ schnorr_batch_identify_invalid() [1/4]

std::vector< std::size_t > secp256k1::schnorr_batch_identify_invalid	(	const SchnorrBatchCachedEntry *	entries,
		std::size_t	n
	)

◆ schnorr_batch_identify_invalid() [2/4]

void secp256k1::schnorr_batch_identify_invalid	(	const SchnorrBatchCachedEntry *	entries,
		std::size_t	n,
		std::vector< std::size_t > &	invalid_out
	)

◆ schnorr_batch_identify_invalid() [3/4]

std::vector< std::size_t > secp256k1::schnorr_batch_identify_invalid	(	const SchnorrBatchEntry *	entries,
		std::size_t	n
	)

◆ schnorr_batch_identify_invalid() [4/4]

void secp256k1::schnorr_batch_identify_invalid	(	const SchnorrBatchEntry *	entries,
		std::size_t	n,
		std::vector< std::size_t > &	invalid_out
	)

◆ schnorr_batch_verify() [1/4]

bool secp256k1::schnorr_batch_verify	(	const SchnorrBatchCachedEntry *	entries,
		std::size_t	n
	)

◆ schnorr_batch_verify() [2/4]

bool secp256k1::schnorr_batch_verify	(	const SchnorrBatchEntry *	entries,
		std::size_t	n
	)

◆ schnorr_batch_verify() [3/4]

bool secp256k1::schnorr_batch_verify ( const std::vector< SchnorrBatchCachedEntry > & entries )

◆ schnorr_batch_verify() [4/4]

bool secp256k1::schnorr_batch_verify ( const std::vector< SchnorrBatchEntry > & entries )

◆ schnorr_keypair_create()

SchnorrKeypair secp256k1::schnorr_keypair_create ( const fast::Scalar & private_key )

◆ schnorr_pubkey()

std::array< std::uint8_t, 32 > secp256k1::schnorr_pubkey ( const fast::Scalar & private_key )

◆ schnorr_sign() [1/2]

SchnorrSignature secp256k1::schnorr_sign	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ schnorr_sign() [2/2]

SchnorrSignature secp256k1::schnorr_sign	(	const SchnorrKeypair &	kp,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ schnorr_sign_verified() [1/2]

SchnorrSignature secp256k1::schnorr_sign_verified	(	const fast::Scalar &	private_key,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ schnorr_sign_verified() [2/2]

SchnorrSignature secp256k1::schnorr_sign_verified	(	const SchnorrKeypair &	kp,
		const std::array< std::uint8_t, 32 > &	msg,
		const std::array< std::uint8_t, 32 > &	aux_rand
	)

◆ schnorr_verify() [1/5]

bool secp256k1::schnorr_verify	(	const SchnorrXonlyPubkey &	pubkey,
		const std::array< std::uint8_t, 32 > &	msg,
		const SchnorrSignature &	sig
	)

◆ schnorr_verify() [2/5]

bool secp256k1::schnorr_verify	(	const SchnorrXonlyPubkey &	pubkey,
		const std::uint8_t *	msg32,
		const SchnorrSignature &	sig
	)

◆ schnorr_verify() [3/5]

bool secp256k1::schnorr_verify	(	const std::array< std::uint8_t, 32 > &	pubkey_x,
		const std::array< std::uint8_t, 32 > &	msg,
		const SchnorrSignature &	sig
	)

◆ schnorr_verify() [4/5]

bool secp256k1::schnorr_verify	(	const std::array< std::uint8_t, 32 > &	pubkey_x,
		const std::uint8_t *	msg32,
		const SchnorrSignature &	sig
	)

◆ schnorr_verify() [5/5]

bool secp256k1::schnorr_verify	(	const std::uint8_t *	pubkey_x32,
		const std::uint8_t *	msg32,
		const SchnorrSignature &	sig
	)

◆ schnorr_xonly_from_keypair()

SchnorrXonlyPubkey secp256k1::schnorr_xonly_from_keypair ( const SchnorrKeypair & kp )

◆ schnorr_xonly_pubkey_parse() [1/2]

bool secp256k1::schnorr_xonly_pubkey_parse	(	SchnorrXonlyPubkey &	out,
		const std::array< std::uint8_t, 32 > &	pubkey_x
	)

◆ schnorr_xonly_pubkey_parse() [2/2]

bool secp256k1::schnorr_xonly_pubkey_parse	(	SchnorrXonlyPubkey &	out,
		const std::uint8_t *	pubkey_x32
	)

◆ segwit_scriptpubkey()

std::vector< std::uint8_t > secp256k1::segwit_scriptpubkey	(	std::uint8_t	version,
		const std::uint8_t *	program,
		std::size_t	program_len
	)

noexcept

◆ segwit_scriptpubkey_p2tr()

std::array< std::uint8_t, 34 > secp256k1::segwit_scriptpubkey_p2tr ( const std::uint8_t output_key[32] )

noexcept

◆ segwit_scriptpubkey_p2wpkh()

std::array< std::uint8_t, 22 > secp256k1::segwit_scriptpubkey_p2wpkh ( const std::uint8_t pubkey_hash[20] )

noexcept

◆ segwit_scriptpubkey_p2wsh()

std::array< std::uint8_t, 34 > secp256k1::segwit_scriptpubkey_p2wsh ( const std::uint8_t script_hash[32] )

noexcept

◆ shamir_trick()

fast::Point secp256k1::shamir_trick	(	const fast::Scalar &	a,
		const fast::Point &	P,
		const fast::Scalar &	b,
		const fast::Point &	Q
	)

◆ silent_payment_address()

SilentPaymentAddress secp256k1::silent_payment_address	(	const fast::Scalar &	scan_privkey,
		const fast::Scalar &	spend_privkey
	)

◆ silent_payment_create_output()

std::pair< fast::Point, fast::Scalar > secp256k1::silent_payment_create_output	(	const std::vector< fast::Scalar > &	input_privkeys,
		const SilentPaymentAddress &	recipient,
		std::uint32_t	k = `0`
	)

◆ silent_payment_scan()

std::vector< std::pair< std::uint32_t, fast::Scalar > > secp256k1::silent_payment_scan	(	const fast::Scalar &	scan_privkey,
		const fast::Scalar &	spend_privkey,
		const std::vector< fast::Point > &	input_pubkeys,
		const std::vector< std::array< std::uint8_t, 32 > > &	output_pubkeys
	)

◆ strauss_optimal_window()

unsigned secp256k1::strauss_optimal_window ( std::size_t n )

◆ tagged_hash()

std::array< std::uint8_t, 32 > secp256k1::tagged_hash	(	const char *	tag,
		const void *	data,
		std::size_t	len
	)

◆ taproot_branch_hash()

std::array< std::uint8_t, 32 > secp256k1::taproot_branch_hash	(	const std::array< std::uint8_t, 32 > &	a,
		const std::array< std::uint8_t, 32 > &	b
	)

◆ taproot_keypath_sighash()

std::array< std::uint8_t, 32 > secp256k1::taproot_keypath_sighash	(	const TapSighashTxData &	tx_data,
		std::size_t	input_index,
		std::uint8_t	hash_type,
		const std::uint8_t *	annex = `nullptr`,
		std::size_t	annex_len = `0`
	)

noexcept

◆ taproot_leaf_hash()

std::array< std::uint8_t, 32 > secp256k1::taproot_leaf_hash	(	const std::uint8_t *	script,
		std::size_t	script_len,
		std::uint8_t	leaf_version = `0xC0`
	)

◆ taproot_merkle_root()

std::array< std::uint8_t, 32 > secp256k1::taproot_merkle_root ( const std::vector< std::array< std::uint8_t, 32 > > & leaf_hashes )

◆ taproot_merkle_root_from_proof()

std::array< std::uint8_t, 32 > secp256k1::taproot_merkle_root_from_proof	(	const std::array< std::uint8_t, 32 > &	leaf_hash,
		const std::vector< std::array< std::uint8_t, 32 > > &	proof
	)

◆ taproot_output_key()

std::pair< std::array< std::uint8_t, 32 >, int > secp256k1::taproot_output_key	(	const std::array< std::uint8_t, 32 > &	internal_key_x,
		const std::uint8_t *	merkle_root = `nullptr`,
		std::size_t	merkle_root_len = `0`
	)

◆ taproot_tweak_hash()

std::array< std::uint8_t, 32 > secp256k1::taproot_tweak_hash	(	const std::array< std::uint8_t, 32 > &	internal_key_x,
		const std::uint8_t *	merkle_root = `nullptr`,
		std::size_t	merkle_root_len = `0`
	)

◆ taproot_tweak_privkey()

Scalar secp256k1::taproot_tweak_privkey	(	const Scalar &	private_key,
		const std::uint8_t *	merkle_root = `nullptr`,
		std::size_t	merkle_root_len = `0`
	)

◆ taproot_verify_commitment()

bool secp256k1::taproot_verify_commitment	(	const std::array< std::uint8_t, 32 > &	output_key_x,
		int	output_key_parity,
		const std::array< std::uint8_t, 32 > &	internal_key_x,
		const std::uint8_t *	merkle_root = `nullptr`,
		std::size_t	merkle_root_len = `0`
	)

◆ tapscript_sighash()

std::array< std::uint8_t, 32 > secp256k1::tapscript_sighash	(	const TapSighashTxData &	tx_data,
		std::size_t	input_index,
		std::uint8_t	hash_type,
		const std::array< std::uint8_t, 32 > &	tapleaf_hash,
		std::uint8_t	key_version,
		std::uint32_t	code_separator_pos,
		const std::uint8_t *	annex = `nullptr`,
		std::size_t	annex_len = `0`
	)

noexcept

◆ tx_vsize()

std::uint64_t secp256k1::tx_vsize ( const WitnessTx & tx )

noexcept

◆ tx_weight()

std::uint64_t secp256k1::tx_weight ( const WitnessTx & tx )

noexcept

◆ validate_p2wpkh_witness()

bool secp256k1::validate_p2wpkh_witness	(	const std::vector< std::vector< std::uint8_t > > &	witness,
		const std::uint8_t	program[20]
	)

noexcept

◆ validate_p2wsh_witness()

bool secp256k1::validate_p2wsh_witness	(	const std::vector< std::vector< std::uint8_t > > &	witness,
		const std::uint8_t	program[32]
	)

noexcept

◆ wif_decode()

WIFDecodeResult secp256k1::wif_decode ( const std::string & wif )

◆ wif_encode()

std::string secp256k1::wif_encode	(	const fast::Scalar &	private_key,
		bool	compressed = `true`,
		Network	net = `Network::Mainnet`
	)

◆ witness_commitment()

std::array< std::uint8_t, 32 > secp256k1::witness_commitment	(	const std::array< std::uint8_t, 32 > &	witness_root,
		const std::array< std::uint8_t, 32 > &	witness_nonce
	)

noexcept

◆ witness_script_hash()

std::array< std::uint8_t, 32 > secp256k1::witness_script_hash	(	const std::uint8_t *	script,
		std::size_t	script_len
	)

noexcept

◆ witness_serialize()

std::vector< std::uint8_t > secp256k1::witness_serialize ( const WitnessTx & tx )

noexcept

◆ witness_weight()

std::size_t secp256k1::witness_weight ( const std::vector< std::vector< std::uint8_t > > & witness )

noexcept

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ ParticipantId

◆ WitnessItem

◆ WitnessStack

Enumeration Type Documentation

◆ Bech32Encoding

◆ Network

◆ SighashType

◆ WitnessProgramType

Function Documentation

◆ address_cashaddr()

◆ address_p2pkh()

◆ address_p2sh()

◆ address_p2sh_p2wpkh()

◆ address_p2tr()

◆ address_p2tr_raw()

◆ address_p2wpkh()

◆ address_p2wsh()

◆ aead_chacha20_poly1305_decrypt()

◆ aead_chacha20_poly1305_encrypt()

◆ base58check_decode()

◆ base58check_encode()

◆ bech32_decode()

◆ bech32_encode()

◆ bip143_build_preimage()

◆ bip143_hash_outputs()

◆ bip143_hash_prevouts()

◆ bip143_hash_sequence()

◆ bip143_p2wpkh_script_code()

◆ bip143_sighash()

◆ bip32_derive_path()

◆ bip32_master_key()

◆ bip39_generate()

◆ bip39_mnemonic_to_entropy()

◆ bip39_mnemonic_to_seed()

◆ bip39_validate()

◆ bip39_wordlist_english()

◆ cashaddr_encode()

◆ chacha20_block()

◆ chacha20_crypt()

◆ compute_a_eff()

◆ compute_txid()

◆ compute_wtxid()

◆ derive_public_key()

◆ ecdh_compute()

◆ ecdh_compute_raw()

◆ ecdh_compute_xonly()

◆ ecdsa_adaptor_adapt()

◆ ecdsa_adaptor_extract()

◆ ecdsa_adaptor_sign()

◆ ecdsa_adaptor_verify()

◆ ecdsa_batch_identify_invalid() [1/2]

◆ ecdsa_batch_identify_invalid() [2/2]

◆ ecdsa_batch_verify() [1/2]

◆ ecdsa_batch_verify() [2/2]

◆ ecdsa_recover()

◆ ecdsa_sign()

◆ ecdsa_sign_hedged()

◆ ecdsa_sign_hedged_verified()

◆ ecdsa_sign_recoverable()

◆ ecdsa_sign_verified()

◆ ecdsa_verify() [1/2]

◆ ecdsa_verify() [2/2]

◆ ecies_decrypt()

◆ ecies_encrypt()

◆ effective_generator()

◆ ellswift_create() [1/2]

◆ ellswift_create() [2/2]

◆ ellswift_create_fast()

◆ ellswift_decode()

◆ ellswift_encode_x()

◆ ellswift_xdh()

◆ ellswift_xdh_fast()

◆ fast_scan_batch()

◆ fe_to_data() [1/2]