diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 96a34f70c..206fa7d8f 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -95,6 +95,7 @@ add_executable(test_tapyrus
         sanity_tests.cpp
         scheduler_tests.cpp
         script_p2sh_tests.cpp
+        script_risky_combinations_tests.cpp
         script_standard_tests.cpp
         script_tests.cpp
         scriptnum_tests.cpp
diff --git a/src/test/chainstate_tests.cpp b/src/test/chainstate_tests.cpp
index fcc07644c..e5cb29daa 100644
--- a/src/test/chainstate_tests.cpp
+++ b/src/test/chainstate_tests.cpp
@@ -936,6 +936,167 @@ BOOST_AUTO_TEST_CASE(duplicate_nonreissuable_issuance_rejected)
     }
 }
 
+/**
+ * Regression test: burning an NFT must not erase its colorId from
+ * g_colorid_state, so a later re-issuance attempt is still rejected.
+ *
+ * "Burn" means spending the sole live NFT UTXO to an uncolored output —
+ * VerifyTokenBalances allows colored input value with no matching colored
+ * output (the value is simply discarded). This does not touch
+ * g_colorid_state: CIssuedColorIds::Erase() is only ever called from
+ * DisconnectBlock (reorg), never from a normal spend/burn. So after a burn,
+ * total live supply of the colorId is zero, but g_colorid_state must still
+ * report it as issued forever.
+ *
+ * As in duplicate_nonreissuable_issuance_rejected, actually re-deriving the
+ * same colorId requires the exact defining TPC outpoint to look unspent
+ * again (a SHA-256 preimage collision in practice), so the re-issuance
+ * attempt is exercised directly against CheckColorIdentifierValidity with a
+ * synthetic CCoinsViewCache that presents the (long since spent) defining
+ * outpoint as unspent — simulating the same reorg-shaped bug the
+ * NON_REISSUABLE test guards against.
+ */
+BOOST_AUTO_TEST_CASE(duplicate_nft_issuance_after_burn_rejected)
+{
+    CScript payTo = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+
+    CKey key;
+    // Arbitrary non-coinbase key; low byte 3 is not load-bearing, just chosen
+    // to avoid clashing with any of TestChainSetup's pre-defined keys.
+    const unsigned char vchKeyBytes[32] = {
+        3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+    };
+    key.Set(vchKeyBytes, vchKeyBytes + 32, true);
+    CPubKey pubkey = key.GetPubKey();
+    std::vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());
+    std::vector<unsigned char> pubkeyHash(20);
+    CHash160().Write(pubkey.data(), pubkey.size()).Finalize(pubkeyHash.data());
+
+    // Block: spend coinbase[1] into a plain TPC P2PKH output that will define
+    // the NFT's color id below.
+    CMutableTransaction spendTx;
+    spendTx.nFeatures = 1;
+    spendTx.vin.resize(1);
+    spendTx.vout.resize(1);
+    spendTx.vin[0].prevout.hashMalFix = m_coinbase_txns[1]->GetHashMalFix();
+    spendTx.vin[0].prevout.n = 0;
+    spendTx.vout[0].nValue = 100 * CENT;
+    spendTx.vout[0].scriptPubKey = CScript() << OP_DUP << OP_HASH160
+                                             << ToByteVector(pubkeyHash)
+                                             << OP_EQUALVERIFY << OP_CHECKSIG;
+    {
+        std::vector<unsigned char> vchSig;
+        uint256 sigHash = SignatureHash(
+            m_coinbase_txns[1]->vout[0].scriptPubKey, spendTx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+        coinbaseKey.Sign_Schnorr(sigHash, vchSig);
+        vchSig.push_back(SIGHASH_ALL);
+        spendTx.vin[0].scriptSig = CScript() << vchSig;
+    }
+    CreateAndProcessBlock({spendTx}, payTo);
+
+    // Block: issue an NFT (nValue must be exactly 1) from the defining P2PKH UTXO.
+    COutPoint definingUtxo(spendTx.GetHashMalFix(), 0);
+    ColorIdentifier colorid(definingUtxo, TokenTypes::NFT);
+    CScript colorScript = CScript() << colorid.toVector() << OP_COLOR
+                                    << OP_DUP << OP_HASH160
+                                    << ToByteVector(pubkeyHash)
+                                    << OP_EQUALVERIFY << OP_CHECKSIG;
+
+    CMutableTransaction issueTx;
+    issueTx.nFeatures = 1;
+    issueTx.vin.resize(1);
+    issueTx.vout.resize(1);
+    issueTx.vin[0].prevout = definingUtxo;
+    issueTx.vout[0].nValue = 1;
+    issueTx.vout[0].scriptPubKey = colorScript;
+    {
+        std::vector<unsigned char> vchSig;
+        uint256 sigHash = SignatureHash(
+            spendTx.vout[0].scriptPubKey, issueTx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+        key.Sign_Schnorr(sigHash, vchSig);
+        vchSig.push_back(SIGHASH_ALL);
+        issueTx.vin[0].scriptSig = CScript() << vchSig << vchPubKey;
+    }
+    CreateAndProcessBlock({issueTx}, payTo);
+
+    {
+        LOCK(cs_main);
+        BOOST_REQUIRE(g_colorid_state && g_colorid_state->IsIssued(colorid));
+    }
+
+    // Block: burn the NFT — spend issueTx:0 (the only live unit) plus a TPC
+    // coinbase input (for fee/tpcin>0) to a plain uncolored output. No output
+    // carries colorid, so its value is simply discarded (a genuine burn).
+    CMutableTransaction burnTx;
+    burnTx.nFeatures = 1;
+    burnTx.vin.resize(2);
+    burnTx.vout.resize(1);
+    burnTx.vin[0].prevout = COutPoint(issueTx.GetHashMalFix(), 0);
+    burnTx.vin[1].prevout.hashMalFix = m_coinbase_txns[2]->GetHashMalFix();
+    burnTx.vin[1].prevout.n = 0;
+    burnTx.vout[0].nValue = 1;
+    burnTx.vout[0].scriptPubKey = CScript() << OP_DUP << OP_HASH160
+                                            << ToByteVector(pubkeyHash)
+                                            << OP_EQUALVERIFY << OP_CHECKSIG;
+    {
+        std::vector<unsigned char> vchSig;
+        uint256 sigHash = SignatureHash(
+            issueTx.vout[0].scriptPubKey, burnTx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+        key.Sign_Schnorr(sigHash, vchSig);
+        vchSig.push_back(SIGHASH_ALL);
+        burnTx.vin[0].scriptSig = CScript() << vchSig << vchPubKey;
+    }
+    {
+        std::vector<unsigned char> vchSig;
+        uint256 sigHash = SignatureHash(
+            m_coinbase_txns[2]->vout[0].scriptPubKey, burnTx, 1, SIGHASH_ALL, 0, SigVersion::BASE);
+        coinbaseKey.Sign_Schnorr(sigHash, vchSig);
+        vchSig.push_back(SIGHASH_ALL);
+        burnTx.vin[1].scriptSig = CScript() << vchSig;
+    }
+    CreateAndProcessBlock({burnTx}, payTo);
+
+    // The burn destroyed the only live unit of colorid, but g_colorid_state
+    // must still remember it was issued -- Erase() is reorg-only.
+    {
+        LOCK(cs_main);
+        BOOST_REQUIRE(g_colorid_state && g_colorid_state->IsIssued(colorid));
+    }
+
+    // Build a synthetic CCoinsViewCache that presents definingUtxo as unspent
+    // again, simulating a reorg that restored the UTXO while g_colorid_state
+    // retained the record. CheckColorIdentifierValidity must still reject the
+    // re-issuance with "bad-txns-colorid-already-issued", even though the
+    // colorId's supply is currently zero.
+    {
+        LOCK(cs_main);
+
+        CCoinsView dummy;
+        CCoinsViewCache syntheticView(&dummy);
+        Coin tpcCoin;
+        tpcCoin.out.nValue    = spendTx.vout[0].nValue;
+        tpcCoin.out.scriptPubKey = spendTx.vout[0].scriptPubKey;
+        tpcCoin.nHeight       = 6;
+        tpcCoin.fCoinBase     = false;
+        syntheticView.AddCoin(definingUtxo, std::move(tpcCoin), /*potential_overwrite=*/false);
+
+        CMutableTransaction reissueTx;
+        reissueTx.nFeatures = 1;
+        reissueTx.vin.resize(1);
+        reissueTx.vout.resize(1);
+        reissueTx.vin[0].prevout   = definingUtxo;
+        reissueTx.vout[0].nValue   = 1;
+        reissueTx.vout[0].scriptPubKey = colorScript;
+
+        CValidationState state;
+        bool valid = CheckColorIdentifierValidity(
+            CTransaction(reissueTx), state, syntheticView, chainActive.Tip()->nHeight);
+
+        BOOST_CHECK(!valid);
+        BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-colorid-already-issued");
+    }
+}
+
 /**
  * Regression test: VerifyTokenBalances must not use DoS=100 for tpcin<=0.
  *
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
index 0acff8a4c..9b422c068 100644
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -3089,16 +3089,35 @@
 [
     "0x47 0x3044022073df1d1a15d0e6fd8a14f0c1ba4409239c97d4fbc3cb113095c0929582d8447e0220271ec24bc865852e239693b20f0efbbe584d1b4cc4777948f18473ce30dc976a01 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x19 0x76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac",
     "0x21 0xc11863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262 COLOR HASH160 0x14 0xda8a647bba351bbae4cee0089d373c97ec240580 EQUAL",
-    "",
+    "CP2SH_COLORED",
     "OK",
-    "CP2SH(P2PKH) ECDSA"
+    "CP2SH(P2PKH) ECDSA, redeem script genuinely satisfied (passes with the flag on)"
 ],
 [
     "0x41 0xbc4b27bef382c8159db61d673868137020c08e7cb25b9d9653c706a025b02eadba29657e2937fd58f1dcfdb582433cb63a06a15379de562fadba9877cc531d3101 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x19 0x76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac",
     "0x21 0xc11863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262 COLOR HASH160 0x14 0xda8a647bba351bbae4cee0089d373c97ec240580 EQUAL",
+    "CP2SH_COLORED",
+    "OK",
+    "CP2SH(P2PKH) SCHNORR, redeem script genuinely satisfied (passes with the flag on)"
+],
+
+["The next two show what SCRIPT_VERIFY_CP2SH_COLORED actually changes: same"],
+["scriptSig/scriptPubKey (redeem script HASH160 matches; the sig inside it does"],
+["NOT correspond to the pubkey), flag off vs flag on."],
+
+[
+    "0x47 0x304402202539b3b68e870d525765d24cc08fadd7502ffd8735564eb545a9a3057f85469d02207611be2fde48142a19497f6c4cb4146c71bb4cd6bc567dbae30bb7ecd46bc73801 0x21 0x026292d4b98eecee53d2b78bea0883bbf85bcb4fcdd4479369bfc7c3ee3b46ea49 0x19 0x76a914aba705eb3d02be6c4563d3f6874a3e81004ec83988ac",
+    "0x21 0xc1c6a2c97c58b8e8264ebc66ffa99a1536ec324c21263722368a00b3dfb025abec COLOR HASH160 0x14 0x45601212e04228745b047c1fc4e8d78d83a762b1 EQUAL",
     "",
     "OK",
-    "CP2SH(P2PKH) SCHNORR"
+    "CP2SH(P2PKH), broken inner signature, flag OFF -- only the HASH160 preimage is checked, so this passes"
+],
+[
+    "0x47 0x304402202539b3b68e870d525765d24cc08fadd7502ffd8735564eb545a9a3057f85469d02207611be2fde48142a19497f6c4cb4146c71bb4cd6bc567dbae30bb7ecd46bc73801 0x21 0x026292d4b98eecee53d2b78bea0883bbf85bcb4fcdd4479369bfc7c3ee3b46ea49 0x19 0x76a914aba705eb3d02be6c4563d3f6874a3e81004ec83988ac",
+    "0x21 0xc1c6a2c97c58b8e8264ebc66ffa99a1536ec324c21263722368a00b3dfb025abec COLOR HASH160 0x14 0x45601212e04228745b047c1fc4e8d78d83a762b1 EQUAL",
+    "CP2SH_COLORED",
+    "EVAL_FALSE",
+    "CP2SH(P2PKH), same script, flag ON -- the redeem script is now actually evaluated and its CHECKSIG fails"
 ],
 ["The End"]
 ]
diff --git a/src/test/data/tx_invalid.json b/src/test/data/tx_invalid.json
index 19b21b4f1..f47beaa93 100644
--- a/src/test/data/tx_invalid.json
+++ b/src/test/data/tx_invalid.json
@@ -887,5 +887,48 @@
   ["0000000000000000000000000000000000000000000000000000000000000100", 11, "DUP HASH160 0x14 0x4c9c3dfac4207d5d8cb89df5722cb3d712385e3f EQUALVERIFY CHECKSIG", 1011]],
   "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", "WITNESS"],
   
+  ["Colored coin spends (OP_COLOR): invalid CP2PKH / CP2SH(P2PKH) variants"],
+  ["Note: these only exercise script-level (VerifyScript) rejections. The"],
+  ["consensus-level 'OP_COLOR must be exactly CP2PKH or CP2SH, else"],
+  ["bad-txns-nonstandard-opcolor' rule (CheckColorIdentifierValidity) is not"],
+  ["reachable from this harness -- it is covered in txvalidation_tests.cpp."],
+
+  ["CP2PKH invalid: signature from the wrong key (correct pubkey pushed)"],
+  [[["e814a0b9ffca0211cd0d607e43cae079d5ac1baac8994f15018d5c5651324d8e", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR DUP HASH160 0x14 0x5e9a45bba03b45737b421c38366b590a89be80fd EQUALVERIFY CHECKSIG"]],
+  "01000000018e4d3251565c8d01154f99c8aa1bacd579e0ca437e600dcd1102caffb9a014e8000000006a473044022058a1e91ce4978c8d235c61e6783094c9bb29a2d274590f1edcd920fcaa369c4502202c0dd847d5deab020ca5f02523974dd44d815715551c5295bdf97dd76f04443f012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b1ffffffff0100000000000000000000000000", ""],
+
+  ["CP2PKH invalid: wrong pubkey pushed (does not match embedded hash)"],
+  [[["e814a0b9ffca0211cd0d607e43cae079d5ac1baac8994f15018d5c5651324d8e", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR DUP HASH160 0x14 0x5e9a45bba03b45737b421c38366b590a89be80fd EQUALVERIFY CHECKSIG"]],
+  "01000000018e4d3251565c8d01154f99c8aa1bacd579e0ca437e600dcd1102caffb9a014e8000000006a473044022058a1e91ce4978c8d235c61e6783094c9bb29a2d274590f1edcd920fcaa369c4502202c0dd847d5deab020ca5f02523974dd44d815715551c5295bdf97dd76f04443f01210233115655789d58c0b3d1660df65e44e652eb620fb5ee06939a9513249e4aa8e7ffffffff0100000000000000000000000000", ""],
+
+  ["CP2PKH invalid: color identifier payload is all-zero (rejected by EvalScript itself, not just consensus)"],
+  [[["b51a255d9d383c17cb958726e520415b045e2fba73ac4194fd85f28a9c6b543f", 0, "0x21 0xc10000000000000000000000000000000000000000000000000000000000000000 COLOR DUP HASH160 0x14 0x5e9a45bba03b45737b421c38366b590a89be80fd EQUALVERIFY CHECKSIG"]],
+  "01000000013f546b9c8af285fd9441ac73ba2f5e045b4120e5268795cb173c389d5d251ab5000000006a4730440220231f650579cbc80e180959911b3acaa756c264f6abccfdce4ff864bcb8d01f5f02204b78cab66ab4948cd6be3f60047c0db17f9fdd2c2104d2742c12af7bf9be6241012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b1ffffffff0100000000000000000000000000", ""],
+
+  ["CP2SH(P2PKH) invalid: redeem script does not hash to the embedded scripthash"],
+  [[["30be58e04d2818fabc4a7e8cffdf22e3d5ed8d421e63d64b20fa84458116972f", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR HASH160 0x14 0x21e7adb7d667d8bf4a2db3b1107fecf74269a96b EQUAL"]],
+  "01000000012f9716814584fa204bd6631e428dedd5e322dfff8c7e4abcfa18284de058be30000000008447304402205a07d3acd38e6f4151cbb4249e8116115fae3dd859812c94ad8edf9c1a8fa90e0220052f2620585a81c5e1954204abe0d21f646b492fdaea259d583994e69d9ff56101210233115655789d58c0b3d1660df65e44e652eb620fb5ee06939a9513249e4aa8e71976a91433b0afdd23a1c43c4337bfbaae34b3fe0db939e088acffffffff0100000000000000000000000000", ""],
+
+  ["P2SH(CP2PKH) invalid: OP_COLOR is unexpected inside a plain (uncolored) P2SH redeem script"],
+  [[["d71550dad4de82aef0e3c4c594d8e066c532a7007899ff4c78ea930f9009f9fc", 0, "HASH160 0x14 0xf4eca5b0452c281be60d90d1c36c182f39551c66 EQUAL"]],
+  "0100000001fcf909900f93ea784cff997800a732c566e0d894c5c4e3f0ae82ded4da5015d700000000a6463043021f72838cc7bc2de3968bbdaf157c7a3da40a6585fb837469957d6218a58c8b160220673212a09c44d9bbb0c1b654ed968eebc4da72ff6be0bcdcd6d6ddae1892d7c7012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b13c21c111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113bc76a9145e9a45bba03b45737b421c38366b590a89be80fd88acffffffff0100000000000000000000000000", ""],
+
+  ["The following two scripts are proven ACCEPTED by the raw interpreter in"],
+  ["script_risky_combinations_tests.cpp (risk_opcolor_stack_manipulation and"],
+  ["risk_opcolor_with_timelock) and rejected only by CheckColorIdentifierValidity"],
+  ["(consensus layer, see txvalidation_tests.cpp) -- a check this VerifyScript-only"],
+  ["harness cannot reach. To still exercise these exact script shapes here, the"],
+  ["signature is deliberately wrong, so the failure below is EVAL_FALSE (a"],
+  ["cryptographic signature mismatch), NOT proof that OP_COLOR's template"],
+  ["restriction is enforced at this layer -- it is not."],
+
+  ["SWAP-derived OP_COLOR, wrong signature"],
+  [[["6b3fa0499cd96b34ae40da7343cef8ff2ea61e1d382b2557c748fcd1658502c7", 0, "0x21 0xc22d62163d58906df7daa4aa14bbd74ef624333c074f922faa437ddaa538869ef1 SWAP COLOR DROP DUP HASH160 0x14 0xbe803c9776fc0302352fcff912c3e6de07d8deee EQUALVERIFY CHECKSIG"]],
+  "0100000001c7028565d1fc48c757252b381d1ea62efff8ce4373da40ae346bd99c49a03f6b000000008c473044022015138b446d133d86bc05f5365e2895de59d73413334ac670c8e553cb1f5dcb480220276597f1cd19fb4e7c8c7ee4809e95b1f25ef2cf38da83d1239520ad8c937eaf012102e219573f570f3f61f8be3bbaeb1408b3691cfaedf489b5499177553419528b0921c1107242fc3c7a88276516ae8987cfe9d39e204179b15e826dc511799418ba2015ffffffff0100000000000000000000000000", ""],
+
+  ["OP_COLOR + CHECKLOCKTIMEVERIFY, wrong signature (locktime itself is satisfied)"],
+  [[["decb42c916d02a34fdba9a8e9b295aacf0423c1deee3babc69613a5ff4acb679", 0, "0x21 0xc13101b19114d1456c945f627fc6ca90a87cd25ff557c8b23ce981492f7ef23037 COLOR 0x03 0x20a107 CHECKLOCKTIMEVERIFY DROP DUP HASH160 0x14 0xbe803c9776fc0302352fcff912c3e6de07d8deee EQUALVERIFY CHECKSIG"]],
+  "010000000179b6acf45f3a6169bcbae3ee1d3c42f0ac5a299b8e9abafd342ad016c942cbde000000006a473044022076f7020243dcc33793f95a9cd4b0c1aed30e393e7aad88f0928db2e32735225002201cfec9c67df0359229231085d62a0d3373ebf0e04fca833561543152f2ba1252012102e219573f570f3f61f8be3bbaeb1408b3691cfaedf489b5499177553419528b09000000000100000000000000000020a10700", ""],
+
   ["Make diffs cleaner by leaving a comment here without comma at the end"]
   ]
\ No newline at end of file
diff --git a/src/test/data/tx_valid.json b/src/test/data/tx_valid.json
index 08e555e23..0c6f91846 100644
--- a/src/test/data/tx_valid.json
+++ b/src/test/data/tx_valid.json
@@ -447,6 +447,26 @@
   [[["1111111111111111111111111111111111111111111111111111111111111111", 0, "0x00 0x14 0x751e76e8199196d454941c45d1b3a323f1433bd6", 5000000]],
   "010000000111111111111111111111111111111111111111111111111111111111111111110000000000ffffffff0130244c0000000000fd02014cdc1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111175210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798ac02483045022100c1a4a6581996a7fdfea77d58d537955a5655c1d619b6f3ab6874f28bb2e19708022056402db6fede03caae045a3be616a1a2d0919a475ed4be828dc9ff21f24063aa01210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179800000000", ""],
   
+  ["Colored coin spends (OP_COLOR): CP2PKH and CP2SH(P2PKH), ECDSA and Schnorr"],
+  ["CP2SH cases use flags=\"CP2SH_COLORED\" so the redeem script's own CHECKSIG"],
+  ["is genuinely evaluated, not just the OP_HASH160(redeemScript) preimage check."],
+
+  ["CP2PKH valid ECDSA"],
+  [[["e814a0b9ffca0211cd0d607e43cae079d5ac1baac8994f15018d5c5651324d8e", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR DUP HASH160 0x14 0x5e9a45bba03b45737b421c38366b590a89be80fd EQUALVERIFY CHECKSIG"]],
+  "01000000018e4d3251565c8d01154f99c8aa1bacd579e0ca437e600dcd1102caffb9a014e8000000006a47304402204ff979d5770f4ad6a07be099e2748760540b27a430ff529fad4a9254696dc20b022048c565d237518686e47d8d7d35bbf000fb73eec8fec0445b3dc6fa923717ab05012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b1ffffffff0100000000000000000000000000", ""],
+
+  ["CP2PKH valid SCHNORR"],
+  [[["e814a0b9ffca0211cd0d607e43cae079d5ac1baac8994f15018d5c5651324d8e", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR DUP HASH160 0x14 0x5e9a45bba03b45737b421c38366b590a89be80fd EQUALVERIFY CHECKSIG"]],
+  "01000000018e4d3251565c8d01154f99c8aa1bacd579e0ca437e600dcd1102caffb9a014e800000000644102efa7e8cb06e4ad2b8c36f71efb521b271377a4e4e26cb91b5f6e0794dd35ba25ce09c676c2bd91ea407ec696aaf4c79e367c9cbd205bb0c36a08d74ff441b7012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b1ffffffff0100000000000000000000000000", ""],
+
+  ["CP2SH(P2PKH) valid ECDSA"],
+  [[["30be58e04d2818fabc4a7e8cffdf22e3d5ed8d421e63d64b20fa84458116972f", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR HASH160 0x14 0x21e7adb7d667d8bf4a2db3b1107fecf74269a96b EQUAL"]],
+  "01000000012f9716814584fa204bd6631e428dedd5e322dfff8c7e4abcfa18284de058be30000000008447304402202410a4885f8d131e6e8ceddc56e69d120278ce32cc743eb29cdff4ab7681c7cd022021bd0f85cb4382befc2fb114e2b2da51173977e50c3917729599bb4fa9f30106012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b11976a9145e9a45bba03b45737b421c38366b590a89be80fd88acffffffff0100000000000000000000000000", "CP2SH_COLORED"],
+
+  ["CP2SH(P2PKH) valid SCHNORR"],
+  [[["30be58e04d2818fabc4a7e8cffdf22e3d5ed8d421e63d64b20fa84458116972f", 0, "0x21 0xc111bc115c0226329c9a35a7fee1d29c1f5248e0f7841d57829b50278263149113 COLOR HASH160 0x14 0x21e7adb7d667d8bf4a2db3b1107fecf74269a96b EQUAL"]],
+  "01000000012f9716814584fa204bd6631e428dedd5e322dfff8c7e4abcfa18284de058be30000000007e414dba95fc8d1db75137a3d7b658e359da1492d0fcd2521870bb7bc51a6ff440cf38f3ceb62cb130f52c5366d1d02ef67dab2f59d4fe03ec7136062302bf8b75e6012102fc4672572cb02c5ebb43623c3cc5b213d16bfcee45aab502aaa2d92afd2775b11976a9145e9a45bba03b45737b421c38366b590a89be80fd88acffffffff0100000000000000000000000000", "CP2SH_COLORED"],
+
   ["Make diffs cleaner by leaving a comment here without comma at the end"]
   ]
   
\ No newline at end of file
diff --git a/src/test/script_risky_combinations_tests.cpp b/src/test/script_risky_combinations_tests.cpp
new file mode 100644
index 000000000..763007b02
--- /dev/null
+++ b/src/test/script_risky_combinations_tests.cpp
@@ -0,0 +1,446 @@
+// Copyright (c) 2019-2020 Chaintope Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+// Verifies, with runnable proofs, the "risky but permitted" operator
+// combinations documented for the Tapyrus script interpreter:
+//
+//  1. Zero-of-N CHECKMULTISIG is a trivial anyone-can-spend pass.
+//  2. OP_COLOR accepts a color id assembled by prior stack manipulation,
+//     not just an immediate push -- closed off only at the consensus layer
+//     (CheckColorIdentifierValidity), not by the interpreter itself.
+//  3. OP_CHECKDATASIG(VERIFY) has no built-in binding to the spending
+//     transaction, so a (signature, message) pair replays across unrelated
+//     transactions -- unlike OP_CHECKSIG.
+//  4. OP_CHECKSIG calls made independently (outside OP_CHECKMULTISIG) can
+//     mix ECDSA and Schnorr freely; only CHECKMULTISIG enforces uniformity.
+//  5. OP_CHECKLOCKTIMEVERIFY can be combined directly with OP_COLOR in a
+//     single scriptPubKey at the interpreter level, even though the design
+//     intends CLTV/CSV to live only inside a CP2SH redeem script.
+//
+// Each finding is exercised with multiple cases: the risky behavior itself,
+// plus a control/contrast case showing where the behavior does NOT apply,
+// so a future change that narrows (or accidentally widens) these behaviors
+// will be caught here.
+
+#include <key.h>
+#include <keystore.h>
+#include <coloridentifier.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/standard.h>
+#include <test/test_tapyrus.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(script_risky_combinations_tests, BasicTestingSetup)
+
+namespace {
+
+CMutableTransaction BuildCreditingTx(const CScript& scriptPubKey, CAmount nValue = 0)
+{
+    CMutableTransaction txCredit;
+    txCredit.nFeatures = 1;
+    txCredit.nLockTime = 0;
+    txCredit.vin.resize(1);
+    txCredit.vout.resize(1);
+    txCredit.vin[0].prevout.SetNull();
+    txCredit.vin[0].scriptSig = CScript() << CScriptNum(0) << CScriptNum(0);
+    txCredit.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
+    txCredit.vout[0].scriptPubKey = scriptPubKey;
+    txCredit.vout[0].nValue = nValue;
+    return txCredit;
+}
+
+CMutableTransaction BuildSpendingTx(const CScript& scriptSig, const CTransaction& txCredit,
+                                    uint32_t nSequence = CTxIn::SEQUENCE_FINAL, uint32_t nLockTime = 0)
+{
+    CMutableTransaction txSpend;
+    txSpend.nFeatures = 1;
+    txSpend.nLockTime = nLockTime;
+    txSpend.vin.resize(1);
+    txSpend.vout.resize(1);
+    txSpend.vin[0].prevout.hashMalFix = txCredit.GetHashMalFix();
+    txSpend.vin[0].prevout.n = 0;
+    txSpend.vin[0].scriptSig = scriptSig;
+    txSpend.vin[0].nSequence = nSequence;
+    txSpend.vout[0].scriptPubKey = CScript();
+    txSpend.vout[0].nValue = txCredit.vout[0].nValue;
+    return txSpend;
+}
+
+// Verifies exactly as production does: a fresh ColorIdentifier per call
+// (see scriptcheck.h) unless the caller wants to inspect what OP_COLOR set.
+bool Verify(const CScript& scriptSig, const CScript& scriptPubKey, const CMutableTransaction& spendMut,
+            CAmount amount, unsigned int flags, ScriptError* err, ColorIdentifier* colorIdOut = nullptr)
+{
+    CTransaction spend(spendMut);
+    PrecomputedTransactionData txdata(spend);
+    ColorIdentifier localColorId;
+    ColorIdentifier& colorId = colorIdOut ? *colorIdOut : localColorId;
+    return VerifyScript(scriptSig, scriptPubKey, &spend.vin[0].scriptWitness, flags,
+                         TransactionSignatureChecker(&spend, 0, amount, txdata), colorId, err);
+}
+
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Risk 1: Zero-of-N CHECKMULTISIG is a trivial anyone-can-spend pass.
+// ---------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(risk_checkmultisig_zero_of_n)
+{
+    CKey key1, key2;
+    key1.MakeNewKey(true);
+    key2.MakeNewKey(true);
+    CPubKey pub1 = key1.GetPubKey();
+    CPubKey pub2 = key2.GetPubKey();
+
+    // 1a: "0-of-2" multisig -- looks like it needs two keys, actually needs none.
+    {
+        CScript scriptPubKey = CScript() << OP_0 << ToByteVector(pub1) << ToByteVector(pub2) << OP_2 << OP_CHECKMULTISIG;
+        CScript scriptSig = CScript() << OP_0; // only the mandatory dummy element; zero real signatures
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(scriptSig, CTransaction(credit));
+        ScriptError err;
+        bool ok = Verify(scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK_MESSAGE(ok, "0-of-2 CHECKMULTISIG should be spendable with zero signatures: " + std::string(ScriptErrorString(err)));
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+    }
+
+    // 1b: NULLDUMMY is still enforced even in the trivial-pass case: a non-empty
+    // dummy element still fails, proving the risk is specifically "M == 0", not
+    // a general relaxation of CHECKMULTISIG's stack bookkeeping.
+    {
+        CScript scriptPubKey = CScript() << OP_0 << ToByteVector(pub1) << ToByteVector(pub2) << OP_2 << OP_CHECKMULTISIG;
+        CScript scriptSig = CScript() << std::vector<unsigned char>{0xab, 0xcd}; // non-empty dummy (2 bytes, so this isn't itself a MINIMALDATA violation)
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(scriptSig, CTransaction(credit));
+        ScriptError err;
+        bool ok = Verify(scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(!ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_NULLDUMMY);
+    }
+
+    // 1c: degenerate 0-of-0 also passes trivially.
+    {
+        CScript scriptPubKey = CScript() << OP_0 << OP_0 << OP_CHECKMULTISIG;
+        CScript scriptSig = CScript() << OP_0;
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(scriptSig, CTransaction(credit));
+        ScriptError err;
+        bool ok = Verify(scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+    }
+
+    // 1d: control -- 1-of-2 with no real signature correctly fails. The risk
+    // is specific to M == 0, not a general multisig weakness.
+    {
+        CScript scriptPubKey = CScript() << OP_1 << ToByteVector(pub1) << ToByteVector(pub2) << OP_2 << OP_CHECKMULTISIG;
+        CScript scriptSig = CScript() << OP_0; // dummy only; M=1 signature is required but absent
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(scriptSig, CTransaction(credit));
+        ScriptError err;
+        bool ok = Verify(scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(!ok);
+        // CHECKMULTISIG's mandatory extra "dummy" pop means it needs two
+        // stack items here (dummy + one real signature); scriptSig supplies
+        // only one, so this fails on stack underflow before signature
+        // verification is ever reached.
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_INVALID_STACK_OPERATION);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Risk 2: OP_COLOR accepts a color id assembled by prior stack manipulation.
+// Closed off only by CheckColorIdentifierValidity (consensus layer), not by
+// the interpreter -- so we show the interpreter alone says OK, while the
+// standardness/consensus template matcher (IsColoredPayToPubkeyHash) would
+// have refused to recognize the script as colored at all.
+//
+// Using STANDARD_SCRIPT_VERIFY_FLAGS (which includes SCRIPT_VERIFY_CP2SH_COLORED)
+// is not significant here: that flag only gates redeem-script evaluation for
+// CP2SH-shaped scriptPubKeys (IsColoredPayToScriptHash()), and the SWAP/ALTSTACK
+// scripts below aren't P2SH-shaped at all -- they're plain scripts evaluated
+// directly by EvalScript, so the flag never engages.
+// ---------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(risk_opcolor_stack_manipulation)
+{
+    CKey key;
+    key.MakeNewKey(true);
+    CPubKey pub = key.GetPubKey();
+
+    COutPoint outA(uint256S("0000000000000000000000000000000000000000000000000000000000000001"), 0);
+    COutPoint outB(uint256S("0000000000000000000000000000000000000000000000000000000000000002"), 0);
+    ColorIdentifier realCid(outA, TokenTypes::REISSUABLE);
+    ColorIdentifier decoyCid(outB, TokenTypes::NON_REISSUABLE);
+    BOOST_REQUIRE(realCid != decoyCid);
+
+    // 2a: SWAP -- the color id actually consumed is chosen by the scriptSig,
+    // not fixed by the scriptPubKey text.
+    {
+        CScript scriptPubKey = CScript() << decoyCid.toVector() << OP_SWAP << OP_COLOR << OP_DROP
+                                          << OP_DUP << OP_HASH160 << ToByteVector(pub.GetID())
+                                          << OP_EQUALVERIFY << OP_CHECKSIG;
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit));
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key.Sign_ECDSA(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << ToByteVector(pub) << realCid.toVector();
+
+        ColorIdentifier resultColorId;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err, &resultColorId);
+        BOOST_CHECK_MESSAGE(ok, "SWAP-derived OP_COLOR should be accepted by the raw interpreter: " + std::string(ScriptErrorString(err)));
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+        BOOST_CHECK_MESSAGE(resultColorId == realCid, "OP_COLOR should bind to the SWAP-selected id, not the literal one written in scriptPubKey");
+        BOOST_CHECK(resultColorId != decoyCid);
+
+        // The consensus-layer template matcher does not recognize this shape at all.
+        std::vector<unsigned char> hashOut, cidOut;
+        BOOST_CHECK(!scriptPubKey.IsColoredPayToPubkeyHash(hashOut, cidOut));
+        ColorIdentifier fromTemplate = GetColorIdFromScript(scriptPubKey);
+        BOOST_CHECK(fromTemplate.type == TokenTypes::NONE);
+    }
+
+    // 2b: ALTSTACK -- a different technique (stash-and-restore) achieves the
+    // same result, showing this isn't a one-off quirk of SWAP specifically.
+    {
+        CScript scriptPubKey = CScript() << decoyCid.toVector() << OP_TOALTSTACK << OP_COLOR << OP_FROMALTSTACK << OP_DROP
+                                          << OP_DUP << OP_HASH160 << ToByteVector(pub.GetID())
+                                          << OP_EQUALVERIFY << OP_CHECKSIG;
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit));
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key.Sign_ECDSA(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << ToByteVector(pub) << realCid.toVector();
+
+        ColorIdentifier resultColorId;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err, &resultColorId);
+        BOOST_CHECK_MESSAGE(ok, "ALTSTACK-derived OP_COLOR should be accepted by the raw interpreter: " + std::string(ScriptErrorString(err)));
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+        BOOST_CHECK(resultColorId == realCid);
+
+        std::vector<unsigned char> hashOut, cidOut;
+        BOOST_CHECK(!scriptPubKey.IsColoredPayToPubkeyHash(hashOut, cidOut));
+    }
+
+    // 2c: control -- the canonical CP2PKH template (immediate push then
+    // OP_COLOR) IS recognized by the consensus-layer matcher, confirming the
+    // mismatch above is about non-canonical shapes specifically.
+    {
+        ColorIdentifier cid(outA, TokenTypes::REISSUABLE);
+        CScript canonical = CScript() << cid.toVector() << OP_COLOR << OP_DUP << OP_HASH160
+                                       << ToByteVector(pub.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+        std::vector<unsigned char> hashOut, cidOut;
+        BOOST_CHECK(canonical.IsColoredPayToPubkeyHash(hashOut, cidOut));
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Risk 3: OP_CHECKDATASIG(VERIFY) has no built-in binding to the spending
+// transaction -- a (signature, message) pair replays across unrelated
+// transactions. Contrasted with OP_CHECKSIG, which is bound to the tx via
+// SignatureHash and does NOT replay.
+// ---------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(risk_checkdatasig_replay)
+{
+    CKey key;
+    key.MakeNewKey(true);
+    CPubKey pub = key.GetPubKey();
+
+    // 3a: sign a message once; the same scriptSig satisfies two wildly
+    // different spending transactions (different amount, sequence, locktime,
+    // and even a different output).
+    {
+        std::vector<unsigned char> message = {'h', 'e', 'l', 'l', 'o'};
+        uint256 msgHash;
+        CSHA256().Write(message.data(), message.size()).Finalize(msgHash.begin());
+        std::vector<unsigned char> vchSig;
+        BOOST_REQUIRE(key.Sign_ECDSA(msgHash, vchSig)); // no hashtype byte for data signatures
+
+        CScript scriptPubKey = CScript() << ToByteVector(pub) << OP_CHECKDATASIGVERIFY << OP_1;
+        CScript scriptSig = CScript() << vchSig << message;
+
+        CMutableTransaction creditA = BuildCreditingTx(scriptPubKey, 1000);
+        CMutableTransaction spendA = BuildSpendingTx(scriptSig, CTransaction(creditA), CTxIn::SEQUENCE_FINAL, 0);
+        ScriptError errA;
+        bool okA = Verify(scriptSig, scriptPubKey, spendA, creditA.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &errA);
+        BOOST_CHECK(okA);
+        BOOST_CHECK_EQUAL(errA, SCRIPT_ERR_OK);
+
+        CMutableTransaction creditB = BuildCreditingTx(scriptPubKey, 999999);
+        CMutableTransaction spendB = BuildSpendingTx(scriptSig, CTransaction(creditB), 12345, 700000);
+        spendB.vout[0].scriptPubKey = CScript() << OP_RETURN; // unrelated output too
+        ScriptError errB;
+        bool okB = Verify(scriptSig, scriptPubKey, spendB, creditB.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &errB);
+        BOOST_CHECK_MESSAGE(okB, "the identical (sig, message) pair should replay across an unrelated transaction context");
+        BOOST_CHECK_EQUAL(errB, SCRIPT_ERR_OK);
+    }
+
+    // 3b: control -- OP_CHECKSIG does NOT replay: the same scriptSig fails
+    // against a transaction with a different nLockTime, because the
+    // signature is over that transaction's SignatureHash.
+    {
+        CScript scriptPubKey = CScript() << ToByteVector(pub) << OP_CHECKSIG;
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey, 1000);
+        CMutableTransaction spendOriginal = BuildSpendingTx(CScript(), CTransaction(credit), CTxIn::SEQUENCE_FINAL, 0);
+        uint256 sighash = SignatureHash(scriptPubKey, spendOriginal, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key.Sign_ECDSA(sighash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        CScript scriptSig = CScript() << sig;
+
+        CMutableTransaction spendSame = BuildSpendingTx(scriptSig, CTransaction(credit), CTxIn::SEQUENCE_FINAL, 0);
+        ScriptError errSame;
+        bool okSame = Verify(scriptSig, scriptPubKey, spendSame, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &errSame);
+        BOOST_CHECK(okSame);
+
+        CMutableTransaction spendDifferent = BuildSpendingTx(scriptSig, CTransaction(credit), CTxIn::SEQUENCE_FINAL, 999);
+        ScriptError errDifferent;
+        bool okDifferent = Verify(scriptSig, scriptPubKey, spendDifferent, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &errDifferent);
+        BOOST_CHECK_MESSAGE(!okDifferent, "OP_CHECKSIG must NOT replay across a transaction with a different nLockTime");
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Risk 4: ECDSA and Schnorr can be freely mixed outside OP_CHECKMULTISIG.
+// Contrasted with OP_CHECKMULTISIG, which enforces a single scheme.
+// ---------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(risk_mixed_signature_schemes)
+{
+    CKey key1, key2;
+    key1.MakeNewKey(true);
+    key2.MakeNewKey(true);
+    CPubKey pub1 = key1.GetPubKey();
+    CPubKey pub2 = key2.GetPubKey();
+
+    CScript scriptPubKey = CScript() << OP_IF << ToByteVector(pub1) << OP_CHECKSIG
+                                      << OP_ELSE << ToByteVector(pub2) << OP_CHECKSIG << OP_ENDIF;
+
+    // 4a: branch A satisfied with an ECDSA signature.
+    {
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit));
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key1.Sign_ECDSA(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << OP_1;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+    }
+
+    // 4b: the SAME scriptPubKey's other branch satisfied with a Schnorr
+    // signature -- no uniformity is required across independent CHECKSIGs.
+    {
+        CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit));
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key2.Sign_Schnorr(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << OP_0;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+    }
+
+    // 4c: control -- OP_CHECKMULTISIG rejects the same mix (one ECDSA + one
+    // Schnorr signature) with a dedicated error, proving the risk really is
+    // specific to standalone CHECKSIG calls.
+    {
+        CScript msPubKey = CScript() << OP_2 << ToByteVector(pub1) << ToByteVector(pub2) << OP_2 << OP_CHECKMULTISIG;
+        CMutableTransaction credit = BuildCreditingTx(msPubKey);
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit));
+        uint256 hash = SignatureHash(msPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig1, sig2;
+        BOOST_REQUIRE(key1.Sign_ECDSA(hash, sig1));
+        sig1.push_back((unsigned char)SIGHASH_ALL);
+        BOOST_REQUIRE(key2.Sign_Schnorr(hash, sig2));
+        sig2.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << OP_0 << sig1 << sig2;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, msPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(!ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_MIXED_SCHEME_MULTISIG);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Risk 5: OP_CHECKLOCKTIMEVERIFY can be combined directly with OP_COLOR in a
+// single scriptPubKey at the interpreter level, even though the design
+// intends time-locked colored coins to live only inside a CP2SH redeem
+// script (CheckColorIdentifierValidity enforces that at the consensus
+// layer; the interpreter itself has no opinion).
+// ---------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE(risk_opcolor_with_timelock)
+{
+    CKey key;
+    key.MakeNewKey(true);
+    CPubKey pub = key.GetPubKey();
+
+    COutPoint outpoint(uint256S("0000000000000000000000000000000000000000000000000000000000000003"), 0);
+    ColorIdentifier colorId(outpoint, TokenTypes::REISSUABLE);
+    const int64_t lockHeight = 500000; // block-height style (< LOCKTIME_THRESHOLD)
+
+    CScript scriptPubKey = CScript() << colorId.toVector() << OP_COLOR
+                                      << CScriptNum(lockHeight) << OP_CHECKLOCKTIMEVERIFY << OP_DROP
+                                      << OP_DUP << OP_HASH160 << ToByteVector(pub.GetID())
+                                      << OP_EQUALVERIFY << OP_CHECKSIG;
+
+    CMutableTransaction credit = BuildCreditingTx(scriptPubKey);
+
+    // 5a: locktime satisfied -> interpreter accepts the direct OP_COLOR + CLTV combination.
+    {
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit), 0, lockHeight);
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key.Sign_ECDSA(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << ToByteVector(pub);
+
+        ColorIdentifier resultColorId;
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err, &resultColorId);
+        BOOST_CHECK_MESSAGE(ok, "OP_COLOR directly combined with CHECKLOCKTIMEVERIFY should be accepted by the raw interpreter: " + std::string(ScriptErrorString(err)));
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+        BOOST_CHECK(resultColorId == colorId);
+
+        // The consensus-layer template matcher does not recognize this shape
+        // as colored at all -- CheckColorIdentifierValidity, not the
+        // interpreter, is what actually keeps this pattern out of real blocks.
+        std::vector<unsigned char> hashOut, cidOut;
+        BOOST_CHECK(!scriptPubKey.IsColoredPayToPubkeyHash(hashOut, cidOut));
+        ColorIdentifier fromTemplate = GetColorIdFromScript(scriptPubKey);
+        BOOST_CHECK(fromTemplate.type == TokenTypes::NONE);
+    }
+
+    // 5b: control -- locktime not yet satisfied correctly fails, proving the
+    // CLTV portion of the combined script is genuinely being enforced (this
+    // isn't just OP_COLOR silently swallowing the whole script).
+    {
+        CMutableTransaction spend = BuildSpendingTx(CScript(), CTransaction(credit), 0, lockHeight - 1);
+        uint256 hash = SignatureHash(scriptPubKey, spend, 0, SIGHASH_ALL, credit.vout[0].nValue, SigVersion::BASE);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(key.Sign_ECDSA(hash, sig));
+        sig.push_back((unsigned char)SIGHASH_ALL);
+        spend.vin[0].scriptSig = CScript() << sig << ToByteVector(pub);
+
+        ScriptError err;
+        bool ok = Verify(spend.vin[0].scriptSig, scriptPubKey, spend, credit.vout[0].nValue, STANDARD_SCRIPT_VERIFY_FLAGS, &err);
+        BOOST_CHECK(!ok);
+        BOOST_CHECK_EQUAL(err, SCRIPT_ERR_UNSATISFIED_LOCKTIME);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 676a9e638..c81a54292 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -191,7 +191,8 @@ void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScript
         SCRIPT_VERIFY_MINIMALIF,
         SCRIPT_VERIFY_NULLFAIL,
         SCRIPT_VERIFY_WITNESS_PUBKEYTYPE,
-        SCRIPT_VERIFY_CONST_SCRIPTCODE};
+        SCRIPT_VERIFY_CONST_SCRIPTCODE,
+        SCRIPT_VERIFY_CP2SH_COLORED};
     // If we add many more flags, this loop can get too expensive, but we can
     // rewrite in the future to randomly pick a set of flags to evaluate.
     for (auto extra_flags: test_flags_list) {
@@ -1623,12 +1624,12 @@ BOOST_AUTO_TEST_CASE(script_build)
         CScript cp2sh_spk = CScript() << cp2sh_cid.toVector() << OP_COLOR
                                       << OP_HASH160 << ToByteVector(CScriptID(cp2sh_inner))
                                       << OP_EQUAL;
-        tests.push_back(TestBuilder(cp2sh_spk, "CP2SH(P2PKH) ECDSA", SCRIPT_VERIFY_NONE,
+        tests.push_back(TestBuilder(cp2sh_spk, "CP2SH(P2PKH) ECDSA, redeem script genuinely satisfied (passes with the flag on)", SCRIPT_VERIFY_CP2SH_COLORED,
                                     /*P2SH=*/true, WitnessMode::NONE, 0, 0, false, cp2sh_inner)
                             .PushSig(keys.key1, SignatureScheme::ECDSA)
                             .Push(keys.pubkey1C)
                             .PushRedeem());
-        tests.push_back(TestBuilder(cp2sh_spk, "CP2SH(P2PKH) SCHNORR", SCRIPT_VERIFY_NONE,
+        tests.push_back(TestBuilder(cp2sh_spk, "CP2SH(P2PKH) SCHNORR, redeem script genuinely satisfied (passes with the flag on)", SCRIPT_VERIFY_CP2SH_COLORED,
                                     /*P2SH=*/true, WitnessMode::NONE, 0, 0, false, cp2sh_inner)
                             .PushSig(keys.key1, SignatureScheme::SCHNORR)
                             .Push(keys.pubkey1C)
@@ -2629,12 +2630,12 @@ BOOST_AUTO_TEST_CASE(colored_coin_standard_scripts)
 
     // CP2SH(P2PKH) — colored P2SH where the outer script has OP_COLOR and the
     // redeem script is a plain P2PKH; valid ECDSA and SCHNORR spends
-    tests.push_back(TestBuilder(cp2sh, "CP2SH(P2PKH) ECDSA", SCRIPT_VERIFY_NONE, /*P2SH=*/true)
+    tests.push_back(TestBuilder(cp2sh, "CP2SH(P2PKH) ECDSA", SCRIPT_VERIFY_CP2SH_COLORED, /*P2SH=*/true)
                         .PushSig(keys.key1, SignatureScheme::ECDSA)
                         .Push(keys.pubkey1C)
                         .PushRedeem());
 
-    tests.push_back(TestBuilder(cp2sh, "CP2SH(P2PKH) SCHNORR", SCRIPT_VERIFY_NONE, /*P2SH=*/true)
+    tests.push_back(TestBuilder(cp2sh, "CP2SH(P2PKH) SCHNORR", SCRIPT_VERIFY_CP2SH_COLORED, /*P2SH=*/true)
                         .PushSig(keys.key1, SignatureScheme::SCHNORR)
                         .Push(keys.pubkey1C)
                         .PushRedeem());
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index c1e21e531..d01c0bb2e 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -47,6 +47,7 @@ static std::map<std::string, unsigned int> mapFlagNames = {
     {std::string("DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM},
     {std::string("WITNESS_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_WITNESS_PUBKEYTYPE},
     {std::string("CONST_SCRIPTCODE"), (unsigned int)SCRIPT_VERIFY_CONST_SCRIPTCODE},
+    {std::string("CP2SH_COLORED"), (unsigned int)SCRIPT_VERIFY_CP2SH_COLORED},
 };
 
 unsigned int ParseScriptFlags(std::string strFlags)
@@ -98,7 +99,6 @@ BOOST_AUTO_TEST_CASE(tx_valid)
     UniValue tests = read_json(std::string(json_tests::tx_valid));
 
     ScriptError err;
-    ColorIdentifier colorId;
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
@@ -163,6 +163,9 @@ BOOST_AUTO_TEST_CASE(tx_valid)
                 }
                 unsigned int verify_flags = ParseScriptFlags(test[2].get_str());
                 const CScriptWitness *witness = &tx.vin[i].scriptWitness;
+                // Fresh per input, matching CScriptCheck in production (scriptcheck.h) --
+                // OP_COLOR state must not leak across inputs or across test cases.
+                ColorIdentifier colorId;
                 BOOST_CHECK_MESSAGE(VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout],
                                                  witness, verify_flags, TransactionSignatureChecker(&tx, i, amount, txdata), colorId, &err),
                                     strTest);
@@ -186,7 +189,6 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
     // Initialize to SCRIPT_ERR_OK. The tests expect err to be changed to a
     // value other than SCRIPT_ERR_OK.
     ScriptError err = SCRIPT_ERR_OK;
-    ColorIdentifier colorId;
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
@@ -250,6 +252,9 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
                     amount = mapprevOutValues[tx.vin[i].prevout];
                 }
                 const CScriptWitness *witness = &tx.vin[i].scriptWitness;
+                // Fresh per input, matching CScriptCheck in production (scriptcheck.h) --
+                // OP_COLOR state must not leak across inputs or across test cases.
+                ColorIdentifier colorId;
                 fValid = VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout],
                                       witness, verify_flags, TransactionSignatureChecker(&tx, i, amount, txdata), colorId, &err);
             }
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 4bfbe47eb..c13687845 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -1600,4 +1600,191 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_burn_script, TestChainSetup)
     testTx(this, MakeTransactionRef(spendChangeTx), true);
 }
 
+/*
+ * Risky-but-permitted combination: a "0-of-2" CHECKMULTISIG output is
+ * genuinely spendable by anyone with zero signatures -- not merely a script-
+ * level curiosity but a real, minable, mempool-accepted spend. Unlike the
+ * colored-coin combinations above, there is no consensus-layer check that
+ * catches this: it is accepted at every layer, exactly as classic Bitcoin
+ * multisig has always behaved.
+ */
+BOOST_FIXTURE_TEST_CASE(tx_mempool_risk_checkmultisig_zero_of_n, TestChainSetup)
+{
+    initKeys();
+
+    // Looks like it requires two keys; OP_0 as the "required signatures"
+    // count means it actually requires none.
+    CScript zeroOfTwoScript = CScript() << OP_0 << ToByteVector(pubkey1) << ToByteVector(pubkey2) << OP_2 << OP_CHECKMULTISIG;
+
+    CMutableTransaction fundTx;
+    fundTx.nFeatures = 1;
+    fundTx.vin.resize(1);
+    fundTx.vout.resize(1);
+    fundTx.vin[0].prevout.hashMalFix = m_coinbase_txns[0]->GetHashMalFix();
+    fundTx.vin[0].prevout.n = 0;
+    fundTx.vout[0].nValue = 49 * COIN;
+    fundTx.vout[0].scriptPubKey = zeroOfTwoScript;
+
+    std::vector<unsigned char> vchSig;
+    CMutableTransaction coinbaseIn(*m_coinbase_txns[0]);
+    Sign(vchSig, coinbaseKey, m_coinbase_txns[0]->vout[0].scriptPubKey, coinbaseIn, 0, fundTx, 0);
+    fundTx.vin[0].scriptSig = CScript() << vchSig;
+    testTx(this, MakeTransactionRef(fundTx), true); // mines the funding tx into a block
+
+    // Spend the "0-of-2" output with ZERO signatures -- just the mandatory
+    // dummy element. No knowledge of either private key is used anywhere.
+    CMutableTransaction spendTx;
+    spendTx.nFeatures = 1;
+    spendTx.vin.resize(1);
+    spendTx.vout.resize(1);
+    spendTx.vin[0].prevout.hashMalFix = fundTx.GetHashMalFix();
+    spendTx.vin[0].prevout.n = 0;
+    spendTx.vin[0].scriptSig = CScript() << OP_0;
+    spendTx.vout[0].nValue = 48 * COIN;
+    spendTx.vout[0].scriptPubKey = CScript() << ToByteVector(pubkey0) << OP_CHECKSIG;
+
+    testTx(this, MakeTransactionRef(spendTx), true); // accepted end-to-end: mempool AND mined into a block
+}
+
+/*
+ * Risky-but-permitted combination: OP_CHECKDATASIGVERIFY has no built-in
+ * binding to the spending transaction. The identical (signature, message)
+ * pair is replayed across two independently-funded UTXOs whose spending
+ * transactions differ in every other respect (amount, nLockTime, nSequence,
+ * destination) -- both are accepted end-to-end by the mempool and mined
+ * into blocks. This is deliberately NOT a double-spend of the same UTXO
+ * (which would obviously be rejected for an unrelated reason); it is two
+ * distinct, unrelated transactions satisfied by the same witness data.
+ */
+BOOST_FIXTURE_TEST_CASE(tx_mempool_risk_checkdatasig_replay, TestChainSetup)
+{
+    initKeys();
+
+    CScript dataSigScript = CScript() << ToByteVector(pubkey0) << OP_CHECKDATASIGVERIFY << OP_1;
+
+    auto fundOne = [&](int coinbaseIdx) {
+        CMutableTransaction fundTx;
+        fundTx.nFeatures = 1;
+        fundTx.vin.resize(1);
+        fundTx.vout.resize(1);
+        fundTx.vin[0].prevout.hashMalFix = m_coinbase_txns[coinbaseIdx]->GetHashMalFix();
+        fundTx.vin[0].prevout.n = 0;
+        fundTx.vout[0].nValue = 49 * COIN;
+        fundTx.vout[0].scriptPubKey = dataSigScript;
+        std::vector<unsigned char> vchSig;
+        CMutableTransaction coinbaseIn(*m_coinbase_txns[coinbaseIdx]);
+        Sign(vchSig, coinbaseKey, m_coinbase_txns[coinbaseIdx]->vout[0].scriptPubKey, coinbaseIn, 0, fundTx, 0);
+        fundTx.vin[0].scriptSig = CScript() << vchSig;
+        testTx(this, MakeTransactionRef(fundTx), true);
+        return fundTx;
+    };
+
+    CMutableTransaction fundA = fundOne(0);
+    CMutableTransaction fundB = fundOne(1);
+
+    // Sign ONE message ONCE.
+    std::vector<unsigned char> message = {'h', 'e', 'l', 'l', 'o'};
+    uint256 msgHash;
+    CSHA256().Write(message.data(), message.size()).Finalize(msgHash.begin());
+    std::vector<unsigned char> dataSig;
+    BOOST_REQUIRE(key0.Sign_ECDSA(msgHash, dataSig));
+    CScript identicalScriptSig = CScript() << dataSig << message;
+
+    CMutableTransaction spendA;
+    spendA.nFeatures = 1;
+    spendA.vin.resize(1);
+    spendA.vout.resize(1);
+    spendA.vin[0].prevout.hashMalFix = fundA.GetHashMalFix();
+    spendA.vin[0].prevout.n = 0;
+    spendA.vin[0].scriptSig = identicalScriptSig;
+    spendA.vout[0].nValue = 48 * COIN;
+    spendA.vout[0].scriptPubKey = CScript() << OP_TRUE;
+    testTx(this, MakeTransactionRef(spendA), true);
+
+    // A completely different transaction shape (different UTXO, amount, and
+    // destination) -- reusing the byte-for-byte identical scriptSig from
+    // spendA above. (nLockTime/nSequence are left at defaults: a large,
+    // not-yet-reached nLockTime would be rejected as a non-final transaction
+    // for reasons unrelated to CHECKDATASIG, which would muddy the point.)
+    CMutableTransaction spendB;
+    spendB.nFeatures = 1;
+    spendB.vin.resize(1);
+    spendB.vout.resize(1);
+    spendB.vin[0].prevout.hashMalFix = fundB.GetHashMalFix();
+    spendB.vin[0].prevout.n = 0;
+    spendB.vin[0].scriptSig = identicalScriptSig;
+    spendB.vout[0].nValue = 10 * COIN;
+    spendB.vout[0].scriptPubKey = CScript() << OP_DUP << OP_HASH160 << ToByteVector(pubkeyHash2) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+    testTx(this, MakeTransactionRef(spendB), true); // the replayed witness is accepted end-to-end again
+}
+
+/*
+ * Risky-but-permitted combination: independent OP_CHECKSIG calls (not
+ * OP_CHECKMULTISIG) can freely mix ECDSA and Schnorr signatures. The same
+ * scriptPubKey shape is funded twice; one spend satisfies the IF branch
+ * with an ECDSA signature, the other satisfies the ELSE branch with a
+ * Schnorr signature -- both accepted end-to-end.
+ */
+BOOST_FIXTURE_TEST_CASE(tx_mempool_risk_mixed_signature_schemes, TestChainSetup)
+{
+    initKeys();
+
+    CScript branchScript = CScript() << OP_IF << ToByteVector(pubkey0) << OP_CHECKSIG
+                                      << OP_ELSE << ToByteVector(pubkey1) << OP_CHECKSIG << OP_ENDIF;
+
+    auto fundOne = [&](int coinbaseIdx) {
+        CMutableTransaction fundTx;
+        fundTx.nFeatures = 1;
+        fundTx.vin.resize(1);
+        fundTx.vout.resize(1);
+        fundTx.vin[0].prevout.hashMalFix = m_coinbase_txns[coinbaseIdx]->GetHashMalFix();
+        fundTx.vin[0].prevout.n = 0;
+        fundTx.vout[0].nValue = 49 * COIN;
+        fundTx.vout[0].scriptPubKey = branchScript;
+        std::vector<unsigned char> vchSig;
+        CMutableTransaction coinbaseIn(*m_coinbase_txns[coinbaseIdx]);
+        Sign(vchSig, coinbaseKey, m_coinbase_txns[coinbaseIdx]->vout[0].scriptPubKey, coinbaseIn, 0, fundTx, 0);
+        fundTx.vin[0].scriptSig = CScript() << vchSig;
+        testTx(this, MakeTransactionRef(fundTx), true);
+        return fundTx;
+    };
+
+    CMutableTransaction fundA = fundOne(2);
+    CMutableTransaction fundB = fundOne(3);
+
+    // Branch A: ECDSA signature for pubkey0 (condition pushed as OP_1/true).
+    CMutableTransaction spendA;
+    spendA.nFeatures = 1;
+    spendA.vin.resize(1);
+    spendA.vout.resize(1);
+    spendA.vin[0].prevout.hashMalFix = fundA.GetHashMalFix();
+    spendA.vin[0].prevout.n = 0;
+    spendA.vout[0].nValue = 48 * COIN;
+    spendA.vout[0].scriptPubKey = CScript() << OP_TRUE;
+    uint256 hashA = SignatureHash(branchScript, spendA, 0, SIGHASH_ALL, fundA.vout[0].nValue, SigVersion::BASE);
+    std::vector<unsigned char> sigA;
+    BOOST_REQUIRE(key0.Sign_ECDSA(hashA, sigA));
+    sigA.push_back((unsigned char)SIGHASH_ALL);
+    spendA.vin[0].scriptSig = CScript() << sigA << OP_1;
+    testTx(this, MakeTransactionRef(spendA), true);
+
+    // Branch B: the SAME scriptPubKey shape's other branch, satisfied with a
+    // Schnorr signature for pubkey1 (condition pushed as OP_0/false).
+    CMutableTransaction spendB;
+    spendB.nFeatures = 1;
+    spendB.vin.resize(1);
+    spendB.vout.resize(1);
+    spendB.vin[0].prevout.hashMalFix = fundB.GetHashMalFix();
+    spendB.vin[0].prevout.n = 0;
+    spendB.vout[0].nValue = 48 * COIN;
+    spendB.vout[0].scriptPubKey = CScript() << OP_TRUE;
+    uint256 hashB = SignatureHash(branchScript, spendB, 0, SIGHASH_ALL, fundB.vout[0].nValue, SigVersion::BASE);
+    std::vector<unsigned char> sigB;
+    BOOST_REQUIRE(key1.Sign_Schnorr(hashB, sigB));
+    sigB.push_back((unsigned char)SIGHASH_ALL);
+    spendB.vin[0].scriptSig = CScript() << sigB << OP_0;
+    testTx(this, MakeTransactionRef(spendB), true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()