Bitcoin Core  27.99.0
P2P Digital Currency
chainparams.cpp
Go to the documentation of this file.
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 
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 
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  }
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) {
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 
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);
134 }
ArgsManager gArgs
Definition: args.cpp:41
ArgsManager & args
Definition: bitcoind.cpp:268
static std::unique_ptr< const CChainParams > globalChainParams
const CChainParams & Params()
Return the currently selected parameters.
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
std::unique_ptr< const CChainParams > CreateChainParams(const ArgsManager &args, const ChainType chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
void ReadSigNetArgs(const ArgsManager &args, CChainParams::SigNetOptions &options)
Definition: chainparams.cpp:24
void ReadRegTestArgs(const ArgsManager &args, CChainParams::RegTestOptions &options)
Definition: chainparams.cpp:42
void SelectBaseParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain.
ChainType
Definition: chaintype.h:11
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: args.cpp:360
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: args.cpp:369
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: args.cpp:505
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:81
static std::unique_ptr< const CChainParams > Main()
static std::unique_ptr< const CChainParams > RegTest(const RegTestOptions &options)
static std::unique_ptr< const CChainParams > TestNet()
static std::unique_ptr< const CChainParams > SigNet(const SigNetOptions &options)
const struct VBDeploymentInfo VersionBitsDeploymentInfo[Consensus::MAX_VERSION_BITS_DEPLOYMENTS]
std::optional< Consensus::BuriedDeployment > GetBuriedDeployment(const std::string_view name)
#define LogPrintf(...)
Definition: logging.h:244
DeploymentPos
Definition: params.h:32
@ MAX_VERSION_BITS_DEPLOYMENTS
Definition: params.h:36
const char * name
Definition: rest.cpp:50
std::vector< std::string > SplitString(std::string_view str, char sep)
Definition: string.h:21
RegTestOptions holds configurations for creating a regtest CChainParams.
Definition: chainparams.h:153
std::unordered_map< Consensus::DeploymentPos, VersionBitsParameters > version_bits_parameters
Definition: chainparams.h:154
std::unordered_map< Consensus::BuriedDeployment, int > activation_heights
Definition: chainparams.h:155
SigNetOptions holds configurations for creating a signet CChainParams.
Definition: chainparams.h:136
std::optional< std::vector< uint8_t > > challenge
Definition: chainparams.h:137
std::optional< std::vector< std::string > > seeds
Definition: chainparams.h:138
VersionBitsParameters holds activation parameters.
Definition: chainparams.h:144
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
bool ParseInt32(std::string_view str, int32_t *out)
Convert string to signed 32-bit integer with strict parse error feedback.
bool ParseInt64(std::string_view str, int64_t *out)
Convert string to signed 64-bit integer with strict parse error feedback.
assert(!tx.IsCoinBase())