21 typedef std::vector<unsigned char>
valtype;
24 : m_txto{tx}, nIn{input_idx}, nHashType{hash_type}, amount{amount}, checker{&m_txto, nIn, amount,
MissingDataBehavior::
FAIL},
30 : m_txto{tx}, nIn{input_idx}, nHashType{hash_type}, amount{amount},
42 if (!provider.
GetKey(address, key))
56 if (!key.
Sign(hash, vchSig))
58 vchSig.push_back((
unsigned char)hashtype);
80 if (!leaf_hash)
return false;
88 if (!key.
SignSchnorr(hash, sig, merkle_root, {}))
return false;
112 const auto it = sigdata.
signatures.find(address);
114 pubkey = it->second.first;
120 pubkey = pk_it->second.first;
123 const auto& tap_pk_it = sigdata.
tap_pubkeys.find(address);
125 pubkey = tap_pk_it->second.GetEvenCorrespondingCPubKey();
129 return provider.
GetPubKey(address, pubkey);
135 const auto it = sigdata.
signatures.find(keyid);
137 sig_out = it->second.second;
142 sigdata.
misc_pubkeys.emplace(keyid, std::make_pair(pubkey, std::move(info)));
144 if (creator.
CreateSig(provider, sig_out, keyid, scriptcode, sigversion)) {
160 sigdata.
taproot_misc_pubkeys.emplace(pubkey, std::make_pair(std::set<uint256>({leaf_hash}), info));
162 it->second.first.insert(leaf_hash);
166 auto lookup_key = std::make_pair(pubkey, leaf_hash);
169 sig_out = it->second;
172 if (creator.
CreateSchnorrSig(provider, sig_out, pubkey, &leaf_hash,
nullptr, sigversion)) {
179 template<
typename M,
typename K,
typename V>
182 auto it = map.find(key);
183 if (it != map.end()) {
194 template<
typename Pk>
221 assert(last - first == 20);
224 std::copy(first, last, key_id.
begin());
231 std::vector<unsigned char>
ToPKBytes(
const Key& key)
const {
return {key.begin(), key.end()}; }
263 template <
typename I>
266 if (pubkey.IsValid())
return pubkey;
296 template <
typename I>
300 std::copy(first, last, pubkey.
begin());
328 TapSatisfier ms_satisfier{provider, sigdata, creator, script, leaf_hash};
356 std::vector<unsigned char> sig;
374 std::vector<std::vector<unsigned char>> smallest_result_stack;
376 const auto& [script, leaf_ver] = key;
377 std::vector<std::vector<unsigned char>> result_stack;
378 if (
SignTaprootScript(provider, creator, sigdata, leaf_ver, script, result_stack)) {
379 result_stack.emplace_back(std::begin(script), std::end(script));
380 result_stack.push_back(*control_blocks.begin());
381 if (smallest_result_stack.size() == 0 ||
383 smallest_result_stack = std::move(result_stack);
387 if (smallest_result_stack.size() != 0) {
388 result = std::move(smallest_result_stack);
406 std::vector<unsigned char> sig;
408 std::vector<valtype> vSolutions;
409 whichTypeRet =
Solver(scriptPubKey, vSolutions);
411 switch (whichTypeRet) {
417 if (!
CreateSig(creator, sigdata, provider, sig,
CPubKey(vSolutions[0]), scriptPubKey, sigversion))
return false;
418 ret.push_back(std::move(sig));
423 if (!
GetPubKey(provider, sigdata, keyID, pubkey)) {
428 if (!
CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion))
return false;
429 ret.push_back(std::move(sig));
436 ret.emplace_back(scriptRet.
begin(), scriptRet.
end());
444 size_t required = vSolutions.front()[0];
446 for (
size_t i = 1; i < vSolutions.size() - 1; ++i) {
451 if (
CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) {
452 if (
ret.size() < required + 1) {
453 ret.push_back(std::move(sig));
457 bool ok =
ret.size() == required + 1;
458 for (
size_t i = 0; i +
ret.size() < required + 1; ++i) {
464 ret.push_back(vSolutions[0]);
469 ret.emplace_back(scriptRet.
begin(), scriptRet.
end());
488 }
else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
490 }
else if (v.size() == 1 && v[0] == 0x81) {
503 std::vector<valtype> result;
514 subscript =
CScript(result[0].begin(), result[0].end());
532 CScript witnessscript(result[0].begin(), result[0].end());
542 if (!solved && result.empty()) {
543 WshSatisfier ms_satisfier{provider, sigdata, creator, witnessscript};
547 result.emplace_back(witnessscript.
begin(), witnessscript.
end());
564 result.emplace_back(subscript.
begin(), subscript.
end());
582 bool CheckECDSASignature(
const std::vector<unsigned char>& scriptSig,
const std::vector<unsigned char>& vchPubKey,
const CScript& scriptCode,
SigVersion sigversion)
const override
584 if (m_checker.CheckECDSASignature(scriptSig, vchPubKey, scriptCode, sigversion)) {
595 std::vector<valtype> script;
596 std::vector<valtype> witness;
599 Stacks(
const Stacks&) =
delete;
600 explicit Stacks(
const SignatureData& data) : witness(data.scriptWitness.stack) {
617 SignatureExtractorChecker extractor_checker(data, tx_checker);
624 std::vector<std::vector<unsigned char>> solutions;
631 CScript redeem_script(stack.script.back().begin(), stack.script.back().end());
633 next_script = std::move(redeem_script);
636 script_type =
Solver(next_script, solutions);
637 stack.script.pop_back();
641 CScript witness_script(stack.witness.back().begin(), stack.witness.back().end());
643 next_script = std::move(witness_script);
646 script_type =
Solver(next_script, solutions);
647 stack.witness.pop_back();
648 stack.script = std::move(stack.witness);
649 stack.witness.clear();
654 assert(solutions.size() > 1);
655 unsigned int num_pubkeys = solutions.size()-2;
656 unsigned int last_success_key = 0;
657 for (
const valtype& sig : stack.script) {
658 for (
unsigned int i = last_success_key; i < num_pubkeys; ++i) {
659 const valtype& pubkey = solutions[i+1];
661 if (data.
signatures.count(
CPubKey(pubkey).GetID()) || extractor_checker.CheckECDSASignature(sig, pubkey, next_script, sigversion)) {
662 last_success_key = i + 1;
682 *
this = std::move(sigdata);
720 DummySignatureChecker() =
default;
721 bool CheckECDSASignature(
const std::vector<unsigned char>& sig,
const std::vector<unsigned char>& vchPubKey,
const CScript& scriptCode,
SigVersion sigversion)
const override {
return sig.size() != 0; }
736 DummySignatureCreator(
char r_len,
char s_len) : m_r_len(r_len), m_s_len(s_len) {}
741 vchSig.assign(m_r_len + m_s_len + 7,
'\000');
743 vchSig[1] = m_r_len + m_s_len + 4;
747 vchSig[4 + m_r_len] = 0x02;
748 vchSig[5 + m_r_len] = m_s_len;
749 vchSig[6 + m_r_len] = 0x01;
755 sig.assign(64,
'\000');
771 std::vector<valtype> solutions;
772 auto whichtype =
Solver(script, solutions);
774 auto h160 =
uint160(solutions[0]);
793 std::vector<CTxOut> spent_outputs;
794 for (
unsigned int i = 0; i < mtx.
vin.size(); ++i) {
796 auto coin = coins.find(txin.
prevout);
797 if (coin == coins.end() || coin->second.IsSpent()) {
798 txdata.
Init(txConst, {},
true);
801 spent_outputs.emplace_back(coin->second.out.nValue, coin->second.out.scriptPubKey);
804 if (spent_outputs.size() == mtx.
vin.size()) {
805 txdata.
Init(txConst, std::move(spent_outputs),
true);
809 for (
unsigned int i = 0; i < mtx.
vin.size(); ++i) {
811 auto coin = coins.find(txin.
prevout);
812 if (coin == coins.end() || coin->second.IsSpent()) {
813 input_errors[i] =
_(
"Input not found or already spent");
816 const CScript& prevPubKey = coin->second.out.scriptPubKey;
817 const CAmount& amount = coin->second.out.nValue;
821 if (!fHashSingle || (i < mtx.
vout.size())) {
829 input_errors[i] =
_(
"Missing amount");
837 input_errors[i] =
Untranslated(
"Unable to sign input, invalid stack size (possibly missing key)");
840 input_errors[i] =
Untranslated(
"CHECK(MULTI)SIG failing with non-zero signature (possibly need more signatures)");
846 input_errors.erase(i);
849 return input_errors.empty();
std::vector< unsigned char > valtype
static constexpr CAmount MAX_MONEY
No amount larger than this (in satoshi) is valid.
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
#define CHECK_NONFATAL(condition)
Identity function.
virtual bool CheckLockTime(const CScriptNum &nLockTime) const
virtual bool CheckSchnorrSignature(Span< const unsigned char > sig, Span< const unsigned char > pubkey, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror=nullptr) const
virtual bool CheckSequence(const CScriptNum &nSequence) const
virtual bool CheckECDSASignature(const std::vector< unsigned char > &scriptSig, const std::vector< unsigned char > &vchPubKey, const CScript &scriptCode, SigVersion sigversion) const
Interface for signature creators.
virtual bool CreateSchnorrSig(const SigningProvider &provider, std::vector< unsigned char > &sig, const XOnlyPubKey &pubkey, const uint256 *leaf_hash, const uint256 *merkle_root, SigVersion sigversion) const =0
virtual const BaseSignatureChecker & Checker() const =0
virtual bool CreateSig(const SigningProvider &provider, std::vector< unsigned char > &vchSig, const CKeyID &keyid, const CScript &scriptCode, SigVersion sigversion) const =0
Create a singular (non-script) signature.
An encapsulated private key.
bool SignSchnorr(const uint256 &hash, Span< unsigned char > sig, const uint256 *merkle_root, const uint256 &aux) const
Create a BIP-340 Schnorr signature, for the xonly-pubkey corresponding to *this, optionally tweaked b...
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
bool IsCompressed() const
Check whether the public key corresponding to this private key is (to be) compressed.
A reference to a CKey: the Hash160 of its serialized public key.
An encapsulated public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Serialized script, used inside transaction inputs and outputs.
bool IsPayToScriptHash() const
bool IsWitnessProgram(int &version, std::vector< unsigned char > &program) const
static opcodetype EncodeOP_N(int n)
A reference to a CScript: the Hash160 of its serialization.
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
An output of a transaction.
bool CheckECDSASignature(const std::vector< unsigned char > &scriptSig, const std::vector< unsigned char > &vchPubKey, const CScript &scriptCode, SigVersion sigversion) const override
A signature creator for transactions.
bool CreateSchnorrSig(const SigningProvider &provider, std::vector< unsigned char > &sig, const XOnlyPubKey &pubkey, const uint256 *leaf_hash, const uint256 *merkle_root, SigVersion sigversion) const override
MutableTransactionSignatureCreator(const CMutableTransaction &tx LIFETIMEBOUND, unsigned int input_idx, const CAmount &amount, int hash_type)
const CMutableTransaction & m_txto
bool CreateSig(const SigningProvider &provider, std::vector< unsigned char > &vchSig, const CKeyID &keyid, const CScript &scriptCode, SigVersion sigversion) const override
Create a singular (non-script) signature.
const PrecomputedTransactionData * m_txdata
An interface to be implemented by keystores that support signing.
virtual bool GetCScript(const CScriptID &scriptid, CScript &script) const
virtual bool GetTaprootSpendData(const XOnlyPubKey &output_key, TaprootSpendData &spenddata) const
bool GetKeyByXOnly(const XOnlyPubKey &pubkey, CKey &key) const
virtual bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const
bool GetKeyOriginByXOnly(const XOnlyPubKey &pubkey, KeyOriginInfo &info) const
virtual bool GetTaprootBuilder(const XOnlyPubKey &output_key, TaprootBuilder &builder) const
virtual bool GetKey(const CKeyID &address, CKey &key) const
virtual bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const
constexpr std::size_t size() const noexcept
constexpr C * end() const noexcept
constexpr C * begin() const noexcept
Utility class to construct Taproot outputs from internal key and script tree.
const unsigned char * begin() const
constexpr unsigned char * begin()
uint160 RIPEMD160(Span< const unsigned char > data)
Compute the 160-bit RIPEMD-160 hash of an array.
bool SignatureHashSchnorr(uint256 &hash_out, ScriptExecutionData &execdata, const T &tx_to, uint32_t in_pos, uint8_t hash_type, SigVersion sigversion, const PrecomputedTransactionData &cache, MissingDataBehavior mdb)
uint256 ComputeTapleafHash(uint8_t leaf_version, Span< const unsigned char > script)
Compute the BIP341 tapleaf hash from leaf version & script.
uint256 SignatureHash(const CScript &scriptCode, const T &txTo, unsigned int nIn, int nHashType, const CAmount &amount, SigVersion sigversion, const PrecomputedTransactionData *cache)
bool EvalScript(std::vector< std::vector< unsigned char > > &stack, const CScript &script, unsigned int flags, const BaseSignatureChecker &checker, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ TAPROOT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, key path spending; see BIP 341.
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
@ TAPSCRIPT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, script path spending, leaf version 0xc0; see...
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
@ SCRIPT_VERIFY_STRICTENC
static constexpr uint8_t TAPROOT_LEAF_TAPSCRIPT
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
MissingDataBehavior
Enum to specify what *TransactionSignatureChecker's behavior should be when dealing with missing tran...
@ FAIL
Just act as if the signature was invalid.
NodeRef< typename Ctx::Key > FromScript(const CScript &script, const Ctx &ctx)
static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
std::vector< unsigned char > ToByteVector(const T &in)
std::string ScriptErrorString(const ScriptError serror)
enum ScriptError_t ScriptError
@ SCRIPT_ERR_INVALID_STACK_OPERATION
@ SCRIPT_ERR_SIG_NULLFAIL
static const int64_t values[]
A selection of numbers that do not trigger int64_t overflow when added/subtracted.
size_t GetSerializeSize(const T &t)
static bool SignStep(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &scriptPubKey, std::vector< valtype > &ret, TxoutType &whichTypeRet, SigVersion sigversion, SignatureData &sigdata)
Sign scriptPubKey using signature made with creator.
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
static bool CreateTaprootScriptSig(const BaseSignatureCreator &creator, SignatureData &sigdata, const SigningProvider &provider, std::vector< unsigned char > &sig_out, const XOnlyPubKey &pubkey, const uint256 &leaf_hash, SigVersion sigversion)
void UpdateInput(CTxIn &input, const SignatureData &data)
bool IsSegWitOutput(const SigningProvider &provider, const CScript &script)
Check whether a scriptPubKey is known to be segwit.
static bool CreateSig(const BaseSignatureCreator &creator, SignatureData &sigdata, const SigningProvider &provider, std::vector< unsigned char > &sig_out, const CPubKey &pubkey, const CScript &scriptcode, SigVersion sigversion)
static bool SignTaprootScript(const SigningProvider &provider, const BaseSignatureCreator &creator, SignatureData &sigdata, int leaf_version, Span< const unsigned char > script_bytes, std::vector< valtype > &result)
std::vector< unsigned char > valtype
static bool SignTaproot(const SigningProvider &provider, const BaseSignatureCreator &creator, const WitnessV1Taproot &output, SignatureData &sigdata, std::vector< valtype > &result)
const BaseSignatureCreator & DUMMY_MAXIMUM_SIGNATURE_CREATOR
A signature creator that just produces 72-byte empty signatures.
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
const BaseSignatureChecker & DUMMY_CHECKER
A signature checker that accepts all signatures.
bool SignTransaction(CMutableTransaction &mtx, const SigningProvider *keystore, const std::map< COutPoint, Coin > &coins, int nHashType, std::map< int, bilingual_str > &input_errors)
Sign the CMutableTransaction.
static CScript PushAll(const std::vector< valtype > &values)
const BaseSignatureCreator & DUMMY_SIGNATURE_CREATOR
A signature creator that just produces 71-byte empty signatures.
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey, CMutableTransaction &txTo, unsigned int nIn, const CAmount &amount, int nHashType, SignatureData &sig_data)
Produce a satisfying script (scriptSig or witness).
miniscript::Availability MsLookupHelper(const M &map, const K &key, V &value)
static bool GetCScript(const SigningProvider &provider, const SignatureData &sigdata, const CScriptID &scriptid, CScript &script)
std::pair< CPubKey, std::vector< unsigned char > > SigPair
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
@ NULL_DATA
unspendable OP_RETURN script that carries data
A mutable version of CTransaction.
std::vector< CTxOut > vout
std::vector< std::vector< unsigned char > > stack
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
bool m_bip341_taproot_ready
Whether the 5 fields above are initialized.
bool m_spent_outputs_ready
Whether m_spent_outputs is initialized.
Context for solving a Miniscript.
const BaseSignatureCreator & m_creator
miniscript::Availability SatRIPEMD160(const std::vector< unsigned char > &hash, std::vector< unsigned char > &preimage) const
std::vector< unsigned char > ToPKBytes(const Key &key) const
Conversion to raw public key.
bool CheckAfter(uint32_t value) const
Time lock satisfactions.
const miniscript::MiniscriptContext m_script_ctx
The context of the script we are satisfying (either P2WSH or Tapscript).
miniscript::Availability SatSHA256(const std::vector< unsigned char > &hash, std::vector< unsigned char > &preimage) const
Hash preimage satisfactions.
miniscript::Availability SatHASH256(const std::vector< unsigned char > &hash, std::vector< unsigned char > &preimage) const
const SigningProvider & m_provider
Satisfier(const SigningProvider &provider LIFETIMEBOUND, SignatureData &sig_data LIFETIMEBOUND, const BaseSignatureCreator &creator LIFETIMEBOUND, const CScript &witscript LIFETIMEBOUND, miniscript::MiniscriptContext script_ctx)
miniscript::Availability SatHASH160(const std::vector< unsigned char > &hash, std::vector< unsigned char > &preimage) const
SignatureData & m_sig_data
bool CheckOlder(uint32_t value) const
std::optional< CPubKey > CPubFromPKHBytes(I first, I last) const
Get a CPubKey from a key hash. Note the key hash may be of an xonly pubkey.
static bool KeyCompare(const Key &a, const Key &b)
miniscript::MiniscriptContext MsContext() const
const CScript & m_witness_script
uint256 m_tapleaf_hash
The tapleaf hash.
bool m_annex_present
Whether an annex is present.
bool m_annex_init
Whether m_annex_present and (when needed) m_annex_hash are initialized.
bool m_codeseparator_pos_init
Whether m_codeseparator_pos is initialized.
bool m_tapleaf_hash_init
Whether m_tapleaf_hash is initialized.
uint32_t m_codeseparator_pos
Opcode position of the last executed OP_CODESEPARATOR (or 0xFFFFFFFF if none executed).
uint160 missing_redeem_script
ScriptID of the missing redeemScript (if any)
std::vector< CKeyID > missing_sigs
KeyIDs of pubkeys for signatures which could not be found.
std::map< std::vector< uint8_t >, std::vector< uint8_t > > ripemd160_preimages
Mapping from a RIPEMD160 hash to its preimage provided to solve a Script.
void MergeSignatureData(SignatureData sigdata)
std::map< CKeyID, XOnlyPubKey > tap_pubkeys
Misc Taproot pubkeys involved in this input, by hash. (Equivalent of misc_pubkeys but for Taproot....
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a ...
TaprootSpendData tr_spenddata
Taproot spending data.
bool witness
Stores whether the input this SigData corresponds to is a witness input.
std::map< CKeyID, std::pair< CPubKey, KeyOriginInfo > > misc_pubkeys
std::optional< TaprootBuilder > tr_builder
Taproot tree used to build tr_spenddata.
CScript scriptSig
The scriptSig of an input. Contains complete signatures or the traditional partial signatures format.
std::map< std::vector< uint8_t >, std::vector< uint8_t > > sha256_preimages
Mapping from a SHA256 hash to its preimage provided to solve a Script.
std::vector< unsigned char > taproot_key_path_sig
std::map< std::pair< XOnlyPubKey, uint256 >, std::vector< unsigned char > > taproot_script_sigs
Schnorr signature for key path spending.
std::map< XOnlyPubKey, std::pair< std::set< uint256 >, KeyOriginInfo > > taproot_misc_pubkeys
Miscellaneous Taproot pubkeys involved in this input along with their leaf script hashes and key orig...
std::map< std::vector< uint8_t >, std::vector< uint8_t > > hash256_preimages
Mapping from a HASH256 hash to its preimage provided to solve a Script.
CScript redeem_script
The redeemScript (if any) for the input.
uint256 missing_witness_script
SHA256 of the missing witnessScript (if any)
std::vector< CKeyID > missing_pubkeys
KeyIDs of pubkeys which could not be found.
CScript witness_script
The witnessScript (if any) for the input. witnessScripts are used in P2WSH outputs.
CScriptWitness scriptWitness
The scriptWitness of an input. Contains complete signatures or the traditional partial signatures for...
bool complete
Stores whether the scriptSig and scriptWitness are complete.
std::map< std::vector< uint8_t >, std::vector< uint8_t > > hash160_preimages
Mapping from a HASH160 hash to its preimage provided to solve a Script.
Miniscript satisfier specific to Tapscript context.
std::optional< XOnlyPubKey > FromPKBytes(I first, I last) const
Conversion from a raw xonly public key.
const uint256 & m_leaf_hash
miniscript::Availability Sign(const XOnlyPubKey &key, std::vector< unsigned char > &sig) const
Satisfy a BIP340 signature check.
TapSatisfier(const SigningProvider &provider LIFETIMEBOUND, SignatureData &sig_data LIFETIMEBOUND, const BaseSignatureCreator &creator LIFETIMEBOUND, const CScript &script LIFETIMEBOUND, const uint256 &leaf_hash LIFETIMEBOUND)
std::optional< XOnlyPubKey > FromPKHBytes(I first, I last) const
Conversion from a raw xonly public key hash.
uint256 merkle_root
The Merkle root of the script tree (0 if no scripts).
std::map< std::pair< std::vector< unsigned char >, int >, std::set< std::vector< unsigned char >, ShortestVectorFirstComparator > > scripts
Map from (script, leaf_version) to (sets of) control blocks.
void Merge(TaprootSpendData other)
Merge other TaprootSpendData (for the same scriptPubKey) into this.
XOnlyPubKey internal_key
The BIP341 internal key.
Miniscript satisfier specific to P2WSH context.
WshSatisfier(const SigningProvider &provider LIFETIMEBOUND, SignatureData &sig_data LIFETIMEBOUND, const BaseSignatureCreator &creator LIFETIMEBOUND, const CScript &witscript LIFETIMEBOUND)
std::optional< CPubKey > FromPKBytes(I first, I last) const
Conversion from a raw compressed public key.
std::optional< CPubKey > FromPKHBytes(I first, I last) const
Conversion from a raw compressed public key hash.
miniscript::Availability Sign(const CPubKey &key, std::vector< unsigned char > &sig) const
Satisfy an ECDSA signature check.
bilingual_str _(const char *psz)
Translation function.
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
std::vector< typename std::common_type< Args... >::type > Vector(Args &&... args)
Construct a vector with the specified elements.