elements-cli \- manual page for elements-cli v23.3.4

elements-qt \- manual page for elements-qt v23.3.4

.HP

\fB\-par=\fR<n>

.IP

Set the number of script verification threads (\fB\-24\fR to 15, 0 = auto, <0 =

leave that many cores free, default: 0)

.HP

suffix units [k|K|m|M|g|G|t|T] (default: M). Lowercase is 1000

base while uppercase is 1024 base

.HP

.IP

Enable all P2P network activity (default: 1). Can be changed by the

.IP

Tor control port password (default: empty)

.HP

\fB\-whitebind=\fR<[permissions@]addr>

.IP

Bind to the given address and add permission flags to the peers

elements-tx \- manual page for elements-tx v23.3.4

elements-util \- manual page for elements-util v23.3.4

elements-wallet \- manual page for elements-wallet v23.3.4

elementsd \- manual page for elementsd v23.3.4

.HP

\fB\-par=\fR<n>

.IP

Set the number of script verification threads (\fB\-24\fR to 15, 0 = auto, <0 =

leave that many cores free, default: 0)

.HP

suffix units [k|K|m|M|g|G|t|T] (default: M). Lowercase is 1000

base while uppercase is 1024 base

.HP

.IP

Enable all P2P network activity (default: 1). Can be changed by the

.IP

Tor control port password (default: empty)

.HP

\fB\-whitebind=\fR<[permissions@]addr>

.IP

Bind to the given address and add permission flags to the peers

test/serialize_tests.cpp \

test/settings_tests.cpp \

test/sighash_tests.cpp \

test/sigcache_tests.cpp \

test/sigopcount_tests.cpp \

test/skiplist_tests.cpp \

test/sock_tests.cpp \

argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-rangeproofcache", strprintf("Enable the range proof validation cache (default: %u). Use -norangeproofcache to disable.", 1), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-maxtipage=<n>", strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", DEFAULT_MAX_TIP_AGE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-printpriority", strprintf("Log transaction fee rate in " + CURRENCY_UNIT + "/kvB when mining blocks (default: %u)", DEFAULT_PRINTPRIORITY), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);

argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

#include <random.h>

#include <uint256.h>

#include <util/system.h>

#include <hash.h>

#include <cuckoocache.h>

class CSignatureCache

{

//! Salted SHA256 midstates, domain-separated by signature or proof type.

CSHA256 m_salted_hasher_ecdsa;

CSHA256 m_salted_hasher_schnorr;

CHashWriter m_salted_hasher_range_proof;

CHashWriter m_salted_hasher_surjection_proof;

typedef CuckooCache::cache<uint256, SignatureCacheHasher> map_type;

map_type setValid;

std::shared_mutex cs_sigcache;

CSignatureCache():

m_salted_hasher_range_proof(SER_GETHASH,0),

m_salted_hasher_surjection_proof(SER_GETHASH,0)

{

uint256 nonce = GetRandHash();

// Use 64-byte, type-specific salted midstates so later hash computations

// can start after the first SHA256 chunk.

static constexpr unsigned char PADDING_ECDSA[32] = {'E'};

static constexpr unsigned char PADDING_SCHNORR[32] = {'S'};

static constexpr unsigned char PADDING_RANGE_PROOF[32] = {'r'};

m_salted_hasher_ecdsa.Write(PADDING_ECDSA, 32);

m_salted_hasher_schnorr.Write(nonce.begin(), 32);

m_salted_hasher_schnorr.Write(PADDING_SCHNORR, 32);

m_salted_hasher_range_proof << nonce << PADDING_RANGE_PROOF;

m_salted_hasher_surjection_proof << nonce << PADDING_SURJECTION_PROOF;

}

void

}

// ELEMENTS:

void ComputeEntryRangeProof(uint256& entry,

const std::vector<unsigned char>& proof,

const std::vector<unsigned char>& commitment,

const std::vector<unsigned char>& asset_commitment,

const CScript& script_pub_key) const

{

CHashWriter hasher = m_salted_hasher_range_proof;

// We commit to both commitments and the scriptPubKey because these are

// committed to by the rangeproof itself; a change in any of them would

// invalidate the proof. Since these are exactly the arguments to

// CachingRangeProofChecker::VerifyRangeProof (below), there is no

// additional data that could affect the rangeproof's validity.

// Serialization length-prefixes every field, including the variable-length

// proof and script, so distinct argument tuples cannot share an encoding.

hasher << proof << commitment << asset_commitment << script_pub_key;

entry = hasher.GetSHA256();

}

void ComputeEntrySurjectionProof(uint256& entry, const uint256 &hash, const std::vector<unsigned char>& proof, const std::vector<unsigned char>& commitment, const std::vector<secp256k1_generator>& vTags) const {

CHashWriter hasher = m_salted_hasher_surjection_proof;

// We hash all arguments passed to CachingSurjectionProofChecker::VerifySurjectionProof,

// to ensure that any change in the way that the verification function is called will

// trigger a cache miss and explicit verification. However, we note that the `wtxid`

// (hash) commits to all the other data such that we could technically hash only it.

// We retain the other data as a defense against future refactorings.

//

// Serialize vTags as a flat byte vector (each secp256k1_generator is 64 bytes).

std::vector<unsigned char> vTagsBytes;

vTagsBytes.reserve(vTags.size() * 64);

for (const auto& tag : vTags) {

vTagsBytes.insert(vTagsBytes.end(), std::begin(tag.data), std::end(tag.data));

}

hasher << hash << proof << commitment << vTagsBytes;

entry = hasher.GetSHA256();

}

bool

void InitRangeproofCache()

{

if (!gArgs.GetBoolArg("-rangeproofcache", true)) {

LogPrintf("Range proof cache disabled via -norangeproofcache\n");

return;

}

// nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,

// setup_bytes creates the minimum possible cache (2 elements).

size_t nMaxCacheSize = std::min(std::max((int64_t)0, gArgs.GetIntArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE) / 4), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);

bool CachingRangeProofChecker::VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchValueCommitment, const std::vector<unsigned char>& vchAssetCommitment, const CScript& scriptPubKey, const secp256k1_context* secp256k1_ctx_verify_amounts) const

{

// ELEMENTS: NOTE FOR FUTURE EDITORS: every argument to this function that

// carries data (i.e. everything except the secp256k1 context, which is

// stateless) MUST be included in ComputeEntryRangeProof. Omitting any

// argument risks returning a cached positive result for a proof that was

// verified with different inputs.

uint256 entry;

const bool useCache = gArgs.GetBoolArg("-rangeproofcache", true);

if (useCache) {

rangeProofCache.ComputeEntryRangeProof(entry, vchRangeProof, vchValueCommitment, vchAssetCommitment, scriptPubKey);

if (rangeProofCache.Get(entry, !store)) {

return true;

}

}

if (vchRangeProof.size() == 0) {

return false;

}

if (useCache && store) {

rangeProofCache.Set(entry);

}

// wtxid commits to all data including surj targets

// we need to specify the proof and output asset point to be unique

uint256 entry;

surjectionProofCache.ComputeEntrySurjectionProof(entry, wtxid, vchproof, std::vector<unsigned char>(std::begin(gen.data), std::end(gen.data)), vTags);

if (surjectionProofCache.Get(entry, !store)) {

return true;

return true;

}

void TestComputeEntryRangeProof(uint256& entry,

const std::vector<unsigned char>& proof,

const std::vector<unsigned char>& commitment,

const std::vector<unsigned char>& asset_commitment,

const CScript& script_pub_key)

{

rangeProofCache.ComputeEntryRangeProof(entry, proof, commitment, asset_commitment, script_pub_key);

}

void TestComputeEntrySurjectionProof(uint256& entry,

const uint256& hash,

const std::vector<unsigned char>& proof,

const std::vector<unsigned char>& commitment,

const std::vector<secp256k1_generator>& vTags)

{

surjectionProofCache.ComputeEntrySurjectionProof(entry, hash, proof, commitment, vTags);

}