Skip to content

Make deployment options available on all networks in unit tests #98

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
darosior wants to merge 2 commits into from
Closed

Make deployment options available on all networks in unit tests #98

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
67a2c96
chainparams: encapsulate deployment configuration logic
darosior Sep 29, 2025
6665296
chainparams: make deployment configuration options always available i…
darosior Sep 29, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
85 changes: 54 additions & 31 deletions src/chainparams.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -42,30 +42,8 @@ static void HandleRenounceArgs(const ArgsManager& args, CChainParams::RenouncePa
}
}

void ReadSigNetArgs(const ArgsManager& args, CChainParams::SigNetOptions& options)
static void HandleDeploymentArgs(const ArgsManager& args, CChainParams::DeploymentOptions& options)
{
if (!args.GetArgs("-signetseednode").empty()) {
options.seeds.emplace(args.GetArgs("-signetseednode"));
}
if (!args.GetArgs("-signetchallenge").empty()) {
const auto signet_challenge = args.GetArgs("-signetchallenge");
if (signet_challenge.size() != 1) {
throw std::runtime_error("-signetchallenge cannot be multiple values.");
}
const auto val{TryParseHex<uint8_t>(signet_challenge[0])};
if (!val) {
throw std::runtime_error(strprintf("-signetchallenge must be hex, not '%s'.", signet_challenge[0]));
}
options.challenge.emplace(*val);
}
HandleRenounceArgs(args, options.renounce);
}

void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& options)
{
if (auto value = args.GetBoolArg("-fastprune")) options.fastprune = *value;
if (HasTestOption(args, "bip94")) options.enforce_bip94 = true;

for (const std::string& arg : args.GetArgs("-testactivationheight")) {
const auto found{arg.find('@')};
if (found == std::string::npos) {
Expand All @@ -86,8 +64,6 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
}
}

HandleRenounceArgs(args, options.renounce);

for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
if (vDeploymentParams.size() != 3) {
Expand Down Expand Up @@ -115,6 +91,44 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
}
}

void ReadMainNetArgs(const ArgsManager& args, CChainParams::MainNetOptions& options)
{
HandleDeploymentArgs(args, options.dep_opts);
}

void ReadTestNetArgs(const ArgsManager& args, CChainParams::TestNetOptions& options)
{
HandleDeploymentArgs(args, options.dep_opts);
}

void ReadSigNetArgs(const ArgsManager& args, CChainParams::SigNetOptions& options)
{
if (!args.GetArgs("-signetseednode").empty()) {
options.seeds.emplace(args.GetArgs("-signetseednode"));
}
if (!args.GetArgs("-signetchallenge").empty()) {
const auto signet_challenge = args.GetArgs("-signetchallenge");
if (signet_challenge.size() != 1) {
throw std::runtime_error("-signetchallenge cannot be multiple values.");
}
const auto val{TryParseHex<uint8_t>(signet_challenge[0])};
if (!val) {
throw std::runtime_error(strprintf("-signetchallenge must be hex, not '%s'.", signet_challenge[0]));
}
options.challenge.emplace(*val);
}
HandleRenounceArgs(args, options.renounce);
}

void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& options)
{
if (auto value = args.GetBoolArg("-fastprune")) options.fastprune = *value;
if (HasTestOption(args, "bip94")) options.enforce_bip94 = true;

HandleDeploymentArgs(args, options.dep_opts);
HandleRenounceArgs(args, options.renounce);
}

static std::unique_ptr<const CChainParams> globalChainParams;

const CChainParams &Params() {
Expand All @@ -125,12 +139,21 @@ const CChainParams &Params() {
std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const ChainType chain)
{
switch (chain) {
case ChainType::MAIN:
return CChainParams::Main();
case ChainType::TESTNET:
return CChainParams::TestNet();
case ChainType::TESTNET4:
return CChainParams::TestNet4();
case ChainType::MAIN: {
auto opts = CChainParams::MainNetOptions{};
ReadMainNetArgs(args, opts);
return CChainParams::Main(opts);
}
case ChainType::TESTNET: {
auto opts = CChainParams::TestNetOptions{};
ReadTestNetArgs(args, opts);
return CChainParams::TestNet(opts);
}
case ChainType::TESTNET4: {
auto opts = CChainParams::TestNetOptions{};
ReadTestNetArgs(args, opts);
return CChainParams::TestNet4(opts);
}
case ChainType::SIGNET: {
auto opts = CChainParams::SigNetOptions{};
ReadSigNetArgs(args, opts);
Expand Down
4 changes: 2 additions & 2 deletions src/chainparamsbase.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,10 +16,10 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
argsman.AddArg("-chain=<chain>", "Use the chain <chain> (default: main). Allowed values: " LIST_CHAIN_NAMES, ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-regtest", "Enter regression test mode, which uses a special chain in which blocks can be solved instantly. "
"This is intended for regression testing tools and app development. Equivalent to -chain=regtest.", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-testactivationheight=name@height.", "Set the activation height of 'name' (segwit, bip34, dersig, cltv, csv). (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
argsman.AddArg("-testactivationheight=name@height.", "Set the activation height of 'name' (segwit, bip34, dersig, cltv, csv). (test-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
argsman.AddArg("-testnet", "Use the testnet3 chain. Equivalent to -chain=test. Support for testnet3 is deprecated and will be removed in an upcoming release. Consider moving to testnet4 now by using -testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-testnet4", "Use the testnet4 chain. Equivalent to -chain=testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-vbparams=deployment:start:end[:min_activation_height]", "Use given start/end times and min_activation_height for specified version bits deployment (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-vbparams=deployment:start:end[:min_activation_height]", "Use given start/end times and min_activation_height for specified version bits deployment (test-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-renounce=deployment", "Unconditionally disable an heretical deployment attempt", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-signet", "Use the signet chain. Equivalent to -chain=signet. Note that the network is defined by the -signetchallenge parameter", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
argsman.AddArg("-signetchallenge", "Blocks must satisfy the given script to be considered valid (only for signet networks; defaults to the global default signet test network challenge)", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::CHAINPARAMS);
Expand Down
10 changes: 10 additions & 0 deletions src/init.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1343,6 +1343,16 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
const ArgsManager& args = *Assert(node.args);
const CChainParams& chainparams = Params();

// Prevent setting deployment parameters on mainnet.
if (chainparams.GetChainType() == ChainType::MAIN) {
if (args.IsArgSet("-testactivationheight")) {
return InitError(_("The -testactivationheight option may not be used on mainnet."));
}
if (args.IsArgSet("-vbparams")) {
return InitError(_("The -vbparams option may not be used on mainnet."));
}
}

// Disallow mainnet/testnet operation
if (Params().GetChainType() == ChainType::MAIN || Params().GetChainType() == ChainType::TESTNET) {
return InitError(Untranslated(strprintf("Selected network '%s' is unsupported for this client, select -regtest or -signet instead.\n", Params().GetChainTypeString())));
Expand Down
85 changes: 49 additions & 36 deletions src/kernel/chainparams.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -116,12 +116,43 @@ struct SetupDeployment
};
}

void CChainParams::ApplyDeploymentOptions(const DeploymentOptions& opts)
{
for (const auto& [dep, height] : opts.activation_heights) {
switch (dep) {
case Consensus::BuriedDeployment::DEPLOYMENT_TAPROOT:
consensus.TaprootHeight = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT:
consensus.SegwitHeight = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB:
consensus.BIP34Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG:
consensus.BIP66Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_CLTV:
consensus.BIP65Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_CSV:
consensus.CSVHeight = int{height};
break;
}
}

for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
}
}

/**
* Main network on which people trade goods and services.
*/
class CMainParams : public CChainParams {
public:
CMainParams() {
CMainParams(const MainNetOptions& opts) {
m_chain_type = ChainType::MAIN;
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Expand Down Expand Up @@ -149,6 +180,8 @@ class CMainParams : public CChainParams {
dep = SetupDeployment{.activate = 0x30000000, .abandon = 0, .never = true, .period = 2016};
}

ApplyDeploymentOptions(opts.dep_opts);

consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000b1f3b93b65b16d035a82be84"};
consensus.defaultAssumeValid = uint256{"00000000000000000001b658dd1120e82e66d2790811f89ede9742ada3ed6d77"}; // 886157

Expand Down Expand Up @@ -246,7 +279,7 @@ class CMainParams : public CChainParams {
*/
class CTestNetParams : public CChainParams {
public:
CTestNetParams() {
CTestNetParams(const TestNetOptions& opts) {
m_chain_type = ChainType::TESTNET;
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Expand All @@ -273,6 +306,8 @@ class CTestNetParams : public CChainParams {
dep = SetupDeployment{.activate = 0x30000000, .abandon = 0, .never = true, .period = 2016};
}

ApplyDeploymentOptions(opts.dep_opts);

consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000015f5e0c9f13455b0eb17"};
consensus.defaultAssumeValid = uint256{"00000000000003fc7967410ba2d0a8a8d50daedc318d43e8baf1a9782c236a57"}; // 3974606

Expand Down Expand Up @@ -341,7 +376,7 @@ class CTestNetParams : public CChainParams {
*/
class CTestNet4Params : public CChainParams {
public:
CTestNet4Params() {
CTestNet4Params(const TestNetOptions& opts) {
m_chain_type = ChainType::TESTNET4;
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Expand All @@ -365,6 +400,8 @@ class CTestNet4Params : public CChainParams {
dep = SetupDeployment{.activate = 0x30000000, .abandon = 0, .never = true, .period = 2016};
}

ApplyDeploymentOptions(opts.dep_opts);

consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000001d6dce8651b6094e4c1"};
consensus.defaultAssumeValid = uint256{"0000000000003ed4f08dbdf6f7d6b271a6bcffce25675cb40aa9fa43179a89f3"}; // 72600

Expand Down Expand Up @@ -495,6 +532,8 @@ class SigNetParams : public CChainParams {
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = SetupDeployment{.activate = 0x30000000, .abandon = 0, .never = true, .period = 432};
INQ_DEPLOYMENTS_SIGNET

ApplyDeploymentOptions(options.dep_opts);

RenounceDeployments(options.renounce, consensus.vDeployments);

// message start is defined as the first 4 bytes of the sha256d of the block script
Expand Down Expand Up @@ -577,33 +616,7 @@ class CRegTestParams : public CChainParams
m_assumed_blockchain_size = 0;
m_assumed_chain_state_size = 0;

for (const auto& [dep, height] : opts.activation_heights) {
switch (dep) {
case Consensus::BuriedDeployment::DEPLOYMENT_TAPROOT:
consensus.TaprootHeight = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT:
consensus.SegwitHeight = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB:
consensus.BIP34Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG:
consensus.BIP66Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_CLTV:
consensus.BIP65Height = int{height};
break;
case Consensus::BuriedDeployment::DEPLOYMENT_CSV:
consensus.CSVHeight = int{height};
break;
}
}

for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
}
ApplyDeploymentOptions(opts.dep_opts);

RenounceDeployments(opts.renounce, consensus.vDeployments);

Expand Down Expand Up @@ -683,19 +696,19 @@ std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions&
return std::make_unique<const CRegTestParams>(options);
}

std::unique_ptr<const CChainParams> CChainParams::Main()
std::unique_ptr<const CChainParams> CChainParams::Main(const MainNetOptions& options)
{
return std::make_unique<const CMainParams>();
return std::make_unique<const CMainParams>(options);
}

std::unique_ptr<const CChainParams> CChainParams::TestNet()
std::unique_ptr<const CChainParams> CChainParams::TestNet(const TestNetOptions& options)
{
return std::make_unique<const CTestNetParams>();
return std::make_unique<const CTestNetParams>(options);
}

std::unique_ptr<const CChainParams> CChainParams::TestNet4()
std::unique_ptr<const CChainParams> CChainParams::TestNet4(const TestNetOptions& options)
{
return std::make_unique<const CTestNet4Params>();
return std::make_unique<const CTestNet4Params>(options);
}

std::vector<int> CChainParams::GetAvailableSnapshotHeights() const
Expand Down
44 changes: 31 additions & 13 deletions src/kernel/chainparams.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -138,39 +138,55 @@ class CChainParams

using RenounceParameters = std::vector<Consensus::BuriedDeployment>;

/**
* VersionBitsParameters holds activation parameters
*/
struct VersionBitsParameters {
int64_t start_time;
int64_t timeout;
};

struct DeploymentOptions {
std::unordered_map<Consensus::DeploymentPos, VersionBitsParameters> version_bits_parameters{};
std::unordered_map<Consensus::BuriedDeployment, int> activation_heights{};
};

/**
* SigNetOptions holds configurations for creating a signet CChainParams.
*/
struct SigNetOptions {
DeploymentOptions dep_opts{};
std::optional<std::vector<uint8_t>> challenge{};
std::optional<std::vector<std::string>> seeds{};
RenounceParameters renounce{};
};

/**
* VersionBitsParameters holds activation parameters
*/
struct VersionBitsParameters {
int64_t start_time;
int64_t timeout;
};

/**
* RegTestOptions holds configurations for creating a regtest CChainParams.
*/
struct RegTestOptions {
std::unordered_map<Consensus::DeploymentPos, VersionBitsParameters> version_bits_parameters{};
std::unordered_map<Consensus::BuriedDeployment, int> activation_heights{};
DeploymentOptions dep_opts{};
RenounceParameters renounce{};
bool fastprune{false};
bool enforce_bip94{false};
};

struct MainNetOptions {
DeploymentOptions dep_opts{};
};

struct TestNetOptions {
DeploymentOptions dep_opts{};
};

static std::unique_ptr<const CChainParams> RegTest(const RegTestOptions& options);
static std::unique_ptr<const CChainParams> SigNet(const SigNetOptions& options);
static std::unique_ptr<const CChainParams> Main();
static std::unique_ptr<const CChainParams> TestNet();
static std::unique_ptr<const CChainParams> TestNet4();
static std::unique_ptr<const CChainParams> Main(const MainNetOptions& options);
static std::unique_ptr<const CChainParams> Main() { const MainNetOptions opts{}; return Main(opts); }
static std::unique_ptr<const CChainParams> TestNet(const TestNetOptions& options);
static std::unique_ptr<const CChainParams> TestNet() { const TestNetOptions opts{}; return TestNet(opts); }
static std::unique_ptr<const CChainParams> TestNet4(const TestNetOptions& options);
static std::unique_ptr<const CChainParams> TestNet4() { const TestNetOptions opts{}; return TestNet4(opts); }

protected:
CChainParams() = default;
Expand All @@ -192,6 +208,8 @@ class CChainParams
CCheckpointData checkpointData;
std::vector<AssumeutxoData> m_assumeutxo_data;
ChainTxData chainTxData;

void ApplyDeploymentOptions(const DeploymentOptions& opts);
};

std::optional<ChainType> GetNetworkForMagic(const MessageStartChars& pchMessageStart);
Expand Down
Loading