diff --git a/src/consensus/tx_check.cpp b/src/consensus/tx_check.cpp
--- a/src/consensus/tx_check.cpp
+++ b/src/consensus/tx_check.cpp
@@ -14,38 +14,39 @@
                                    CValidationState &state) {
     // Basic checks that don't depend on any context
     if (tx.vin.empty()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-txns-vin-empty");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-vin-empty");
     }
 
     if (tx.vout.empty()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-txns-vout-empty");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-vout-empty");
     }
 
     // Size limit
     if (::GetSerializeSize(tx, PROTOCOL_VERSION) > MAX_TX_SIZE) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-txns-oversize");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-oversize");
     }
 
     // Check for negative or overflow output values
     Amount nValueOut = Amount::zero();
     for (const auto &txout : tx.vout) {
         if (txout.nValue < Amount::zero()) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-vout-negative");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-txns-vout-negative");
         }
 
         if (txout.nValue > MAX_MONEY) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-vout-toolarge");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-txns-vout-toolarge");
         }
 
         nValueOut += txout.nValue;
         if (!MoneyRange(nValueOut)) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-txouttotal-toolarge");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID,
+                                 "bad-txns-txouttotal-toolarge");
         }
     }
 
@@ -54,9 +55,9 @@
 
 bool CheckCoinbase(const CTransaction &tx, CValidationState &state) {
     if (!tx.IsCoinBase()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-cb-missing", false,
-                         "first tx is not coinbase");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-cb-missing",
+                             "first tx is not coinbase");
     }
 
     if (!CheckTransactionCommon(tx, state)) {
@@ -66,8 +67,8 @@
 
     if (tx.vin[0].scriptSig.size() < 2 ||
         tx.vin[0].scriptSig.size() > MAX_COINBASE_SCRIPTSIG_SIZE) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-cb-length");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-cb-length");
     }
 
     return true;
@@ -75,8 +76,8 @@
 
 bool CheckRegularTransaction(const CTransaction &tx, CValidationState &state) {
     if (tx.IsCoinBase()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                         REJECT_INVALID, "bad-tx-coinbase");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-tx-coinbase");
     }
 
     if (!CheckTransactionCommon(tx, state)) {
@@ -87,13 +88,13 @@
     std::unordered_set<COutPoint, SaltedOutpointHasher> vInOutPoints;
     for (const auto &txin : tx.vin) {
         if (txin.prevout.IsNull()) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-prevout-null");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-txns-prevout-null");
         }
 
         if (!vInOutPoints.insert(txin.prevout).second) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-inputs-duplicate");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-txns-inputs-duplicate");
         }
     }
 
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -44,13 +44,16 @@
     if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) {
         // While this is only one transaction, we use txns in the error to
         // ensure continuity with other clients.
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-nonfinal", false, "non-final transaction");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-nonfinal",
+                             "non-final transaction");
     }
 
     if (IsMagneticAnomalyEnabled(params, nHeight)) {
         // Size limit
         if (::GetSerializeSize(tx, PROTOCOL_VERSION) < MIN_TX_SIZE) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-undersize");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-txns-undersize");
         }
     }
 
@@ -157,7 +160,9 @@
                    Amount &txfee) {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
-        return state.DoS(0, ValidationInvalidReason::TX_MISSING_INPUTS, false, REJECT_INVALID, "bad-txns-inputs-missingorspent", false, strprintf("%s: inputs missing/spent", __func__));
+        return state.Invalid(ValidationInvalidReason::TX_MISSING_INPUTS, false,
+                             REJECT_INVALID, "bad-txns-inputs-missingorspent",
+                             strprintf("%s: inputs missing/spent", __func__));
     }
 
     Amount nValueIn = Amount::zero();
@@ -169,25 +174,36 @@
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase() &&
             nSpendHeight - coin.GetHeight() < COINBASE_MATURITY) {
-            return state.DoS(0, ValidationInvalidReason::TX_MISSING_INPUTS, false, REJECT_INVALID, "bad-txns-premature-spend-of-coinbase", false, strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.GetHeight()));
+            return state.Invalid(
+                ValidationInvalidReason::TX_MISSING_INPUTS, false,
+                REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",
+                strprintf("tried to spend coinbase at depth %d",
+                          nSpendHeight - coin.GetHeight()));
         }
 
         // Check for negative or overflow input values
         nValueIn += coin.GetTxOut().nValue;
         if (!MoneyRange(coin.GetTxOut().nValue) || !MoneyRange(nValueIn)) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-inputvalues-outofrange");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID,
+                                 "bad-txns-inputvalues-outofrange");
         }
     }
 
     const Amount value_out = tx.GetValueOut();
     if (nValueIn < value_out) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-in-belowout", false, strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-in-belowout",
+                             strprintf("value in (%s) < value out (%s)",
+                                       FormatMoney(nValueIn),
+                                       FormatMoney(value_out)));
     }
 
     // Tally transaction fees
     const Amount txfee_aux = nValueIn - value_out;
     if (!MoneyRange(txfee_aux)) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-txns-fee-outofrange");
     }
 
     txfee = txfee_aux;
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -363,7 +363,8 @@
     // Rather not work on nonstandard transactions (unless -testnet)
     std::string reason;
     if (fRequireStandard && !IsStandardTx(tx, reason)) {
-        return state.DoS(0, ValidationInvalidReason::TX_NOT_STANDARD, false, REJECT_NONSTANDARD, reason);
+        return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD, false,
+                             REJECT_NONSTANDARD, reason);
     }
 
     // Only accept nLockTime-using transactions that can be mined in the next
@@ -374,7 +375,9 @@
             consensusParams, tx, ctxState, STANDARD_LOCKTIME_VERIFY_FLAGS)) {
         // We copy the state from a dummy to ensure we don't increase the
         // ban score of peer for transaction that could be valid in the future.
-        return state.DoS(0, ValidationInvalidReason::TX_NOT_STANDARD, false, REJECT_NONSTANDARD, ctxState.GetRejectReason(), ctxState.CorruptionPossible(), ctxState.GetDebugMessage());
+        return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD, false,
+                             REJECT_NONSTANDARD, ctxState.GetRejectReason(),
+                             ctxState.GetDebugMessage());
     }
 
     // Is it already in the memory pool?
@@ -453,7 +456,8 @@
         // own.
         if (!CheckSequenceLocks(pool, tx, STANDARD_LOCKTIME_VERIFY_FLAGS,
                                 &lp)) {
-            return state.DoS(0, ValidationInvalidReason::TX_NOT_STANDARD, false, REJECT_NONSTANDARD, "non-BIP68-final");
+            return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD,
+                                 false, REJECT_NONSTANDARD, "non-BIP68-final");
         }
 
         Amount nFees = Amount::zero();
@@ -496,7 +500,9 @@
         // Do not change this to use virtualsize without coordinating a network
         // policy upgrade.
         if (!bypass_limits && nModifiedFees < minRelayTxFee.GetFee(nSize)) {
-            return state.DoS(0, ValidationInvalidReason::TX_MEMPOOL_POLICY, false, REJECT_INSUFFICIENTFEE, "min relay fee not met");
+            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
+                                 false, REJECT_INSUFFICIENTFEE,
+                                 "min relay fee not met");
         }
 
         if (nAbsurdFee != Amount::zero() && nFees > nAbsurdFee) {
@@ -528,7 +534,10 @@
                 .GetFee(nVirtualSize);
         if (!bypass_limits && mempoolRejectFee > Amount::zero() &&
             nModifiedFees < mempoolRejectFee) {
-            return state.DoS(0, ValidationInvalidReason::TX_MEMPOOL_POLICY, false, REJECT_INSUFFICIENTFEE, "mempool min fee not met", false, strprintf("%d < %d", nModifiedFees, mempoolRejectFee));
+            return state.Invalid(
+                ValidationInvalidReason::TX_MEMPOOL_POLICY, false,
+                REJECT_INSUFFICIENTFEE, "mempool min fee not met",
+                strprintf("%d < %d", nModifiedFees, mempoolRejectFee));
         }
 
         // Calculate in-mempool ancestors, up to a limit.
@@ -548,7 +557,9 @@
         if (!pool.CalculateMemPoolAncestors(
                 entry, setAncestors, nLimitAncestors, nLimitAncestorSize,
                 nLimitDescendants, nLimitDescendantSize, errString)) {
-            return state.DoS(0, ValidationInvalidReason::TX_MEMPOOL_POLICY, false, REJECT_NONSTANDARD, "too-long-mempool-chain", false, errString);
+            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
+                                 false, REJECT_NONSTANDARD,
+                                 "too-long-mempool-chain", errString);
         }
 
         // Check again against the next block's script verification flags
@@ -599,7 +610,9 @@
                 std::chrono::hours{
                     gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});
             if (!pool.exists(txid)) {
-                return state.DoS(0, ValidationInvalidReason::TX_MEMPOOL_POLICY, false, REJECT_INSUFFICIENTFEE, "mempool full");
+                return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
+                                     false, REJECT_INSUFFICIENTFEE,
+                                     "mempool full");
             }
         }
     }
@@ -1037,7 +1050,8 @@
         if (!txLimitSigChecks.consume_and_check(nSigChecksOut) ||
             (pBlockLimitSigChecks &&
              !pBlockLimitSigChecks->consume_and_check(nSigChecksOut))) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "too-many-sigchecks");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "too-many-sigchecks");
         }
         return true;
     }
@@ -1094,7 +1108,10 @@
             // careful thought should be taken as to the correct behavior - we
             // may want to continue peering with non-upgraded nodes even after
             // soft-fork super-majority signaling has occurred.
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(scriptError)));
+            return state.Invalid(
+                ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID,
+                strprintf("mandatory-script-verify-flag-failed (%s)",
+                          ScriptErrorString(scriptError)));
         }
 
         nSigChecksTotal += check.GetScriptExecutionMetrics().nSigChecks;
@@ -1606,7 +1623,10 @@
         for (const auto &tx : block.vtx) {
             for (size_t o = 0; o < tx->vout.size(); o++) {
                 if (view.HaveCoin(COutPoint(tx->GetId(), o))) {
-                    return state.DoS(100, ValidationInvalidReason::CONSENSUS, error("ConnectBlock(): tried to overwrite transaction"), REJECT_INVALID, "bad-txns-BIP30");
+                    return state.Invalid(
+                        ValidationInvalidReason::CONSENSUS,
+                        error("ConnectBlock(): tried to overwrite transaction"),
+                        REJECT_INVALID, "bad-txns-BIP30");
                 }
             }
         }
@@ -1662,7 +1682,10 @@
         // disk, and older versions may have saved a weird block.
         // - its checks are not applied to pre-CTOR chains, which we might visit
         // with checkpointing off.
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, error("ConnectBlock(): tried to overwrite transaction"), REJECT_INVALID, "tx-duplicate");
+        return state.Invalid(
+            ValidationInvalidReason::CONSENSUS,
+            error("ConnectBlock(): tried to overwrite transaction"),
+            REJECT_INVALID, "tx-duplicate");
     }
 
     size_t txIndex = 0;
@@ -1679,14 +1702,20 @@
                 // CheckTxInputs may return MISSING_INPUTS but we can't return
                 // that, as it's not defined for a block, so we reset the reason
                 // flag to CONSENSUS here.
-                state.DoS(100, ValidationInvalidReason::CONSENSUS, false, state.GetRejectCode(), state.GetRejectReason(), state.CorruptionPossible(), state.GetDebugMessage());
+                state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                              state.GetRejectCode(), state.GetRejectReason(),
+                              state.GetDebugMessage());
             }
             return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
                          tx.GetId().ToString(), FormatStateMessage(state));
         }
         nFees += txfee;
         if (!MoneyRange(nFees)) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, error("%s: accumulated fee in the block out of range.", __func__), REJECT_INVALID, "bad-txns-accumulated-fee-outofrange");
+            return state.Invalid(
+                ValidationInvalidReason::CONSENSUS,
+                error("%s: accumulated fee in the block out of range.",
+                      __func__),
+                REJECT_INVALID, "bad-txns-accumulated-fee-outofrange");
         }
 
         // The following checks do not apply to the coinbase.
@@ -1703,7 +1732,10 @@
         }
 
         if (!SequenceLocks(tx, nLockTimeFlags, &prevheights, *pindex)) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, error("%s: contains a non-BIP68-final transaction", __func__), REJECT_INVALID, "bad-txns-nonfinal");
+            return state.Invalid(
+                ValidationInvalidReason::CONSENSUS,
+                error("%s: contains a non-BIP68-final transaction", __func__),
+                REJECT_INVALID, "bad-txns-nonfinal");
         }
 
         // Don't cache results if we're actually connecting blocks (still
@@ -1733,7 +1765,9 @@
                 // event of a future soft-fork, we may need to consider whether
                 // rewriting to CONSENSUS or RECENT_CONSENSUS_CHANGE would be
                 // more appropriate.
-                state.DoS(100 - state.GetDoS(), ValidationInvalidReason::CONSENSUS, false, state.GetRejectCode(), state.GetRejectReason(), state.CorruptionPossible(), state.GetDebugMessage());
+                state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                              state.GetRejectCode(), state.GetRejectReason(),
+                              state.GetDebugMessage());
             }
             return error("ConnectBlock(): CheckInputs on %s failed with %s",
                          tx.GetId().ToString(), FormatStateMessage(state));
@@ -1763,7 +1797,11 @@
     Amount blockReward =
         nFees + GetBlockSubsidy(pindex->nHeight, consensusParams);
     if (block.vtx[0]->GetValueOut() > blockReward) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, error("ConnectBlock(): coinbase pays too much ""(actual=%d vs limit=%d)", block.vtx[0]->GetValueOut(), blockReward), REJECT_INVALID, "bad-cb-amount");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS,
+                             error("ConnectBlock(): coinbase pays too much "
+                                   "(actual=%d vs limit=%d)",
+                                   block.vtx[0]->GetValueOut(), blockReward),
+                             REJECT_INVALID, "bad-cb-amount");
     }
 
     const std::vector<CTxDestination> whitelist =
@@ -1790,13 +1828,16 @@
         }
 
         // We did not find an output that match the miner fund requirements.
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-minerfund");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-cb-minerfund");
     }
 
 MinerFundSuccess:
 
     if (!control.Wait()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "blk-bad-inputs", false, "parallel script check failed");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "blk-bad-inputs",
+                             "parallel script check failed");
     }
 
     int64_t nTime4 = GetTimeMicros();
@@ -2200,7 +2241,12 @@
 
     // Check that the request is consistent with current finalization.
     if (pindexFinalized && !AreOnTheSameFork(pindex, pindexFinalized)) {
-        return state.DoS(20, ValidationInvalidReason::BLOCK_FINALIZATION, error("%s: Trying to finalize block %s which conflicts ""with already finalized block", __func__, pindex->GetBlockHash().ToString()), REJECT_AGAINST_FINALIZED, "bad-fork-prior-finalized");
+        return state.Invalid(
+            ValidationInvalidReason::BLOCK_FINALIZATION,
+            error("%s: Trying to finalize block %s which conflicts "
+                  "with already finalized block",
+                  __func__, pindex->GetBlockHash().ToString()),
+            REJECT_AGAINST_FINALIZED, "bad-fork-prior-finalized");
     }
 
     if (IsBlockFinalized(pindex)) {
@@ -3367,7 +3413,9 @@
     // Check proof of work matches claimed amount
     if (validationOptions.shouldValidatePoW() &&
         !CheckProofOfWork(block.GetHash(), block.nBits, params)) {
-        return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "high-hash", false, "proof of work failed");
+        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
+                             false, REJECT_INVALID, "high-hash",
+                             "proof of work failed");
     }
 
     return true;
@@ -3392,14 +3440,18 @@
         bool mutated;
         uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
         if (block.hashMerkleRoot != hashMerkleRoot2) {
-            return state.DoS(100, ValidationInvalidReason::BLOCK_MUTATED, false, REJECT_INVALID, "bad-txnmrklroot", true, "hashMerkleRoot mismatch");
+            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false,
+                                 REJECT_INVALID, "bad-txnmrklroot",
+                                 "hashMerkleRoot mismatch");
         }
 
         // Check for merkle tree malleability (CVE-2012-2459): repeating
         // sequences of transactions in a block without affecting the merkle
         // root of a block, while still invalidating it.
         if (mutated) {
-            return state.DoS(100, ValidationInvalidReason::BLOCK_MUTATED, false, REJECT_INVALID, "bad-txns-duplicate", true, "duplicate transaction");
+            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false,
+                                 REJECT_INVALID, "bad-txns-duplicate",
+                                 "duplicate transaction");
         }
     }
 
@@ -3409,7 +3461,9 @@
 
     // First transaction must be coinbase.
     if (block.vtx.empty()) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-missing", false, "first tx is not coinbase");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-cb-missing",
+                             "first tx is not coinbase");
     }
 
     // Size limits.
@@ -3417,12 +3471,16 @@
 
     // Bail early if there is no way this block is of reasonable size.
     if ((block.vtx.size() * MIN_TRANSACTION_SIZE) > nMaxBlockSize) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-blk-length", false, "size limits failed");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-blk-length",
+                             "size limits failed");
     }
 
     auto currentBlockSize = ::GetSerializeSize(block, PROTOCOL_VERSION);
     if (currentBlockSize > nMaxBlockSize) {
-        return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-blk-length", false, "size limits failed");
+        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                             REJECT_INVALID, "bad-blk-length",
+                             "size limits failed");
     }
 
     // And a valid coinbase.
@@ -3478,7 +3536,9 @@
     if (block.nBits !=
         GetNextWorkRequired(pindexPrev, &block, consensusParams)) {
         LogPrintf("bad bits after height: %d\n", pindexPrev->nHeight);
-        return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "bad-diffbits", false, "incorrect proof of work");
+        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
+                             false, REJECT_INVALID, "bad-diffbits",
+                             "incorrect proof of work");
     }
 
     // Check against checkpoints
@@ -3488,7 +3548,11 @@
         // Check that the block chain matches the known block chain up to a
         // checkpoint.
         if (!Checkpoints::CheckBlock(checkpoints, nHeight, block.GetHash())) {
-            return state.DoS(100, ValidationInvalidReason::BLOCK_CHECKPOINT, error("%s: rejected by checkpoint lock-in at %d", __func__, nHeight), REJECT_CHECKPOINT, "checkpoint mismatch");
+            return state.Invalid(
+                ValidationInvalidReason::BLOCK_CHECKPOINT,
+                error("%s: rejected by checkpoint lock-in at %d", __func__,
+                      nHeight),
+                REJECT_CHECKPOINT, "checkpoint mismatch");
         }
 
         // Don't accept any forks from the main chain prior to last checkpoint.
@@ -3496,13 +3560,19 @@
         // in our MapBlockIndex.
         CBlockIndex *pcheckpoint = Checkpoints::GetLastCheckpoint(checkpoints);
         if (pcheckpoint && nHeight < pcheckpoint->nHeight) {
-            return state.DoS(100, ValidationInvalidReason::BLOCK_CHECKPOINT, error("%s: forked chain older than last checkpoint (height %d)", __func__, nHeight), REJECT_CHECKPOINT, "bad-fork-prior-to-checkpoint");
+            return state.Invalid(
+                ValidationInvalidReason::BLOCK_CHECKPOINT,
+                error("%s: forked chain older than last checkpoint (height %d)",
+                      __func__, nHeight),
+                REJECT_CHECKPOINT, "bad-fork-prior-to-checkpoint");
         }
     }
 
     // Check timestamp against prev
     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) {
-        return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "time-too-old", false, "block's timestamp is too early");
+        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
+                             false, REJECT_INVALID, "time-too-old",
+                             "block's timestamp is too early");
     }
 
     // Check timestamp
@@ -3518,7 +3588,10 @@
     if ((block.nVersion < 2 && nHeight >= consensusParams.BIP34Height) ||
         (block.nVersion < 3 && nHeight >= consensusParams.BIP66Height) ||
         (block.nVersion < 4 && nHeight >= consensusParams.BIP65Height)) {
-        return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_OBSOLETE, strprintf("bad-version(0x%08x)", block.nVersion), false, strprintf("rejected nVersion=0x%08x block", block.nVersion));
+        return state.Invalid(
+            ValidationInvalidReason::BLOCK_INVALID_HEADER, false,
+            REJECT_OBSOLETE, strprintf("bad-version(0x%08x)", block.nVersion),
+            strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
 
     return true;
@@ -3604,10 +3677,18 @@
         if (fIsMagneticAnomalyEnabled) {
             if (prevTx && (tx.GetId() <= prevTx->GetId())) {
                 if (tx.GetId() == prevTx->GetId()) {
-                    return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "tx-duplicate", false, strprintf("Duplicated transaction %s", tx.GetId().ToString()));
+                    return state.Invalid(ValidationInvalidReason::CONSENSUS,
+                                         false, REJECT_INVALID, "tx-duplicate",
+                                         strprintf("Duplicated transaction %s",
+                                                   tx.GetId().ToString()));
                 }
 
-                return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "tx-ordering", false, strprintf("Transaction order is invalid (%s < %s)", tx.GetId().ToString(), prevTx->GetId().ToString()));
+                return state.Invalid(
+                    ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID,
+                    "tx-ordering",
+                    strprintf("Transaction order is invalid (%s < %s)",
+                              tx.GetId().ToString(),
+                              prevTx->GetId().ToString()));
             }
 
             if (prevTx || !tx.IsCoinBase()) {
@@ -3628,7 +3709,9 @@
         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             !std::equal(expect.begin(), expect.end(),
                         block.vtx[0]->vin[0].scriptSig.begin())) {
-            return state.DoS(100, ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-height", false, "block height mismatch in coinbase");
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+                                 REJECT_INVALID, "bad-cb-height",
+                                 "block height mismatch in coinbase");
         }
     }
 
@@ -3678,13 +3761,17 @@
         // Get prev block index
         BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
         if (mi == mapBlockIndex.end()) {
-            return state.DoS(10, ValidationInvalidReason::BLOCK_MISSING_PREV, error("%s: prev block not found", __func__), 0, "prev-blk-not-found");
+            return state.Invalid(ValidationInvalidReason::BLOCK_MISSING_PREV,
+                                 error("%s: prev block not found", __func__), 0,
+                                 "prev-blk-not-found");
         }
 
         CBlockIndex *pindexPrev = (*mi).second;
         assert(pindexPrev);
         if (pindexPrev->nStatus.isInvalid()) {
-            return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_PREV, error("%s: prev block invalid", __func__), REJECT_INVALID, "bad-prevblk");
+            return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_PREV,
+                                 error("%s: prev block invalid", __func__),
+                                 REJECT_INVALID, "bad-prevblk");
         }
 
         if (!ContextualCheckBlockHeader(chainparams, block, state, pindexPrev,
@@ -3728,7 +3815,10 @@
                         setDirtyBlockIndex.insert(invalid_walk);
                         invalid_walk = invalid_walk->pprev;
                     }
-                    return state.DoS(100, ValidationInvalidReason::BLOCK_INVALID_PREV, error("%s: prev block invalid", __func__), REJECT_INVALID, "bad-prevblk");
+                    return state.Invalid(
+                        ValidationInvalidReason::BLOCK_INVALID_PREV,
+                        error("%s: prev block invalid", __func__),
+                        REJECT_INVALID, "bad-prevblk");
                 }
             }
         }