1  // Copyright (c) 2010 Satoshi Nakamoto
  2  // Copyright (c) 2009-2022 The Bitcoin Core developers
  3  // Distributed under the MIT software license, see the accompanying
  4  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  5  
  6  #include <chainparams.h>
  7  
  8  #include <chainparamsbase.h>
  9  #include <common/args.h>
 10  #include <consensus/params.h>
 11  #include <deploymentinfo.h>
 12  #include <logging.h>
 13  #include <tinyformat.h>
 14  #include <util/chaintype.h>
 15  #include <util/strencodings.h>
 16  #include <util/string.h>
 17  
 18  #include <cassert>
 19  #include <cstdint>
 20  #include <limits>
 21  #include <stdexcept>
 22  #include <vector>
 23  
 24  using util::SplitString;
 25  
 26  void ReadSigNetArgs(const ArgsManager& args, CChainParams::SigNetOptions& options)
 27  {
 28      if (!args.GetArgs("-signetseednode").empty()) {
 29          options.seeds.emplace(args.GetArgs("-signetseednode"));
 30      }
 31      if (!args.GetArgs("-signetchallenge").empty()) {
 32          const auto signet_challenge = args.GetArgs("-signetchallenge");
 33          if (signet_challenge.size() != 1) {
 34              throw std::runtime_error("-signetchallenge cannot be multiple values.");
 35          }
 36          const auto val{TryParseHex<uint8_t>(signet_challenge[0])};
 37          if (!val) {
 38              throw std::runtime_error(strprintf("-signetchallenge must be hex, not '%s'.", signet_challenge[0]));
 39          }
 40          options.challenge.emplace(*val);
 41      }
 42  }
 43  
 44  void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& options)
 45  {
 46      if (auto value = args.GetBoolArg("-fastprune")) options.fastprune = *value;
 47      if (HasTestOption(args, "bip94")) options.enforce_bip94 = true;
 48  
 49      for (const std::string& arg : args.GetArgs("-testactivationheight")) {
 50          const auto found{arg.find('@')};
 51          if (found == std::string::npos) {
 52              throw std::runtime_error(strprintf("Invalid format (%s) for -testactivationheight=name@height.", arg));
 53          }
 54  
 55          const auto value{arg.substr(found + 1)};
 56          int32_t height;
 57          if (!ParseInt32(value, &height) || height < 0 || height >= std::numeric_limits<int>::max()) {
 58              throw std::runtime_error(strprintf("Invalid height value (%s) for -testactivationheight=name@height.", arg));
 59          }
 60  
 61          const auto deployment_name{arg.substr(0, found)};
 62          if (const auto buried_deployment = GetBuriedDeployment(deployment_name)) {
 63              options.activation_heights[*buried_deployment] = height;
 64          } else {
 65              throw std::runtime_error(strprintf("Invalid name (%s) for -testactivationheight=name@height.", arg));
 66          }
 67      }
 68  
 69      for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
 70          std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
 71          if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {
 72              throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");
 73          }
 74          CChainParams::VersionBitsParameters vbparams{};
 75          if (!ParseInt64(vDeploymentParams[1], &vbparams.start_time)) {
 76              throw std::runtime_error(strprintf("Invalid nStartTime (%s)", vDeploymentParams[1]));
 77          }
 78          if (!ParseInt64(vDeploymentParams[2], &vbparams.timeout)) {
 79              throw std::runtime_error(strprintf("Invalid nTimeout (%s)", vDeploymentParams[2]));
 80          }
 81          if (vDeploymentParams.size() >= 4) {
 82              if (!ParseInt32(vDeploymentParams[3], &vbparams.min_activation_height)) {
 83                  throw std::runtime_error(strprintf("Invalid min_activation_height (%s)", vDeploymentParams[3]));
 84              }
 85          } else {
 86              vbparams.min_activation_height = 0;
 87          }
 88          bool found = false;
 89          for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
 90              if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
 91                  options.version_bits_parameters[Consensus::DeploymentPos(j)] = vbparams;
 92                  found = true;
 93                  LogPrintf("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, min_activation_height=%d\n", vDeploymentParams[0], vbparams.start_time, vbparams.timeout, vbparams.min_activation_height);
 94                  break;
 95              }
 96          }
 97          if (!found) {
 98              throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
 99          }
100      }
101  }
102  
103  static std::unique_ptr<const CChainParams> globalChainParams;
104  
105  const CChainParams &Params() {
106      assert(globalChainParams);
107      return *globalChainParams;
108  }
109  
110  std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)
111  {
112      switch (chain) {
113      case ChainType::MAIN:
114          return CChainParams::Main();
115      case ChainType::TESTNET:
116          return CChainParams::TestNet();
117      case ChainType::TESTNET4:
118          return CChainParams::TestNet4();
119      case ChainType::SIGNET: {
120          auto opts = CChainParams::SigNetOptions{};
121          ReadSigNetArgs(args, opts);
122          return CChainParams::SigNet(opts);
123      }
124      case ChainType::REGTEST: {
125          auto opts = CChainParams::RegTestOptions{};
126          ReadRegTestArgs(args, opts);
127          return CChainParams::RegTest(opts);
128      }
129      }
130      assert(false);
131  }
132  
133  void SelectParams(const ChainType chain)
134  {
135      SelectBaseParams(chain);
136      globalChainParams = CreateChainParams(gArgs, chain);
137  }