diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 665704a7f..184eedaca 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -1,100 +1,113 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 #include <compressor.h>
 #include <core_io.h>
 #include <core_memusage.h>
 #include <policy/policy.h>
 #include <pubkey.h>
 #include <script/descriptor.h>
+#include <script/interpreter.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <univalue.h>
 
 #include <memory>
 
 void initialize() {
     // Fuzzers using pubkey must hold an ECCVerifyHandle.
     static const ECCVerifyHandle verify_handle;
 
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
-    const CScript script(buffer.begin(), buffer.end());
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+    const std::optional<CScript> script_opt =
+        ConsumeDeserializable<CScript>(fuzzed_data_provider);
+    if (!script_opt) {
+        return;
+    }
+    const CScript script{*script_opt};
 
     std::vector<uint8_t> compressed;
     if (CompressScript(script, compressed)) {
         const unsigned int size = compressed[0];
         compressed.erase(compressed.begin());
         assert(size >= 0 && size <= 5);
         CScript decompressed_script;
         const bool ok = DecompressScript(decompressed_script, size, compressed);
         assert(ok);
         assert(script == decompressed_script);
     }
 
     CTxDestination address;
     (void)ExtractDestination(script, address);
 
     txnouttype type_ret;
     std::vector<CTxDestination> addresses;
     int required_ret;
     (void)ExtractDestinations(script, type_ret, addresses, required_ret);
 
     const FlatSigningProvider signing_provider;
     (void)InferDescriptor(script, signing_provider);
 
     (void)script.IsWitnessProgram();
 
     (void)IsSolvable(signing_provider, script);
 
     txnouttype which_type;
     (void)IsStandard(script, which_type);
 
     (void)RecursiveDynamicUsage(script);
 
     std::vector<std::vector<uint8_t>> solutions;
     (void)Solver(script, solutions);
 
     (void)script.HasValidOps();
     (void)script.IsPayToScriptHash();
     (void)script.IsPushOnly();
     (void)script.IsUnspendable();
     (void)script.IsWitnessProgram();
 
     (void)FormatScript(script);
     (void)ScriptToAsmStr(script, false);
     (void)ScriptToAsmStr(script, true);
 
     UniValue o1(UniValue::VOBJ);
     ScriptPubKeyToUniv(script, o1, true);
     UniValue o2(UniValue::VOBJ);
     ScriptPubKeyToUniv(script, o2, false);
     UniValue o3(UniValue::VOBJ);
     ScriptToUniv(script, o3, true);
     UniValue o4(UniValue::VOBJ);
     ScriptToUniv(script, o4, false);
 
     {
-        FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
         const std::vector<uint8_t> bytes =
             ConsumeRandomLengthByteVector(fuzzed_data_provider);
         // DecompressScript(..., ..., bytes) is not guaranteed to be defined if
-        // bytes.size() <= 23.
-        if (bytes.size() >= 24) {
+        // the bytes vector is too short
+        if (bytes.size() >= 32) {
             CScript decompressed_script;
             DecompressScript(
                 decompressed_script,
                 fuzzed_data_provider.ConsumeIntegral<unsigned int>(), bytes);
         }
     }
+
+    const std::optional<CScript> other_script =
+        ConsumeDeserializable<CScript>(fuzzed_data_provider);
+    if (other_script) {
+        CScript script_mut{script};
+        (void)FindAndDelete(script_mut, *other_script);
+    }
 }