mirror of https://github.com/bitcoin/bitcoin.git
Merge bitcoin/bitcoin#31981: Add checkBlock() to Mining interface
a18e572328test: more template verification tests (Sjors Provoost)10c908808ftest: move gbt proposal mode tests to new file (Sjors Provoost)94959b8deeAdd checkBlock to Mining interface (Sjors Provoost)6077157531ipc: drop BlockValidationState special handling (Sjors Provoost)74690f4ed8validation: refactor TestBlockValidity (Sjors Provoost) Pull request description: This PR adds the IPC equivalent of the `getblocktemplate` RPC in `proposal` mode. In order to do so it has `TestBlockValidity` return error reasons as a string instead of `BlockValidationState`. This avoids complexity in IPC code for handling the latter struct. The new Mining interface method is used in `miner_tests`. It's not used by the `getblocktemplate` and `generateblock` RPC calls, see https://github.com/bitcoin/bitcoin/pull/31981#discussion_r2096473337 The `inconclusive-not-best-prevblk` check is moved from RPC code to `TestBlockValidity`. Test coverage is increased by `mining_template_verification.py`. Superseedes #31564 ## Background ### Verifying block templates (no PoW) Stratum v2 allows miners to generate their own block template. Pools may wish (or need) to verify these templates. This typically involves comparing mempools, asking miners to providing missing transactions and then reconstructing the proposed block.[^0] This is not sufficient to ensure a proposed block is actually valid. In some schemes miners could take advantage of incomplete validation[^1]. The Stratum Reference Implementation (SRI), currently the only Stratum v2 implementation, collects all missing mempool transactions, but does not yet fully verify the block.[^2]. It could use the `getblocktemplate` RPC in `proposal` mode, but using IPC is more performant, as it avoids serialising up to 4 MB of transaction data as JSON. (although SRI could use this PR, the Template Provider role doesn't need it, so this is _not_ part of #31098) [^0]: https://github.com/stratum-mining/sv2-spec/blob/main/06-Job-Declaration-Protocol.md [^1]: https://delvingbitcoin.org/t/pplns-with-job-declaration/1099/45?u=sjors [^2]: https://github.com/stratum-mining/stratum/blob/v1.1.0/roles/jd-server/src/lib/job_declarator/message_handler.rs#L196 ACKs for top commit: davidgumberg: reACKa18e572328achow101: ACKa18e572328TheCharlatan: ACKa18e572328ryanofsky: Code review ACKa18e572328just adding another NONFATAL_UNREACHABLE since last review Tree-SHA512: 1a6c29f45a1666114f10f55aed155980b90104db27761c78aada4727ce3129e6ae7a522d90a56314bd767bd7944dfa46e85fb9f714370fc83e6a585be7b044f1
This commit is contained in:
Ava Chow
commit
9a7eece5a4
|
|
@ -114,6 +114,21 @@ public:
|
|||
*/
|
||||
virtual std::unique_ptr<BlockTemplate> createNewBlock(const node::BlockCreateOptions& options = {}) = 0;
|
||||
|
||||
/**
|
||||
* Checks if a given block is valid.
|
||||
*
|
||||
* @param[in] block the block to check
|
||||
* @param[in] options verification options: the proof-of-work check can be
|
||||
* skipped in order to verify a template generated by
|
||||
* external software.
|
||||
* @param[out] reason failure reason (BIP22)
|
||||
* @param[out] debug more detailed rejection reason
|
||||
* @returns whether the block is valid
|
||||
*
|
||||
* For signets the challenge verification is skipped when check_pow is false.
|
||||
*/
|
||||
virtual bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) = 0;
|
||||
|
||||
//! Get internal node context. Useful for RPC and testing,
|
||||
//! but not accessible across processes.
|
||||
virtual node::NodeContext* context() { return nullptr; }
|
||||
|
|
|
|||
|
|
@ -14,13 +14,7 @@
|
|||
#include <validation.h>
|
||||
|
||||
namespace mp {
|
||||
// Custom serialization for BlockValidationState.
|
||||
void CustomBuildMessage(InvokeContext& invoke_context,
|
||||
const BlockValidationState& src,
|
||||
ipc::capnp::messages::BlockValidationState::Builder&& builder);
|
||||
void CustomReadMessage(InvokeContext& invoke_context,
|
||||
const ipc::capnp::messages::BlockValidationState::Reader& reader,
|
||||
BlockValidationState& dest);
|
||||
// Custom serializations
|
||||
} // namespace mp
|
||||
|
||||
#endif // BITCOIN_IPC_CAPNP_MINING_TYPES_H
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ interface Mining $Proxy.wrap("interfaces::Mining") {
|
|||
getTip @2 (context :Proxy.Context) -> (result: Common.BlockRef, hasResult: Bool);
|
||||
waitTipChanged @3 (context :Proxy.Context, currentTip: Data, timeout: Float64) -> (result: Common.BlockRef);
|
||||
createNewBlock @4 (options: BlockCreateOptions) -> (result: BlockTemplate);
|
||||
checkBlock @5 (block: Data, options: BlockCheckOptions) -> (reason: Text, debug: Text, result: Bool);
|
||||
}
|
||||
|
||||
interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
|
||||
|
|
@ -45,12 +46,7 @@ struct BlockWaitOptions $Proxy.wrap("node::BlockWaitOptions") {
|
|||
feeThreshold @1 : Int64 $Proxy.name("fee_threshold");
|
||||
}
|
||||
|
||||
# Note: serialization of the BlockValidationState C++ type is somewhat fragile
|
||||
# and using the struct can be awkward. It would be good if testBlockValidity
|
||||
# method were changed to return validity information in a simpler format.
|
||||
struct BlockValidationState {
|
||||
mode @0 :Int32;
|
||||
result @1 :Int32;
|
||||
rejectReason @2 :Text;
|
||||
debugMessage @3 :Text;
|
||||
struct BlockCheckOptions $Proxy.wrap("node::BlockCheckOptions") {
|
||||
checkMerkleRoot @0 :Bool $Proxy.name("check_merkle_root");
|
||||
checkPow @1 :Bool $Proxy.name("check_pow");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,40 +8,4 @@
|
|||
#include <mp/proxy-types.h>
|
||||
|
||||
namespace mp {
|
||||
void CustomBuildMessage(InvokeContext& invoke_context,
|
||||
const BlockValidationState& src,
|
||||
ipc::capnp::messages::BlockValidationState::Builder&& builder)
|
||||
{
|
||||
if (src.IsValid()) {
|
||||
builder.setMode(0);
|
||||
} else if (src.IsInvalid()) {
|
||||
builder.setMode(1);
|
||||
} else if (src.IsError()) {
|
||||
builder.setMode(2);
|
||||
} else {
|
||||
assert(false);
|
||||
}
|
||||
builder.setResult(static_cast<int>(src.GetResult()));
|
||||
builder.setRejectReason(src.GetRejectReason());
|
||||
builder.setDebugMessage(src.GetDebugMessage());
|
||||
}
|
||||
|
||||
void CustomReadMessage(InvokeContext& invoke_context,
|
||||
const ipc::capnp::messages::BlockValidationState::Reader& reader,
|
||||
BlockValidationState& dest)
|
||||
{
|
||||
if (reader.getMode() == 0) {
|
||||
assert(reader.getResult() == 0);
|
||||
assert(reader.getRejectReason().size() == 0);
|
||||
assert(reader.getDebugMessage().size() == 0);
|
||||
} else if (reader.getMode() == 1) {
|
||||
dest.Invalid(static_cast<BlockValidationResult>(reader.getResult()), reader.getRejectReason(), reader.getDebugMessage());
|
||||
} else if (reader.getMode() == 2) {
|
||||
assert(reader.getResult() == 0);
|
||||
dest.Error(reader.getRejectReason());
|
||||
assert(reader.getDebugMessage().size() == 0);
|
||||
} else {
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
} // namespace mp
|
||||
|
|
|
|||
|
|
@ -984,6 +984,15 @@ public:
|
|||
return std::make_unique<BlockTemplateImpl>(assemble_options, BlockAssembler{chainman().ActiveChainstate(), context()->mempool.get(), assemble_options}.CreateNewBlock(), m_node);
|
||||
}
|
||||
|
||||
bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) override
|
||||
{
|
||||
LOCK(chainman().GetMutex());
|
||||
BlockValidationState state{TestBlockValidity(chainman().ActiveChainstate(), block, /*check_pow=*/options.check_pow, /*=check_merkle_root=*/options.check_merkle_root)};
|
||||
reason = state.GetRejectReason();
|
||||
debug = state.GetDebugMessage();
|
||||
return state.IsValid();
|
||||
}
|
||||
|
||||
NodeContext* context() override { return &m_node; }
|
||||
ChainstateManager& chainman() { return *Assert(m_node.chainman); }
|
||||
KernelNotifications& notifications() { return *Assert(m_node.notifications); }
|
||||
|
|
|
|||
|
|
@ -179,10 +179,10 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
|
|||
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
|
||||
pblock->nNonce = 0;
|
||||
|
||||
BlockValidationState state;
|
||||
if (m_options.test_block_validity && !TestBlockValidity(state, chainparams, m_chainstate, *pblock, pindexPrev,
|
||||
/*fCheckPOW=*/false, /*fCheckMerkleRoot=*/false)) {
|
||||
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString()));
|
||||
if (m_options.test_block_validity) {
|
||||
if (BlockValidationState state{TestBlockValidity(m_chainstate, *pblock, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
|
||||
throw std::runtime_error(strprintf("TestBlockValidity failed: %s", state.ToString()));
|
||||
}
|
||||
}
|
||||
const auto time_2{SteadyClock::now()};
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
#include <cstddef>
|
||||
#include <policy/policy.h>
|
||||
#include <script/script.h>
|
||||
#include <uint256.h>
|
||||
#include <util/time.h>
|
||||
|
||||
namespace node {
|
||||
|
|
@ -85,6 +86,17 @@ struct BlockWaitOptions {
|
|||
CAmount fee_threshold{MAX_MONEY};
|
||||
};
|
||||
|
||||
struct BlockCheckOptions {
|
||||
/**
|
||||
* Set false to omit the merkle root check
|
||||
*/
|
||||
bool check_merkle_root{true};
|
||||
|
||||
/**
|
||||
* Set false to omit the proof-of-work check
|
||||
*/
|
||||
bool check_pow{true};
|
||||
};
|
||||
} // namespace node
|
||||
|
||||
#endif // BITCOIN_NODE_TYPES_H
|
||||
|
|
|
|||
|
|
@ -388,8 +388,7 @@ static RPCHelpMan generateblock()
|
|||
block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
|
||||
RegenerateCommitments(block, chainman);
|
||||
|
||||
BlockValidationState state;
|
||||
if (!TestBlockValidity(state, chainman.GetParams(), chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), /*fCheckPOW=*/false, /*fCheckMerkleRoot=*/false)) {
|
||||
if (BlockValidationState state{TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
|
||||
throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
|
||||
}
|
||||
}
|
||||
|
|
@ -745,13 +744,7 @@ static RPCHelpMan getblocktemplate()
|
|||
return "duplicate-inconclusive";
|
||||
}
|
||||
|
||||
// TestBlockValidity only supports blocks built on the current Tip
|
||||
if (block.hashPrevBlock != tip) {
|
||||
return "inconclusive-not-best-prevblk";
|
||||
}
|
||||
BlockValidationState state;
|
||||
TestBlockValidity(state, chainman.GetParams(), chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), /*fCheckPOW=*/false, /*fCheckMerkleRoot=*/true);
|
||||
return BIP22ValidationResult(state);
|
||||
return BIP22ValidationResult(TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/true));
|
||||
}
|
||||
|
||||
const UniValue& aClientRules = oparam.find_value("rules");
|
||||
|
|
|
|||
|
|
@ -19,6 +19,5 @@ interface FooInterface $Proxy.wrap("FooImplementation") {
|
|||
passUniValue @2 (arg :Text) -> (result :Text);
|
||||
passTransaction @3 (arg :Data) -> (result :Data);
|
||||
passVectorChar @4 (arg :Data) -> (result :Data);
|
||||
passBlockState @5 (arg :Mining.BlockValidationState) -> (result :Mining.BlockValidationState);
|
||||
passScript @6 (arg :Data) -> (result :Data);
|
||||
passScript @5 (arg :Data) -> (result :Data);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -102,25 +102,6 @@ void IpcPipeTest()
|
|||
std::vector<char> vec2{foo->passVectorChar(vec1)};
|
||||
BOOST_CHECK_EQUAL(std::string_view(vec1.begin(), vec1.end()), std::string_view(vec2.begin(), vec2.end()));
|
||||
|
||||
BlockValidationState bs1;
|
||||
bs1.Invalid(BlockValidationResult::BLOCK_MUTATED, "reject reason", "debug message");
|
||||
BlockValidationState bs2{foo->passBlockState(bs1)};
|
||||
BOOST_CHECK_EQUAL(bs1.IsValid(), bs2.IsValid());
|
||||
BOOST_CHECK_EQUAL(bs1.IsError(), bs2.IsError());
|
||||
BOOST_CHECK_EQUAL(bs1.IsInvalid(), bs2.IsInvalid());
|
||||
BOOST_CHECK_EQUAL(static_cast<int>(bs1.GetResult()), static_cast<int>(bs2.GetResult()));
|
||||
BOOST_CHECK_EQUAL(bs1.GetRejectReason(), bs2.GetRejectReason());
|
||||
BOOST_CHECK_EQUAL(bs1.GetDebugMessage(), bs2.GetDebugMessage());
|
||||
|
||||
BlockValidationState bs3;
|
||||
BlockValidationState bs4{foo->passBlockState(bs3)};
|
||||
BOOST_CHECK_EQUAL(bs3.IsValid(), bs4.IsValid());
|
||||
BOOST_CHECK_EQUAL(bs3.IsError(), bs4.IsError());
|
||||
BOOST_CHECK_EQUAL(bs3.IsInvalid(), bs4.IsInvalid());
|
||||
BOOST_CHECK_EQUAL(static_cast<int>(bs3.GetResult()), static_cast<int>(bs4.GetResult()));
|
||||
BOOST_CHECK_EQUAL(bs3.GetRejectReason(), bs4.GetRejectReason());
|
||||
BOOST_CHECK_EQUAL(bs3.GetDebugMessage(), bs4.GetDebugMessage());
|
||||
|
||||
auto script1{CScript() << OP_11};
|
||||
auto script2{foo->passScript(script1)};
|
||||
BOOST_CHECK_EQUAL(HexStr(script1), HexStr(script2));
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include <util/translation.h>
|
||||
#include <validation.h>
|
||||
#include <versionbits.h>
|
||||
#include <pow.h>
|
||||
|
||||
#include <test/util/setup_common.h>
|
||||
|
||||
|
|
@ -666,7 +667,44 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
|||
CScript scriptPubKey = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
|
||||
BlockAssembler::Options options;
|
||||
options.coinbase_output_script = scriptPubKey;
|
||||
std::unique_ptr<BlockTemplate> block_template;
|
||||
|
||||
// Create and check a simple template
|
||||
std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options);
|
||||
BOOST_REQUIRE(block_template);
|
||||
{
|
||||
CBlock block{block_template->getBlock()};
|
||||
{
|
||||
std::string reason;
|
||||
std::string debug;
|
||||
BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = false}, reason, debug));
|
||||
BOOST_REQUIRE_EQUAL(reason, "bad-txnmrklroot");
|
||||
BOOST_REQUIRE_EQUAL(debug, "hashMerkleRoot mismatch");
|
||||
}
|
||||
|
||||
block.hashMerkleRoot = BlockMerkleRoot(block);
|
||||
|
||||
{
|
||||
std::string reason;
|
||||
std::string debug;
|
||||
BOOST_REQUIRE(mining->checkBlock(block, {.check_pow = false}, reason, debug));
|
||||
BOOST_REQUIRE_EQUAL(reason, "");
|
||||
BOOST_REQUIRE_EQUAL(debug, "");
|
||||
}
|
||||
|
||||
{
|
||||
// A block template does not have proof-of-work, but it might pass
|
||||
// verification by coincidence. Grind the nonce if needed:
|
||||
while (CheckProofOfWork(block.GetHash(), block.nBits, Assert(m_node.chainman)->GetParams().GetConsensus())) {
|
||||
block.nNonce++;
|
||||
}
|
||||
|
||||
std::string reason;
|
||||
std::string debug;
|
||||
BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = true}, reason, debug));
|
||||
BOOST_REQUIRE_EQUAL(reason, "high-hash");
|
||||
BOOST_REQUIRE_EQUAL(debug, "proof of work failed");
|
||||
}
|
||||
}
|
||||
|
||||
// We can't make transactions until we have inputs
|
||||
// Therefore, load 110 blocks :)
|
||||
|
|
|
|||
|
|
@ -4600,42 +4600,78 @@ MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef&
|
|||
return result;
|
||||
}
|
||||
|
||||
bool TestBlockValidity(BlockValidationState& state,
|
||||
const CChainParams& chainparams,
|
||||
Chainstate& chainstate,
|
||||
const CBlock& block,
|
||||
CBlockIndex* pindexPrev,
|
||||
bool fCheckPOW,
|
||||
bool fCheckMerkleRoot)
|
||||
|
||||
BlockValidationState TestBlockValidity(
|
||||
Chainstate& chainstate,
|
||||
const CBlock& block,
|
||||
const bool check_pow,
|
||||
const bool check_merkle_root)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
assert(pindexPrev && pindexPrev == chainstate.m_chain.Tip());
|
||||
CCoinsViewCache viewNew(&chainstate.CoinsTip());
|
||||
// Lock must be held throughout this function for two reasons:
|
||||
// 1. We don't want the tip to change during several of the validation steps
|
||||
// 2. To prevent a CheckBlock() race condition for fChecked, see ProcessNewBlock()
|
||||
AssertLockHeld(chainstate.m_chainman.GetMutex());
|
||||
|
||||
BlockValidationState state;
|
||||
CBlockIndex* tip{Assert(chainstate.m_chain.Tip())};
|
||||
|
||||
if (block.hashPrevBlock != *Assert(tip->phashBlock)) {
|
||||
state.Invalid({}, "inconclusive-not-best-prevblk");
|
||||
return state;
|
||||
}
|
||||
|
||||
// For signets CheckBlock() verifies the challenge iff fCheckPow is set.
|
||||
if (!CheckBlock(block, state, chainstate.m_chainman.GetConsensus(), /*fCheckPow=*/check_pow, /*fCheckMerkleRoot=*/check_merkle_root)) {
|
||||
// This should never happen, but belt-and-suspenders don't approve the
|
||||
// block if it does.
|
||||
if (state.IsValid()) NONFATAL_UNREACHABLE();
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* At this point ProcessNewBlock would call AcceptBlock(), but we
|
||||
* don't want to store the block or its header. Run individual checks
|
||||
* instead:
|
||||
* - skip AcceptBlockHeader() because:
|
||||
* - we don't want to update the block index
|
||||
* - we do not care about duplicates
|
||||
* - we already ran CheckBlockHeader() via CheckBlock()
|
||||
* - we already checked for prev-blk-not-found
|
||||
* - we know the tip is valid, so no need to check bad-prevblk
|
||||
* - we already ran CheckBlock()
|
||||
* - do run ContextualCheckBlockHeader()
|
||||
* - do run ContextualCheckBlock()
|
||||
*/
|
||||
|
||||
if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainstate.m_chainman, tip)) {
|
||||
if (state.IsValid()) NONFATAL_UNREACHABLE();
|
||||
return state;
|
||||
}
|
||||
|
||||
if (!ContextualCheckBlock(block, state, chainstate.m_chainman, tip)) {
|
||||
if (state.IsValid()) NONFATAL_UNREACHABLE();
|
||||
return state;
|
||||
}
|
||||
|
||||
// We don't want ConnectBlock to update the actual chainstate, so create
|
||||
// a cache on top of it, along with a dummy block index.
|
||||
CBlockIndex index_dummy{block};
|
||||
uint256 block_hash(block.GetHash());
|
||||
CBlockIndex indexDummy(block);
|
||||
indexDummy.pprev = pindexPrev;
|
||||
indexDummy.nHeight = pindexPrev->nHeight + 1;
|
||||
indexDummy.phashBlock = &block_hash;
|
||||
index_dummy.pprev = tip;
|
||||
index_dummy.nHeight = tip->nHeight + 1;
|
||||
index_dummy.phashBlock = &block_hash;
|
||||
CCoinsViewCache view_dummy(&chainstate.CoinsTip());
|
||||
|
||||
// NOTE: CheckBlockHeader is called by CheckBlock
|
||||
if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainstate.m_chainman, pindexPrev)) {
|
||||
LogError("%s: Consensus::ContextualCheckBlockHeader: %s\n", __func__, state.ToString());
|
||||
return false;
|
||||
// Set fJustCheck to true in order to update, and not clear, validation caches.
|
||||
if(!chainstate.ConnectBlock(block, state, &index_dummy, view_dummy, /*fJustCheck=*/true)) {
|
||||
if (state.IsValid()) NONFATAL_UNREACHABLE();
|
||||
return state;
|
||||
}
|
||||
if (!CheckBlock(block, state, chainparams.GetConsensus(), fCheckPOW, fCheckMerkleRoot)) {
|
||||
LogError("%s: Consensus::CheckBlock: %s\n", __func__, state.ToString());
|
||||
return false;
|
||||
}
|
||||
if (!ContextualCheckBlock(block, state, chainstate.m_chainman, pindexPrev)) {
|
||||
LogError("%s: Consensus::ContextualCheckBlock: %s\n", __func__, state.ToString());
|
||||
return false;
|
||||
}
|
||||
if (!chainstate.ConnectBlock(block, state, &indexDummy, viewNew, true)) {
|
||||
return false;
|
||||
}
|
||||
assert(state.IsValid());
|
||||
|
||||
return true;
|
||||
// Ensure no check returned successfully while also setting an invalid state.
|
||||
if (!state.IsValid()) NONFATAL_UNREACHABLE();
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
/* This function is called from the RPC code for pruneblockchain */
|
||||
|
|
|
|||
|
|
@ -384,14 +384,28 @@ public:
|
|||
/** Context-independent validity checks */
|
||||
bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
||||
|
||||
/** Check a block is completely valid from start to finish (only works on top of our current best block) */
|
||||
bool TestBlockValidity(BlockValidationState& state,
|
||||
const CChainParams& chainparams,
|
||||
Chainstate& chainstate,
|
||||
const CBlock& block,
|
||||
CBlockIndex* pindexPrev,
|
||||
bool fCheckPOW = true,
|
||||
bool fCheckMerkleRoot = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
/**
|
||||
* Verify a block, including transactions.
|
||||
*
|
||||
* @param[in] block The block we want to process. Must connect to the
|
||||
* current tip.
|
||||
* @param[in] chainstate The chainstate to connect to.
|
||||
* @param[in] check_pow perform proof-of-work check, nBits in the header
|
||||
* is always checked
|
||||
* @param[in] check_merkle_root check the merkle root
|
||||
*
|
||||
* @return Valid or Invalid state. This doesn't currently return an Error state,
|
||||
* and shouldn't unless there is something wrong with the existing
|
||||
* chainstate. (This is different from functions like AcceptBlock which
|
||||
* can fail trying to save new data.)
|
||||
*
|
||||
* For signets the challenge verification is skipped when check_pow is false.
|
||||
*/
|
||||
BlockValidationState TestBlockValidity(
|
||||
Chainstate& chainstate,
|
||||
const CBlock& block,
|
||||
bool check_pow,
|
||||
bool check_merkle_root) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
|
||||
|
||||
/** Check with the proof of work on each blockheader matches the value in nBits */
|
||||
bool HasValidProofOfWork(const std::vector<CBlockHeader>& headers, const Consensus::Params& consensusParams);
|
||||
|
|
|
|||
|
|
@ -5,8 +5,10 @@
|
|||
"""Test mining RPCs
|
||||
|
||||
- getmininginfo
|
||||
- getblocktemplate proposal mode
|
||||
- submitblock"""
|
||||
- getblocktemplate
|
||||
- submitblock
|
||||
|
||||
mining_template_verification.py tests getblocktemplate in proposal mode"""
|
||||
|
||||
import copy
|
||||
from decimal import Decimal
|
||||
|
|
@ -54,18 +56,6 @@ VERSIONBITS_TOP_BITS = 0x20000000
|
|||
VERSIONBITS_DEPLOYMENT_TESTDUMMY_BIT = 28
|
||||
DEFAULT_BLOCK_MIN_TX_FEE = 1000 # default `-blockmintxfee` setting [sat/kvB]
|
||||
|
||||
|
||||
def assert_template(node, block, expect, rehash=True):
|
||||
if rehash:
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
rsp = node.getblocktemplate(template_request={
|
||||
'data': block.serialize().hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
})
|
||||
assert_equal(rsp, expect)
|
||||
|
||||
|
||||
class MiningTest(BitcoinTestFramework):
|
||||
def set_test_params(self):
|
||||
self.num_nodes = 3
|
||||
|
|
@ -225,8 +215,13 @@ class MiningTest(BitcoinTestFramework):
|
|||
block.nBits = int(tmpl["bits"], 16)
|
||||
block.nNonce = 0
|
||||
block.vtx = [create_coinbase(height=int(tmpl["height"]))]
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
block.solve()
|
||||
assert_template(node, block, None)
|
||||
assert_equal(node.getblocktemplate(template_request={
|
||||
'data': block.serialize().hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
}), None)
|
||||
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nTime = t
|
||||
|
|
@ -376,12 +371,6 @@ class MiningTest(BitcoinTestFramework):
|
|||
self.wallet = MiniWallet(node)
|
||||
self.mine_chain()
|
||||
|
||||
def assert_submitblock(block, result_str_1, result_str_2=None):
|
||||
block.solve()
|
||||
result_str_2 = result_str_2 or 'duplicate-invalid'
|
||||
assert_equal(result_str_1, node.submitblock(hexdata=block.serialize().hex()))
|
||||
assert_equal(result_str_2, node.submitblock(hexdata=block.serialize().hex()))
|
||||
|
||||
self.log.info('getmininginfo')
|
||||
mining_info = node.getmininginfo()
|
||||
assert_equal(mining_info['blocks'], 200)
|
||||
|
|
@ -433,103 +422,24 @@ class MiningTest(BitcoinTestFramework):
|
|||
block.nBits = int(tmpl["bits"], 16)
|
||||
block.nNonce = 0
|
||||
block.vtx = [coinbase_tx]
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
|
||||
self.log.info("getblocktemplate: segwit rule must be set")
|
||||
assert_raises_rpc_error(-8, "getblocktemplate must be called with the segwit rule set", node.getblocktemplate, {})
|
||||
|
||||
self.log.info("getblocktemplate: Test valid block")
|
||||
assert_template(node, block, None)
|
||||
|
||||
self.log.info("submitblock: Test block decode failure")
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.submitblock, block.serialize()[:-15].hex())
|
||||
|
||||
self.log.info("getblocktemplate: Test bad input hash for coinbase transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx[0].vin[0].prevout.hash += 1
|
||||
assert_template(node, bad_block, 'bad-cb-missing')
|
||||
|
||||
self.log.info("submitblock: Test bad input hash for coinbase transaction")
|
||||
bad_block.solve()
|
||||
assert_equal("bad-cb-missing", node.submitblock(hexdata=bad_block.serialize().hex()))
|
||||
|
||||
self.log.info("submitblock: Test block with no transactions")
|
||||
no_tx_block = copy.deepcopy(block)
|
||||
no_tx_block.vtx.clear()
|
||||
no_tx_block.hashMerkleRoot = 0
|
||||
no_tx_block.solve()
|
||||
assert_equal("bad-blk-length", node.submitblock(hexdata=no_tx_block.serialize().hex()))
|
||||
|
||||
self.log.info("submitblock: Test empty block")
|
||||
assert_equal('high-hash', node.submitblock(hexdata=CBlock().serialize().hex()))
|
||||
|
||||
self.log.info("getblocktemplate: Test truncated final transaction")
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {
|
||||
'data': block.serialize()[:-1].hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
})
|
||||
|
||||
self.log.info("getblocktemplate: Test duplicate transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx.append(bad_block.vtx[0])
|
||||
assert_template(node, bad_block, 'bad-txns-duplicate')
|
||||
assert_submitblock(bad_block, 'bad-txns-duplicate', 'bad-txns-duplicate')
|
||||
|
||||
self.log.info("getblocktemplate: Test invalid transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_tx = copy.deepcopy(bad_block.vtx[0])
|
||||
bad_tx.vin[0].prevout.hash = 255
|
||||
bad_block.vtx.append(bad_tx)
|
||||
assert_template(node, bad_block, 'bad-txns-inputs-missingorspent')
|
||||
assert_submitblock(bad_block, 'bad-txns-inputs-missingorspent')
|
||||
|
||||
self.log.info("getblocktemplate: Test nonfinal transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx[0].nLockTime = 2**32 - 1
|
||||
assert_template(node, bad_block, 'bad-txns-nonfinal')
|
||||
assert_submitblock(bad_block, 'bad-txns-nonfinal')
|
||||
|
||||
self.log.info("getblocktemplate: Test bad tx count")
|
||||
# The tx count is immediately after the block header
|
||||
bad_block_sn = bytearray(block.serialize())
|
||||
assert_equal(bad_block_sn[BLOCK_HEADER_SIZE], 1)
|
||||
bad_block_sn[BLOCK_HEADER_SIZE] += 1
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {
|
||||
'data': bad_block_sn.hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
})
|
||||
|
||||
self.log.info("getblocktemplate: Test bad bits")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nBits = 469762303 # impossible in the real world
|
||||
assert_template(node, bad_block, 'bad-diffbits')
|
||||
|
||||
self.log.info("getblocktemplate: Test bad merkle root")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.hashMerkleRoot += 1
|
||||
assert_template(node, bad_block, 'bad-txnmrklroot', False)
|
||||
assert_submitblock(bad_block, 'bad-txnmrklroot', 'bad-txnmrklroot')
|
||||
|
||||
self.log.info("getblocktemplate: Test bad timestamps")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nTime = 2**32 - 1
|
||||
assert_template(node, bad_block, 'time-too-new')
|
||||
assert_submitblock(bad_block, 'time-too-new', 'time-too-new')
|
||||
bad_block.nTime = 0
|
||||
assert_template(node, bad_block, 'time-too-old')
|
||||
assert_submitblock(bad_block, 'time-too-old', 'time-too-old')
|
||||
|
||||
self.log.info("getblocktemplate: Test not best block")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.hashPrevBlock = 123
|
||||
assert_template(node, bad_block, 'inconclusive-not-best-prevblk')
|
||||
assert_submitblock(bad_block, 'prev-blk-not-found', 'prev-blk-not-found')
|
||||
|
||||
self.log.info('submitheader tests')
|
||||
assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='xx' * BLOCK_HEADER_SIZE))
|
||||
assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='ff' * (BLOCK_HEADER_SIZE-2)))
|
||||
assert_raises_rpc_error(-25, 'Must submit previous header', lambda: node.submitheader(hexdata=super(CBlock, bad_block).serialize().hex()))
|
||||
|
||||
missing_ancestor_block = copy.deepcopy(block)
|
||||
missing_ancestor_block.hashPrevBlock = 123
|
||||
assert_raises_rpc_error(-25, 'Must submit previous header', lambda: node.submitheader(hexdata=super(CBlock, missing_ancestor_block).serialize().hex()))
|
||||
|
||||
block.nTime += 1
|
||||
block.solve()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,302 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2024-Present The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test getblocktemplate RPC in proposal mode
|
||||
|
||||
Generate several blocks and test them against the getblocktemplate RPC.
|
||||
"""
|
||||
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
import copy
|
||||
|
||||
from test_framework.blocktools import (
|
||||
create_block,
|
||||
create_coinbase,
|
||||
add_witness_commitment,
|
||||
)
|
||||
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
assert_raises_rpc_error,
|
||||
)
|
||||
|
||||
from test_framework.messages import (
|
||||
BLOCK_HEADER_SIZE,
|
||||
uint256_from_compact,
|
||||
)
|
||||
|
||||
from test_framework.wallet import (
|
||||
MiniWallet,
|
||||
)
|
||||
|
||||
def assert_template(node, block, expect, *, rehash=True, submit=True, solve=True, expect_submit=None):
|
||||
if rehash:
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
|
||||
rsp = node.getblocktemplate(template_request={
|
||||
'data': block.serialize().hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
})
|
||||
assert_equal(rsp, expect)
|
||||
# Only attempt to submit invalid templates
|
||||
if submit and expect is not None:
|
||||
# submitblock runs checks in a different order, so may not return
|
||||
# the same error
|
||||
if expect_submit is None:
|
||||
expect_submit = expect
|
||||
if solve:
|
||||
block.solve()
|
||||
assert_equal(node.submitblock(block.serialize().hex()), expect_submit)
|
||||
|
||||
class MiningTemplateVerificationTest(BitcoinTestFramework):
|
||||
|
||||
def set_test_params(self):
|
||||
self.num_nodes = 1
|
||||
|
||||
def valid_block_test(self, node, block):
|
||||
self.log.info("Valid block")
|
||||
assert_template(node, block, None)
|
||||
|
||||
def cb_missing_test(self, node, block):
|
||||
self.log.info("Bad input hash for coinbase transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx[0].vin[0].prevout.hash += 1
|
||||
assert_template(node, bad_block, 'bad-cb-missing')
|
||||
|
||||
def block_without_transactions_test(self, node, block):
|
||||
self.log.info("Block with no transactions")
|
||||
|
||||
no_tx_block = copy.deepcopy(block)
|
||||
no_tx_block.vtx.clear()
|
||||
no_tx_block.hashMerkleRoot = 0
|
||||
no_tx_block.solve()
|
||||
assert_template(node, no_tx_block, 'bad-blk-length', rehash=False)
|
||||
|
||||
def truncated_final_transaction_test(self, node, block):
|
||||
self.log.info("Truncated final transaction")
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate,
|
||||
template_request={
|
||||
"data": block.serialize()[:-1].hex(),
|
||||
"mode": "proposal",
|
||||
"rules": ["segwit"],
|
||||
}
|
||||
)
|
||||
|
||||
def duplicate_transaction_test(self, node, block):
|
||||
self.log.info("Duplicate transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx.append(bad_block.vtx[0])
|
||||
assert_template(node, bad_block, 'bad-txns-duplicate')
|
||||
|
||||
def thin_air_spending_test(self, node, block):
|
||||
self.log.info("Transaction that spends from thin air")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_tx = copy.deepcopy(bad_block.vtx[0])
|
||||
bad_tx.vin[0].prevout.hash = 255
|
||||
bad_block.vtx.append(bad_tx)
|
||||
assert_template(node, bad_block, 'bad-txns-inputs-missingorspent')
|
||||
|
||||
def non_final_transaction_test(self, node, block):
|
||||
self.log.info("Non-final transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.vtx[0].nLockTime = 2**32 - 1
|
||||
assert_template(node, bad_block, 'bad-txns-nonfinal')
|
||||
|
||||
def bad_tx_count_test(self, node, block):
|
||||
self.log.info("Bad tx count")
|
||||
# The tx count is immediately after the block header
|
||||
bad_block_sn = bytearray(block.serialize())
|
||||
assert_equal(bad_block_sn[BLOCK_HEADER_SIZE], 1)
|
||||
bad_block_sn[BLOCK_HEADER_SIZE] += 1
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {
|
||||
'data': bad_block_sn.hex(),
|
||||
'mode': 'proposal',
|
||||
'rules': ['segwit'],
|
||||
})
|
||||
|
||||
def nbits_test(self, node, block):
|
||||
self.log.info("Extremely high nBits")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nBits = 469762303 # impossible in the real world
|
||||
assert_template(node, bad_block, "bad-diffbits", solve=False, expect_submit="high-hash")
|
||||
|
||||
self.log.info("Lowering nBits should make the block invalid")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nBits -= 1
|
||||
assert_template(node, bad_block, "bad-diffbits")
|
||||
|
||||
def merkle_root_test(self, node, block):
|
||||
self.log.info("Bad merkle root")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.hashMerkleRoot += 1
|
||||
assert_template(node, bad_block, 'bad-txnmrklroot', rehash=False)
|
||||
|
||||
def bad_timestamp_test(self, node, block):
|
||||
self.log.info("Bad timestamps")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.nTime = 2**32 - 1
|
||||
assert_template(node, bad_block, 'time-too-new')
|
||||
bad_block.nTime = 0
|
||||
assert_template(node, bad_block, 'time-too-old')
|
||||
|
||||
def current_tip_test(self, node, block):
|
||||
self.log.info("Block must build on the current tip")
|
||||
bad_block = copy.deepcopy(block)
|
||||
bad_block.hashPrevBlock = 123
|
||||
bad_block.solve()
|
||||
|
||||
assert_template(node, bad_block, "inconclusive-not-best-prevblk", expect_submit="prev-blk-not-found")
|
||||
|
||||
def pow_test(self, node, block):
|
||||
'''Modifies block with the generated PoW'''
|
||||
self.log.info("Generate a block")
|
||||
target = uint256_from_compact(block.nBits)
|
||||
# Ensure that it doesn't meet the target by coincidence
|
||||
while block.sha256 <= target:
|
||||
block.nNonce += 1
|
||||
block.rehash()
|
||||
self.log.debug("Found a nonce")
|
||||
|
||||
self.log.info("A block template doesn't need PoW")
|
||||
assert_template(node, block, None)
|
||||
|
||||
self.log.info("Add proof of work")
|
||||
block.solve()
|
||||
assert_template(node, block, None)
|
||||
|
||||
def submit_test(self, node, block_0_height, block):
|
||||
self.log.info("getblocktemplate call in previous tests did not submit the block")
|
||||
assert_equal(node.getblockcount(), block_0_height + 1)
|
||||
|
||||
self.log.info("Submitting this block should succeed")
|
||||
assert_equal(node.submitblock(block.serialize().hex()), None)
|
||||
node.waitforblockheight(2)
|
||||
|
||||
def transaction_test(self, node, block_0_height, tx):
|
||||
self.log.info("make block template with a transaction")
|
||||
|
||||
block_1 = node.getblock(node.getblockhash(block_0_height + 1))
|
||||
block_2_hash = node.getblockhash(block_0_height + 2)
|
||||
|
||||
block_3 = create_block(
|
||||
int(block_2_hash, 16),
|
||||
create_coinbase(block_0_height + 3),
|
||||
block_1["mediantime"] + 1,
|
||||
txlist=[tx["hex"]],
|
||||
)
|
||||
assert_equal(len(block_3.vtx), 2)
|
||||
add_witness_commitment(block_3)
|
||||
block_3.solve()
|
||||
assert_template(node, block_3, None)
|
||||
|
||||
self.log.info("checking block validity did not update the UTXO set")
|
||||
# Call again to ensure the UTXO set wasn't updated
|
||||
assert_template(node, block_3, None)
|
||||
|
||||
def overspending_transaction_test(self, node, block_0_height, tx):
|
||||
self.log.info("Add an transaction that spends too much")
|
||||
|
||||
block_1 = node.getblock(node.getblockhash(block_0_height + 1))
|
||||
block_2_hash = node.getblockhash(block_0_height + 2)
|
||||
|
||||
bad_tx = copy.deepcopy(tx)
|
||||
bad_tx["tx"].vout[0].nValue = 10000000000
|
||||
bad_tx_hex = bad_tx["tx"].serialize().hex()
|
||||
assert_equal(
|
||||
node.testmempoolaccept([bad_tx_hex])[0]["reject-reason"],
|
||||
"bad-txns-in-belowout",
|
||||
)
|
||||
block_3 = create_block(
|
||||
int(block_2_hash, 16),
|
||||
create_coinbase(block_0_height + 3),
|
||||
block_1["mediantime"] + 1,
|
||||
txlist=[bad_tx_hex],
|
||||
)
|
||||
assert_equal(len(block_3.vtx), 2)
|
||||
add_witness_commitment(block_3)
|
||||
block_3.solve()
|
||||
|
||||
assert_template(node, block_3, "bad-txns-in-belowout")
|
||||
|
||||
def spend_twice_test(self, node, block_0_height, tx):
|
||||
block_1 = node.getblock(node.getblockhash(block_0_height + 1))
|
||||
block_2_hash = node.getblockhash(block_0_height + 2)
|
||||
|
||||
self.log.info("Can't spend coins twice")
|
||||
tx_hex = tx["tx"].serialize().hex()
|
||||
tx_2 = copy.deepcopy(tx)
|
||||
tx_2_hex = tx_2["tx"].serialize().hex()
|
||||
# Nothing wrong with these transactions individually
|
||||
assert_equal(node.testmempoolaccept([tx_hex])[0]["allowed"], True)
|
||||
assert_equal(node.testmempoolaccept([tx_2_hex])[0]["allowed"], True)
|
||||
# But can't be combined
|
||||
assert_equal(
|
||||
node.testmempoolaccept([tx_hex, tx_2_hex])[0]["package-error"],
|
||||
"package-contains-duplicates",
|
||||
)
|
||||
block_3 = create_block(
|
||||
int(block_2_hash, 16),
|
||||
create_coinbase(block_0_height + 3),
|
||||
block_1["mediantime"] + 1,
|
||||
txlist=[tx_hex, tx_2_hex],
|
||||
)
|
||||
assert_equal(len(block_3.vtx), 3)
|
||||
add_witness_commitment(block_3)
|
||||
|
||||
assert_template(node, block_3, "bad-txns-inputs-missingorspent", submit=False)
|
||||
|
||||
return block_3
|
||||
|
||||
def parallel_test(self, node, block_3):
|
||||
# Ensure that getblocktemplate can be called concurrently by many threads.
|
||||
self.log.info("Check blocks in parallel")
|
||||
check_50_blocks = lambda n: [
|
||||
assert_template(n, block_3, "bad-txns-inputs-missingorspent", submit=False)
|
||||
for _ in range(50)
|
||||
]
|
||||
rpcs = [node.cli for _ in range(6)]
|
||||
with ThreadPoolExecutor(max_workers=len(rpcs)) as threads:
|
||||
list(threads.map(check_50_blocks, rpcs))
|
||||
|
||||
def run_test(self):
|
||||
node = self.nodes[0]
|
||||
|
||||
block_0_height = node.getblockcount()
|
||||
self.generate(node, sync_fun=self.no_op, nblocks=1)
|
||||
block_1 = node.getblock(node.getbestblockhash())
|
||||
block_2 = create_block(
|
||||
int(block_1["hash"], 16),
|
||||
create_coinbase(block_0_height + 2),
|
||||
block_1["mediantime"] + 1,
|
||||
)
|
||||
|
||||
self.valid_block_test(node, block_2)
|
||||
self.cb_missing_test(node, block_2)
|
||||
self.block_without_transactions_test(node, block_2)
|
||||
self.truncated_final_transaction_test(node, block_2)
|
||||
self.duplicate_transaction_test(node, block_2)
|
||||
self.thin_air_spending_test(node, block_2)
|
||||
self.non_final_transaction_test(node, block_2)
|
||||
self.bad_tx_count_test(node, block_2)
|
||||
self.nbits_test(node, block_2)
|
||||
self.merkle_root_test(node, block_2)
|
||||
self.bad_timestamp_test(node, block_2)
|
||||
self.current_tip_test(node, block_2)
|
||||
# This sets the PoW for the next test
|
||||
self.pow_test(node, block_2)
|
||||
self.submit_test(node, block_0_height, block_2)
|
||||
|
||||
self.log.info("Generate a transaction")
|
||||
tx = MiniWallet(node).create_self_transfer()
|
||||
|
||||
self.transaction_test(node, block_0_height, tx)
|
||||
self.overspending_transaction_test(node, block_0_height, tx)
|
||||
block_3 = self.spend_twice_test(node, block_0_height, tx)
|
||||
self.parallel_test(node, block_3)
|
||||
|
||||
if __name__ == "__main__":
|
||||
MiningTemplateVerificationTest(__file__).main()
|
||||
|
|
@ -209,6 +209,7 @@ BASE_SCRIPTS = [
|
|||
'rpc_decodescript.py',
|
||||
'rpc_blockchain.py --v1transport',
|
||||
'rpc_blockchain.py --v2transport',
|
||||
'mining_template_verification.py',
|
||||
'rpc_deprecated.py',
|
||||
'wallet_disable.py',
|
||||
'wallet_change_address.py',
|
||||
|
|
|
|||
Loading…
Reference in New Issue