36 const CKey key = [&] {
38 k.Set(buffer.begin(), buffer.end(),
true);
54 assert(!(invalid_key == key));
61 CKey uncompressed_key;
62 uncompressed_key.
Set(buffer.begin(), buffer.end(),
false);
63 assert(!(uncompressed_key == key));
77 CKey negated_key = key;
80 assert(!(negated_key == key));
83 assert(negated_key == key);
91 const bool ok = key.
Derive(child_key, child_chaincode, 0, random_uint256);
94 assert(!(child_key == key));
95 assert(child_chaincode != random_uint256);
119 assert(pubkey_deserialized == pubkey);
145 const bool ok_add_key = fillable_signing_provider.
AddKey(key);
152 const bool ok_add_key_pubkey = fillable_signing_provider_pub.
AddKeyPubKey(key, pubkey);
153 assert(ok_add_key_pubkey);
157 const bool is_standard_tx_pubkey =
IsStandard(tx_pubkey_script, std::nullopt, which_type_tx_pubkey);
158 assert(is_standard_tx_pubkey);
162 const bool is_standard_tx_multisig =
IsStandard(tx_multisig_script, std::nullopt, which_type_tx_multisig);
163 assert(is_standard_tx_multisig);
166 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_pubkey;
167 const TxoutType outtype_tx_pubkey =
Solver(tx_pubkey_script, v_solutions_ret_tx_pubkey);
169 assert(v_solutions_ret_tx_pubkey.size() == 1);
170 assert(v_solutions_ret_tx_pubkey[0].size() == 33);
172 std::vector<std::vector<unsigned char>> v_solutions_ret_tx_multisig;
173 const TxoutType outtype_tx_multisig =
Solver(tx_multisig_script, v_solutions_ret_tx_multisig);
175 assert(v_solutions_ret_tx_multisig.size() == 3);
176 assert(v_solutions_ret_tx_multisig[0].size() == 1);
177 assert(v_solutions_ret_tx_multisig[1].size() == 33);
178 assert(v_solutions_ret_tx_multisig[2].size() == 1);
187 assert(script_for_destination.size() == 25);
192 const CPubKey pubkey_from_address_string =
AddrToPubKey(fillable_signing_provider, destination_address);
193 assert(pubkey_from_address_string == pubkey);
201 const bool ok_get_pubkey = fillable_signing_provider.
GetPubKey(key_id, pubkey_out);
205 const bool ok_get_key = fillable_signing_provider.
GetKey(key_id, key_out);
211 const bool ok_get_key_origin = fillable_signing_provider.
GetKeyOrigin(key_id, key_origin_info);
212 assert(!ok_get_key_origin);
216 const std::vector<unsigned char> vch_pubkey{pubkey.
begin(), pubkey.
end()};
220 const CPubKey pubkey_ctor_1{vch_pubkey};
221 assert(pubkey == pubkey_ctor_1);
223 const CPubKey pubkey_ctor_2{vch_pubkey.
begin(), vch_pubkey.end()};
224 assert(pubkey == pubkey_ctor_2);
227 pubkey_set.
Set(vch_pubkey.begin(), vch_pubkey.end());
228 assert(pubkey == pubkey_set);
232 const CPubKey invalid_pubkey{};
233 assert(!invalid_pubkey.IsValid());
234 assert(!invalid_pubkey.IsFullyValid());
235 assert(!(pubkey == invalid_pubkey));
236 assert(pubkey != invalid_pubkey);
237 assert(pubkey < invalid_pubkey);
242 unsigned int sum = 0;
243 for (
size_t i = 0; i < pubkey.
size(); ++i) {
250 CPubKey decompressed_pubkey = pubkey;
253 const bool ok = decompressed_pubkey.
Decompress();
260 std::vector<unsigned char> vch_sig;
261 const bool ok = key.
Sign(random_uint256, vch_sig,
false);
266 const std::vector<unsigned char> vch_invalid_sig{vch_sig.begin(), vch_sig.begin() + vch_sig.size() - 1};
267 assert(!pubkey.
Verify(random_uint256, vch_invalid_sig));
272 std::vector<unsigned char> vch_compact_sig;
273 const bool ok_sign_compact = key.
SignCompact(random_uint256, vch_compact_sig);
277 const bool ok_recover_compact = recover_pubkey.
RecoverCompact(random_uint256, vch_compact_sig);
278 assert(ok_recover_compact);
279 assert(recover_pubkey == pubkey);
285 const bool ok = pubkey.
Derive(child_pubkey, child_chaincode, 0, random_uint256);
287 assert(child_pubkey != pubkey);
292 assert(child_chaincode != random_uint256);
298 for (
const bool skip_check : {
true,
false}) {
300 const bool ok = loaded_key.
Load(priv_key, pubkey, skip_check);
302 assert(key == loaded_key);
void SelectParams(const std::string &network)
Sets the params returned by Params() to those for the given chain name.
static const std::string REGTEST
An encapsulated private key.
bool Negate()
Negate private key.
const unsigned char * end() const
unsigned int size() const
Simple read-only vector-like interface.
bool IsValid() const
Check whether this private key is valid.
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
CPubKey GetPubKey() const
Compute the public key from a private key.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
const unsigned char * begin() const
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
bool Load(const CPrivKey &privkey, const CPubKey &vchPubKey, bool fSkipCheck)
Load private key and check that public key matches.
bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child key.
bool SignCompact(const uint256 &hash, std::vector< unsigned char > &vchSig) const
Create a compact signature (65 bytes), which allows reconstructing the used public key.
A reference to a CKey: the Hash160 of its serialized public key.
An encapsulated public key.
bool RecoverCompact(const uint256 &hash, const std::vector< unsigned char > &vchSig)
Recover a public key from a compact signature.
const unsigned char * end() const
bool IsCompressed() const
Check whether this is a compressed public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
static bool CheckLowS(const std::vector< unsigned char > &vchSig)
Check whether a signature is normalized (lower-S).
bool Decompress()
Turn this public key into an uncompressed public key.
bool Verify(const uint256 &hash, const std::vector< unsigned char > &vchSig) const
Verify a DER signature (~72 bytes).
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
unsigned int size() const
Simple read-only vector-like interface to the pubkey data.
static bool ValidSize(const std::vector< unsigned char > &vch)
const unsigned char * begin() const
void Serialize(Stream &s) const
Implement serialization, as if this was a byte vector.
void Unserialize(Stream &s)
uint256 GetHash() const
Get the 256-bit hash of this public key.
const unsigned char * data() const
bool Derive(CPubKey &pubkeyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode &cc) const
Derive BIP32 child pubkey.
void Set(const T pbegin, const T pend)
Initialize a public key using begin/end iterators to byte data.
Serialized script, used inside transaction inputs and outputs.
bool IsPushOnly(const_iterator pc) const
Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical).
bool IsPayToScriptHash() const
bool IsUnspendable() const
Returns whether the script is guaranteed to fail at execution, regardless of the initial stack.
bool IsPayToWitnessScriptHash() const
bool HasValidOps() const
Check if the script contains valid OP_CODES.
Double ended buffer combining vector and stream-like interfaces.
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
virtual bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
virtual bool GetKey(const CKeyID &address, CKey &keyOut) const override
virtual std::set< CKeyID > GetKeys() const
virtual bool AddKey(const CKey &key)
virtual bool HaveKey(const CKeyID &address) const override
virtual bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const
constexpr bool IsNull() const
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
void ECC_Start()
Initialize the elliptic curve support.
std::vector< unsigned char, secure_allocator< unsigned char > > CPrivKey
CPrivKey is a serialized private key, with all parameters included (SIZE bytes)
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeSecret(const CKey &key)
std::string EncodeDestination(const CTxDestination &dest)
CKey DecodeSecret(const std::string &str)
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
std::vector< CTxDestination > GetAllDestinationsForKey(const CPubKey &key)
Get all destinations (potentially) supported by the wallet for the given key.
bool IsStandard(const CScript &scriptPubKey, const std::optional< unsigned > &max_datacarrier_bytes, TxoutType &whichType)
CPubKey HexToPubKey(const std::string &hex_in)
CPubKey AddrToPubKey(const FillableSigningProvider &keystore, const std::string &addr_in)
bool IsSegWitOutput(const SigningProvider &provider, const CScript &script)
Check whether a scriptPubKey is known to be segwit.
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
FUZZ_TARGET_INIT(key, initialize_key)
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.