// Copyright (c) 2009-present 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 <key_io.h>

#include <pubkey.h>

#include <script/descriptor.h>

#include <test/fuzz/fuzz.h>

#include <test/fuzz/util/descriptor.h>

#include <util/chaintype.h>

#include <util/strencodings.h>

//! The converter of mocked descriptors, needs to be initialized when the target is.

MockedDescriptorConverter MOCKED_DESC_CONVERTER;

/** Test a successfully parsed descriptor. */

static void TestDescriptor(const Descriptor& desc, FlatSigningProvider& sig_provider, std::string& dummy, std::optional<bool>& is_ranged, std::optional<bool>& is_solvable)

{

    // Trivial helpers.

    (void)desc.IsRange();

    (void)desc.IsSingleType();

    (void)desc.GetOutputType();

    if (is_ranged.has_value()) {

  Branch (25:9): [True: 31.7k, False: 5.77k]

        assert(desc.IsRange() == *is_ranged);

  Branch (26:9): [True: 31.7k, False: 0]

    } else {

        is_ranged = desc.IsRange();

    }

    if (is_solvable.has_value()) {

  Branch (30:9): [True: 31.7k, False: 5.77k]

        assert(desc.IsSolvable() == *is_solvable);

  Branch (31:9): [True: 31.7k, False: 0]

    } else {

        is_solvable = desc.IsSolvable();

    }

    // Serialization to string representation.

    (void)desc.ToString();

    (void)desc.ToPrivateString(sig_provider, dummy);

    (void)desc.ToNormalizedString(sig_provider, dummy);

    // Serialization to Script.

    DescriptorCache cache;

    std::vector<CScript> out_scripts;

    (void)desc.Expand(0, sig_provider, out_scripts, sig_provider, &cache);

    (void)desc.ExpandPrivate(0, sig_provider, sig_provider);

    (void)desc.ExpandFromCache(0, cache, out_scripts, sig_provider);

    // If we could serialize to script we must be able to infer using the same provider.

    if (!out_scripts.empty()) {

  Branch (49:9): [True: 35.8k, False: 1.72k]

        assert(InferDescriptor(out_scripts.back(), sig_provider));

  Branch (50:9): [True: 35.8k, False: 0]

        // The ScriptSize() must match the size of the serialized Script. (ScriptSize() is set for all descs but 'combo()'.)

        const bool is_combo{!desc.IsSingleType()};

        assert(is_combo || desc.ScriptSize() == out_scripts.back().size());

  Branch (54:9): [True: 730, False: 35.1k]
  Branch (54:9): [True: 35.1k, False: 0]
  Branch (54:9): [True: 35.8k, False: 0]

    }

    const auto max_sat_maxsig{desc.MaxSatisfactionWeight(true)};

    const auto max_sat_nonmaxsig{desc.MaxSatisfactionWeight(false)};

    // Whether an estimate is available must not depend on the signature-size

    // assumption, and assuming non-max-size signatures must never increase it.

    assert(max_sat_maxsig.has_value() == max_sat_nonmaxsig.has_value());

  Branch (61:5): [True: 37.5k, False: 0]

    assert(max_sat_nonmaxsig <= max_sat_maxsig);

  Branch (62:5): [True: 37.5k, False: 0]

    const auto max_elems{desc.MaxSatisfactionElems()};

    // We must be able to estimate the max satisfaction size for any solvable descriptor (but combo).

    const bool is_nontop_or_nonsolvable{!*is_solvable || !desc.GetOutputType()};

  Branch (65:41): [True: 359, False: 37.1k]
  Branch (65:58): [True: 1.49k, False: 35.7k]

    const bool is_input_size_info_set{max_sat_maxsig && max_sat_nonmaxsig && max_elems};

  Branch (66:39): [True: 36.3k, False: 1.24k]
  Branch (66:57): [True: 36.3k, False: 0]
  Branch (66:78): [True: 36.3k, False: 0]

    assert(is_input_size_info_set || is_nontop_or_nonsolvable);

  Branch (67:5): [True: 36.3k, False: 1.24k]
  Branch (67:5): [True: 1.24k, False: 0]
  Branch (67:5): [True: 37.5k, False: 0]

    auto max_key_expr = desc.GetMaxKeyExpr();

    auto key_count = desc.GetKeyCount();

    assert((max_key_expr == 0 && key_count == 0) || max_key_expr + 1 == key_count);

  Branch (71:5): [True: 9.08k, False: 28.4k]
  Branch (71:5): [True: 359, False: 8.72k]
  Branch (71:5): [True: 37.1k, False: 0]
  Branch (71:5): [True: 37.5k, False: 0]

}

void initialize_descriptor_parse()

{

    static ECC_Context ecc_context{};

    SelectParams(ChainType::MAIN);

}

void initialize_mocked_descriptor_parse()

{

    initialize_descriptor_parse();

    MOCKED_DESC_CONVERTER.Init();

}

FUZZ_TARGET(mocked_descriptor_parse, .init = initialize_mocked_descriptor_parse)

{

    const std::string mocked_descriptor{buffer.begin(), buffer.end()};

    if (const auto descriptor = MOCKED_DESC_CONVERTER.GetDescriptor(mocked_descriptor)) {

  Branch (89:20): [True: 5.93k, False: 25]

        if (IsTooExpensive(MakeUCharSpan(*descriptor))) return;

  Branch (90:13): [True: 20, False: 5.91k]

        FlatSigningProvider signing_provider;

        std::string error;

        const auto desc = Parse(*descriptor, signing_provider, error);

        std::optional<bool> is_ranged;

        std::optional<bool> is_solvable;

        for (const auto& d : desc) {

  Branch (96:28): [True: 24.3k, False: 5.91k]

            assert(d);

  Branch (97:13): [True: 24.3k, False: 0]

            TestDescriptor(*d, signing_provider, error, is_ranged, is_solvable);

        }

    }

}

FUZZ_TARGET(descriptor_parse, .init = initialize_descriptor_parse)

{

    if (IsTooExpensive(buffer)) return;

  Branch (105:9): [True: 11, False: 4.59k]

    const std::string descriptor(buffer.begin(), buffer.end());

    FlatSigningProvider signing_provider;

    std::string error;

    for (const bool require_checksum : {true, false}) {

  Branch (110:38): [True: 9.18k, False: 4.59k]

        const auto desc = Parse(descriptor, signing_provider, error, require_checksum);

        std::optional<bool> is_ranged;

        std::optional<bool> is_solvable;

        for (const auto& d : desc) {

  Branch (114:28): [True: 13.2k, False: 9.18k]

            assert(d);

  Branch (115:13): [True: 13.2k, False: 0]

            TestDescriptor(*d, signing_provider, error, is_ranged, is_solvable);

        }

    }

}