5 #include <test/data/tx_invalid.json.h>
6 #include <test/data/tx_valid.json.h>
38 #include <boost/test/unit_test.hpp>
45 typedef std::vector<unsigned char>
valtype;
77 if (strFlags.empty() || strFlags ==
"NONE")
return flags;
79 std::vector<std::string> words =
SplitString(strFlags,
',');
80 for (
const std::string& word : words)
83 BOOST_ERROR(
"Bad test: unknown verification flag '" << word <<
"'");
94 standard_flags_missing &= ~(pair.second);
96 return standard_flags_missing == 0;
105 std::map<std::string, unsigned int>::const_iterator it =
mapFlagNames.begin();
107 if (
flags & it->second) {
108 ret += it->first +
",";
112 return ret.substr(0,
ret.size() - 1);
119 const std::map<COutPoint, int64_t>& map_prevout_values,
unsigned int flags,
122 bool tx_valid =
true;
124 for (
unsigned int i = 0; i < tx.
vin.size() && tx_valid; ++i) {
126 const CAmount amount = map_prevout_values.count(input.
prevout) ? map_prevout_values.at(input.
prevout) : 0;
131 BOOST_ERROR(
"Bad test: " << strTest);
135 BOOST_CHECK_MESSAGE(tx_valid, strTest);
141 BOOST_CHECK_MESSAGE(!tx_valid, strTest);
144 return (tx_valid == expect_valid);
181 std::set<unsigned int> flags_combos;
183 const unsigned int flags_excluding_one =
TrimFlags(
flags & ~(pair.second));
184 if (
flags != flags_excluding_one) {
185 flags_combos.insert(flags_excluding_one);
195 BOOST_CHECK_MESSAGE(
CheckMapFlagNames(),
"mapFlagNames is missing a script verification flag");
199 for (
unsigned int idx = 0; idx < tests.
size(); idx++) {
201 std::string strTest = test.
write();
202 if (test[0].isArray())
206 BOOST_ERROR(
"Bad test: " << strTest);
210 std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
211 std::map<COutPoint, int64_t> mapprevOutValues;
214 for (
unsigned int inpIdx = 0; inpIdx < inputs.
size(); inpIdx++) {
215 const UniValue& input = inputs[inpIdx];
221 if (vinput.
size() < 3 || vinput.
size() > 4)
227 mapprevOutScriptPubKeys[outpoint] =
ParseScript(vinput[2].get_str());
228 if (vinput.
size() >= 4)
230 mapprevOutValues[outpoint] = vinput[3].
getInt<int64_t>();
235 BOOST_ERROR(
"Bad test: " << strTest);
239 std::string transaction = test[1].
get_str();
251 if (~verify_flags !=
FillFlags(~verify_flags)) {
252 BOOST_ERROR(
"Bad test flags: " << strTest);
255 BOOST_CHECK_MESSAGE(
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues, ~verify_flags, txdata, strTest,
true),
256 "Tx unexpectedly failed: " << strTest);
262 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues,
flags, txdata, strTest,
true)) {
263 BOOST_ERROR(
"Tx unexpectedly failed with flag " <<
name <<
" unset: " << strTest);
267 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues,
flags, txdata, strTest,
true)) {
268 BOOST_ERROR(
"Tx unexpectedly failed with random flags " <<
ToString(
flags) <<
": " << strTest);
274 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues, ~flags_excluding_one, txdata, strTest,
false)) {
275 BOOST_ERROR(
"Too many flags unset: " << strTest);
287 for (
unsigned int idx = 0; idx < tests.
size(); idx++) {
289 std::string strTest = test.
write();
290 if (test[0].isArray())
294 BOOST_ERROR(
"Bad test: " << strTest);
298 std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
299 std::map<COutPoint, int64_t> mapprevOutValues;
302 for (
unsigned int inpIdx = 0; inpIdx < inputs.
size(); inpIdx++) {
303 const UniValue& input = inputs[inpIdx];
309 if (vinput.
size() < 3 || vinput.
size() > 4)
315 mapprevOutScriptPubKeys[outpoint] =
ParseScript(vinput[2].get_str());
316 if (vinput.
size() >= 4)
318 mapprevOutValues[outpoint] = vinput[3].
getInt<int64_t>();
323 BOOST_ERROR(
"Bad test: " << strTest);
327 std::string transaction = test[1].
get_str();
333 BOOST_CHECK_MESSAGE(test[2].get_str() ==
"BADTX", strTest);
341 if (verify_flags !=
FillFlags(verify_flags)) {
342 BOOST_ERROR(
"Bad test flags: " << strTest);
346 BOOST_CHECK_MESSAGE(
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues, verify_flags, txdata, strTest,
false),
347 "Tx unexpectedly passed: " << strTest);
353 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues,
flags, txdata, strTest,
false)) {
354 BOOST_ERROR(
"Tx unexpectedly passed with flag " <<
name <<
" set: " << strTest);
358 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues,
flags, txdata, strTest,
false)) {
359 BOOST_ERROR(
"Tx unexpectedly passed with random flags " <<
name <<
": " << strTest);
365 if (!
CheckTxScripts(tx, mapprevOutScriptPubKeys, mapprevOutValues, flags_excluding_one, txdata, strTest,
true)) {
366 BOOST_ERROR(
"Too many flags set: " << strTest);
384 auto createTransaction =[](
size_t payloadSize) {
387 tx.
vout.emplace_back(1,
CScript() << OP_RETURN << std::vector<unsigned char>(payloadSize));
393 auto maxPayloadSize = maxTransactionSize - oversizedTransactionBaseSize;
403 BOOST_CHECK_MESSAGE(!
CheckTransaction(createTransaction(maxPayloadSize), state),
"Oversized transaction should be invalid");
411 unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
412 std::vector<unsigned char> vch(ch, ch +
sizeof(ch) -1);
420 tx.
vin.push_back(tx.
vin[0]);
429 std::vector<CMutableTransaction> dummyTransactions =
434 t1.vin[0].prevout.hash = dummyTransactions[0].GetHash();
435 t1.vin[0].prevout.n = 1;
436 t1.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
437 t1.vin[1].prevout.hash = dummyTransactions[1].GetHash();
438 t1.vin[1].prevout.n = 0;
439 t1.vin[1].scriptSig << std::vector<unsigned char>(65, 0) << std::vector<unsigned char>(33, 4);
440 t1.vin[2].prevout.hash = dummyTransactions[1].GetHash();
441 t1.vin[2].prevout.n = 1;
442 t1.vin[2].scriptSig << std::vector<unsigned char>(65, 0) << std::vector<unsigned char>(33, 4);
444 t1.vout[0].nValue = 90*
CENT;
445 t1.vout[0].scriptPubKey <<
OP_1;
454 outputm.
vin.resize(1);
455 outputm.
vin[0].prevout.SetNull();
457 outputm.
vout.resize(1);
458 outputm.
vout[0].nValue = 1;
459 outputm.
vout[0].scriptPubKey = outscript;
463 assert(output->vin.size() == 1);
464 assert(output->vin[0] == outputm.
vin[0]);
465 assert(output->vout.size() == 1);
470 inputm.
vin.resize(1);
471 inputm.
vin[0].prevout.hash = output->GetHash();
472 inputm.
vin[0].prevout.n = 0;
473 inputm.
vout.resize(1);
474 inputm.
vout[0].nValue = 1;
486 assert(input.
vin[0].scriptWitness.stack == inputm.
vin[0].scriptWitness.stack);
503 }
else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
505 }
else if (v.size() == 1 && v[0] == 0x81) {
516 std::vector<valtype> stack;
519 stack.back() = std::vector<unsigned char>(redeemScript.
begin(), redeemScript.
end());
534 std::vector<int> sigHashes;
543 for(uint32_t ij = 0; ij < 4500; ij++) {
544 uint32_t i = mtx.
vin.size();
547 mtx.
vin.resize(mtx.
vin.size() + 1);
548 mtx.
vin[i].prevout = outpoint;
551 mtx.
vout.resize(mtx.
vout.size() + 1);
552 mtx.
vout[i].nValue = 1000;
557 for(uint32_t i = 0; i < mtx.
vin.size(); i++) {
559 bool hashSigned =
SignSignature(keystore, scriptPubKey, mtx, i, 1000, sigHashes.at(i % sigHashes.size()), empty);
572 std::vector<Coin> coins;
573 for(uint32_t i = 0; i < mtx.
vin.size(); i++) {
584 for(uint32_t i = 0; i < mtx.
vin.size(); i++) {
585 std::vector<CScriptCheck> vChecks;
587 control.
Add(std::move(vChecks));
590 bool controlCheck = control.
Wait();
620 CScript scriptPubkey1, scriptPubkey2, scriptPubkey1L, scriptPubkey2L, scriptMulti;
625 std::vector<CPubKey> oneandthree;
626 oneandthree.push_back(pubkey1);
627 oneandthree.push_back(pubkey3);
634 CScript destination_script_1, destination_script_2, destination_script_1L, destination_script_2L, destination_script_multi;
786 std::vector<CMutableTransaction> dummyTransactions =
791 t.vin[0].prevout.hash = dummyTransactions[0].GetHash();
792 t.vin[0].prevout.n = 1;
793 t.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
795 t.vout[0].nValue = 90*
CENT;
799 constexpr
auto CheckIsStandard = [](
const auto&
t) {
804 constexpr
auto CheckIsNotStandard = [](
const auto&
t,
const std::string& reason_in) {
816 t.vout[0].nValue = nDustThreshold - 1;
817 CheckIsNotStandard(
t,
"dust");
819 t.vout[0].nValue = nDustThreshold;
823 t.version = std::numeric_limits<uint32_t>::max();
824 CheckIsNotStandard(
t,
"version");
827 CheckIsNotStandard(
t,
"version");
830 CheckIsNotStandard(
t,
"version");
843 t.vout[0].nValue = 674 - 1;
844 CheckIsNotStandard(
t,
"dust");
846 t.vout[0].nValue = 674;
851 CheckIsNotStandard(
t,
"scriptpubkey");
854 t.vout[0].scriptPubKey =
CScript() <<
OP_RETURN <<
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
859 t.vout[0].scriptPubKey =
CScript() <<
OP_RETURN <<
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3800");
861 CheckIsNotStandard(
t,
"scriptpubkey");
871 t.vout[0].scriptPubKey =
CScript() <<
OP_RETURN << 0 <<
ParseHex(
"01") << 2 <<
ParseHex(
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
876 CheckIsNotStandard(
t,
"scriptpubkey");
885 t.vout[0].scriptPubKey =
CScript() <<
OP_RETURN <<
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
886 t.vout[0].nValue = 0;
887 t.vout[1].scriptPubKey =
CScript() <<
OP_RETURN <<
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
888 t.vout[1].nValue = 0;
889 CheckIsNotStandard(
t,
"multi-op-return");
891 t.vout[0].scriptPubKey =
CScript() <<
OP_RETURN <<
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
893 CheckIsNotStandard(
t,
"multi-op-return");
897 CheckIsNotStandard(
t,
"multi-op-return");
904 t.vin[0].scriptSig =
CScript() << std::vector<unsigned char>(1647, 0);
907 t.vin[0].scriptSig =
CScript() << std::vector<unsigned char>(1648, 0);
908 CheckIsNotStandard(
t,
"scriptsig-size");
913 << std::vector<unsigned char>(75, 0)
914 << std::vector<unsigned char>(235, 0)
915 << std::vector<unsigned char>(1234, 0)
919 const std::vector<unsigned char> non_push_ops = {
924 while (pc <
t.vin[0].scriptSig.end()) {
927 t.vin[0].scriptSig.GetOp(pc, opcode);
932 int index = prev_pc -
t.vin[0].scriptSig.begin();
933 unsigned char orig_op = *prev_pc;
935 for (
auto op : non_push_ops) {
936 t.vin[0].scriptSig[index] = op;
937 CheckIsNotStandard(
t,
"scriptsig-not-pushonly");
939 t.vin[0].scriptSig[index] = orig_op;
946 t.vout[0].scriptPubKey =
CScript() << OP_RETURN << std::vector<unsigned char>(19, 0);
956 t.vout[0].scriptPubKey =
CScript() << OP_RETURN << std::vector<unsigned char>(20, 0);
958 CheckIsNotStandard(
t,
"tx-size");
964 t.vin[0].scriptSig =
CScript() << std::vector<unsigned char>(65, 0);
968 CheckIsNotStandard(
t,
"bare-multisig");
973 t.vout[0].nValue = 576;
975 t.vout[0].nValue = 575;
976 CheckIsNotStandard(
t,
"dust");
980 t.vout[0].nValue = 672;
982 t.vout[0].nValue = 671;
983 CheckIsNotStandard(
t,
"dust");
987 t.vout[0].nValue = 546;
989 t.vout[0].nValue = 545;
990 CheckIsNotStandard(
t,
"dust");
993 t.vout[0].scriptPubKey =
CScript() << OP_HASH160 << std::vector<unsigned char>(20, 0) <<
OP_EQUAL;
994 t.vout[0].nValue = 540;
996 t.vout[0].nValue = 539;
997 CheckIsNotStandard(
t,
"dust");
1000 t.vout[0].scriptPubKey =
CScript() << OP_0 << std::vector<unsigned char>(20, 0);
1001 t.vout[0].nValue = 294;
1003 t.vout[0].nValue = 293;
1004 CheckIsNotStandard(
t,
"dust");
1007 t.vout[0].scriptPubKey =
CScript() << OP_0 << std::vector<unsigned char>(32, 0);
1008 t.vout[0].nValue = 330;
1010 t.vout[0].nValue = 329;
1011 CheckIsNotStandard(
t,
"dust");
1014 t.vout[0].scriptPubKey =
CScript() << OP_1 << std::vector<unsigned char>(32, 0);
1015 t.vout[0].nValue = 330;
1017 t.vout[0].nValue = 329;
1018 CheckIsNotStandard(
t,
"dust");
1021 for (
int op =
OP_1; op <=
OP_16; op += 1) {
1022 t.vout[0].scriptPubKey =
CScript() << (
opcodetype)op << std::vector<unsigned char>(2, 0);
1023 t.vout[0].nValue = 240;
1026 t.vout[0].nValue = 239;
1027 CheckIsNotStandard(
t,
"dust");
1036 "000000000000000000000000000000000000000000000000000000000000abcd");
std::vector< unsigned char > valtype
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
static constexpr CAmount MAX_MONEY
No amount larger than this (in satoshi) is valid.
int64_t CAmount
Amount in satoshis (Can be negative)
#define Assert(val)
Identity function.
RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before co...
void Add(std::vector< T > &&vChecks)
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Abstract view on the open txout dataset.
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
An encapsulated private key.
CPubKey GetPubKey() const
Compute the public key from a private key.
A reference to a CKey: the Hash160 of its serialized public key.
An outpoint - a combination of a transaction hash and an index n into its vout.
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.
static opcodetype EncodeOP_N(int n)
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
const std::vector< CTxIn > vin
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
CTxOut out
unspent transaction output
uint32_t nHeight
at which height this containing transaction was included in the active block chain
unsigned int fCoinBase
whether containing transaction was a coinbase
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 AddCScript(const CScript &redeemScript)
A signature creator for transactions.
Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction ...
const std::string & get_str() const
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
const UniValue & get_array() const
std::string GetRejectReason() const
constexpr unsigned char * end()
constexpr unsigned char * begin()
void emplace_back(Args &&... args)
static int32_t GetTransactionWeight(const CTransaction &tx)
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const int WITNESS_SCALE_FACTOR
CScript ParseScript(const std::string &s)
BOOST_AUTO_TEST_SUITE_END()
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)
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
@ SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_SIGPUSHONLY
@ SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS
@ SCRIPT_VERIFY_CONST_SCRIPTCODE
@ SCRIPT_VERIFY_MINIMALIF
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION
@ SCRIPT_VERIFY_STRICTENC
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE
@ SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_MINIMALDATA
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ ASSERT_FAIL
Abort execution through assertion failure (for consensus code)
UniValue read_json(const std::string &jsondata)
CKey GenerateRandomKey(bool compressed) noexcept
std::vector< std::string > SplitString(std::string_view str, char sep)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs to mitigate two potential denial-of-service attacks:
bool IsStandardTx(const CTransaction &tx, const std::optional< unsigned > &max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate &dust_relay_fee, std::string &reason)
Check for standard transaction types.
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize.
static constexpr decltype(CTransaction::version) TX_MAX_STANDARD_VERSION
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
static constexpr TransactionSerParams TX_NO_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
std::shared_ptr< const CTransaction > CTransactionRef
std::vector< unsigned char > ToByteVector(const T &in)
opcodetype
Script opcodes.
std::string ScriptErrorString(const ScriptError serror)
enum ScriptError_t ScriptError
@ SCRIPT_ERR_UNKNOWN_ERROR
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)
constexpr deserialize_type deserialize
static constexpr CAmount CENT
static constexpr size_t DEFAULT_SIGNATURE_CACHE_BYTES
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
void UpdateInput(CTxIn &input, const SignatureData &data)
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
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).
const SigningProvider & DUMMY_SIGNING_PROVIDER
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
A mutable version of CTransaction.
std::vector< CTxOut > vout
void MergeSignatureData(SignatureData sigdata)
static uint64_t InsecureRandBits(int bits)
bool IsValidFlagCombination(unsigned flags)
Flags that are not forbidden by an assert in script validation.
Txid TxidFromString(std::string_view str)
DEPRECATED due to missing length-check and hex-check, please use the safer FromHex,...
SignatureData CombineSignatures(const CMutableTransaction &input1, const CMutableTransaction &input2, const CTransactionRef tx)
static void CheckWithFlag(const CTransactionRef &output, const CMutableTransaction &input, uint32_t flags, bool success)
unsigned int FillFlags(unsigned int flags)
std::vector< unsigned char > valtype
BOOST_AUTO_TEST_CASE(tx_valid)
unsigned int ParseScriptFlags(std::string strFlags)
static void ReplaceRedeemScript(CScript &script, const CScript &redeemScript)
std::string FormatScriptFlags(unsigned int flags)
static void CreateCreditAndSpend(const FillableSigningProvider &keystore, const CScript &outscript, CTransactionRef &output, CMutableTransaction &input, bool success=true)
std::set< unsigned int > ExcludeIndividualFlags(unsigned int flags)
static CScript PushAll(const std::vector< valtype > &values)
static std::map< std::string, unsigned int > mapFlagNames
bool CheckTxScripts(const CTransaction &tx, const std::map< COutPoint, CScript > &map_prevout_scriptPubKeys, const std::map< COutPoint, int64_t > &map_prevout_values, unsigned int flags, const PrecomputedTransactionData &txdata, const std::string &strTest, bool expect_valid)
unsigned int TrimFlags(unsigned int flags)
std::vector< CMutableTransaction > SetupDummyInputs(FillableSigningProvider &keystoreRet, CCoinsViewCache &coinsRet, const std::array< CAmount, 4 > &nValues)
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)