// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2020 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 <arith_uint256.h>

#include <chainparamsseeds.h>
#include <consensus/merkle.h>
#include <hash.h> // for signet block challenge hash
#include <tinyformat.h>
#include <util/system.h>
#include <util/strencodings.h>
#include <versionbitsinfo.h>

#include <assert.h>

#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>

static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
    CMutableTransaction txNew;
    txNew.nVersion = 1;
    txNew.vin.resize(1);
    txNew.vout.resize(1);
    txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
    txNew.vout[0].nValue = genesisReward;
    txNew.vout[0].scriptPubKey = genesisOutputScript;

    CBlock genesis;
    genesis.nTime    = nTime;
    genesis.nBits    = nBits;
    genesis.nNonce   = nNonce;
    genesis.nVersion = nVersion;
    genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
    genesis.hashPrevBlock.SetNull();
    genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
    return genesis;
}

/**
 * Build the genesis block. Note that the output of its generation
 * transaction cannot be spent since it did not originally exist in the
 * database.
 *
 * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
 *   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
 *     CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
 *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
 *   vMerkleTree: 4a5e1e
 */
static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
    const char* pszTimestamp = "MoonBite: fair launch, no premine, every coin mined from zero";
    const CScript genesisOutputScript = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
}

static std::vector<uint256> GetFrozenMWEBOutputIDs()
{
    // The output frozen upstream was a Litecoin-mainnet incident artifact.
    // That output cannot exist on this chain, so nothing is frozen.
    return {};
}

/**
 * Main network
 */
class CMainParams : public CChainParams {
public:
    CMainParams() {
        strNetworkID = CBaseChainParams::MAIN;
        consensus.signet_blocks = false;
        consensus.signet_challenge.clear();
        consensus.nSubsidyHalvingInterval = 1650000;
        // MoonBite takes NO protocol revenue. There is no treasury, no dev
        // tail, no fee split and no team allocation: 100% of every block
        // subsidy plus 100% of every transaction fee goes to the miner who
        // found the block. The mechanism below is left inert (rate 0, empty
        // script) rather than ripped out, so the zero is explicit and
        // auditable in consensus code rather than merely absent.
        consensus.nTreasuryRateBps = 0;
        consensus.nTreasurySunsetHeight = 0;
        consensus.treasuryScript.clear();

        // MoonBite launches in 2026 from a fresh genesis, so every soft fork is
        // active from block 1. The inherited Litecoin heights left P2SH unenforced
        // for ~4 years and segwit inactive for ~23 - which would have made the
        // moon1... bech32 addresses this wallet already issues anyone-can-spend.
        // There is no legacy chain here to stay compatible with.
        consensus.BIP16Height = 1;
        consensus.BIP34Height = 1;
        consensus.BIP34Hash = uint256();
        consensus.BIP65Height = 1;
        consensus.BIP66Height = 1;
        consensus.CSVHeight = 1;
        consensus.SegwitHeight = 1;
        consensus.MinBIP9WarningHeight = 2017; // segwit height + miner confirmation window
        consensus.powLimit = uint256S("000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // MoonBite: 0x1f0fffff, bootstrap floor (genesis nBits 0x1f0ffff0)
        consensus.nPowTargetTimespan = 2 * 60 * 60; // 2 hours (60 blocks x 2 min)
        consensus.nPowTargetSpacing = 2 * 60; // MoonBite: 2-minute blocks
        consensus.fPowAllowMinDifficultyBlocks = false;
        consensus.fPowNoRetargeting = false;
        consensus.nRuleChangeActivationThreshold = 45; // 75% of 60
        consensus.nMinerConfirmationWindow = 60; // nPowTargetTimespan / nPowTargetSpacing
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

        // Deployment of Taproot (BIPs 340-342)
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartHeight = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeoutHeight = 2016;

        // Deployment of MWEB (LIP-0002, LIP-0003, and LIP-0004)
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].bit = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nStartHeight = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nTimeoutHeight = 2016;

        // MoonBite (bug-bounty #6, 2026-10-09): pin a minimum-chain-work floor and
        // an assumevalid block so a node in initial sync rejects low-work attacker
        // header chains immediately instead of downloading/validating them (IBD
        // resource-exhaustion + weakened eclipse resistance on a fresh node).
        // Values are taken from buried, final blocks of the live mainnet, far
        // below the tip, so a node can never stall below them.
        consensus.nMinimumChainWork = uint256{}; // fresh chain reset 2026-10: no buried work yet
        consensus.defaultAssumeValid = uint256{}; // fresh chain reset 2026-10: no assumed-valid block yet

        consensus.mweb_input_metadata_grandfather_blockhash = uint256(); // no grandfathered block on a fresh chain
        consensus.frozen_mweb_output_ids = GetFrozenMWEBOutputIDs();

        /**
         * The message start string is designed to be unlikely to occur in normal data.
         * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
         * a large 32-bit integer with any alignment.
         */
        pchMessageStart[0] = 0xe2;
        pchMessageStart[1] = 0x9b;
        pchMessageStart[2] = 0x4d;
        pchMessageStart[3] = 0x4d;
        nDefaultPort = 9444;
        nPruneAfterHeight = 100000;
        m_assumed_blockchain_size = 1;
        m_assumed_chain_state_size = 2;

        // MoonBite (ADR-001/ADR-002 rev): mainnet genesis re-mined for RandomX PoW
        // (fixed 32-byte MBITE_RX_SEED cache key) with the 10 MBITE coinbase and
        // the 0x1f0ffff0 bootstrap floor. Merkle root changed with the reward.
        // Public launch: genesis nTime is 2026-10-17 09:00 CEST (1792220400).
        // A block must be timestamped after its parent and no more than 2 h
        // ahead of every node's clock, so no valid block 1 can exist before
        // 07:00 CEST, the announced launch. Nobody, the founder included, can
        // mine earlier.
        genesis = CreateGenesisBlock(1792220400, 4036, 0x1f0ffff0, 1, 10 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
    consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock == uint256S("0xffe25d9248b7f56d8934719ed5c7357f7595451c4b9d391d9b8377e62a83e39c"));
        assert(genesis.hashMerkleRoot == uint256S("0x967b739fb4d866f2edcfb027987d46d59265e49a25d76bc5ebb9e22484ab48d6"));

        // Note that of those which support the service bits prefix, most only support a subset of
        // possible options.
        // This is fine at runtime as we'll fall back to using them as an addrfetch if they don't support the
        // service bits we want, but we should get them updated to support all service bits wanted by any
        // release ASAP to avoid it where possible.

        // MoonBite (MBITE) base58 identity: P2PKH addresses lead with 'M'
        // (version 50) for the MoonBite brand; P2SH uses the legacy '3'
        // (version 5) so it no longer collides with the P2PKH 'M' prefix.
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,50);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
        base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,5);
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,176);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};

        bech32_hrp = "moon";
        mweb_hrp = "moonmweb";

        vFixedSeeds.clear(); // fresh chain reset 2026-10: no fixed seeds until new infra exists

        fDefaultConsistencyChecks = false;
        fRequireStandard = true;
        m_is_test_chain = false;
        m_is_mockable_chain = false;

        checkpointData = {
            {
                {0, consensus.hashGenesisBlock},
            }
        };

        chainTxData = ChainTxData{
            // Fresh chain: no history to estimate sync progress from. The
            // inherited Litecoin figures (283M transactions) pinned the
            // progress display near zero forever.
            /* nTime    */ 0,
            /* nTxCount */ 0,
            /* dTxRate  */ 0
        };
    }
};

/**
 * Testnet (v3)
 */
class CTestNetParams : public CChainParams {
public:
    CTestNetParams() {
        strNetworkID = CBaseChainParams::TESTNET;
        consensus.signet_blocks = false;
        consensus.signet_challenge.clear();
        consensus.nSubsidyHalvingInterval = 1650000;
        // MoonBite takes NO protocol revenue. There is no treasury, no dev
        // tail, no fee split and no team allocation: 100% of every block
        // subsidy plus 100% of every transaction fee goes to the miner who
        // found the block. The mechanism below is left inert (rate 0, empty
        // script) rather than ripped out, so the zero is explicit and
        // auditable in consensus code rather than merely absent.
        consensus.nTreasuryRateBps = 0;
        consensus.nTreasurySunsetHeight = 0;
        consensus.treasuryScript.clear();
        consensus.BIP16Height = 0; // always enforce P2SH BIP16 on testnet
        consensus.BIP34Height = 1;
        consensus.BIP34Hash = uint256();
        consensus.BIP65Height = 1; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
        consensus.BIP66Height = 1; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
        consensus.CSVHeight = 1;
        consensus.SegwitHeight = 1;
        consensus.MinBIP9WarningHeight = 2017;
        consensus.powLimit = uint256S("000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // MoonBite: 0x1f0fffff, bootstrap floor (genesis nBits 0x1f0ffff0)
        consensus.nPowTargetTimespan = 2 * 60 * 60; // 2 hours (60 blocks x 2 min)
        consensus.nPowTargetSpacing = 2 * 60; // MoonBite: 2-minute blocks
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = false;
        consensus.nRuleChangeActivationThreshold = 45; // 75% of 60 for testchains
        consensus.nMinerConfirmationWindow = 60; // nPowTargetTimespan / nPowTargetSpacing
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

        // Deployment of Taproot (BIPs 340-342)
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartHeight = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeoutHeight = 2016;

        // Deployment of MWEB (LIP-0002, LIP-0003, and LIP-0004)
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].bit = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nStartHeight = 1;
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nTimeoutHeight = 2016;

        // Inherited from Litecoin testnet and meaningless here: MoonBite testnet
        // starts at height 0, so a node would never accumulate that chain work
        // and would reject its own chain as insufficient. Zeroed to match
        // mainnet and regtest, which were already corrected.
        consensus.nMinimumChainWork = uint256{};
        consensus.defaultAssumeValid = uint256{};

        pchMessageStart[0] = 0xe2;
        pchMessageStart[1] = 0x9b;
        pchMessageStart[2] = 0x4d;
        pchMessageStart[3] = 0x74;
        nDefaultPort = 19555;
        nPruneAfterHeight = 1000;
        m_assumed_blockchain_size = 4;
        m_assumed_chain_state_size = 1;

        // MoonBite (ADR-001/ADR-002 rev): testnet genesis re-mined for RandomX PoW
        // (fixed 32-byte MBITE_RX_SEED cache key) with the 10 MBITE coinbase and
        // the 0x1f0ffff0 bootstrap floor. Merkle root changed with the reward.
        genesis = CreateGenesisBlock(1792000060, 4200, 0x1f0ffff0, 1, 10 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
    consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock == uint256S("0x5c2a77cdb0cab1697ca99b770dd0c6acc28baa241b98403587a0355ed58356bc"));
        assert(genesis.hashMerkleRoot == uint256S("0x967b739fb4d866f2edcfb027987d46d59265e49a25d76bc5ebb9e22484ab48d6"));

        vSeeds.clear();
        // MoonBite testnet: the inherited Litecoin DNS seeds
        // (testnet-seed.litecointools.com, seed-b.litecoin.loshan.co.uk,
        // dnsseed-testnet.thrasher.io) were removed — they resolve to Litecoin
        // nodes that reject MoonBite's magic bytes. No public MoonBite testnet
        // DNS seed exists yet; discover testnet peers with -addnode/-connect.

        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
        base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,58);
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

        bech32_hrp = "tmoon";
        mweb_hrp = "tmoonmweb";

        // Seeded from Litecoin/Bitcoin testnet hosts on ports 19335/18333, none
        // of which speak MoonBite. Cleared until real MoonBite testnet seeds exist.
        vFixedSeeds.clear();

        fDefaultConsistencyChecks = false;
        fRequireStandard = false;
        m_is_test_chain = true;
        m_is_mockable_chain = false;

        // Litecoin testnet checkpoints removed: MoonBite testnet has its own
        // genesis, so block 300 could never match and the chain would refuse to
        // sync past it. Genesis is the only fixed point on a new chain.
        checkpointData = {
            {
                {0, consensus.hashGenesisBlock},
            }
        };

        chainTxData = ChainTxData{
            /* nTime    */ 0,
            /* nTxCount */ 0,
            /* dTxRate  */ 0,
        };
    }
};

/**
 * Regression test
 */
class CRegTestParams : public CChainParams {
public:
    explicit CRegTestParams(const ArgsManager& args) {
        strNetworkID =  CBaseChainParams::REGTEST;
        consensus.signet_blocks = false;
        consensus.signet_challenge.clear();
        // MoonBite: regtest mirrors the mainnet halving/sunset schedule so that
        // short dev/test chains never straddle a subsidy transition. Reorg-style
        // tests reuse the same block at different heights; with a fast (150-block)
        // regtest halving those reused blocks would fail the height-exact treasury
        // check (ADR-005). The halving/treasury-sunset transition maths itself is
        // still covered directly by validation_tests (330000/660000 params).
        consensus.nSubsidyHalvingInterval = 1650000;
        // MoonBite takes NO protocol revenue. There is no treasury, no dev
        // tail, no fee split and no team allocation: 100% of every block
        // subsidy plus 100% of every transaction fee goes to the miner who
        // found the block. The mechanism below is left inert (rate 0, empty
        // script) rather than ripped out, so the zero is explicit and
        // auditable in consensus code rather than merely absent.
        consensus.nTreasuryRateBps = 0;
        consensus.nTreasurySunsetHeight = 0;
        consensus.treasuryScript.clear();

        consensus.BIP16Height = 0;
        consensus.BIP34Height = 500; // BIP34 activated on regtest (Used in functional tests)
        consensus.BIP34Hash = uint256();
        consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in functional tests)
        consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in functional tests)
        consensus.CSVHeight = 432; // CSV activated on regtest (Used in rpc activation tests)
        consensus.SegwitHeight = 0; // SEGWIT is always activated on regtest unless overridden
        consensus.MinBIP9WarningHeight = 0;
        consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
        consensus.nPowTargetTimespan = 2 * 60 * 60; // 2 hours (60 blocks x 2 min)
        consensus.nPowTargetSpacing = 2 * 60; // MoonBite: 2-minute blocks
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = true;
        consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
        consensus.nMinerConfirmationWindow = 144; // regtest keeps the 144-block window (mainnet/testnet use 60)

        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
        consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

        // Deployment of MWEB (LIP-0002 and LIP-0003)
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].bit = 4;
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nStartTime = 1601450001; // September 30, 2020
        consensus.vDeployments[Consensus::DEPLOYMENT_MWEB].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

        consensus.nMinimumChainWork = uint256{};
        consensus.defaultAssumeValid = uint256{};
        consensus.frozen_mweb_output_ids = GetFrozenMWEBOutputIDs();
        pchMessageStart[0] = 0xfa;
        pchMessageStart[1] = 0xbf;
        pchMessageStart[2] = 0xb5;
        pchMessageStart[3] = 0xda;
        nDefaultPort = 19444;
        nPruneAfterHeight = 1000;
        m_assumed_blockchain_size = 0;
        m_assumed_chain_state_size = 0;

        UpdateActivationParametersFromArgs(args);

        // MoonBite (ADR-001/ADR-002 rev): regtest genesis re-mined for RandomX PoW
        // with the 10 MBITE coinbase. nNonce ground so RandomX(header) < the
        // 0x207fffff target.
        genesis = CreateGenesisBlock(1792000120, 0, 0x207fffff, 1, 10 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
    consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock == uint256S("0x61dc2ef13c0f0f26a9a90c7f34d09578f10e8490687d1314f97233e525f2fe99"));
        assert(genesis.hashMerkleRoot == uint256S("0x967b739fb4d866f2edcfb027987d46d59265e49a25d76bc5ebb9e22484ab48d6"));

        vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
        vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.

        fDefaultConsistencyChecks = true;
        fRequireStandard = true;
        m_is_test_chain = true;
        m_is_mockable_chain = true;

        checkpointData = {
            {
                {0, consensus.hashGenesisBlock},
            }
        };

        chainTxData = ChainTxData{
            0,
            0,
            0
        };

        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
        base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,58);
        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

        bech32_hrp = "rmoon";
        mweb_hrp = "rmoonmweb";
    }

    /**
     * Allows modifying the Version Bits regtest parameters.
     */
    void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout, int64_t nStartHeight, int64_t nTimeoutHeight)
    {
        consensus.vDeployments[d].nStartTime = nStartTime;
        consensus.vDeployments[d].nTimeout = nTimeout;
        consensus.vDeployments[d].nStartHeight = nStartHeight;
        consensus.vDeployments[d].nTimeoutHeight = nTimeoutHeight;
    }
    void UpdateActivationParametersFromArgs(const ArgsManager& args);
};

void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
{
    if (args.IsArgSet("-segwitheight")) {
        int64_t height = args.GetArg("-segwitheight", consensus.SegwitHeight);
        if (height < -1 || height >= std::numeric_limits<int>::max()) {
            throw std::runtime_error(strprintf("Activation height %ld for segwit is out of valid range. Use -1 to disable segwit.", height));
        } else if (height == -1) {
            LogPrintf("Segwit disabled for testing\n");
            height = std::numeric_limits<int>::max();
        }
        consensus.SegwitHeight = static_cast<int>(height);
    }

    if (!args.IsArgSet("-vbparams")) return;

    for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
        std::vector<std::string> vDeploymentParams;
        boost::split(vDeploymentParams, strDeployment, boost::is_any_of(":"));
        if (vDeploymentParams.size() < 3 || 5 < vDeploymentParams.size()) {
            throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:heightstart:heightend]");
        }
        int64_t nStartTime, nTimeout, nStartHeight, nTimeoutHeight;
        if (!ParseInt64(vDeploymentParams[1], &nStartTime)) {
            throw std::runtime_error(strprintf("Invalid nStartTime (%s)", vDeploymentParams[1]));
        }
        if (!ParseInt64(vDeploymentParams[2], &nTimeout)) {
            throw std::runtime_error(strprintf("Invalid nTimeout (%s)", vDeploymentParams[2]));
        }
        if (vDeploymentParams.size() > 3 && !ParseInt64(vDeploymentParams[3], &nStartHeight)) {
            throw std::runtime_error(strprintf("Invalid nStartHeight (%s)", vDeploymentParams[3]));
        }
        if (vDeploymentParams.size() > 4 && !ParseInt64(vDeploymentParams[4], &nTimeoutHeight)) {
            throw std::runtime_error(strprintf("Invalid nTimeoutHeight (%s)", vDeploymentParams[4]));
        }
        bool found = false;
        for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
            if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
                UpdateVersionBitsParameters(Consensus::DeploymentPos(j), nStartTime, nTimeout, nStartHeight, nTimeoutHeight);
                found = true;
                LogPrintf("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, start_height=%d, timeout_height=%d\n", vDeploymentParams[0], nStartTime, nTimeout, nStartHeight, nTimeoutHeight);
                break;
            }
        }
        if (!found) {
            throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
        }
    }
}

static std::unique_ptr<const CChainParams> globalChainParams;

const CChainParams &Params() {
    assert(globalChainParams);
    return *globalChainParams;
}

std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
{
    if (chain == CBaseChainParams::MAIN) {
        return std::unique_ptr<CChainParams>(new CMainParams());
    } else if (chain == CBaseChainParams::TESTNET) {
        return std::unique_ptr<CChainParams>(new CTestNetParams());
    } else if (chain == CBaseChainParams::SIGNET) {
        return std::unique_ptr<CChainParams>(new CTestNetParams()); // TODO: Support SigNet
    } else if (chain == CBaseChainParams::REGTEST) {
        return std::unique_ptr<CChainParams>(new CRegTestParams(args));
    }
    throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
}

void SelectParams(const std::string& network)
{
    SelectBaseParams(network);
    globalChainParams = CreateChainParams(gArgs, network);
}