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  void ReadSigNetArgs(const ArgsManager& args, CChainParams::SigNetOptions& options)
 25  {
 26      if (args.IsArgSet("-signetseednode")) {
 27          options.seeds.emplace(args.GetArgs("-signetseednode"));
 28      }
 29      if (args.IsArgSet("-signetchallenge")) {
 30          const auto signet_challenge = args.GetArgs("-signetchallenge");
 31          if (signet_challenge.size() != 1) {
 32              throw std::runtime_error("-signetchallenge cannot be multiple values.");
 33          }
 34          const auto val{TryParseHex<uint8_t>(signet_challenge[0])};
 35          if (!val) {
 36              throw std::runtime_error(strprintf("-signetchallenge must be hex, not '%s'.", signet_challenge[0]));
 37          }
 38          options.challenge.emplace(*val);
 39      }
 40  }
 41  
 42  void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& options)
 43  {
 44      if (auto value = args.GetBoolArg("-fastprune")) options.fastprune = *value;
 45  
 46      for (const std::string& arg : args.GetArgs("-testactivationheight")) {
 47          const auto found{arg.find('@')};
 48          if (found == std::string::npos) {
 49              throw std::runtime_error(strprintf("Invalid format (%s) for -testactivationheight=name@height.", arg));
 50          }
 51  
 52          const auto value{arg.substr(found + 1)};
 53          int32_t height;
 54          if (!ParseInt32(value, &height) || height < 0 || height >= std::numeric_limits<int>::max()) {
 55              throw std::runtime_error(strprintf("Invalid height value (%s) for -testactivationheight=name@height.", arg));
 56          }
 57  
 58          const auto deployment_name{arg.substr(0, found)};
 59          if (const auto buried_deployment = GetBuriedDeployment(deployment_name)) {
 60              options.activation_heights[*buried_deployment] = height;
 61          } else {
 62              throw std::runtime_error(strprintf("Invalid name (%s) for -testactivationheight=name@height.", arg));
 63          }
 64      }
 65  
 66      if (!args.IsArgSet("-vbparams")) return;
 67  
 68      for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
 69          std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
 70          if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {
 71              throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");
 72          }
 73          CChainParams::VersionBitsParameters vbparams{};
 74          if (!ParseInt64(vDeploymentParams[1], &vbparams.start_time)) {
 75              throw std::runtime_error(strprintf("Invalid nStartTime (%s)", vDeploymentParams[1]));
 76          }
 77          if (!ParseInt64(vDeploymentParams[2], &vbparams.timeout)) {
 78              throw std::runtime_error(strprintf("Invalid nTimeout (%s)", vDeploymentParams[2]));
 79          }
 80          if (vDeploymentParams.size() >= 4) {
 81              if (!ParseInt32(vDeploymentParams[3], &vbparams.min_activation_height)) {
 82                  throw std::runtime_error(strprintf("Invalid min_activation_height (%s)", vDeploymentParams[3]));
 83              }
 84          } else {
 85              vbparams.min_activation_height = 0;
 86          }
 87          bool found = false;
 88          for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
 89              if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
 90                  options.version_bits_parameters[Consensus::DeploymentPos(j)] = vbparams;
 91                  found = true;
 92                  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);
 93                  break;
 94              }
 95          }
 96          if (!found) {
 97              throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
 98          }
 99      }
100  }
101  
102  static std::unique_ptr<const CChainParams> globalChainParams;
103  
104  const CChainParams &Params() {
105      assert(globalChainParams);
106      return *globalChainParams;
107  }
108  
109  std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)
110  {
111      switch (chain) {
112      case ChainType::MAIN:
113          return CChainParams::Main();
114      case ChainType::TESTNET:
115          return CChainParams::TestNet();
116      case ChainType::SIGNET: {
117          auto opts = CChainParams::SigNetOptions{};
118          ReadSigNetArgs(args, opts);
119          return CChainParams::SigNet(opts);
120      }
121      case ChainType::REGTEST: {
122          auto opts = CChainParams::RegTestOptions{};
123          ReadRegTestArgs(args, opts);
124          return CChainParams::RegTest(opts);
125      }
126      }
127      assert(false);
128  }
129  
130  void SelectParams(const ChainType chain)
131  {
132      SelectBaseParams(chain);
133      globalChainParams = CreateChainParams(gArgs, chain);
134  }