// Copyright (c) 2017-2022 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 <test/data/bip341_wallet_vectors.json.h>

#include <key.h>
#include <key_io.h>
#include <script/script.h>
#include <script/signingprovider.h>
#include <script/solver.h>
#include <test/util/setup_common.h>
#include <util/strencodings.h>

#include <boost/test/unit_test.hpp>

#include <univalue.h>

using namespace util::hex_literals;

BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)

BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
{
    CTxDestination dest;
    BOOST_CHECK(!IsValidDestination(dest));
}

BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
{
    CKey keys[3];
    CPubKey pubkeys[3];
    for (int i = 0; i < 3; i++) {
        keys[i].MakeNewKey(true);
        pubkeys[i] = keys[i].GetPubKey();
    }

    CScript s;
    std::vector<std::vector<unsigned char> > solutions;

    // TxoutType::PUBKEY
    s.clear();
    s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));

    // TxoutType::PUBKEYHASH
    s.clear();
    s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));

    // TxoutType::SCRIPTHASH
    CScript redeemScript(s); // initialize with leftover P2PKH script
    s.clear();
    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));

    // TxoutType::MULTISIG
    s.clear();
    s << OP_1 <<
        ToByteVector(pubkeys[0]) <<
        ToByteVector(pubkeys[1]) <<
        OP_2 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
    BOOST_CHECK_EQUAL(solutions.size(), 4U);
    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
    BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));

    s.clear();
    s << OP_2 <<
        ToByteVector(pubkeys[0]) <<
        ToByteVector(pubkeys[1]) <<
        ToByteVector(pubkeys[2]) <<
        OP_3 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
    BOOST_CHECK_EQUAL(solutions.size(), 5U);
    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
    BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
    BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));

    // TxoutType::NULL_DATA
    s.clear();
    s << OP_RETURN <<
        std::vector<unsigned char>({0}) <<
        std::vector<unsigned char>({75}) <<
        std::vector<unsigned char>({255});
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
    BOOST_CHECK_EQUAL(solutions.size(), 0U);

    // TxoutType::WITNESS_V0_KEYHASH
    s.clear();
    s << OP_0 << ToByteVector(pubkeys[0].GetID());
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_KEYHASH);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));

    // TxoutType::WITNESS_V0_SCRIPTHASH
    uint256 scriptHash;
    CSHA256().Write(redeemScript.data(), redeemScript.size())
        .Finalize(scriptHash.begin());

    s.clear();
    s << OP_0 << ToByteVector(scriptHash);
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_SCRIPTHASH);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));

    // TxoutType::WITNESS_V1_TAPROOT
    s.clear();
    s << OP_1 << ToByteVector(uint256::ZERO);
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V1_TAPROOT);
    BOOST_CHECK_EQUAL(solutions.size(), 1U);
    BOOST_CHECK(solutions[0] == ToByteVector(uint256::ZERO));

    // TxoutType::WITNESS_UNKNOWN
    s.clear();
    s << OP_16 << ToByteVector(uint256::ONE);
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
    BOOST_CHECK_EQUAL(solutions.size(), 2U);
    BOOST_CHECK(solutions[0] == std::vector<unsigned char>{16});
    BOOST_CHECK(solutions[1] == ToByteVector(uint256::ONE));

    // TxoutType::ANCHOR
    std::vector<unsigned char> anchor_bytes{0x4e, 0x73};
    s.clear();
    s << OP_1 << anchor_bytes;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::ANCHOR);
    BOOST_CHECK(solutions.empty());

    // Sanity-check IsPayToAnchor
    int version{-1};
    std::vector<unsigned char> witness_program;
    BOOST_CHECK(s.IsPayToAnchor());
    BOOST_CHECK(s.IsWitnessProgram(version, witness_program));
    BOOST_CHECK(CScript::IsPayToAnchor(version, witness_program));

    // TxoutType::NONSTANDARD
    s.clear();
    s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
}

BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
{
    CKey key = GenerateRandomKey();
    CPubKey pubkey = key.GetPubKey();

    CScript s;
    std::vector<std::vector<unsigned char> > solutions;

    // TxoutType::PUBKEY with incorrectly sized pubkey
    s.clear();
    s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::PUBKEYHASH with incorrectly sized key hash
    s.clear();
    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::SCRIPTHASH with incorrectly sized script hash
    s.clear();
    s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::MULTISIG 0/2
    s.clear();
    s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::MULTISIG 2/1
    s.clear();
    s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::MULTISIG n = 2 with 1 pubkey
    s.clear();
    s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::MULTISIG n = 1 with 0 pubkeys
    s.clear();
    s << OP_1 << OP_1 << OP_CHECKMULTISIG;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::NULL_DATA with other opcodes
    s.clear();
    s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::WITNESS_UNKNOWN with incorrect program size
    s.clear();
    s << OP_0 << std::vector<unsigned char>(19, 0x01);
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);

    // TxoutType::ANCHOR but wrong witness version
    s.clear();
    s << OP_2 << std::vector<unsigned char>{0x4e, 0x73};
    BOOST_CHECK(!s.IsPayToAnchor());
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);

    // TxoutType::ANCHOR but wrong 2-byte data push
    s.clear();
    s << OP_1 << std::vector<unsigned char>{0xff, 0xff};
    BOOST_CHECK(!s.IsPayToAnchor());
    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
}

BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
{
    CKey key = GenerateRandomKey();
    CPubKey pubkey = key.GetPubKey();

    CScript s;
    CTxDestination address;

    // TxoutType::PUBKEY
    s.clear();
    s << ToByteVector(pubkey) << OP_CHECKSIG;
    BOOST_CHECK(!ExtractDestination(s, address));
    BOOST_CHECK(std::get<PubKeyDestination>(address) == PubKeyDestination(pubkey));

    // TxoutType::PUBKEYHASH
    s.clear();
    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
    BOOST_CHECK(ExtractDestination(s, address));
    BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));

    // TxoutType::SCRIPTHASH
    CScript redeemScript(s); // initialize with leftover P2PKH script
    s.clear();
    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
    BOOST_CHECK(ExtractDestination(s, address));
    BOOST_CHECK(std::get<ScriptHash>(address) == ScriptHash(redeemScript));

    // TxoutType::MULTISIG
    s.clear();
    s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
    BOOST_CHECK(!ExtractDestination(s, address));

    // TxoutType::NULL_DATA
    s.clear();
    s << OP_RETURN << std::vector<unsigned char>({75});
    BOOST_CHECK(!ExtractDestination(s, address));

    // TxoutType::WITNESS_V0_KEYHASH
    s.clear();
    s << OP_0 << ToByteVector(pubkey.GetID());
    BOOST_CHECK(ExtractDestination(s, address));
    WitnessV0KeyHash keyhash;
    CHash160().Write(pubkey).Finalize(keyhash);
    BOOST_CHECK(std::get<WitnessV0KeyHash>(address) == keyhash);

    // TxoutType::WITNESS_V0_SCRIPTHASH
    s.clear();
    WitnessV0ScriptHash scripthash;
    CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
    s << OP_0 << ToByteVector(scripthash);
    BOOST_CHECK(ExtractDestination(s, address));
    BOOST_CHECK(std::get<WitnessV0ScriptHash>(address) == scripthash);

    // TxoutType::WITNESS_UNKNOWN with unknown version
    s.clear();
    s << OP_1 << ToByteVector(pubkey);
    BOOST_CHECK(ExtractDestination(s, address));
    WitnessUnknown unk{1, ToByteVector(pubkey)};
    BOOST_CHECK(std::get<WitnessUnknown>(address) == unk);
}

BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
{
    CKey keys[3];
    CPubKey pubkeys[3];
    for (int i = 0; i < 3; i++) {
        keys[i].MakeNewKey(true);
        pubkeys[i] = keys[i].GetPubKey();
    }

    CScript expected, result;

    // PKHash
    expected.clear();
    expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
    result = GetScriptForDestination(PKHash(pubkeys[0]));
    BOOST_CHECK(result == expected);

    // CScriptID
    CScript redeemScript(result);
    expected.clear();
    expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
    result = GetScriptForDestination(ScriptHash(redeemScript));
    BOOST_CHECK(result == expected);

    // CNoDestination
    expected.clear();
    result = GetScriptForDestination(CNoDestination());
    BOOST_CHECK(result == expected);

    // GetScriptForRawPubKey
    expected.clear();
    expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
    result = GetScriptForRawPubKey(pubkeys[0]);
    BOOST_CHECK(result == expected);

    // GetScriptForMultisig
    expected.clear();
    expected << OP_2 <<
        ToByteVector(pubkeys[0]) <<
        ToByteVector(pubkeys[1]) <<
        ToByteVector(pubkeys[2]) <<
        OP_3 << OP_CHECKMULTISIG;
    result = GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
    BOOST_CHECK(result == expected);

    // WitnessV0KeyHash
    expected.clear();
    expected << OP_0 << ToByteVector(pubkeys[0].GetID());
    result = GetScriptForDestination(WitnessV0KeyHash(Hash160(ToByteVector(pubkeys[0]))));
    BOOST_CHECK(result == expected);
    result = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
    BOOST_CHECK(result == expected);

    // WitnessV0ScriptHash (multisig)
    CScript witnessScript;
    witnessScript << OP_1 << ToByteVector(pubkeys[0]) << OP_1 << OP_CHECKMULTISIG;

    uint256 scriptHash;
    CSHA256().Write(witnessScript.data(), witnessScript.size())
        .Finalize(scriptHash.begin());

    expected.clear();
    expected << OP_0 << ToByteVector(scriptHash);
    result = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
    BOOST_CHECK(result == expected);
}

BOOST_AUTO_TEST_CASE(script_standard_taproot_builder)
{
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,2}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,1}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,2}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,0}), false);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,1}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2}), false);
    // REDUCED_DATA limits Taproot tree depth to 7 instead of 128
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2,3,4,5,6,7,7}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({7,7,6,5,4,3,2,1}), true);
    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({8,8,7,6,5,4,3,2,1}), false);

    XOnlyPubKey key_inner{"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"_hex_u8};
    XOnlyPubKey key_1{"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"_hex_u8};
    XOnlyPubKey key_2{"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"_hex_u8};
    CScript script_1 = CScript() << ToByteVector(key_1) << OP_CHECKSIG;
    CScript script_2 = CScript() << ToByteVector(key_2) << OP_CHECKSIG;
    constexpr uint256 hash_3{"31fe7061656bea2a36aa60a2f7ef940578049273746935d296426dc0afd86b68"};

    TaprootBuilder builder;
    BOOST_CHECK(builder.IsValid() && builder.IsComplete());
    builder.Add(2, script_2, 0xc0);
    BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
    builder.AddOmitted(2, hash_3);
    BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
    builder.Add(1, script_1, 0xc0);
    BOOST_CHECK(builder.IsValid() && builder.IsComplete());
    builder.Finalize(key_inner);
    BOOST_CHECK(builder.IsValid() && builder.IsComplete());
    BOOST_CHECK_EQUAL(EncodeDestination(builder.GetOutput()), "bc1pj6gaw944fy0xpmzzu45ugqde4rz7mqj5kj0tg8kmr5f0pjq8vnaqgynnge");
}

BOOST_AUTO_TEST_CASE(bip341_spk_test_vectors)
{
    using control_set = decltype(TaprootSpendData::scripts)::mapped_type;

    UniValue tests;
    tests.read(json_tests::bip341_wallet_vectors);

    const auto& vectors = tests["scriptPubKey"];

    for (const auto& vec : vectors.getValues()) {
        TaprootBuilder spktest;
        std::map<std::pair<std::vector<unsigned char>, int>, int> scriptposes;
        std::function<void (const UniValue&, int)> parse_tree = [&](const UniValue& node, int depth) {
            if (node.isNull()) return;
            if (node.isObject()) {
                auto script = ParseHex(node["script"].get_str());
                int idx = node["id"].getInt<int>();
                int leaf_version = node["leafVersion"].getInt<int>();
                scriptposes[{script, leaf_version}] = idx;
                spktest.Add(depth, script, leaf_version);
            } else {
                parse_tree(node[0], depth + 1);
                parse_tree(node[1], depth + 1);
            }
        };
        parse_tree(vec["given"]["scriptTree"], 0);
        spktest.Finalize(XOnlyPubKey(ParseHex(vec["given"]["internalPubkey"].get_str())));
        BOOST_CHECK_EQUAL(HexStr(GetScriptForDestination(spktest.GetOutput())), vec["expected"]["scriptPubKey"].get_str());
        BOOST_CHECK_EQUAL(EncodeDestination(spktest.GetOutput()), vec["expected"]["bip350Address"].get_str());
        auto spend_data = spktest.GetSpendData();
        BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].isNull(), spend_data.merkle_root.IsNull());
        if (!spend_data.merkle_root.IsNull()) {
            BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].get_str(), HexStr(spend_data.merkle_root));
        }
        BOOST_CHECK_EQUAL(spend_data.scripts.size(), scriptposes.size());
        for (const auto& scriptpos : scriptposes) {
            BOOST_CHECK(spend_data.scripts[scriptpos.first] == control_set{ParseHex(vec["expected"]["scriptPathControlBlocks"][scriptpos.second].get_str())});
        }
    }
}

BOOST_AUTO_TEST_SUITE_END()
