crate::ix!();



//-------------------------------------------[.cpp/bitcoin/src/test/txvalidationcache_tests.cpp]

pub struct Dersig100Setup {
    base: TestChain100Setup,
}

impl Default for Dersig100Setup {
    
    fn default() -> Self {
        todo!();
        /*


            : TestChain100Setup{{"-testactivationheight=dersig@102"}}
        */
    }
}

#[EXCLUSIVE_LOCKS_REQUIRED(cs_main)]
pub fn check_input_scripts(
        tx:                      &Transaction,
        state:                   &mut TxValidationState,
        inputs:                  &CoinsViewCache,
        flags:                   u32,
        cache_sig_store:         bool,
        cache_full_script_store: bool,
        txdata:                  &mut PrecomputedTransactionData,
        pv_checks:               *mut Vec<ScriptCheck>) -> bool {
    
    todo!();
        /*
        
        */
}

#[cfg(test)]
pub mod txvalidationcache_tests {

    #[test] fn tx_mempool_block_doublespend_dersig_100setup() {
        todo!();
        /*
        
            // Make sure skipping validation of transactions that were
            // validated going into the memory pool does not allow
            // double-spends in blocks to pass validation when they should not.

            CScript scriptPubKey = CScript() <<  ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;

            const auto ToMemPool = [this](const CMutableTransaction& tx) {
                LOCK(cs_main);

                const MempoolAcceptResult result = AcceptToMemoryPool(m_node.chainman->ActiveChainstate(), *m_node.mempool, MakeTransactionRef(tx),
                    true /* bypass_limits */);
                return result.m_result_type == MempoolAcceptResult::ResultType::VALID;
            };

            // Create a double-spend of mature coinbase txn:
            std::vector<CMutableTransaction> spends;
            spends.resize(2);
            for (int i = 0; i < 2; i++)
            {
                spends[i].nVersion = 1;
                spends[i].vin.resize(1);
                spends[i].vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
                spends[i].vin[0].prevout.n = 0;
                spends[i].vout.resize(1);
                spends[i].vout[0].nValue = 11*CENT;
                spends[i].vout[0].scriptPubKey = scriptPubKey;

                // Sign:
                std::vector<unsigned char> vchSig;
                uint256 hash = SignatureHash(scriptPubKey, spends[i], 0, SIGHASH_ALL, 0, SigVersion::BASE);
                BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
                vchSig.push_back((unsigned char)SIGHASH_ALL);
                spends[i].vin[0].scriptSig << vchSig;
            }

            CBlock block;

            // Test 1: block with both of those transactions should be rejected.
            block = CreateAndProcessBlock(spends, scriptPubKey);
            {
                LOCK(cs_main);
                BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
            }

            // Test 2: ... and should be rejected if spend1 is in the memory pool
            BOOST_CHECK(ToMemPool(spends[0]));
            block = CreateAndProcessBlock(spends, scriptPubKey);
            {
                LOCK(cs_main);
                BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
            }
            m_node.mempool->clear();

            // Test 3: ... and should be rejected if spend2 is in the memory pool
            BOOST_CHECK(ToMemPool(spends[1]));
            block = CreateAndProcessBlock(spends, scriptPubKey);
            {
                LOCK(cs_main);
                BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
            }
            m_node.mempool->clear();

            // Final sanity test: first spend in *m_node.mempool, second in block, that's OK:
            std::vector<CMutableTransaction> oneSpend;
            oneSpend.push_back(spends[0]);
            BOOST_CHECK(ToMemPool(spends[1]));
            block = CreateAndProcessBlock(oneSpend, scriptPubKey);
            {
                LOCK(cs_main);
                BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() == block.GetHash());
            }
            // spends[1] should have been removed from the mempool when the
            // block with spends[0] is accepted:
            BOOST_CHECK_EQUAL(m_node.mempool->size(), 0U);

        */
    }

    /**
      | Run CheckInputScripts (using CoinsTip()) on
      | the given transaction, for all script
      | flags.  Test that CheckInputScripts passes
      | for all flags that don't overlap with the
      | failing_flags argument, but otherwise
      | fails.  CHECKLOCKTIMEVERIFY and
      | CHECKSEQUENCEVERIFY (and future NOP codes
      | that may get reassigned) have an
      | interaction with
      | DISCOURAGE_UPGRADABLE_NOPS: if the script
      | flags used contain
      | DISCOURAGE_UPGRADABLE_NOPS but don't
      | contain CHECKLOCKTIMEVERIFY (or
      | CHECKSEQUENCEVERIFY), but the script does
      | contain OP_CHECKLOCKTIMEVERIFY (or
      | OP_CHECKSEQUENCEVERIFY), then script
      | execution should fail.
      |
      | Capture this interaction with the
      | upgraded_nop argument: set it when
      | evaluating any script flag that is
      | implemented as an upgraded NOP code.
      */
    #[EXCLUSIVE_LOCKS_REQUIRED(cs_main)]
    pub fn validate_check_inputs_for_all_flags(
            tx:               &Transaction,
            failing_flags:    u32,
            add_to_cache:     bool,
            active_coins_tip: &mut CoinsViewCache)  {
        
        todo!();
            /*
                PrecomputedTransactionData txdata;

                FastRandomContext insecure_rand(true);

                for (int count = 0; count < 10000; ++count) {
                    TxValidationState state;

                    // Randomly selects flag combinations
                    uint32_t test_flags = (uint32_t) insecure_rand.randrange((SCRIPT_VERIFY_END_MARKER - 1) << 1);

                    // Filter out incompatible flag choices
                    if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
                        // CLEANSTACK requires P2SH and WITNESS, see VerifyScript() in
                        // script/interpreter.cpp
                        test_flags |= SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS;
                    }
                    if ((test_flags & SCRIPT_VERIFY_WITNESS)) {
                        // WITNESS requires P2SH
                        test_flags |= SCRIPT_VERIFY_P2SH;
                    }
                    bool ret = CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, nullptr);
                    // CheckInputScripts should succeed iff test_flags doesn't intersect with
                    // failing_flags
                    bool expected_return_value = !(test_flags & failing_flags);
                    BOOST_CHECK_EQUAL(ret, expected_return_value);

                    // Test the caching
                    if (ret && add_to_cache) {
                        // Check that we get a cache hit if the tx was valid
                        std::vector<CScriptCheck> scriptchecks;
                        BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, &scriptchecks));
                        BOOST_CHECK(scriptchecks.empty());
                    } else {
                        // Check that we get script executions to check, if the transaction
                        // was invalid, or we didn't add to cache.
                        std::vector<CScriptCheck> scriptchecks;
                        BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, &scriptchecks));
                        BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
                    }
                }
            */
    }

    #[test] fn checkinputs_test_dersig_100setup() {
        todo!();
        /*
        
            // Test that passing CheckInputScripts with one set of script flags doesn't imply
            // that we would pass again with a different set of flags.
            {
                LOCK(cs_main);
                InitScriptExecutionCache();
            }

            CScript p2pk_scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
            CScript p2sh_scriptPubKey = GetScriptForDestination(ScriptHash(p2pk_scriptPubKey));
            CScript p2pkh_scriptPubKey = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
            CScript p2wpkh_scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(coinbaseKey.GetPubKey()));

            FillableSigningProvider keystore;
            BOOST_CHECK(keystore.AddKey(coinbaseKey));
            BOOST_CHECK(keystore.AddCScript(p2pk_scriptPubKey));

            // flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed pubkey thing

            // Create 2 outputs that match the three scripts above, spending the first
            // coinbase tx.
            CMutableTransaction spend_tx;

            spend_tx.nVersion = 1;
            spend_tx.vin.resize(1);
            spend_tx.vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
            spend_tx.vin[0].prevout.n = 0;
            spend_tx.vout.resize(4);
            spend_tx.vout[0].nValue = 11*CENT;
            spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
            spend_tx.vout[1].nValue = 11*CENT;
            spend_tx.vout[1].scriptPubKey = p2wpkh_scriptPubKey;
            spend_tx.vout[2].nValue = 11*CENT;
            spend_tx.vout[2].scriptPubKey = CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
            spend_tx.vout[3].nValue = 11*CENT;
            spend_tx.vout[3].scriptPubKey = CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;

            // Sign, with a non-DER signature
            {
                std::vector<unsigned char> vchSig;
                uint256 hash = SignatureHash(p2pk_scriptPubKey, spend_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
                BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
                vchSig.push_back((unsigned char) 0); // padding byte makes this non-DER
                vchSig.push_back((unsigned char)SIGHASH_ALL);
                spend_tx.vin[0].scriptSig << vchSig;
            }

            // Test that invalidity under a set of flags doesn't preclude validity
            // under other (eg consensus) flags.
            // spend_tx is invalid according to DERSIG
            {
                LOCK(cs_main);

                TxValidationState state;
                PrecomputedTransactionData ptd_spend_tx;

                BOOST_CHECK(!CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));

                // If we call again asking for scriptchecks (as happens in
                // ConnectBlock), we should add a script check object for this -- we're
                // not caching invalidity (if that changes, delete this test case).
                std::vector<CScriptCheck> scriptchecks;
                BOOST_CHECK(CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
                BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);

                // Test that CheckInputScripts returns true iff DERSIG-enforcing flags are
                // not present.  Don't add these checks to the cache, so that we can
                // test later that block validation works fine in the absence of cached
                // successes.
                ValidateCheckInputsForAllFlags(CTransaction(spend_tx), SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC, false, m_node.chainman->ActiveChainstate().CoinsTip());
            }

            // And if we produce a block with this tx, it should be valid (DERSIG not
            // enabled yet), even though there's no cache entry.
            CBlock block;

            block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
            LOCK(cs_main);
            BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() == block.GetHash());
            BOOST_CHECK(m_node.chainman->ActiveChainstate().CoinsTip().GetBestBlock() == block.GetHash());

            // Test P2SH: construct a transaction that is valid without P2SH, and
            // then test validity with P2SH.
            {
                CMutableTransaction invalid_under_p2sh_tx;
                invalid_under_p2sh_tx.nVersion = 1;
                invalid_under_p2sh_tx.vin.resize(1);
                invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash();
                invalid_under_p2sh_tx.vin[0].prevout.n = 0;
                invalid_under_p2sh_tx.vout.resize(1);
                invalid_under_p2sh_tx.vout[0].nValue = 11*CENT;
                invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
                std::vector<unsigned char> vchSig2(p2pk_scriptPubKey.begin(), p2pk_scriptPubKey.end());
                invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;

                ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx), SCRIPT_VERIFY_P2SH, true, m_node.chainman->ActiveChainstate().CoinsTip());
            }

            // Test CHECKLOCKTIMEVERIFY
            {
                CMutableTransaction invalid_with_cltv_tx;
                invalid_with_cltv_tx.nVersion = 1;
                invalid_with_cltv_tx.nLockTime = 100;
                invalid_with_cltv_tx.vin.resize(1);
                invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash();
                invalid_with_cltv_tx.vin[0].prevout.n = 2;
                invalid_with_cltv_tx.vin[0].nSequence = 0;
                invalid_with_cltv_tx.vout.resize(1);
                invalid_with_cltv_tx.vout[0].nValue = 11*CENT;
                invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;

                // Sign
                std::vector<unsigned char> vchSig;
                uint256 hash = SignatureHash(spend_tx.vout[2].scriptPubKey, invalid_with_cltv_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
                BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
                vchSig.push_back((unsigned char)SIGHASH_ALL);
                invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;

                ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, m_node.chainman->ActiveChainstate().CoinsTip());

                // Make it valid, and check again
                invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
                TxValidationState state;
                PrecomputedTransactionData txdata;
                BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_cltv_tx), state, m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
            }

            // TEST CHECKSEQUENCEVERIFY
            {
                CMutableTransaction invalid_with_csv_tx;
                invalid_with_csv_tx.nVersion = 2;
                invalid_with_csv_tx.vin.resize(1);
                invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash();
                invalid_with_csv_tx.vin[0].prevout.n = 3;
                invalid_with_csv_tx.vin[0].nSequence = 100;
                invalid_with_csv_tx.vout.resize(1);
                invalid_with_csv_tx.vout[0].nValue = 11*CENT;
                invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;

                // Sign
                std::vector<unsigned char> vchSig;
                uint256 hash = SignatureHash(spend_tx.vout[3].scriptPubKey, invalid_with_csv_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
                BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
                vchSig.push_back((unsigned char)SIGHASH_ALL);
                invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;

                ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, m_node.chainman->ActiveChainstate().CoinsTip());

                // Make it valid, and check again
                invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
                TxValidationState state;
                PrecomputedTransactionData txdata;
                BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_csv_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
            }

            // TODO: add tests for remaining script flags

            // Test that passing CheckInputScripts with a valid witness doesn't imply success
            // for the same tx with a different witness.
            {
                CMutableTransaction valid_with_witness_tx;
                valid_with_witness_tx.nVersion = 1;
                valid_with_witness_tx.vin.resize(1);
                valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash();
                valid_with_witness_tx.vin[0].prevout.n = 1;
                valid_with_witness_tx.vout.resize(1);
                valid_with_witness_tx.vout[0].nValue = 11*CENT;
                valid_with_witness_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;

                // Sign
                SignatureData sigdata;
                BOOST_CHECK(ProduceSignature(keystore, MutableTransactionSignatureCreator(&valid_with_witness_tx, 0, 11*CENT, SIGHASH_ALL), spend_tx.vout[1].scriptPubKey, sigdata));
                UpdateInput(valid_with_witness_tx.vin[0], sigdata);

                // This should be valid under all script flags.
                ValidateCheckInputsForAllFlags(CTransaction(valid_with_witness_tx), 0, true, m_node.chainman->ActiveChainstate().CoinsTip());

                // Remove the witness, and check that it is now invalid.
                valid_with_witness_tx.vin[0].scriptWitness.SetNull();
                ValidateCheckInputsForAllFlags(CTransaction(valid_with_witness_tx), SCRIPT_VERIFY_WITNESS, true, m_node.chainman->ActiveChainstate().CoinsTip());
            }

            {
                // Test a transaction with multiple inputs.
                CMutableTransaction tx;

                tx.nVersion = 1;
                tx.vin.resize(2);
                tx.vin[0].prevout.hash = spend_tx.GetHash();
                tx.vin[0].prevout.n = 0;
                tx.vin[1].prevout.hash = spend_tx.GetHash();
                tx.vin[1].prevout.n = 1;
                tx.vout.resize(1);
                tx.vout[0].nValue = 22*CENT;
                tx.vout[0].scriptPubKey = p2pk_scriptPubKey;

                // Sign
                for (int i=0; i<2; ++i) {
                    SignatureData sigdata;
                    BOOST_CHECK(ProduceSignature(keystore, MutableTransactionSignatureCreator(&tx, i, 11*CENT, SIGHASH_ALL), spend_tx.vout[i].scriptPubKey, sigdata));
                    UpdateInput(tx.vin[i], sigdata);
                }

                // This should be valid under all script flags
                ValidateCheckInputsForAllFlags(CTransaction(tx), 0, true, m_node.chainman->ActiveChainstate().CoinsTip());

                // Check that if the second input is invalid, but the first input is
                // valid, the transaction is not cached.
                // Invalidate vin[1]
                tx.vin[1].scriptWitness.SetNull();

                TxValidationState state;
                PrecomputedTransactionData txdata;
                // This transaction is now invalid under segwit, because of the second input.
                BOOST_CHECK(!CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, nullptr));

                std::vector<CScriptCheck> scriptchecks;
                // Make sure this transaction was not cached (ie because the first
                // input was valid)
                BOOST_CHECK(CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, &scriptchecks));
                // Should get 2 script checks back -- caching is on a whole-transaction basis.
                BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);
            }

        */
    }
}