Use undo data in ConnectBlock

sedited · sedited · commit 168fa6702676 · 2025-04-16T10:12:40.000+02:00
diff --git a/src/bench/connectblock.cpp b/src/bench/connectblock.cpp
@@ -9,6 +9,7 @@
 #include <script/interpreter.h>
 #include <sync.h>
 #include <test/util/setup_common.h>
+#include <undo.h>
 #include <validation.h>
 
 #include <cassert>
@@ -100,7 +101,11 @@ void BenchmarkConnectBlock(benchmark::Bench& bench, std::vector<CKey>& keys, std
         auto* pindex{chainman->m_blockman.AddToBlockIndex(test_block, chainman->m_best_header)}; // Doing this here doesn't impact the benchmark
         CCoinsViewCache viewNew{&chainstate.CoinsTip()};
 
-        assert(chainstate.ConnectBlock(test_block, test_block_state, pindex, viewNew));
+        CBlockUndo blockundo;
+        uint256 block_hash{test_block.GetHash()};
+        assert(SpendBlock(block_hash, pindex, chainstate.m_chainman.GetParams(), test_block, viewNew, test_block_state, blockundo));
+
+        assert(chainstate.ConnectBlock(test_block, test_block_state, pindex, block_hash, blockundo));
     });
 }
 
diff --git a/src/coins.cpp b/src/coins.cpp
@@ -302,6 +302,22 @@ bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
     return true;
 }
 
+std::optional<std::vector<Coin>> CCoinsViewCache::GetInputs(const CTransaction& tx) const
+{
+    if (tx.IsCoinBase()) {
+        return {};
+    }
+    std::vector<Coin> coins;
+    coins.reserve(tx.vin.size());
+    for (const auto& txin : tx.vin) {
+        const std::optional<Coin> coin = GetCoin(txin.prevout);
+        if (!coin) return std::nullopt;
+        Assume(!coin->IsSpent());
+        coins.emplace_back(*coin);
+    }
+    return coins;
+}
+
 void CCoinsViewCache::ReallocateCache()
 {
     // Cache should be empty when we're calling this.
diff --git a/src/coins.h b/src/coins.h
@@ -469,6 +469,8 @@ class CCoinsViewCache : public CCoinsViewBacked
     //! Check whether all prevouts of the transaction are present in the UTXO set represented by this view
     bool HaveInputs(const CTransaction& tx) const;
 
+    std::optional<std::vector<Coin>> GetInputs(const CTransaction& tx) const;
+
     //! Force a reallocation of the cache map. This is required when downsizing
     //! the cache because the map's allocator may be hanging onto a lot of
     //! memory despite having called .clear().
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
@@ -123,15 +123,15 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx)
     return nSigOps;
 }
 
-unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
+unsigned int GetP2SHSigOpCount(const CTransaction& tx, std::span<const Coin> inputs)
 {
     if (tx.IsCoinBase())
         return 0;
 
     unsigned int nSigOps = 0;
     for (unsigned int i = 0; i < tx.vin.size(); i++)
     {
-        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
+        const Coin& coin = inputs[i];
         assert(!coin.IsSpent());
         const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash())
@@ -140,7 +140,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& in
     return nSigOps;
 }
 
-int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags)
+int64_t GetTransactionSigOpCost(const CTransaction& tx, std::span<const Coin> inputs, uint32_t flags)
 {
     int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
 
@@ -153,26 +153,19 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i
 
     for (unsigned int i = 0; i < tx.vin.size(); i++)
     {
-        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
+        const Coin& coin = inputs[i];
         assert(!coin.IsSpent());
         const CTxOut &prevout = coin.out;
         nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
     }
     return nSigOps;
 }
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, std::span<const Coin> inputs, int nSpendHeight, CAmount& txfee)
 {
-    // are the actual inputs available?
-    if (!inputs.HaveInputs(tx)) {
-        return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
-                         strprintf("%s: inputs missing/spent", __func__));
-    }
-
     CAmount nValueIn = 0;
     for (unsigned int i = 0; i < tx.vin.size(); ++i) {
-        const COutPoint &prevout = tx.vin[i].prevout;
-        const Coin& coin = inputs.AccessCoin(prevout);
+        const Coin& coin = inputs[i];
         assert(!coin.IsSpent());
 
         // If prev is coinbase, check that it's matured
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
@@ -8,6 +8,7 @@
 #include <consensus/amount.h>
 
 #include <stdint.h>
+#include <undo.h>
 #include <vector>
 
 class CBlockIndex;
@@ -24,7 +25,7 @@ namespace Consensus {
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee);
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, std::span<const Coin> inputs, int nSpendHeight, CAmount& txfee);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
@@ -39,11 +40,11 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx);
 /**
  * Count ECDSA signature operations in pay-to-script-hash inputs.
  *
- * @param[in] mapInputs Map of previous transactions that have outputs we're spending
+ * @param[in] inputs Previous transactions that have outputs we're spending
  * @return maximum number of sigops required to validate this transaction's inputs
  * @see CTransaction::FetchInputs
  */
-unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& mapInputs);
+unsigned int GetP2SHSigOpCount(const CTransaction& tx, std::span<const Coin> inputs);
 
 /**
  * Compute total signature operation cost of a transaction.
@@ -52,7 +53,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& ma
  * @param[in] flags Script verification flags
  * @return Total signature operation cost of tx
  */
-int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags);
+int64_t GetTransactionSigOpCost(const CTransaction& tx, std::span<const Coin> inputs, uint32_t flags);
 
 /**
  * Check if transaction is final and can be included in a block with the
diff --git a/src/node/psbt.cpp b/src/node/psbt.cpp
@@ -137,7 +137,13 @@ PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
 
         if (success) {
             CTransaction ctx = CTransaction(mtx);
-            size_t size(GetVirtualTransactionSize(ctx, GetTransactionSigOpCost(ctx, view, STANDARD_SCRIPT_VERIFY_FLAGS), ::nBytesPerSigOp));
+            std::vector<Coin> spent_outputs;
+            spent_outputs.reserve(ctx.vin.size());
+            for (const auto& input : ctx.vin) {
+                spent_outputs.emplace_back(view.AccessCoin(input.prevout));
+            }
+
+            size_t size(GetVirtualTransactionSize(ctx, GetTransactionSigOpCost(ctx, spent_outputs, STANDARD_SCRIPT_VERIFY_FLAGS), ::nBytesPerSigOp));
             result.estimated_vsize = size;
             // Estimate fee rate
             CFeeRate feerate(fee, size);
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
@@ -9,6 +9,7 @@
 #include <test/util/index.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
+#include <undo.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -100,7 +101,9 @@ BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
             BOOST_CHECK(CheckBlock(block, state, params.GetConsensus()));
             BOOST_CHECK(m_node.chainman->AcceptBlock(new_block, state, &new_block_index, true, nullptr, nullptr, true));
             CCoinsViewCache view(&chainstate.CoinsTip());
-            BOOST_CHECK(chainstate.ConnectBlock(block, state, new_block_index, view));
+            CBlockUndo blockundo;
+            assert(SpendBlock(block.GetHash(), new_block_index, chainstate.m_chainman.GetParams(), block, view, state, blockundo));
+            BOOST_CHECK(chainstate.ConnectBlock(block, state, new_block_index, block.GetHash(), blockundo));
         }
         // Send block connected notification, then stop the index without
         // sending a chainstate flushed notification. Prior to #24138, this
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
@@ -255,7 +255,9 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
                     return;
                 }
-                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
+                std::optional<std::vector<Coin>> coins{coins_view_cache.GetInputs(transaction)};
+                if (!coins) return;
+                if (Consensus::CheckTxInputs(transaction, state, *coins, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
@@ -266,7 +268,10 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
                     return;
                 }
-                (void)GetP2SHSigOpCount(transaction, coins_view_cache);
+
+                std::optional<std::vector<Coin>> coins{coins_view_cache.GetInputs(transaction)};
+                if (!coins) return;
+                (void)GetP2SHSigOpCount(transaction, *coins);
             },
             [&] {
                 const CTransaction transaction{random_mutable_transaction};
@@ -281,7 +286,9 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
                     return;
                 }
-                (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
+                std::optional<std::vector<Coin>> coins{coins_view_cache.GetInputs(transaction)};
+                if (!coins) return;
+                (void)GetTransactionSigOpCost(transaction, *coins, flags);
             },
             [&] {
                 (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
diff --git a/src/test/script_p2sh_tests.cpp b/src/test/script_p2sh_tests.cpp
@@ -362,7 +362,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
 
     BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
     // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), *(Assert(coins.GetInputs(CTransaction(txTo))))), 22U);
 
     CMutableTransaction txToNonStd1;
     txToNonStd1.vout.resize(1);
@@ -374,7 +374,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), *(Assert(coins.GetInputs(CTransaction(txToNonStd1))))), 16U);
 
     CMutableTransaction txToNonStd2;
     txToNonStd2.vout.resize(1);
@@ -386,7 +386,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), *(Assert(coins.GetInputs(CTransaction(txToNonStd2))))), 20U);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
@@ -134,10 +134,10 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         // Legacy counting only includes signature operations in scriptSigs and scriptPubKeys
         // of a transaction and does not take the actual executed sig operations into account.
         // spendingTx in itself does not contain a signature operation.
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 0);
         // creationTx contains two signature operations in its scriptPubKey, but legacy counting
         // is not accurate.
-        assert(GetTransactionSigOpCost(CTransaction(creationTx), coins, flags) == MAX_PUBKEYS_PER_MULTISIG * WITNESS_SCALE_FACTOR);
+        assert(GetTransactionSigOpCost(CTransaction(creationTx), {}, flags) == MAX_PUBKEYS_PER_MULTISIG * WITNESS_SCALE_FACTOR);
         // Sanity check: script verification fails because of an invalid signature.
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
@@ -149,7 +149,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         CScript scriptSig = CScript() << OP_0 << OP_0 << ToByteVector(redeemScript);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, CScriptWitness());
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2 * WITNESS_SCALE_FACTOR);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 2 * WITNESS_SCALE_FACTOR);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
 
@@ -163,22 +163,22 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
 
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 1);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 1);
         // No signature operations if we don't verify the witness.
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags & ~SCRIPT_VERIFY_WITNESS) == 0);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
 
         // The sig op cost for witness version != 0 is zero.
         assert(scriptPubKey[0] == 0x00);
         scriptPubKey[0] = 0x51;
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 0);
         scriptPubKey[0] = 0x00;
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
 
         // The witness of a coinbase transaction is not taken into account.
         spendingTx.vin[0].prevout.SetNull();
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), {}, flags) == 0);
     }
 
     // P2WPKH nested in P2SH
@@ -191,7 +191,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(0);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 1);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 1);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
     }
 
@@ -206,8 +206,8 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(witnessScript.begin(), witnessScript.end());
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 2);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags & ~SCRIPT_VERIFY_WITNESS) == 0);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
 
@@ -223,7 +223,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
         scriptWitness.stack.emplace_back(witnessScript.begin(), witnessScript.end());
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
-        assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), *Assert(coins.GetInputs(CTransaction(spendingTx))), flags) == 2);
         assert(VerifyWithFlag(CTransaction(creationTx), spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
     }
 }
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
diff --git a/src/validation.cpp b/src/validation.cpp
diff --git a/src/validation.h b/src/validation.h

Original file line number	Diff line number	Diff line change
`@@ -123,15 +123,15 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx)`
`123`	`123`	`return nSigOps;`
`124`	`124`	`}`
`125`	`125`
`126`		`-unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)`
	`126`	`+unsigned int GetP2SHSigOpCount(const CTransaction& tx, std::span<const Coin> inputs)`
`127`	`127`	`{`
`128`	`128`	`if (tx.IsCoinBase())`
`129`	`129`	`return 0;`
`130`	`130`
`131`	`131`	`unsigned int nSigOps = 0;`
`132`	`132`	`for (unsigned int i = 0; i < tx.vin.size(); i++)`
`133`	`133`	`{`
`134`		`- const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);`
	`134`	`+ const Coin& coin = inputs[i];`
`135`	`135`	`assert(!coin.IsSpent());`
`136`	`136`	`const CTxOut &prevout = coin.out;`
`137`	`137`	`if (prevout.scriptPubKey.IsPayToScriptHash())`
`@@ -140,7 +140,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& in`
`140`	`140`	`return nSigOps;`
`141`	`141`	`}`
`142`	`142`
`143`		`-int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags)`
	`143`	`+int64_t GetTransactionSigOpCost(const CTransaction& tx, std::span<const Coin> inputs, uint32_t flags)`
`144`	`144`	`{`
`145`	`145`	`int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;`
`146`	`146`
`@@ -153,26 +153,19 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i`
`153`	`153`
`154`	`154`	`for (unsigned int i = 0; i < tx.vin.size(); i++)`
`155`	`155`	`{`
`156`		`- const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);`
	`156`	`+ const Coin& coin = inputs[i];`
`157`	`157`	`assert(!coin.IsSpent());`
`158`	`158`	`const CTxOut &prevout = coin.out;`
`159`	`159`	`nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);`
`160`	`160`	`}`
`161`	`161`	`return nSigOps;`
`162`	`162`	`}`
`163`	`163`
`164`		`-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)`
	`164`	`+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, std::span<const Coin> inputs, int nSpendHeight, CAmount& txfee)`
`165`	`165`	`{`
`166`		`- // are the actual inputs available?`
`167`		`- if (!inputs.HaveInputs(tx)) {`
`168`		`- return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",`
`169`		`- strprintf("%s: inputs missing/spent", __func__));`
`170`		`- }`
`171`		`-`
`172`	`166`	`CAmount nValueIn = 0;`
`173`	`167`	`for (unsigned int i = 0; i < tx.vin.size(); ++i) {`
`174`		`- const COutPoint &prevout = tx.vin[i].prevout;`
`175`		`- const Coin& coin = inputs.AccessCoin(prevout);`
	`168`	`+ const Coin& coin = inputs[i];`
`176`	`169`	`assert(!coin.IsSpent());`
`177`	`170`
`178`	`171`	`// If prev is coinbase, check that it's matured`