// Copyright (c) 2013-2015 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 <clientversion.h>
#include <key.h>
#include <key_io.h>
#include <streams.h>
#include <uint256.h>
#include <util/strencodings.h>
#include <util/system.h>

#include <test/test_bitcoin.h>

#include <boost/test/unit_test.hpp>

#include <string>
#include <vector>

struct TestDerivation {
    std::string pub;
    std::string prv;
    unsigned int nChild;
};

struct TestVector {
    std::string strHexMaster;
    std::vector<TestDerivation> vDerive;

    explicit TestVector(std::string strHexMasterIn)
        : strHexMaster(strHexMasterIn) {}

    TestVector &operator()(std::string pub, std::string prv,
                           unsigned int nChild) {
        vDerive.push_back(TestDerivation());
        TestDerivation &der = vDerive.back();
        der.pub = pub;
        der.prv = prv;
        der.nChild = nChild;
        return *this;
    }
};

// clang-format off
TestVector test1 =
  TestVector("000102030405060708090a0b0c0d0e0f")
    ("<KEY>",
     "<KEY>",
     0x80000000)
    ("<KEY>",
     "<KEY>",
     1)
    ("<KEY>",
     "<KEY>",
     0x80000002)
    ("<KEY>",
     "<KEY>",
     2)
    ("<KEY>",
     "<KEY>",
     1000000000)
    ("<KEY>",
     "<KEY>",
     0);

TestVector test2 =
  TestVector("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542")
    ("<KEY>",
     "<KEY>",
     0)
    ("<KEY>",
     "<KEY>",
     0xFFFFFFFF)
    ("<KEY>",
     "<KEY>",
     1)
    ("<KEY>",
     "<KEY>",
     0xFFFFFFFE)
    ("<KEY>",
     "<KEY>",
     2)
    ("<KEY>",
     "<KEY>",
     0);

TestVector test3 =
  TestVector("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be")
    ("<KEY>",
     "<KEY>",
      0x80000000)
    ("<KEY>",
     "<KEY>",
      0);
// clang-format on

static void RunTest(const TestVector &test) {
    std::vector<uint8_t> seed = ParseHex(test.strHexMaster);
    CExtKey key;
    CExtPubKey pubkey;
    key.SetMaster(seed.data(), seed.size());
    pubkey = key.Neuter();
    for (const TestDerivation &derive : test.vDerive) {
        uint8_t data[74];
        key.Encode(data);
        pubkey.Encode(data);

        // Test private key
        BOOST_CHECK(EncodeExtKey(key) == derive.prv);
        // Ensure a base58 decoded key also matches
        BOOST_CHECK(DecodeExtKey(derive.prv) == key);

        // Test public key
        BOOST_CHECK(EncodeExtPubKey(pubkey) == derive.pub);
        // Ensure a base58 decoded pubkey also matches
        BOOST_CHECK(DecodeExtPubKey(derive.pub) == pubkey);

        // Derive new keys
        CExtKey keyNew;
        BOOST_CHECK(key.Derive(keyNew, derive.nChild));
        CExtPubKey pubkeyNew = keyNew.Neuter();
        if (!(derive.nChild & 0x80000000)) {
            // Compare with public derivation
            CExtPubKey pubkeyNew2;
            BOOST_CHECK(pubkey.Derive(pubkeyNew2, derive.nChild));
            BOOST_CHECK(pubkeyNew == pubkeyNew2);
        }
        key = keyNew;
        pubkey = pubkeyNew;

        CDataStream ssPub(SER_DISK, CLIENT_VERSION);
        ssPub << pubkeyNew;
        BOOST_CHECK(ssPub.size() == 75);

        CDataStream ssPriv(SER_DISK, CLIENT_VERSION);
        ssPriv << keyNew;
        BOOST_CHECK(ssPriv.size() == 75);

        CExtPubKey pubCheck;
        CExtKey privCheck;
        ssPub >> pubCheck;
        ssPriv >> privCheck;

        BOOST_CHECK(pubCheck == pubkeyNew);
        BOOST_CHECK(privCheck == keyNew);
    }
}

BOOST_FIXTURE_TEST_SUITE(bip32_tests, BasicTestingSetup)

BOOST_AUTO_TEST_CASE(bip32_test1) {
    RunTest(test1);
}

BOOST_AUTO_TEST_CASE(bip32_test2) {
    RunTest(test2);
}

BOOST_AUTO_TEST_CASE(bip32_test3) {
    RunTest(test3);
}

bool check_key_size_message(const std::runtime_error &e) {
    BOOST_CHECK_EQUAL(e.what(), "Invalid extended key size\n");
    return true;
}

BOOST_AUTO_TEST_CASE(bip32_serialization) {
    std::vector<std::string> pubkeys{
        "013442193e8000000047fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad1628"
        "2c7ae6236141035a784662a4a20a65bf6aab9ae98a6c068a81c52e4b032c0fb5400c70"
        "6cfccc56",
        "025c1bd648000000012a7857631386ba23dacac34180dd1983734e444fdbf774041578"
        "e9b6adb37c1903501e454bf00751f24b1b489aa925215d66af2234e3891c3b21a52bed"
        "b3cd711c",
        "03bef5a2f98000000204466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3"
        "<KEY>"
        "96ee8dc2",
        "<KEY>"
        "75ac822a3edd02e8445082a72f29b75ca48748a914df60622a609cacfce8ed0e358045"
        "60741d29",
        "05d880d7d83b9aca00c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548"
        "a8b078e65e9e022a471424da5e657499d1ff51cb43c47481a03b1e77f951fe64cec9f5"
        "a48f7011",
        "<KEY>"
        "ea36c8fc3fda028817473b2e81a20b60a24fc7a0d7869368ebc36740cfe08a18a19a9d"
        "dafae67c",
        "01bd16bee500000000f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7"
        "<KEY>"
        "a98d12ea",
        "025a61ff8effffffffbe17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b3854"
        "7f585c9a37d903c01e7425647bdefa82b12d9bad5e3e6865bee0502694b94ca58b666a"
        "bc0a5c3b",
        "03d8ab493700000001f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c92"
        "<KEY>"
        "1a7df5b9",
        "0478412e3afffffffe637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06"
        "cc29a65a0e2902d2b36900396c9282fa14628566582f206a5dd0bcc8d5e892611806ca"
        "fb0301f0",
        "<KEY>"
        "eedf394ed271024d902e1a2fc7a8755ab5b694c575fce742c48d9ff192e63df5193e4c"
        "7afe1f9c",
        "0626132fdb0000000005bcc50a4c1bbfa6d982ae1f410f88ddcbacad781b11b8790c86"
        "f49cdf9e77b0031c0517fff3d483f06ca769bd2326bf30aca1c4de278e676e6ef760c3"
        "301244c6",
        "<KEY>"
        "<KEY>"
        "7712e7f2",
        "02c61368bb000000007c63ec0429a7324b76014ad222a32b7fdd3ae8755d0d2b2e3dfb"
        "5ede9787af990379e45b3cf75f9c5f9befd8e9506fb962f6a9d185ac87001ec44a8d3d"
        "f8d4a9e3",
    };

    for (const std::string &hex : pubkeys) {
        CDataStream ss(SER_DISK, CLIENT_VERSION);
        ss << ParseHex(hex);
        BOOST_CHECK(ss.size() == 75);

        CExtPubKey pubkey;
        BOOST_CHECK_NO_THROW(ss >> pubkey);

        ss << ParseHex(hex + "00");
        BOOST_CHECK(ss.size() == 76);
        BOOST_CHECK_EXCEPTION(ss >> pubkey, std::runtime_error,
                              check_key_size_message);

        ss.clear();
        ss << ParseHex(hex.substr(0, hex.size() - 1));
        BOOST_CHECK(ss.size() == 74);
        BOOST_CHECK_EXCEPTION(ss >> pubkey, std::runtime_error,
                              check_key_size_message);
    }

    std::vector<std::string> privkeys{
        "013442193e8000000047fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad1628"
        "2c7ae623614100edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d9"
        "11a0afea",
        "025c1bd648000000012a7857631386ba23dacac34180dd1983734e444fdbf774041578"
        "<KEY>"
        "<KEY>",
        "03bef5a2f98000000204466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3"
        "<KEY>"
        "fa424dca",
        "<KEY>"
        "75ac822a3edd000f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a"
        "2a764ef4",
        "05d880d7d83b9aca00c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548"
        "a8b078e65e9e00471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6"
        "c3e6e7c8",
        "<KEY>"
        "<KEY>"
        "e0e2f061",
        "01bd16bee500000000f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7"
        "412f232f7c9c00abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f"
        "15ac7e1e",
        "025a61ff8effffffffbe17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b3854"
        "7f585c9a37d900877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18f"
        "d52e6e93",
        "03d8ab493700000001f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c92"
        "7eb246fb38cb00704addf544a06e5ee4bea37098463c23613da32020d604506da8c051"
        "8e1da4b7",
        "0478412e3afffffffe637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06"
        "cc29a65a0e2900f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b"
        "247d6a2d",
        "<KEY>"
        "eedf394ed27100bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a484"
        "2125ac23",
        "<KEY>"
        "f49cdf9e77b0004b7e8b1aa263519f7fbed001d5b0c4a5fdac81db8abe14c327e2f534"
        "92e55fa7",
        "<KEY>"
        "<KEY>"
        "44e1daef",
        "02c61368bb000000007c63ec0429a7324b76014ad222a32b7fdd3ae8755d0d2b2e3dfb"
        "5ede9787af9900129ee831061c31be7d636fc0402fd2299855f40015a2c60b2e5755c5"
        "7270460d",
    };

    for (const std::string &hex : privkeys) {
        CDataStream ss(SER_DISK, CLIENT_VERSION);
        ss << ParseHex(hex);
        BOOST_CHECK(ss.size() == 75);

        CExtKey privkey;
        BOOST_CHECK_NO_THROW(ss >> privkey);

        ss << ParseHex(hex + "00");
        BOOST_CHECK(ss.size() == 76);
        BOOST_CHECK_EXCEPTION(ss >> privkey, std::runtime_error,
                              check_key_size_message);

        ss.clear();
        ss << ParseHex(hex.substr(0, hex.size() - 1));
        BOOST_CHECK(ss.size() == 74);
        BOOST_CHECK_EXCEPTION(ss >> privkey, std::runtime_error,
                              check_key_size_message);
    }
}

BOOST_AUTO_TEST_SUITE_END()
