You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
163 lines
7.1 KiB
163 lines
7.1 KiB
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2019 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_CONSENSUS_VALIDATION_H
|
|
#define BITCOIN_CONSENSUS_VALIDATION_H
|
|
|
|
#include <string>
|
|
#include <version.h>
|
|
#include <consensus/consensus.h>
|
|
#include <primitives/transaction.h>
|
|
#include <primitives/block.h>
|
|
|
|
/** A "reason" why a transaction was invalid, suitable for determining whether the
|
|
* provider of the transaction should be banned/ignored/disconnected/etc.
|
|
*/
|
|
enum class TxValidationResult {
|
|
TX_RESULT_UNSET, //!< initial value. Tx has not yet been rejected
|
|
TX_CONSENSUS, //!< invalid by consensus rules
|
|
/**
|
|
* Invalid by a change to consensus rules more recent than SegWit.
|
|
* Currently unused as there are no such consensus rule changes, and any download
|
|
* sources realistically need to support SegWit in order to provide useful data,
|
|
* so differentiating between always-invalid and invalid-by-pre-SegWit-soft-fork
|
|
* is uninteresting.
|
|
*/
|
|
TX_RECENT_CONSENSUS_CHANGE,
|
|
TX_NOT_STANDARD, //!< didn't meet our local policy rules
|
|
TX_MISSING_INPUTS, //!< transaction was missing some of its inputs
|
|
TX_PREMATURE_SPEND, //!< transaction spends a coinbase too early, or violates locktime/sequence locks
|
|
/**
|
|
* Transaction might be missing a witness, have a witness prior to SegWit
|
|
* activation, or witness may have been malleated (which includes
|
|
* non-standard witnesses).
|
|
*/
|
|
TX_WITNESS_MUTATED,
|
|
/**
|
|
* Tx already in mempool or conflicts with a tx in the chain
|
|
* (if it conflicts with another tx in mempool, we use MEMPOOL_POLICY as it failed to reach the RBF threshold)
|
|
* Currently this is only used if the transaction already exists in the mempool or on chain.
|
|
*/
|
|
TX_CONFLICT,
|
|
TX_MEMPOOL_POLICY, //!< violated mempool's fee/size/descendant/RBF/etc limits
|
|
};
|
|
|
|
/** A "reason" why a block was invalid, suitable for determining whether the
|
|
* provider of the block should be banned/ignored/disconnected/etc.
|
|
* These are much more granular than the rejection codes, which may be more
|
|
* useful for some other use-cases.
|
|
*/
|
|
enum class BlockValidationResult {
|
|
BLOCK_RESULT_UNSET, //!< initial value. Block has not yet been rejected
|
|
BLOCK_CONSENSUS, //!< invalid by consensus rules (excluding any below reasons)
|
|
/**
|
|
* Invalid by a change to consensus rules more recent than SegWit.
|
|
* Currently unused as there are no such consensus rule changes, and any download
|
|
* sources realistically need to support SegWit in order to provide useful data,
|
|
* so differentiating between always-invalid and invalid-by-pre-SegWit-soft-fork
|
|
* is uninteresting.
|
|
*/
|
|
BLOCK_RECENT_CONSENSUS_CHANGE,
|
|
BLOCK_CACHED_INVALID, //!< this block was cached as being invalid and we didn't store the reason why
|
|
BLOCK_INVALID_HEADER, //!< invalid proof of work or time too old
|
|
BLOCK_MUTATED, //!< the block's data didn't match the data committed to by the PoW
|
|
BLOCK_MISSING_PREV, //!< We don't have the previous block the checked one is built on
|
|
BLOCK_INVALID_PREV, //!< A block this one builds on is invalid
|
|
BLOCK_TIME_FUTURE, //!< block timestamp was > 2 hours in the future (or our clock is bad)
|
|
BLOCK_CHECKPOINT, //!< the block failed to meet one of our checkpoints
|
|
};
|
|
|
|
|
|
|
|
/** Base class for capturing information about block/transaction validation. This is subclassed
|
|
* by TxValidationState and BlockValidationState for validation information on transactions
|
|
* and blocks respectively. */
|
|
class ValidationState {
|
|
private:
|
|
enum mode_state {
|
|
MODE_VALID, //!< everything ok
|
|
MODE_INVALID, //!< network rule violation (DoS value may be set)
|
|
MODE_ERROR, //!< run-time error
|
|
} m_mode;
|
|
std::string m_reject_reason;
|
|
std::string m_debug_message;
|
|
protected:
|
|
void Invalid(const std::string &reject_reason="",
|
|
const std::string &debug_message="")
|
|
{
|
|
m_reject_reason = reject_reason;
|
|
m_debug_message = debug_message;
|
|
if (m_mode != MODE_ERROR) m_mode = MODE_INVALID;
|
|
}
|
|
public:
|
|
// ValidationState is abstract. Have a pure virtual destructor.
|
|
virtual ~ValidationState() = 0;
|
|
|
|
ValidationState() : m_mode(MODE_VALID) {}
|
|
bool Error(const std::string& reject_reason)
|
|
{
|
|
if (m_mode == MODE_VALID)
|
|
m_reject_reason = reject_reason;
|
|
m_mode = MODE_ERROR;
|
|
return false;
|
|
}
|
|
bool IsValid() const { return m_mode == MODE_VALID; }
|
|
bool IsInvalid() const { return m_mode == MODE_INVALID; }
|
|
bool IsError() const { return m_mode == MODE_ERROR; }
|
|
std::string GetRejectReason() const { return m_reject_reason; }
|
|
std::string GetDebugMessage() const { return m_debug_message; }
|
|
};
|
|
|
|
inline ValidationState::~ValidationState() {};
|
|
|
|
class TxValidationState : public ValidationState {
|
|
private:
|
|
TxValidationResult m_result = TxValidationResult::TX_RESULT_UNSET;
|
|
public:
|
|
bool Invalid(TxValidationResult result,
|
|
const std::string &reject_reason="",
|
|
const std::string &debug_message="")
|
|
{
|
|
m_result = result;
|
|
ValidationState::Invalid(reject_reason, debug_message);
|
|
return false;
|
|
}
|
|
TxValidationResult GetResult() const { return m_result; }
|
|
};
|
|
|
|
class BlockValidationState : public ValidationState {
|
|
private:
|
|
BlockValidationResult m_result = BlockValidationResult::BLOCK_RESULT_UNSET;
|
|
public:
|
|
bool Invalid(BlockValidationResult result,
|
|
const std::string &reject_reason="",
|
|
const std::string &debug_message="") {
|
|
m_result = result;
|
|
ValidationState::Invalid(reject_reason, debug_message);
|
|
return false;
|
|
}
|
|
BlockValidationResult GetResult() const { return m_result; }
|
|
};
|
|
|
|
// These implement the weight = (stripped_size * 4) + witness_size formula,
|
|
// using only serialization with and without witness data. As witness_size
|
|
// is equal to total_size - stripped_size, this formula is identical to:
|
|
// weight = (stripped_size * 3) + total_size.
|
|
static inline int64_t GetTransactionWeight(const CTransaction& tx)
|
|
{
|
|
return ::GetSerializeSize(tx, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(tx, PROTOCOL_VERSION);
|
|
}
|
|
static inline int64_t GetBlockWeight(const CBlock& block)
|
|
{
|
|
return ::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(block, PROTOCOL_VERSION);
|
|
}
|
|
static inline int64_t GetTransactionInputWeight(const CTxIn& txin)
|
|
{
|
|
// scriptWitness size is added here because witnesses and txins are split up in segwit serialization.
|
|
return ::GetSerializeSize(txin, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(txin, PROTOCOL_VERSION) + ::GetSerializeSize(txin.scriptWitness.stack, PROTOCOL_VERSION);
|
|
}
|
|
|
|
#endif // BITCOIN_CONSENSUS_VALIDATION_H
|