GlcoinCore/elements
1
0
Fork 0
mirror of https://github.com/ElementsProject/elements.git synced 2026-08-13 12:33:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
elements/src/kernel/chainparams.cpp

1935 lines
104 KiB
C++
Raw Normal View History

Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2021 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
ci: lint fixes
2025-12-05 09:31:39 +02:00
#if defined(HAVE_CONFIG_H)
#include <config/bitcoin-config.h>
#endif
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
#include <kernel/chainparams.h>
#include <chainparamsseeds.h>
#include <consensus/amount.h>
#include <consensus/merkle.h>
#include <consensus/params.h>
#include <hash.h>
kernel: Move MessageStartChars to its own file The protocol.h file contains many non-consensus related definitions and should thus not be part of the libbitcoinkernel. This commit makes protocol.h no longer a required include for users of the libbitcoinkernel. This commit is part of the libbitcoinkernel project, namely its stage 1 step 3: Decouple most non-consensus headers from libbitcoinkernel. Co-Authored-By: Cory Fields <cory-nospam-@coryfields.com>
2023-09-06 15:55:14 +02:00
#include <kernel/messagestartchars.h>
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
#include <logging.h>
#include <primitives/block.h>
#include <primitives/transaction.h>
#include <script/interpreter.h>
#include <script/script.h>
#include <uint256.h>
refactor: Replace string chain name constants with ChainTypes This commit effectively moves the definition of these constants out of the chainparamsbase to their own file. Using the ChainType enums provides better type safety compared to passing around strings. The commit is part of an ongoing effort to decouple the libbitcoinkernel library from the ArgsManager and other functionality that should not be part of the kernel library.
2023-04-17 22:20:59 +02:00
#include <util/chaintype.h>
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
#include <util/moneystr.h>
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
#include <util/strencodings.h>
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
#include <issuance.h>
#include <deploymentinfo.h>
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <type_traits>
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
#include <assert.h>
Merge 011a895a82 into merged_master (Bitcoin PR bitcoin/bitcoin#29015)
2026-02-27 22:48:24 +00:00
using util::SplitString;
refactor: Hand-replace some ParseHex -> ""_hex The following scripted-diff commit will replace ParseHex("...") with "..."_hex_u8, but this replacement will not work in cases where vectors are needed instead of arrays, and is not ideal in cases where std::byte is accepted. For example, it is currently necessary to use _hex_v_u8 when calling CScript operator<< because that operator does not currently support std::array or std::byte. Conversely, it is incorrect to use _hex_v instead of _hex in net_processing.cpp for the MakeAndPushMessage argument, because if the argument is a std::vector it is considered variable-length and serialized with a size prefix, but if the argument is a std::array or Span is it considered fixed length and serialized without a prefix. By the same logic, it is also safe to change the NUMS_H constant in pubkey.cpp from a std::vector to std::array because it is never serialized.
2024-08-27 21:21:30 +02:00
using namespace util::hex_literals;
Merge 011a895a82 into merged_master (Bitcoin PR bitcoin/bitcoin#29015)
2026-02-27 22:48:24 +00:00
refactor: Hand-replace some uint256S -> uint256 chainparams.cpp - workaround for MSVC bug triggering C7595 - Calling consteval constructors in initializer lists fails, but works on GCC (13.2.0) & Clang (17.0.6).
2024-08-05 14:51:47 +02:00
// Workaround MSVC bug triggering C7595 when calling consteval constructors in
// initializer lists.
// A fix may be on the way:
// https://developercommunity.visualstudio.com/t/consteval-conversion-function-fails/1579014
#if defined(_MSC_VER)
auto consteval_ctor(auto&& input) { return input; }
#else
#define consteval_ctor(input) (input)
#endif
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
static CScript StrHexToScriptWithDefault(std::string strScript, const CScript defaultScript)
{
CScript returnScript;
if (!strScript.empty()) {
std::vector<unsigned char> scriptData = ParseHex(strScript);
returnScript = CScript(scriptData.begin(), scriptData.end());
} else {
returnScript = defaultScript;
}
return returnScript;
}
// Safer for users if they load incorrect parameters via arguments.
static std::vector<unsigned char> CommitToArguments(const Consensus::Params& params, const std::string& networkID)
{
CSHA256 sha2;
unsigned char commitment[32];
sha2.Write((const unsigned char*)networkID.c_str(), networkID.length());
sha2.Write((const unsigned char*)HexStr(params.fedpegScript).c_str(), HexStr(params.fedpegScript).length());
sha2.Write((const unsigned char*)HexStr(params.signblockscript).c_str(), HexStr(params.signblockscript).length());
sha2.Finalize(commitment);
return std::vector<unsigned char>(commitment, commitment + 32);
}
static CBlock CreateGenesisBlock(const Consensus::Params& params, const CScript& genesisScriptSig, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
{
CMutableTransaction txNew;
refactor: Rename CTransaction::nVersion to version In order to ensure that the change of nVersion to a uint32_t in the previous commit has no effect, rename nVersion to version in this commit so that reviewers can easily spot if a spot was missed or if there is a check somewhere whose semantics have changed.
2024-01-26 15:27:13 -05:00
txNew.version = 1;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
txNew.vin.resize(1);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
txNew.vin[0].scriptSig = genesisScriptSig;
ci(tidy): use emplace_back instead of push_back
2025-08-14 10:00:51 +02:00
txNew.vout.emplace_back(CAsset(), genesisReward, genesisOutputScript);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
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);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
if (g_signed_blocks) {
genesis.proof = CProof(params.signblockscript, CScript());
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
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
*/
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward, const Consensus::Params& params)
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
{
const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
const CScript genesisScriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
Replace CScript _hex_v_u8 appends with _hex This will skip vector conversion before serializing to the prevector in CScript.
2024-09-09 21:13:20 +02:00
const CScript genesisOutputScript = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
return CreateGenesisBlock(params, genesisScriptSig, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
}
/**
* Allows modifying the Version Bits Elements regtest parameters (and liquidv1test).
* Ideally, this would be a method in the base class, inherited everywhere, but that might complicate future merges,
* so we settle for this static function.
*/
static void UpdateElementsActivationParametersFromArgs(Consensus::Params& consensus, const ArgsManager& args)
{
if (!args.IsArgSet("-evbparams")) return;
std::map<std::string,int> map_deployments;
for (const std::string& strDeployment : args.GetArgs("-evbparams")) {
std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
if (vDeploymentParams.size() != 5) {
throw std::runtime_error("ElementsVersion bits parameters malformed, expecting deployment:start:end:period:threshold");
}
int64_t nStartTime = 0, nTimeout = 0, nPeriod = 0, nThreshold = 0;
bool use_nStartTime = false, use_nTimeout = false, use_nPeriod = false, use_nThreshold = false;
if(vDeploymentParams[1].length()) {
if (!ParseInt64(vDeploymentParams[1], &nStartTime)) {
throw std::runtime_error(strprintf("Invalid nStartTime (%s)", vDeploymentParams[1]));
}
use_nStartTime = true;
}
if(vDeploymentParams[2].length()) {
if (!ParseInt64(vDeploymentParams[2], &nTimeout)) {
throw std::runtime_error(strprintf("Invalid nTimeout (%s)", vDeploymentParams[2]));
}
use_nTimeout = true;
}
if(vDeploymentParams[3].length()) {
if (!ParseInt64(vDeploymentParams[3], &nPeriod)) {
throw std::runtime_error(strprintf("Invalid nPeriod (%s)", vDeploymentParams[3]));
}
use_nPeriod = true;
}
if(vDeploymentParams[4].length()) {
if (!ParseInt64(vDeploymentParams[4], &nThreshold)) {
throw std::runtime_error(strprintf("Invalid nThreshold (%s)", vDeploymentParams[4]));
}
use_nThreshold = true;
}
bool found = false;
for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
if(map_deployments[vDeploymentParams[0]]) {
found = true;
LogPrintf("Ignoring duplicated version bits activation parameters for \"%s\"\n", strDeployment.c_str());
break;
}
std::string extra_logging;
map_deployments[vDeploymentParams[0]]=1;
Consensus::DeploymentPos d=Consensus::DeploymentPos(j);
if (use_nStartTime) {
consensus.vDeployments[d].nStartTime = nStartTime;
} else {
nStartTime =consensus.vDeployments[d].nStartTime;
}
if (use_nTimeout) {
consensus.vDeployments[d].nTimeout = nTimeout;
} else {
nTimeout = consensus.vDeployments[d].nTimeout;
}
if (consensus.vDeployments[d].nPeriod) {
if(use_nPeriod) {
consensus.vDeployments[d].nPeriod = nPeriod;
} else {
nPeriod = *consensus.vDeployments[d].nPeriod;
}
extra_logging+= strprintf(", period=%ld", nPeriod);
}
if (consensus.vDeployments[d].nThreshold) {
if(use_nThreshold) {
consensus.vDeployments[d].nThreshold = nThreshold;
} else {
nThreshold = *consensus.vDeployments[d].nThreshold;
}
extra_logging+= strprintf(", threshold=%ld", nThreshold);
}
found = true;
LogPrintf("Setting version bits activation parameters for %s to start=%ld, timeout=%ld%s\n", vDeploymentParams[0], nStartTime, nTimeout, extra_logging.c_str());
break;
}
}
if (!found) {
throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
}
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
}
/**
* Main network on which people trade goods and services.
*/
class CMainParams : public CChainParams {
public:
CMainParams() {
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::MAIN);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
consensus.nSubsidyHalvingInterval = 210000;
consensus.script_flag_exceptions.emplace( // BIP16 exception
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
uint256{"00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"}, SCRIPT_VERIFY_NONE);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.script_flag_exceptions.emplace( // Taproot exception
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
uint256{"0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.BIP34Height = 227931;
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.BIP34Hash = uint256{"000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = false;
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
consensus.enforce_BIP94 = false;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
consensus.nMinerConfirmationWindow = 2016; // 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;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// Deployment of Taproot (BIPs 340-342)
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021
[kernel] update assumevalid and minimumChainWork for v29
2025-03-03 11:08:49 -05:00
consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000b1f3b93b65b16d035a82be84"};
consensus.defaultAssumeValid = uint256{"00000000000000000001b658dd1120e82e66d2790811f89ede9742ada3ed6d77"}; // 886157
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Simplicity
Merge 3c1782e3ce into merged_master (Elements PR #1438)
2025-04-16 11:53:55 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
consensus.genesis_subsidy = 50*COIN;
consensus.connect_genesis_outputs = false;
consensus.subsidy_asset = CAsset();
anyonecanspend_aremine = false;
enforce_pak = false;
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
accept_unlimited_issuances = false;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = false;
accept_discount_ct = false;
create_discount_ct = false;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = PeginSubsidy();
pegin_minimum = PeginMinimum();
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.has_parent_chain = false;
g_signed_blocks = false;
g_con_elementsmode = false;
g_con_blockheightinheader = false;
consensus.total_valid_epochs = 0;
consensus.elements_mode = g_con_elementsmode;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
/**
* 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] = 0xf9;
pchMessageStart[1] = 0xbe;
pchMessageStart[2] = 0xb4;
pchMessageStart[3] = 0xd9;
nDefaultPort = 8333;
nPruneAfterHeight = 100000;
[kernel] update assumed blockchain and chainstate sizes for v29
2025-03-03 11:07:27 -05:00
m_assumed_blockchain_size = 720;
params: Update assumed blockchain and chainstate sizes
2024-08-14 13:42:32 -04:00
m_assumed_chain_state_size = 14;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN, consensus);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.hashGenesisBlock = genesis.GetHash();
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
assert(consensus.hashGenesisBlock == uint256{"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"});
assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"});
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// 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.
vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd
vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9
Change Luke Dashjr seed to dashjr-list-of-p2p-nodes.us To avoid issues with DNS blacklisting, I've setup a separate domain for my DNS seed.
2024-03-21 15:26:20 +00:00
vSeeds.emplace_back("dnsseed.bitcoin.dashjr-list-of-p2p-nodes.us."); // Luke Dashjr
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
Change petertodd seeds to petertodd.net I changed my DNS seeds to .net from .org to avoid issues with DNS blacklisting, that falsely thinks my domain name is pointing to IP addresses with malware and similar things. Right now there are CNAME records, so the .org addresses still work. But eventually, if needed, I'll remove those CNAME's.
2023-11-25 13:59:41 +00:00
vSeeds.emplace_back("seed.btc.petertodd.net."); // Peter Todd, only supports x1, x5, x9, and xd
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost
vSeeds.emplace_back("dnsseed.emzy.de."); // Stephan Oeste
vSeeds.emplace_back("seed.bitcoin.wiz.biz."); // Jason Maurice
chainparams: Add achow101 DNS seeder
2024-04-30 13:19:05 -04:00
vSeeds.emplace_back("seed.mainnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
bech32_hrp = "bc";
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
blech32_hrp = bech32_hrp;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
fDefaultConsistencyChecks = false;
m_is_mockable_chain = false;
checkpointData = {
{
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
{ 11111, uint256{"0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"}},
{ 33333, uint256{"000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"}},
{ 74000, uint256{"0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"}},
{105000, uint256{"00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"}},
{134444, uint256{"00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"}},
{168000, uint256{"000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"}},
{193000, uint256{"000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"}},
{210000, uint256{"000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"}},
{216116, uint256{"00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"}},
{225430, uint256{"00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"}},
{250000, uint256{"000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"}},
{279000, uint256{"0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40"}},
{295000, uint256{"00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983"}},
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
}
};
chainparams: add blockhash to AssumeutxoData This allows us to reference assumeutxo configuration by blockhash as well as height; this is helpful in future changes when we want to reference assumeutxo configurations before the block index is loaded.
2023-05-25 13:05:27 -04:00
m_assumeutxo_data = {
chainparams: add mainnet assumeutxo param at height 840_000
2024-08-08 20:00:45 +02:00
{
.height = 840'000,
.hash_serialized = AssumeutxoHash{uint256{"a2a5521b1b5ab65f67818e5e8eccabb7171a517f9e2382208f77687310768f96"}},
.m_chain_tx_count = 991032194,
.blockhash = consteval_ctor(uint256{"0000000000000000000320283a032748cef8227873ff4872689bf23f1cda83a5"}),
chainparams: add mainnet assumeutxo param at height 880_000
2025-03-01 10:53:48 -05:00
},
{
.height = 880'000,
.hash_serialized = AssumeutxoHash{uint256{"dbd190983eaf433ef7c15f78a278ae42c00ef52e0fd2a54953782175fbadcea9"}},
.m_chain_tx_count = 1145604538,
.blockhash = consteval_ctor(uint256{"000000000000000000010b17283c3c400507969a9c2afd1dcf2082ec5cca2880"}),
chainparams: add mainnet assumeutxo param at height 840_000
2024-08-08 20:00:45 +02:00
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
};
chainTxData = ChainTxData{
[kernel] update chainTxData for v29
2025-03-03 10:58:38 -05:00
// Data from RPC: getchaintxstats 4096 00000000000000000001b658dd1120e82e66d2790811f89ede9742ada3ed6d77
.nTime = 1741017141,
.tx_count = 1161875261,
.dTxRate = 4.620728156243148,
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
};
}
};
/**
* Testnet (v3): public test network which is reset from time to time.
*/
class CTestNetParams : public CChainParams {
public:
CTestNetParams() {
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::TESTNET);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
consensus.nSubsidyHalvingInterval = 210000;
consensus.script_flag_exceptions.emplace( // BIP16 exception
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
uint256{"00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"}, SCRIPT_VERIFY_NONE);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.BIP34Height = 21111;
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.BIP34Hash = uint256{"0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8"};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
consensus.enforce_BIP94 = false;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // 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;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// Deployment of Taproot (BIPs 340-342)
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
[kernel] update assumevalid and minimumChainWork for v29
2025-03-03 11:08:49 -05:00
consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000015f5e0c9f13455b0eb17"};
consensus.defaultAssumeValid = uint256{"00000000000003fc7967410ba2d0a8a8d50daedc318d43e8baf1a9782c236a57"}; // 3974606
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Simplicity
Merge 3c1782e3ce into merged_master (Elements PR #1438)
2025-04-16 11:53:55 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
consensus.genesis_subsidy = 50*COIN;
consensus.connect_genesis_outputs = false;
consensus.subsidy_asset = CAsset();
anyonecanspend_aremine = false;
enforce_pak = false;
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
accept_unlimited_issuances = false;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = false;
accept_discount_ct = false;
create_discount_ct = false;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = PeginSubsidy();
pegin_minimum = PeginMinimum();
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.has_parent_chain = false;
g_signed_blocks = false;
g_con_elementsmode = false;
g_con_blockheightinheader = false;
consensus.total_valid_epochs = 0;
consensus.elements_mode = g_con_elementsmode;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
pchMessageStart[0] = 0x0b;
pchMessageStart[1] = 0x11;
pchMessageStart[2] = 0x09;
pchMessageStart[3] = 0x07;
nDefaultPort = 18333;
nPruneAfterHeight = 1000;
[kernel] update assumed blockchain and chainstate sizes for v29
2025-03-03 11:07:27 -05:00
m_assumed_blockchain_size = 200;
params: Update assumed blockchain and chainstate sizes
2024-08-14 13:42:32 -04:00
m_assumed_chain_state_size = 19;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN, consensus);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.hashGenesisBlock = genesis.GetHash();
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
assert(consensus.hashGenesisBlock == uint256{"000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"});
assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"});
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vFixedSeeds.clear();
vSeeds.clear();
// nodes with support for servicebits filtering should be at the top
vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch.");
Change petertodd seeds to petertodd.net I changed my DNS seeds to .net from .org to avoid issues with DNS blacklisting, that falsely thinks my domain name is pointing to IP addresses with malware and similar things. Right now there are CNAME records, so the .org addresses still work. But eventually, if needed, I'll remove those CNAME's.
2023-11-25 13:59:41 +00:00
vSeeds.emplace_back("seed.tbtc.petertodd.net.");
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl.");
vSeeds.emplace_back("testnet-seed.bluematt.me."); // Just a static list of stable node(s), only supports x9
chainparams: Add achow101 DNS seeder
2024-04-30 13:19:05 -04:00
vSeeds.emplace_back("seed.testnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
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 = "tb";
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
blech32_hrp = bech32_hrp;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
fDefaultConsistencyChecks = false;
m_is_mockable_chain = false;
checkpointData = {
{
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
{546, uint256{"000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70"}},
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
}
};
chainparams: add blockhash to AssumeutxoData This allows us to reference assumeutxo configuration by blockhash as well as height; this is helpful in future changes when we want to reference assumeutxo configurations before the block index is loaded.
2023-05-25 13:05:27 -04:00
m_assumeutxo_data = {
chainparams: add testnet assumeutxo param at height 2_500_000
2023-09-21 10:52:00 +00:00
{
.height = 2'500'000,
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
.hash_serialized = AssumeutxoHash{uint256{"f841584909f68e47897952345234e37fcd9128cd818f41ee6c3ca68db8071be7"}},
scripted-diff: Modernize naming of nChainTx and nTxCount -BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
2024-03-18 23:28:10 +01:00
.m_chain_tx_count = 66484552,
refactor: Hand-replace some uint256S -> uint256 chainparams.cpp - workaround for MSVC bug triggering C7595 - Calling consteval constructors in initializer lists fails, but works on GCC (13.2.0) & Clang (17.0.6).
2024-08-05 14:51:47 +02:00
.blockhash = consteval_ctor(uint256{"0000000000000093bcb68c03a9a168ae252572d348a2eaeba2cdf9231d73206f"}),
chainparams: add testnet assumeutxo param at height 2_500_000
2023-09-21 10:52:00 +00:00
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
};
chainTxData = ChainTxData{
[kernel] update chainTxData for v29
2025-03-03 10:58:38 -05:00
// Data from RPC: getchaintxstats 4096 00000000000003fc7967410ba2d0a8a8d50daedc318d43e8baf1a9782c236a57
.nTime = 1741042082,
.tx_count = 475477615,
.dTxRate = 17.15933950357594,
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
};
}
};
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
/**
* Testnet (v4): public test network which is reset from time to time.
*/
class CTestNet4Params : public CChainParams {
public:
CTestNet4Params() {
Merge da083d4bbd into merged_master (Bitcoin PR bitcoin/bitcoin#29775)
2026-03-11 17:10:37 +00:00
m_chain_type = ChainTypeMetaFrom(ChainType::TESTNET4);
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 1;
consensus.BIP34Hash = uint256{};
consensus.BIP65Height = 1;
consensus.BIP66Height = 1;
consensus.CSVHeight = 1;
consensus.SegwitHeight = 1;
consensus.MinBIP9WarningHeight = 0;
refactor: Testnet4 - Replace uint256S("str") -> uint256{"str"} Ran scripted-diff from 2d9d752e4fc30aabf2ddd36ca7a63432d26d4fea. Follow-up to #29775 which overlapped with work on #30560 (the latter includes the scripted-diff commit).
2024-08-25 21:04:32 +02:00
consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.enforce_BIP94 = true;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // 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;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
// Deployment of Taproot (BIPs 340-342)
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;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
Merge da083d4bbd into merged_master (Bitcoin PR bitcoin/bitcoin#29775)
2026-03-11 17:10:37 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
Merge 55d663cb15 into merged_master (Bitcoin PR bitcoin/bitcoin#30658)
2026-03-13 13:59:08 +00:00
[kernel] update assumevalid and minimumChainWork for v29
2025-03-03 11:08:49 -05:00
consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000001d6dce8651b6094e4c1"};
consensus.defaultAssumeValid = uint256{"0000000000003ed4f08dbdf6f7d6b271a6bcffce25675cb40aa9fa43179a89f3"}; // 72600
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
pchMessageStart[0] = 0x1c;
pchMessageStart[1] = 0x16;
pchMessageStart[2] = 0x3f;
pchMessageStart[3] = 0x28;
nDefaultPort = 48333;
nPruneAfterHeight = 1000;
[kernel] update assumed blockchain and chainstate sizes for v29
2025-03-03 11:07:27 -05:00
m_assumed_blockchain_size = 11;
m_assumed_chain_state_size = 1;
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
const char* testnet4_genesis_msg = "03/May/2024 000000000000000000001ebd58c244970b3aa9d783bb001011fbe8ea8e98e00e";
Replace CScript _hex_v_u8 appends with _hex This will skip vector conversion before serializing to the prevector in CScript.
2024-09-09 21:13:20 +02:00
const CScript testnet4_genesis_script = CScript() << "000000000000000000000000000000000000000000000000000000000000000000"_hex << OP_CHECKSIG;
Merge da083d4bbd into merged_master (Bitcoin PR bitcoin/bitcoin#29775)
2026-03-11 17:10:37 +00:00
genesis = CreateGenesisBlock(consensus, CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)testnet4_genesis_msg, (const unsigned char*)testnet4_genesis_msg + strlen(testnet4_genesis_msg)),
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
testnet4_genesis_script,
1714777860,
393743547,
0x1d00ffff,
1,
50 * COIN);
consensus.hashGenesisBlock = genesis.GetHash();
refactor: Testnet4 - Replace uint256S("str") -> uint256{"str"} Ran scripted-diff from 2d9d752e4fc30aabf2ddd36ca7a63432d26d4fea. Follow-up to #29775 which overlapped with work on #30560 (the latter includes the scripted-diff commit).
2024-08-25 21:04:32 +02:00
assert(consensus.hashGenesisBlock == uint256{"00000000da84f2bafbbc53dee25a72ae507ff4914b867c565be350b0da8bf043"});
assert(genesis.hashMerkleRoot == uint256{"7aa0a7ae1e223414cb807e40cd57e667b718e42aaf9306db9102fe28912b7b4e"});
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
vFixedSeeds.clear();
vSeeds.clear();
// nodes with support for servicebits filtering should be at the top
vSeeds.emplace_back("seed.testnet4.bitcoin.sprovoost.nl."); // Sjors Provoost
vSeeds.emplace_back("seed.testnet4.wiz.biz."); // Jason Maurice
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
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 = "tb";
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_testnet4), std::end(chainparams_seed_testnet4));
fDefaultConsistencyChecks = false;
m_is_mockable_chain = false;
checkpointData = {
{
{},
}
};
m_assumeutxo_data = {
{}
};
chainTxData = ChainTxData{
[kernel] update chainTxData for v29
2025-03-03 10:58:38 -05:00
// Data from RPC: getchaintxstats 4096 0000000000003ed4f08dbdf6f7d6b271a6bcffce25675cb40aa9fa43179a89f3
.nTime = 1741070246,
.tx_count = 7653966,
.dTxRate = 1.239174414591965,
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
};
}
};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
/**
* Signet: test network with an additional consensus parameter (see BIP325).
*/
class SigNetParams : public CChainParams {
public:
explicit SigNetParams(const SigNetOptions& options)
{
std::vector<uint8_t> bin;
chainparams: add signet fixed seeds if default network
2025-03-06 12:59:20 -06:00
vFixedSeeds.clear();
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vSeeds.clear();
if (!options.challenge) {
refactor: Hand-replace some ParseHex -> ""_hex The following scripted-diff commit will replace ParseHex("...") with "..."_hex_u8, but this replacement will not work in cases where vectors are needed instead of arrays, and is not ideal in cases where std::byte is accepted. For example, it is currently necessary to use _hex_v_u8 when calling CScript operator<< because that operator does not currently support std::array or std::byte. Conversely, it is incorrect to use _hex_v instead of _hex in net_processing.cpp for the MakeAndPushMessage argument, because if the argument is a std::vector it is considered variable-length and serialized with a size prefix, but if the argument is a std::array or Span is it considered fixed length and serialized without a prefix. By the same logic, it is also safe to change the NUMS_H constant in pubkey.cpp from a std::vector to std::array because it is never serialized.
2024-08-27 21:21:30 +02:00
bin = "512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae"_hex_v_u8;
chainparams: add signet fixed seeds if default network
2025-03-06 12:59:20 -06:00
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_signet), std::end(chainparams_seed_signet));
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
chainparams: Add achow101 DNS seeder
2024-04-30 13:19:05 -04:00
vSeeds.emplace_back("seed.signet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
[kernel] update assumevalid and minimumChainWork for v29
2025-03-03 11:08:49 -05:00
consensus.nMinimumChainWork = uint256{"000000000000000000000000000000000000000000000000000002b517f3d1a1"};
consensus.defaultAssumeValid = uint256{"000000895a110f46e59eb82bbc5bfb67fa314656009c295509c21b4999f5180a"}; // 237722
[kernel] update assumed blockchain and chainstate sizes for v29
2025-03-03 11:07:27 -05:00
m_assumed_blockchain_size = 9;
m_assumed_chain_state_size = 1;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
chainTxData = ChainTxData{
[kernel] update chainTxData for v29
2025-03-03 10:58:38 -05:00
// Data from RPC: getchaintxstats 4096 000000895a110f46e59eb82bbc5bfb67fa314656009c295509c21b4999f5180a
.nTime = 1741019645,
.tx_count = 16540736,
.dTxRate = 1.064918879911595,
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
};
} else {
bin = *options.challenge;
consensus.nMinimumChainWork = uint256{};
consensus.defaultAssumeValid = uint256{};
m_assumed_blockchain_size = 0;
m_assumed_chain_state_size = 0;
chainTxData = ChainTxData{
0,
0,
0,
};
LogPrintf("Signet with challenge %s\n", HexStr(bin));
}
if (options.seeds) {
vSeeds = *options.seeds;
}
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::SIGNET);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.signet_blocks = true;
consensus.signet_challenge.assign(bin.begin(), bin.end());
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 1;
consensus.BIP34Hash = uint256{};
consensus.BIP65Height = 1;
consensus.BIP66Height = 1;
consensus.CSVHeight = 1;
consensus.SegwitHeight = 1;
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = false;
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
consensus.enforce_BIP94 = false;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
consensus.MinBIP9WarningHeight = 0;
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.powLimit = uint256{"00000377ae000000000000000000000000000000000000000000000000000000"};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
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;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// Activation of Taproot (BIPs 340-342)
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;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Simplicity
Merge 3c1782e3ce into merged_master (Elements PR #1438)
2025-04-16 11:53:55 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
// ELEMENTS: copied from Main
consensus.genesis_subsidy = 50*COIN;
consensus.connect_genesis_outputs = false;
consensus.subsidy_asset = CAsset();
anyonecanspend_aremine = false;
enforce_pak = false;
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
accept_unlimited_issuances = false;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = false;
accept_discount_ct = false;
create_discount_ct = false;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = PeginSubsidy();
pegin_minimum = PeginMinimum();
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.has_parent_chain = false;
g_signed_blocks = false; // lol
g_con_elementsmode = false;
g_con_blockheightinheader = false;
consensus.total_valid_epochs = 0;
consensus.elements_mode = g_con_elementsmode;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
// message start is defined as the first 4 bytes of the sha256d of the block script
HashWriter h{};
h << consensus.signet_challenge;
uint256 hash = h.GetHash();
[refactor] Define MessageStartChars as std::array
2023-09-12 13:01:07 +02:00
std::copy_n(hash.begin(), 4, pchMessageStart.begin());
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
nDefaultPort = 38333;
nPruneAfterHeight = 1000;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN, consensus);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.hashGenesisBlock = genesis.GetHash();
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
assert(consensus.hashGenesisBlock == uint256{"00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"});
assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"});
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
chainparams: add signet assumeutxo param at height 160_000
2023-09-21 11:00:23 +00:00
m_assumeutxo_data = {
{
.height = 160'000,
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
.hash_serialized = AssumeutxoHash{uint256{"fe0a44309b74d6b5883d246cb419c6221bcccf0b308c9b59b7d70783dbdf928a"}},
scripted-diff: Modernize naming of nChainTx and nTxCount -BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
2024-03-18 23:28:10 +01:00
.m_chain_tx_count = 2289496,
refactor: Hand-replace some uint256S -> uint256 chainparams.cpp - workaround for MSVC bug triggering C7595 - Calling consteval constructors in initializer lists fails, but works on GCC (13.2.0) & Clang (17.0.6).
2024-08-05 14:51:47 +02:00
.blockhash = consteval_ctor(uint256{"0000003ca3c99aff040f2563c2ad8f8ec88bd0fd6b8f0895cfaf1ef90353a62c"}),
chainparams: add signet assumeutxo param at height 160_000
2023-09-21 11:00:23 +00:00
}
};
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
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 = "tb";
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
blech32_hrp = bech32_hrp;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
fDefaultConsistencyChecks = false;
m_is_mockable_chain = false;
}
};
/**
* Regression test: intended for private networks only. Has minimal difficulty to ensure that
* blocks can be found instantly.
*/
class CRegTestParams : public CChainParams
{
public:
explicit CRegTestParams(const RegTestOptions& opts)
{
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::REGTEST);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
consensus.nSubsidyHalvingInterval = 150;
consensus.BIP34Height = 1; // Always active unless overridden
consensus.BIP34Hash = uint256();
consensus.BIP65Height = 1; // Always active unless overridden
consensus.BIP66Height = 1; // Always active unless overridden
consensus.CSVHeight = 1; // Always active unless overridden
consensus.SegwitHeight = 0; // Always active unless overridden
consensus.MinBIP9WarningHeight = 0;
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
consensus.powLimit = uint256{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
consensus: lower regtest nPowTargetTimespan to 144 This currently has no effect due to fPowNoRetargeting, except for the getnetworkhashps when called with -1. It will when the next commit enforces the timewarp attack mitigation on regtest.
2024-08-16 09:07:16 +02:00
consensus.nPowTargetTimespan = 24 * 60 * 60; // one day
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
test: Don't enforce BIP94 on regtest unless specified by arg The added regtest option -test=bip94 is only used in the functional test for BIP94. This is done because the default regtest consensus rules should aim to follow to mainnet, not testnet.
2024-10-25 13:49:47 -04:00
consensus.enforce_BIP94 = opts.enforce_bip94;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.fPowNoRetargeting = true;
consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
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_TESTDUMMY].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
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;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nPeriod = 128; // test ability to change from default
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nThreshold = 128;
// Simplicity
Merge 3c1782e3ce into merged_master (Elements PR #1438)
2025-04-16 11:53:55 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nPeriod = 128; // test ability to change from default
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nThreshold = 128;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.nMinimumChainWork = uint256{};
consensus.defaultAssumeValid = uint256{};
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.genesis_subsidy = 50*COIN;
consensus.connect_genesis_outputs = false;
consensus.subsidy_asset = CAsset();
anyonecanspend_aremine = false;
enforce_pak = false;
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
accept_unlimited_issuances = false;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = false;
accept_discount_ct = false;
create_discount_ct = false;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = PeginSubsidy();
pegin_minimum = PeginMinimum();
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.has_parent_chain = false;
g_signed_blocks = false;
g_con_elementsmode = false;
consensus.elements_mode = g_con_elementsmode;
g_con_blockheightinheader = false;
consensus.total_valid_epochs = 0;
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
pchMessageStart[0] = 0xfa;
pchMessageStart[1] = 0xbf;
pchMessageStart[2] = 0xb5;
pchMessageStart[3] = 0xda;
nDefaultPort = 18444;
nPruneAfterHeight = opts.fastprune ? 100 : 1000;
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_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;
consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
}
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN, consensus);
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
consensus.hashGenesisBlock = genesis.GetHash();
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
assert(consensus.hashGenesisBlock == uint256{"0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"});
assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"});
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
vSeeds.clear();
vSeeds.emplace_back("dummySeed.invalid.");
fDefaultConsistencyChecks = true;
m_is_mockable_chain = true;
checkpointData = {
{
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
{0, uint256{"0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"}},
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
}
};
chainparams: add blockhash to AssumeutxoData This allows us to reference assumeutxo configuration by blockhash as well as height; this is helpful in future changes when we want to reference assumeutxo configurations before the block index is loaded.
2023-05-25 13:05:27 -04:00
m_assumeutxo_data = {
fuzz: improve utxo_snapshot target Add the possibility of giving more guidance to the creation of the metadata and/or coins, so that the fuzzer gets the chance to reach more error conditions in ActivateSnapshot and sometimes successfully creates a valid snapshot. This also changes the asserts for the success case that were outdated, and only didn't result in a crash because the fuzzer wasn't able to reach this code before.
2024-06-21 15:24:21 -04:00
{ // For use by unit tests
chainparams: add blockhash to AssumeutxoData This allows us to reference assumeutxo configuration by blockhash as well as height; this is helpful in future changes when we want to reference assumeutxo configurations before the block index is loaded.
2023-05-25 13:05:27 -04:00
.height = 110,
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
.hash_serialized = AssumeutxoHash{uint256{"6657b736d4fe4db0cbc796789e812d5dba7f5c143764b1b6905612f1830609d1"}},
scripted-diff: Modernize naming of nChainTx and nTxCount -BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
2024-03-18 23:28:10 +01:00
.m_chain_tx_count = 111,
refactor: Hand-replace some uint256S -> uint256 chainparams.cpp - workaround for MSVC bug triggering C7595 - Calling consteval constructors in initializer lists fails, but works on GCC (13.2.0) & Clang (17.0.6).
2024-08-05 14:51:47 +02:00
.blockhash = consteval_ctor(uint256{"696e92821f65549c7ee134edceeeeaaa4105647a3c4fd9f298c0aec0ab50425c"}),
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
},
fuzz: improve utxo_snapshot target Add the possibility of giving more guidance to the creation of the metadata and/or coins, so that the fuzzer gets the chance to reach more error conditions in ActivateSnapshot and sometimes successfully creates a valid snapshot. This also changes the asserts for the success case that were outdated, and only didn't result in a crash because the fuzzer wasn't able to reach this code before.
2024-06-21 15:24:21 -04:00
{
// For use by fuzz target src/test/fuzz/utxo_snapshot.cpp
.height = 200,
scripted-diff: Replace uint256S("str") -> uint256{"str"} -BEGIN VERIFY SCRIPT- sed -i --regexp-extended -e 's/\buint256S\("(0x)?([^"]{64})"\)/uint256{"\2"}/g' $(git grep -l uint256S) -END VERIFY SCRIPT-
2024-08-05 09:14:47 +02:00
.hash_serialized = AssumeutxoHash{uint256{"4f34d431c3e482f6b0d67b64609ece3964dc8d7976d02ac68dd7c9c1421738f2"}},
scripted-diff: Modernize naming of nChainTx and nTxCount -BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
2024-03-18 23:28:10 +01:00
.m_chain_tx_count = 201,
refactor: Hand-replace some uint256S -> uint256 chainparams.cpp - workaround for MSVC bug triggering C7595 - Calling consteval constructors in initializer lists fails, but works on GCC (13.2.0) & Clang (17.0.6).
2024-08-05 14:51:47 +02:00
.blockhash = consteval_ctor(uint256{"5e93653318f294fb5aa339d00bbf8cf1c3515488ad99412c37608b139ea63b27"}),
fuzz: improve utxo_snapshot target Add the possibility of giving more guidance to the creation of the metadata and/or coins, so that the fuzzer gets the chance to reach more error conditions in ActivateSnapshot and sometimes successfully creates a valid snapshot. This also changes the asserts for the success case that were outdated, and only didn't result in a crash because the fuzzer wasn't able to reach this code before.
2024-06-21 15:24:21 -04:00
},
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
{
test: add feature_assumeutxo functional test Most ideas for test improvements (TODOs) provided by Russ Yanofsky.
2021-06-17 16:09:38 -04:00
// For use by test/functional/feature_assumeutxo.py
.height = 299,
Merge 21c2879f37 into merged_master (Bitcoin PR bitcoin/bitcoin#30560)
2026-03-11 11:40:25 +00:00
.hash_serialized = AssumeutxoHash{uint256{"4f046c8d36732314b2ccd00be35232e7a211eb87b0fd8858f898f511bc7fae64"}},
scripted-diff: Modernize naming of nChainTx and nTxCount -BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
2024-03-18 23:28:10 +01:00
.m_chain_tx_count = 334,
Merge 21c2879f37 into merged_master (Bitcoin PR bitcoin/bitcoin#30560)
2026-03-11 11:40:25 +00:00
.blockhash = consteval_ctor(uint256{"3bb27e6f7166543430d14d8a4a839a59aef05f845d8e9a0c210901a597269d1b"}),
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
},
};
chainTxData = ChainTxData{
0,
0,
0
};
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
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 = "bcrt";
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
blech32_hrp = bech32_hrp;
}
};
static void MaybeUpdateHeights(const ArgsManager& args, Consensus::Params& consensus)
{
for (const std::string& arg : args.GetArgs("-testactivationheight")) {
const auto found{arg.find('@')};
if (found == std::string::npos) {
throw std::runtime_error(strprintf("Invalid format (%s) for -testactivationheight=name@height.", arg));
}
const auto name{arg.substr(0, found)};
const auto value{arg.substr(found + 1)};
int32_t height;
if (!ParseInt32(value, &height) || height < 0 || height >= std::numeric_limits<int>::max()) {
throw std::runtime_error(strprintf("Invalid height value (%s) for -testactivationheight=name@height.", arg));
}
if (name == "segwit") {
consensus.SegwitHeight = int{height};
} else if (name == "bip34") {
consensus.BIP34Height = int{height};
} else if (name == "dersig") {
consensus.BIP66Height = int{height};
} else if (name == "cltv") {
consensus.BIP65Height = int{height};
} else if (name == "csv") {
consensus.CSVHeight = int{height};
} else {
throw std::runtime_error(strprintf("Invalid name (%s) for -testactivationheight=name@height.", arg));
}
}
}
/**
* Allows modifying the Version Bits regtest parameters.
*/
void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout, int min_activation_height, Consensus::Params& consensus)
{
consensus.vDeployments[d].nStartTime = nStartTime;
consensus.vDeployments[d].nTimeout = nTimeout;
consensus.vDeployments[d].min_activation_height = min_activation_height;
}
void UpdateActivationParametersFromArgs(const ArgsManager& args, Consensus::Params& consensus)
{
MaybeUpdateHeights(args, consensus);
if (!args.IsArgSet("-vbparams")) return;
for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {
throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");
}
int64_t nStartTime, nTimeout;
int min_activation_height = 0;
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() >= 4 && !ParseInt32(vDeploymentParams[3], &min_activation_height)) {
throw std::runtime_error(strprintf("Invalid min_activation_height (%s)", vDeploymentParams[3]));
}
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, min_activation_height, consensus);
found = true;
LogPrintf("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, min_activation_height=%d\n", vDeploymentParams[0], nStartTime, nTimeout, min_activation_height);
break;
}
}
if (!found) {
throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
}
}
}
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
// ELEMENTS
PeginSubsidy ParsePeginSubsidy(const ArgsManager& args) {
PeginSubsidy pegin_subsidy;
pegin_subsidy.height = args.GetIntArg("-peginsubsidyheight", std::numeric_limits<int>::max());
if (pegin_subsidy.height < 0) {
throw std::runtime_error(strprintf("Invalid block height (%d) for -peginsubsidyheight. Must be positive.", pegin_subsidy.height));
}
if (std::optional<CAmount> amount = ParseMoney(args.GetArg("-peginsubsidythreshold", "0"))) {
pegin_subsidy.threshold = amount.value();
} else {
throw std::runtime_error("Invalid -peginsubsidythreshold");
}
return pegin_subsidy;
};
PeginMinimum ParsePeginMinimum(const ArgsManager& args) {
PeginMinimum pegin_minimum;
pegin_minimum.height = args.GetIntArg("-peginminheight", std::numeric_limits<int>::max());
if (pegin_minimum.height < 0) {
throw std::runtime_error(strprintf("Invalid block height (%d) for -peginminheight. Must be positive.", pegin_minimum.height));
}
if (std::optional<CAmount> amount = ParseMoney(args.GetArg("-peginminamount", "0"))) {
pegin_minimum.amount = amount.value();
} else {
throw std::runtime_error("Invalid -peginminamount");
}
return pegin_minimum;
};
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
/**
* Custom params for testing.
*/
class CCustomParams : public CRegTestParams {
protected:
std::string default_magic_str = "5319F20E";
std::string default_signblockscript = "51";
Merge fe48feb32d into merged_master (Elements PR #1447)
2025-04-16 12:25:34 +02:00
bool use_invalid_seeds = true;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
void UpdateFromArgs(const ArgsManager& args)
{
UpdateActivationParametersFromArgs(args, consensus);
consensus.nSubsidyHalvingInterval = args.GetIntArg("-con_nsubsidyhalvinginterval", consensus.nSubsidyHalvingInterval);
consensus.BIP34Height = args.GetIntArg("-con_bip34height", 0);
consensus.BIP34Hash = uint256S(args.GetArg("-con_bip34hash", "0x0"));
consensus.BIP65Height = args.GetIntArg("-con_bip65height", 0);
consensus.BIP66Height = args.GetIntArg("-con_bip66height", 0);
consensus.CSVHeight = args.GetIntArg("-con_csv_deploy_start", 1);
consensus.powLimit = uint256S(args.GetArg("-con_powlimit", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
consensus.nPowTargetTimespan = args.GetIntArg("-con_npowtargettimespan", consensus.nPowTargetTimespan);
consensus.nPowTargetSpacing = args.GetIntArg("-con_npowtargetspacing", consensus.nPowTargetSpacing);
consensus.fPowAllowMinDifficultyBlocks = args.GetBoolArg("-con_fpowallowmindifficultyblocks", consensus.fPowAllowMinDifficultyBlocks);
consensus.fPowNoRetargeting = args.GetBoolArg("-con_fpownoretargeting", consensus.fPowNoRetargeting);
consensus.nRuleChangeActivationThreshold = (uint32_t)args.GetIntArg("-con_nrulechangeactivationthreshold", consensus.nRuleChangeActivationThreshold);
consensus.nMinerConfirmationWindow = (uint32_t)args.GetIntArg("-con_nminerconfirmationwindow", consensus.nMinerConfirmationWindow);
consensus.nMinimumChainWork = uint256S(args.GetArg("-con_nminimumchainwork", "0x0"));
consensus.defaultAssumeValid = uint256S(args.GetArg("-con_defaultassumevalid", "0x00"));
// TODO: Embed in genesis block in nTime field with new genesis block type
consensus.dynamic_epoch_length = args.GetIntArg("-dynamic_epoch_length", consensus.dynamic_epoch_length);
// Default junk keys for testing
consensus.first_extension_space = {ParseHex("02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f")};
std::vector<std::string> pak_list_str = args.GetArgs("-pak");
if (!pak_list_str.empty()) {
consensus.first_extension_space.clear();
for (const auto& entry : pak_list_str) {
consensus.first_extension_space.push_back(ParseHex(entry));
}
}
nPruneAfterHeight = (uint64_t)args.GetIntArg("-npruneafterheight", nPruneAfterHeight);
fDefaultConsistencyChecks = args.GetBoolArg("-fdefaultconsistencychecks", fDefaultConsistencyChecks);
bech32_hrp = args.GetArg("-bech32_hrp", bech32_hrp);
blech32_hrp = args.GetArg("-blech32_hrp", blech32_hrp);
assert(base58Prefixes[PUBKEY_ADDRESS].size() == 1);
assert(base58Prefixes[SCRIPT_ADDRESS].size() == 1);
assert(base58Prefixes[BLINDED_ADDRESS].size() == 1);
assert(base58Prefixes[SECRET_KEY].size() == 1);
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-pubkeyprefix", base58Prefixes[PUBKEY_ADDRESS][0]));
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-scriptprefix", base58Prefixes[SCRIPT_ADDRESS][0]));
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-blindedprefix", base58Prefixes[BLINDED_ADDRESS][0]));
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, args.GetIntArg("-secretprefix", base58Prefixes[SECRET_KEY][0]));
base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentpubkeyprefix", 111));
base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentscriptprefix", 196));
parent_bech32_hrp = args.GetArg("-parent_bech32_hrp", "bcrt");
parent_blech32_hrp = args.GetArg("-parent_blech32_hrp", "bcrt");
std::string extpubprefix = args.GetArg("-extpubkeyprefix", "043587CF");
assert(IsHex(extpubprefix) && extpubprefix.size() == 8 && "-extpubkeyprefix must be hex string of length 8");
base58Prefixes[EXT_PUBLIC_KEY] = ParseHex(extpubprefix);
std::string extprvprefix = args.GetArg("-extprvkeyprefix", "04358394");
assert(IsHex(extprvprefix) && extprvprefix.size() == 8 && "-extprvkeyprefix must be hex string of length 8");
base58Prefixes[EXT_SECRET_KEY] = ParseHex(extprvprefix);
const std::string magic_str = args.GetArg("-pchmessagestart", default_magic_str);
assert(IsHex(magic_str) && magic_str.size() == 8 && "-pchmessagestart must be hex string of length 8");
const std::vector<unsigned char> magic_byte = ParseHex(magic_str);
Merge 1e9d367d0d into merged_master (Bitcoin PR bitcoin/bitcoin#28423)
2025-07-21 14:33:58 +02:00
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart.begin());
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
vSeeds.clear();
Merge fe48feb32d into merged_master (Elements PR #1447)
2025-04-16 12:25:34 +02:00
if (use_invalid_seeds) {
vSeeds.emplace_back("dummySeed.invalid.");
}
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
if (args.IsArgSet("-seednode")) {
const auto seednodes = args.GetArgs("-seednode");
if (seednodes.size() != 1 || seednodes[0] != "0") {
vSeeds = seednodes;
}
}
//
// ELEMENTS fields
// Determines type of genesis block
consensus.genesis_style = args.GetArg("-con_genesis_style", "elements");
// Block signing encumbrance script, default of 51 aka OP_TRUE
std::vector<unsigned char> sign_bytes = ParseHex(args.GetArg("-signblockscript", default_signblockscript));
consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
consensus.max_block_signature_size = args.GetIntArg("-con_max_block_sig_size", consensus.max_block_signature_size);
g_signed_blocks = args.GetBoolArg("-con_signed_blocks", true);
// Note: These globals are needed to avoid circular dependencies.
// Default to true for custom chains.
g_con_blockheightinheader = args.GetBoolArg("-con_blockheightinheader", true);
g_con_elementsmode = args.GetBoolArg("-con_elementsmode", true);
consensus.elements_mode = g_con_elementsmode;
// No subsidy for custom chains by default
consensus.genesis_subsidy = args.GetIntArg("-con_blocksubsidy", 0);
// All non-zero coinbase outputs must go to this scriptPubKey
std::vector<unsigned char> man_bytes = ParseHex(args.GetArg("-con_mandatorycoinbase", ""));
consensus.mandatory_coinbase_destination = CScript(man_bytes.begin(), man_bytes.end()); // Blank script allows any coinbase destination
// Custom chains connect coinbase outputs to db by default
consensus.connect_genesis_outputs = args.GetIntArg("-con_connect_genesis_outputs", true);
initialFreeCoins = args.GetIntArg("-initialfreecoins", initialFreeCoins);
anyonecanspend_aremine = args.GetBoolArg("-anyonecanspendaremine", anyonecanspend_aremine);
consensus.has_parent_chain = args.GetBoolArg("-con_has_parent_chain", consensus.has_parent_chain);
enforce_pak = args.GetBoolArg("-enforce_pak", false);
Merge 6150a745f9 into merged_master (Elements PR #1493)
2025-11-05 11:21:26 +02:00
accept_unlimited_issuances = args.GetBoolArg("-acceptunlimitedissuances", accept_unlimited_issuances);
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Allow multiple op_return outputs by relay policy
multi_data_permitted = args.GetBoolArg("-multi_data_permitted", enforce_pak);
// bitcoin regtest is the parent chain by default
parentGenesisBlockHash = uint256S(args.GetArg("-parentgenesisblockhash", parentGenesisBlockHash.GetHex()));
// Either it has a parent chain or not
const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
assert(consensus.has_parent_chain != parent_genesis_is_null);
consensus.parentChainPowLimit = uint256S(args.GetArg("-con_parentpowlimit", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
consensus.parent_chain_signblockscript = StrHexToScriptWithDefault(args.GetArg("-con_parent_chain_signblockscript", ""), CScript());
consensus.pegin_min_depth = args.GetIntArg("-peginconfirmationdepth", DEFAULT_PEGIN_CONFIRMATION_DEPTH);
const CScript default_script(CScript() << OP_TRUE);
consensus.fedpegScript = StrHexToScriptWithDefault(args.GetArg("-fedpegscript", ""), default_script);
consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
create_discount_ct = args.GetBoolArg("-creatediscountct", create_discount_ct);
accept_discount_ct = args.GetBoolArg("-acceptdiscountct", accept_discount_ct) || create_discount_ct;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = ParsePeginSubsidy(args);
pegin_minimum = ParsePeginMinimum(args);
if (pegin_subsidy.threshold < pegin_minimum.amount) {
throw std::runtime_error(strprintf("Peg-in subsidy threshold (%s) must be greater than or equal to peg-in minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
}
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Calculate pegged Bitcoin asset
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::vector<unsigned char> commit = CommitToArguments(consensus, m_chain_type.chain_name);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
uint256 entropy;
Merge b5a271334c into merged_master (Bitcoin PR bitcoin/bitcoin#28922)
2025-11-10 15:40:17 +02:00
GenerateAssetEntropy(entropy, COutPoint(Txid::FromUint256(uint256(commit)), 0), parentGenesisBlockHash);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.total_valid_epochs = args.GetIntArg("-total_valid_epochs", 2);
// Elements serialization uses derivation, bitcoin serialization uses 0x00
if (g_con_elementsmode) {
CalculateAsset(consensus.pegged_asset, entropy);
} else {
assert(consensus.pegged_asset == CAsset());
}
consensus.parent_pegged_asset.SetHex(args.GetArg("-con_parent_pegged_asset", "0x00"));
initial_reissuance_tokens = args.GetIntArg("-initialreissuancetokens", 0);
// Subsidy asset, like policyAsset, defaults to the pegged_asset
consensus.subsidy_asset = consensus.pegged_asset;
if (args.IsArgSet("-subsidyasset")) {
consensus.subsidy_asset = CAsset(uint256S(args.GetArg("-subsidyasset", "0x00")));
}
UpdateElementsActivationParametersFromArgs(consensus, args);
// END ELEMENTS fields
}
void SetGenesisBlock() {
if (consensus.genesis_style == "bitcoin") {
// For compatibility with bitcoin (regtest)
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN, consensus);
} else if (consensus.genesis_style == "elements") {
// Intended compatibility with Liquid v1 and elements-0.14.1
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::vector<unsigned char> commit = CommitToArguments(consensus, m_chain_type.chain_name);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
if (initialFreeCoins != 0 || initial_reissuance_tokens != 0) {
Merge b5a271334c into merged_master (Bitcoin PR bitcoin/bitcoin#28922)
2025-11-10 15:40:17 +02:00
AppendInitialIssuance(genesis, COutPoint(Txid::FromUint256(uint256(commit)), 0), parentGenesisBlockHash, (initialFreeCoins > 0) ? 1 : 0, initialFreeCoins, (initial_reissuance_tokens > 0) ? 1 : 0, initial_reissuance_tokens, CScript() << OP_TRUE);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
}
} else if (consensus.genesis_style == "dynamic") {
// Liquid v2 HF, from genesis. Upgrading networks still use "elements".
// TODO fill out genesis block with special commitments including epoch
// length in nTime
throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
} else {
throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
}
}
public:
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
CCustomParams(const ChainTypeMeta chain, const ArgsManager& args, const RegTestOptions& opts) : CRegTestParams(opts)
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
{
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = chain;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
//default settings
initialFreeCoins = 0;
anyonecanspend_aremine = true;
// Default signature size is the size of dummy push, and single 72 byte DER signature
consensus.max_block_signature_size = 74;
consensus.dynamic_epoch_length = 10;
// bitcoin regtest is the parent chain by default
consensus.has_parent_chain = true;
parentGenesisBlockHash = uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206");
bech32_hrp = "ert";
blech32_hrp = "el";
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 235);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 75);
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, 4);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, 239);
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
create_discount_ct = false;
accept_discount_ct = false;
UpdateFromArgs(args);
SetGenesisBlock();
consensus.hashGenesisBlock = genesis.GetHash();
}
};
/**
* Liquid testnet (customparams with a few defaults).
*/
class CLiquidTestNetParams : public CCustomParams {
public:
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
CLiquidTestNetParams(const ChainTypeMeta chain, const ArgsManager& args, const RegTestOptions& opts) : CCustomParams(chain, args, opts)
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
{
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = chain;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// not a debug chain
fDefaultConsistencyChecks = false;
initialFreeCoins = 2100000000000000;
anyonecanspend_aremine = false;
consensus.max_block_signature_size = 150;
consensus.dynamic_epoch_length = 1000;
// no parent chain by default
consensus.has_parent_chain = false;
parentGenesisBlockHash = uint256();
bech32_hrp = "tex";
blech32_hrp = "tlq";
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 36);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 19);
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, 23);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, base58Prefixes[SECRET_KEY][0]);
// turn on Simplicity unconditionally on Liquid Testnet
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
// disable automatic dynafed
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = 0;
nDefaultPort = 18891;
Merge fe48feb32d into merged_master (Elements PR #1447)
2025-04-16 12:25:34 +02:00
use_invalid_seeds = false;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
vSeeds.clear();
vFixedSeeds = std::vector<uint8_t>(std::begin(pnSeed6_liquidtestnet), std::end(pnSeed6_liquidtestnet));
default_magic_str = "410EDD62";
default_signblockscript = "51210217e403ddb181872c32a0cd468c710040b2f53d8cac69f18dad07985ee37e9a7151ae";
create_discount_ct = false;
accept_discount_ct = true;
Merge remote-tracking branch 'origin/master' into HEAD
2026-06-19 13:46:12 +01:00
accept_unlimited_issuances = true;
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
UpdateFromArgs(args);
multi_data_permitted = true;
SetGenesisBlock();
consensus.hashGenesisBlock = genesis.GetHash();
if (!args.IsArgSet("-seednode")) {
vSeeds.emplace_back("seed.liquid-testnet.blockstream.com");
vSeeds.emplace_back("seed.liquidtestnet.com");
Merge 246a764f23 into merged_master (Elements PR #1446)
2025-04-16 12:15:40 +02:00
vSeeds.emplace_back("liquid.network.");
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
}
}
};
/**
* Liquid v1
*/
class CLiquidV1Params : public CChainParams {
public:
explicit CLiquidV1Params(const ArgsManager& args)
{
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::LIQUID1);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.nSubsidyHalvingInterval = 150;
consensus.BIP34Height = 0;
consensus.BIP34Hash = uint256();
consensus.BIP65Height = 0;
consensus.BIP66Height = 0;
consensus.CSVHeight = 0;
consensus.SegwitHeight = 0;
consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks;
consensus.nPowTargetSpacing = 60; // Minute block assumption
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = true;
consensus.nRuleChangeActivationThreshold = 108;
consensus.nMinerConfirmationWindow = 144;
consensus.nMinimumChainWork = uint256();
consensus.defaultAssumeValid = uint256();
nPruneAfterHeight = 1000;
fDefaultConsistencyChecks = false;
m_assumed_blockchain_size = 3;
m_assumed_chain_state_size = 1;
bech32_hrp = "ex"; // ex(plicit)
blech32_hrp = "lq"; // l(i)q(uid)
parent_bech32_hrp = "bc";
parent_blech32_hrp = "bc"; // Doesn't exist but...
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 57);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 39);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, 128);
base58Prefixes[BLINDED_ADDRESS]= std::vector<unsigned char>(1,12);
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
pchMessageStart[0] = 0xfa;
pchMessageStart[1] = 0xbf;
pchMessageStart[2] = 0xb5;
pchMessageStart[3] = 0xda;
nDefaultPort = 7042;
vSeeds.clear();
vSeeds.emplace_back("seed.liquidnetwork.io");
Merge 246a764f23 into merged_master (Elements PR #1446)
2025-04-16 12:15:40 +02:00
vSeeds.emplace_back("liquid.network.");
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
vFixedSeeds = std::vector<uint8_t>(std::begin(pnSeed6_liquidv1), std::end(pnSeed6_liquidv1));
//
// ELEMENTS fields
consensus.genesis_style = "elements"; // unused here but let's set it anyways
// Block signing encumberance script, default of 51 aka OP_TRUE
std::vector<unsigned char> sign_bytes = ParseHex("5b21026a2a106ec32c8a1e8052e5d02a7b0a150423dbd9b116fc48d46630ff6e6a05b92102791646a8b49c2740352b4495c118d876347bf47d0551c01c4332fdc2df526f1a2102888bda53a424466b0451627df22090143bbf7c060e9eacb1e38426f6b07f2ae12102aee8967150dee220f613de3b239320355a498808084a93eaf39a34dcd62024852102d46e9259d0a0bb2bcbc461a3e68f34adca27b8d08fbe985853992b4b104e27412102e9944e35e5750ab621e098145b8e6cf373c273b7c04747d1aa020be0af40ccd62102f9a9d4b10a6d6c56d8c955c547330c589bb45e774551d46d415e51cd9ad5116321033b421566c124dfde4db9defe4084b7aa4e7f36744758d92806b8f72c2e943309210353dcc6b4cf6ad28aceb7f7b2db92a4bf07ac42d357adf756f3eca790664314b621037f55980af0455e4fb55aad9b85a55068bb6dc4740ea87276dc693f4598db45fa210384001daa88dabd23db878dbb1ce5b4c2a5fa72c3113e3514bf602325d0c37b8e21039056d089f2fe72dbc0a14780b4635b0dc8a1b40b7a59106325dd1bc45cc70493210397ab8ea7b0bf85bc7fc56bb27bf85e75502e94e76a6781c409f3f2ec3d1122192103b00e3b5b77884bf3cae204c4b4eac003601da75f96982ffcb3dcb29c5ee419b92103c1f3c0874cfe34b8131af34699589aacec4093399739ae352e8a46f80a6f68375fae");
consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
// 11 signatures, 15 pubkeys, plus wiggle room
consensus.max_block_signature_size = 12*74+16*33;
g_signed_blocks = true;
g_con_blockheightinheader = true;
g_con_elementsmode = true;
consensus.elements_mode = g_con_elementsmode;
consensus.total_valid_epochs = 2;
consensus.dynamic_epoch_length = 20160;
consensus.genesis_subsidy = 0;
// All non-zero coinbase outputs must go to this scriptPubKey
std::vector<unsigned char> man_bytes = ParseHex("76a914fc26751a5025129a2fd006c6fbfa598ddd67f7e188ac");
consensus.mandatory_coinbase_destination = CScript(man_bytes.begin(), man_bytes.end()); // Blank script allows any coinbase destination
// Custom chains connect coinbase outputs to db by default
consensus.connect_genesis_outputs = true;
initialFreeCoins = 0;
anyonecanspend_aremine = false;
consensus.has_parent_chain = true;
enforce_pak = true;
Merge remote-tracking branch 'origin/master' into HEAD
2026-06-19 13:46:12 +01:00
accept_unlimited_issuances = args.GetBoolArg("-acceptunlimitedissuances", true);
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = true;
create_discount_ct = args.GetBoolArg("-creatediscountct", false);
accept_discount_ct = args.GetBoolArg("-acceptdiscountct", true) || create_discount_ct;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = ParsePeginSubsidy(args);
pegin_minimum = ParsePeginMinimum(args);
if (pegin_subsidy.threshold < pegin_minimum.amount) {
throw std::runtime_error(strprintf("Peg-in subsidy threshold (%s) must be greater than or equal to peg-in minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
}
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
parentGenesisBlockHash = uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
assert(consensus.has_parent_chain != parent_genesis_is_null);
consensus.parentChainPowLimit = uint256S("0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.parent_chain_signblockscript = CScript(); // It has PoW
consensus.pegin_min_depth = 100;
const CScript default_script(CScript() << OP_TRUE);
consensus.fedpegScript = StrHexToScriptWithDefault("745c87635b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc40102102f8a00b269f8c5e59c67d36db3cdc11b11b21f64b4bffb2815e9100d9aa8daf072103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5f6702c00fb275522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb5368ae", default_script);
// Calculate pegged Bitcoin asset
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::vector<unsigned char> commit = CommitToArguments(consensus, m_chain_type.chain_name);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
uint256 entropy;
Merge b5a271334c into merged_master (Bitcoin PR bitcoin/bitcoin#28922)
2025-11-10 15:40:17 +02:00
GenerateAssetEntropy(entropy, COutPoint(Txid::FromUint256(uint256(commit)), 0), parentGenesisBlockHash);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// Elements serialization uses derivation, bitcoin serialization uses 0x00
if (g_con_elementsmode) {
CalculateAsset(consensus.pegged_asset, entropy);
} else {
assert(consensus.pegged_asset == CAsset());
}
consensus.parent_pegged_asset.SetHex("0x00"); // No parent pegged asset
initial_reissuance_tokens = 0;
consensus.subsidy_asset = consensus.pegged_asset;
// Legacy PAK list
consensus.first_extension_space = {
ParseHex("02555f97c44ad9286ef060a02b00e8e6be2626ed3eb9230705d3ca2f977daae61e"
"03cddbc847f64f898b883d717a7f637bedf9ac2ecd243721eada223f1b1790f75b"),
ParseHex("033fad80bd2b818d1ca8a8d4a25dafcf5e740be07db6788be1f2f15266e3c6805d"
"0253ff3f140ef8f594d54996eab810a82550c79204279920d95681afe699d00da5"),
ParseHex("03f2d35e88741f930a3938bfa7075377ec2da4f1d7699a779e2cbf7a389195dc67"
"026132199a025299b5e0f4ab3f44294c81c5302f6d45ddda6316c18ae515793cf6"),
ParseHex("036286d30d20ddcd3e867851936802dd8a2d84846c7e52aece0fc303c6deec9e04"
"02c7581da9d9ac0001e1c560c348b5df07d42de166d74eccd4c3bda467fe84f898"),
ParseHex("0327b1884b3d743f4859db7c2df07e6e346d61d77fbc46c1da6db113fbbd43d7c5"
"0383c832ec502cf0990b199a4e46a45a63bfa6c6eb3f4b231472f144e684d6e9f8"),
ParseHex("03075f118532928c7ef27a77644a12a87fbada3cd94cf67b2d2ae5cb169ddaefa4"
"02882c4fed938b20f3472af337cd7674a99f0aab0ae1803e27e978c52c417ce5e1"),
ParseHex("02b988448e337c15cd6ac82b4737e3e2b5e92947da2f7fa96a81db7f9be3fabeb2"
"02f660c7675a1ed4893df838a5c4c07a287997cbd7dc5d884044b338ed606231bc"),
ParseHex("0245b763999e3152418b9cd08b5f54c410a072d5e486826823791848e1bb879061"
"0259740ea12e953db0c5fd135c1a9564ce81a318729668811cf54f884c2f980eb8"),
ParseHex("032f8814144351d5d05ca40c87cbbda67bb5f8b1920a38cf3bd008c1d266bb4682"
"039eb3a0b89656b338c3f4a9fc7bba582dd21935f59471c18e6b43c57e063053d9"),
ParseHex("03d8b2ed1813370955cfb8dec24b7c5cb34b13fa4545d9e6d47d8c05af56a2c7d2"
"026392f13fefce606c60adadfe9e729e0af84f5f8cb6a35b76be244351635b38f7"),
ParseHex("03e2a56e47f41eb83af34fb65c4dfb77ac442b01b5134fd92219bd3f4a999c7de5"
"034e93391cea816e5141dace7e5477bbed90c9daa0670b68b7acc8a44af556bbc1"),
ParseHex("03156b39a4bce80e68c1582aa78f81f0252ccbb039766b5395ee9a0224f41c236d"
"0399a5d1d42f5b6cb587560394e1581eb0c76916db317c0d644a1b9f509a06c4e6"),
ParseHex("029797b15de24dc43a6556e58159c5aa0b69ea390ccdebcd7be10751d8085da08f"
"03248e52371b2c3bce2478a3c3aaf37e4f0d6ba711e058ba407f44fdaaf280ac95"),
ParseHex("03d6a14ab496777401e2eae7992404011537860af7b46c3a8fdea65d29fe4bf26c"
"02dca82e552228f3808b1ea9b38b3342b51e9453dcb1414c551ce08bd726311e30"),
ParseHex("035c9c770ed88e29b364038d68b1c623fbf71e93e6d5357e278e9b64160984ed3c"
"02659aabb69b8413bc46026830ad1e2284901350a75c2bc97906f49cff01503f0f"),
ParseHex("02a8300f0cff92b23e402459e83c52ec5824de82ee4004cf9d254e788304027ef6"
"0389cbda672fa9efea51706863f1d7ae5e5015b2e519003ef0178c99f71be6e8be"),
ParseHex("03fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f"
"02b0fb4fe4670c68329441e47acaaa954ff00e3fd547b9ff4e0fe547df2e775ec5"),
ParseHex("0335f807a1bdc0906adda1a4166f9cdc2aa974a78b15fc29d79a8d7ca529a96008"
"02228dfd7ff95506dd67b1118803eb8ab49352b2e24cd5f38da043847e722009ba"),
ParseHex("03fcc2963daaf8249bfd220e52c693626254b9295ac4f947ae2e0cddb3046724c1"
"02dac03530ac9712a71eafb87766644b61cf4be85d0fdc6a859875b41e7a1dc8e6"),
ParseHex("02d67fcb027c5d8fe354fb36235192cb4fffabffdcc6ce74be255fe869f62d8675"
"03d61d857b2a8cb060fd4b9a98a862f250df5825068665a3c8d93f2ac8a7085888"),
ParseHex("02cddb51ea42acf38762418939be0a9227f0212ff96a870a2c1d85ec65905a7629"
"03d986a2181a38cfef5b5e2a1915aa2d37f193fcbafab9bf311d6138209f316f5b"),
ParseHex("029ec6dd0c310513b3720800025a7ad9013d60a7fb041f6e9b9d3963485ba28657"
"0277247f28eb9481dd21d664093a2bc19a496c7ffebeca0026a1726a5041e671ba"),
ParseHex("03f9dea372c4a667dcfe234ff8e0410c22341149ff7d8780c46954ff74998fbe44"
"0340c4e534906c06b73874cef00a880ab602641c7883de94296f0f601e6517ae7e"),
ParseHex("027661f1530dfc88b34b0c8f606d215f30fb0edfa116b331ff44b2fbe040893c6f"
"029d3160731eddc316121b2a31c82270baa4bbe7f08549891af3b444eb690b2df1"),
ParseHex("03f79461a5559f360c407069b92a8075958bf1f70918872d9dd702db145bccbd42"
"0395058fc702f126176ae13e0ebed05107288900a5a35b121f62923e58798b7b2f"),
ParseHex("02d7f049d9e87c861fc9decfbe167cb13ccc87cce99113f69e3a5dca8bb71b6aed"
"03e82197b2e9cc0ee11a59808cfdb52e824445f8fa99e44dc9c30d1e49950ff9d6"),
ParseHex("0281bfeffcc6841d1355dce039f5d64f72714a4c3adc4d351eaf3c28acbcee15f0"
"0270a16ee1cdfc78755a783efbdb66fe822605cc5f53af707e5038615e22b288e2"),
ParseHex("022d58f7f198f3fe7e0ae45f93aa28fdb483ac25a258663ac593860e11ac1d1abc"
"035049635f866b921f7cd0481c6165f19e14ba52c67f7c4fade1dcd22f9aacea20"),
ParseHex("02d40ea20996c882a75fd8cd433484bd8af92791752b4c2d2f24660de36a9f3f82"
"02d874a87df633068c2eacceed3345ce5fb2dbc9f94c30b93ef4c844a77f2651c0"),
ParseHex("024158f76e16888a49492d4913e45c1b4cba19d87dd5bd24346ef601d31d062537"
"0366e9ad4ce16b65a95fb63aae98fdff6bcbd31816d6336039e529a40a828e9851"),
ParseHex("02d2283a929584cdf557096a7f473ae25c04fd6f73467657c4bc49dfb3095892bd"
"03599136ea1f66a80a2eb1a144458561f4791d2fc5fcd06e32a88c9cb2976c8aac"),
ParseHex("036f4b5f3ae46163fb53b0d6c19c78ea2fdf49c8b419c354f3c24fa1ce9547e6b8"
"0340a79f2477ff2a077fb0b8ebb96714a9aaf242f4b96253260264ed031f2a7ee4"),
ParseHex("02d6825aaa063083567f6d4f35ea62c2af8d34f67ef4c2afa565791fd7efc5f3a6"
"02b1e0d671f91f756a7613797d84c33daddc1dc1df9badf68d4e2c2216a288c923"),
ParseHex("03effb766a6f3729c220b0ffa156ffa66d656e5ec16f15bc513b8d0b1298c761d2"
"0252831192e573788271e235afca8f72736d97e26b3a1406cac34711b6ab670c26"),
ParseHex("038c245fa632a0b6c2712cbadb6f6e346284ee0fba3202875abd774faee2deca29"
"032ff781357db141528b1c7ea2cfed3ebe6bb9a028954665cfba355bbcf3d14c8e"),
ParseHex("0356c22fab025b3e661331ed4dcf8645a4a4fd4a2cae69680339e05df209ef4556"
"032d60805593864388d073193fb9fcf66c389813778dcd4a2e93c8fd164d387f7f"),
ParseHex("0238de9c098e83c4d244294ac394355c8e80b49af10f7c1e23001e6c88be5d45b8"
"03bc04885be94ceffbac90178ef18d4dd6958d7488f7861f0994c659412d9e9463"),
ParseHex("025651f14b6347a000e15473eaf631fd78c9307e07db85e177e31fcde0b3f2a574"
"03d5303909fe1c6665cbc96a538b17274068c8e79757705f68db3df2b561a4c110"),
ParseHex("03627a4855be1edc657927f30a4a869ad830041c1f0e74ab4670588af9532b8de8"
"03444cb85aef9fbba10b3e2662d533858db771010b57b7aedb1ecaa1c5a34918f1"),
ParseHex("032d9af13c8d5f5316fd27a14bafb8ec55684ef2e3b5c64b2645e088f570e5d2cb"
"0239590f39508465decfd8a1bdc61b42333297e80588ed826ddd43678edfa6caae")
};
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 = 1554500; // November 1, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nPeriod = 10080; // one week...
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nThreshold = 10080; // ...of 100% signalling
// Simplicity
Merge 3c1782e3ce into merged_master (Elements PR #1438)
2025-04-16 11:53:55 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].bit = 21;
Merge ea5d6fdf81 into merged_master (Elements PR #1427)
2025-04-16 12:37:22 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nStartTime = 3333333; // April 14, 2025
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].min_activation_height = 0; // No activation delay
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nPeriod = 10080; // one week...
consensus.vDeployments[Consensus::DEPLOYMENT_SIMPLICITY].nThreshold = 10080; // ...of 100% signalling
// Activated from block 1,000,000.
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
// Allow blocksigners to delay activation.
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = 1000000;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
// Finally, create genesis block
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock.GetHex() == "1466275836220db2944ca059a3a10ef6fd2ea684b0688d2c379296888a206003");
}
};
/**
* New: Liquid v1 testing, as close to prod as possible while still being customizable.
*/
class CLiquidV1TestParams : public CLiquidV1Params {
public:
explicit CLiquidV1TestParams(const ArgsManager& args) : CLiquidV1Params(args)
{
// Our goal here is to override ONLY the things from liquidv1 that make no sense for a test chain / which are pointless and burdensome to require people to override manually.
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
m_chain_type = ChainTypeMetaFrom(ChainType::LIQUID1TEST);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
m_is_mockable_chain = false;
vSeeds.clear(); // No network seeds
vFixedSeeds.clear(); // No network seeds
// 51 means OP_TRUE, this can be overridden on the commandline
std::vector<unsigned char> sign_bytes = ParseHex("51");
consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
// Do not mandate a specific destination for fees in testing
consensus.mandatory_coinbase_destination = CScript(); // Blank script allows any coinbase destination
// The bitcoin regtest genesis blockhash is the default, not the mainchain
parentGenesisBlockHash = uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206");
const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
assert(consensus.has_parent_chain != parent_genesis_is_null);
// This is the regtest limit, not the mainchain limit.
consensus.parentChainPowLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.parent_chain_signblockscript = CScript(); // It has PoW
// Default to 8, not 100, for expedited testing.
consensus.pegin_min_depth = DEFAULT_PEGIN_CONFIRMATION_DEPTH;
// Default fedpegscrit is OP_TRUE (tests should override it)
consensus.fedpegScript = CScript() << OP_TRUE;
// For testing purposes, default to the same junk keys that CustomParams uses (this can be overridden.)
consensus.first_extension_space = {ParseHex("02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f")};
// Don't use liquidv1's height to enable taproot
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 0;
// Use all regtest rather than mainchain magic numbers:
bech32_hrp = args.GetArg("-bech32_hrp", "ert");
blech32_hrp = args.GetArg("-blech32_hrp", "el");
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-pubkeyprefix", 235));
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-scriptprefix", 75));
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-blindedprefix", 4));
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, args.GetIntArg("-secretprefix", 239));
base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentpubkeyprefix", 111));
base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentscriptprefix", 196));
parent_bech32_hrp = args.GetArg("-parent_bech32_hrp", "bcrt");
parent_blech32_hrp = args.GetArg("-parent_blech32_hrp", "bcrt");
std::string extpubprefix = args.GetArg("-extpubkeyprefix", "043587CF");
assert(IsHex(extpubprefix) && extpubprefix.size() == 8 && "-extpubkeyprefix must be hex string of length 8");
base58Prefixes[EXT_PUBLIC_KEY] = ParseHex(extpubprefix);
std::string extprvprefix = args.GetArg("-extprvkeyprefix", "04358394");
assert(IsHex(extprvprefix) && extprvprefix.size() == 8 && "-extprvkeyprefix must be hex string of length 8");
base58Prefixes[EXT_SECRET_KEY] = ParseHex(extprvprefix);
const std::string magic_str = args.GetArg("-pchmessagestart", "FABFB5DA");
assert(IsHex(magic_str) && magic_str.size() == 8 && "-pchmessagestart must be hex string of length 8");
const std::vector<unsigned char> magic_byte = ParseHex(magic_str);
Merge 1e9d367d0d into merged_master (Bitcoin PR bitcoin/bitcoin#28423)
2025-07-21 14:33:58 +02:00
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart.begin());
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
// END magic numbers
UpdateFromArgs(args);
SetGenesisBlock();
consensus.hashGenesisBlock = genesis.GetHash();
}
// As much as possible here, our goal is to:
// - Allow overriding anything that can be overridden in CCustomParams;
// - Leave everything alone unless an argument / config parameter was given.
// This is unlike the CCustomParams UpdateFromArgs method, which has lots of defaults in it.
void UpdateFromArgs(const ArgsManager& args)
{
consensus.nSubsidyHalvingInterval = args.GetIntArg("-con_nsubsidyhalvinginterval", consensus.nSubsidyHalvingInterval);
consensus.BIP34Height = args.GetIntArg("-con_bip34height", consensus.BIP34Height);
if (args.IsArgSet("-con_bip34hash")) {
consensus.BIP34Hash = uint256S(args.GetArg("-con_bip34hash", ""));
}
consensus.BIP65Height = args.GetIntArg("-con_bip65height", consensus.BIP65Height);
consensus.BIP66Height = args.GetIntArg("-con_bip66height", consensus.BIP66Height);
if (args.IsArgSet("-con_powlimit")) {
consensus.powLimit = uint256S(args.GetArg("-con_powlimit", ""));
}
consensus.nPowTargetTimespan = args.GetIntArg("-con_npowtargettimespan", consensus.nPowTargetTimespan);
consensus.nPowTargetSpacing = args.GetIntArg("-con_npowtargetspacing", consensus.nPowTargetSpacing);
consensus.fPowAllowMinDifficultyBlocks = args.GetBoolArg("-con_fpowallowmindifficultyblocks", consensus.fPowAllowMinDifficultyBlocks);
consensus.fPowNoRetargeting = args.GetBoolArg("-con_fpownoretargeting", consensus.fPowNoRetargeting);
consensus.nRuleChangeActivationThreshold = (uint32_t)args.GetIntArg("-con_nrulechangeactivationthreshold", consensus.nRuleChangeActivationThreshold);
consensus.nMinerConfirmationWindow = (uint32_t)args.GetIntArg("-con_nminerconfirmationwindow", consensus.nMinerConfirmationWindow);
if (args.IsArgSet("-con_nminimumchainwork")) {
consensus.nMinimumChainWork = uint256S(args.GetArg("-con_nminimumchainwork", ""));
}
if (args.IsArgSet("-con_defaultassumevalid")) {
consensus.defaultAssumeValid = uint256S(args.GetArg("-con_defaultassumevalid", ""));
}
// TODO: Embed in genesis block in nTime field with new genesis block type
consensus.dynamic_epoch_length = args.GetIntArg("-dynamic_epoch_length", consensus.dynamic_epoch_length);
std::vector<std::string> pak_list_str = args.GetArgs("-pak");
if (!pak_list_str.empty()) {
consensus.first_extension_space.clear();
for (const auto& entry : pak_list_str) {
consensus.first_extension_space.push_back(ParseHex(entry));
}
}
nPruneAfterHeight = (uint64_t)args.GetIntArg("-npruneafterheight", nPruneAfterHeight);
fDefaultConsistencyChecks = args.GetBoolArg("-fdefaultconsistencychecks", fDefaultConsistencyChecks);
bech32_hrp = args.GetArg("-bech32_hrp", bech32_hrp);
blech32_hrp = args.GetArg("-blech32_hrp", blech32_hrp);
if (args.IsArgSet("-pubkeyprefix")) {
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-pubkeyprefix", 0));
}
if (args.IsArgSet("-scriptprefix")) {
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-scriptprefix", 0));
}
if (args.IsArgSet("-blindedprefix")) {
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-blindedprefix", 0));
}
if (args.IsArgSet("-secretprefix")) {
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, args.GetIntArg("-secretprefix", 0));
}
if (args.IsArgSet("-parentpubkeyprefix")) {
base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentpubkeyprefix", 0));
}
if (args.IsArgSet("-parentscriptprefix")) {
base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentscriptprefix", 0));
}
parent_bech32_hrp = args.GetArg("-parent_bech32_hrp", parent_bech32_hrp);
parent_blech32_hrp = args.GetArg("-parent_blech32_hrp", parent_blech32_hrp);
std::string extpubprefix = args.GetArg("-extpubkeyprefix", "043587CF");
assert(IsHex(extpubprefix) && extpubprefix.size() == 8 && "-extpubkeyprefix must be hex string of length 8");
base58Prefixes[EXT_PUBLIC_KEY] = ParseHex(extpubprefix);
std::string extprvprefix = args.GetArg("-extprvkeyprefix", "04358394");
assert(IsHex(extprvprefix) && extprvprefix.size() == 8 && "-extprvkeyprefix must be hex string of length 8");
base58Prefixes[EXT_SECRET_KEY] = ParseHex(extprvprefix);
const std::string magic_str = args.GetArg("-pchmessagestart", "143EFCB1");
assert(IsHex(magic_str) && magic_str.size() == 8 && "-pchmessagestart must be hex string of length 8");
const std::vector<unsigned char> magic_byte = ParseHex(magic_str);
Merge 1e9d367d0d into merged_master (Bitcoin PR bitcoin/bitcoin#28423)
2025-07-21 14:33:58 +02:00
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart.begin());
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
vSeeds.clear();
if (args.IsArgSet("-seednode")) {
const auto seednodes = args.GetArgs("-seednode");
if (seednodes.size() != 1 || seednodes[0] != "0") {
vSeeds = seednodes;
}
}
//
// ELEMENTS fields
// Determines type of genesis block
consensus.genesis_style = args.GetArg("-con_genesis_style", consensus.genesis_style);
// Block signing encumberance script
if (args.IsArgSet("-signblockscript")) {
std::vector<unsigned char> sign_bytes = ParseHex(args.GetArg("-signblockscript", ""));
consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
}
consensus.max_block_signature_size = args.GetIntArg("-con_max_block_sig_size", consensus.max_block_signature_size);
g_signed_blocks = args.GetBoolArg("-con_signed_blocks", g_signed_blocks);
// Note: These globals are needed to avoid circular dependencies.
g_con_blockheightinheader = args.GetBoolArg("-con_blockheightinheader", g_con_blockheightinheader);
// Doesn't make any sense to use this chain in !elementsmode. Don't do it.
assert(args.GetBoolArg("-con_elementsmode", true));
g_con_elementsmode = true;
consensus.elements_mode = true;
consensus.genesis_subsidy = args.GetIntArg("-con_blocksubsidy", consensus.genesis_subsidy);
// All non-zero coinbase outputs must go to this scriptPubKey
if (args.IsArgSet("-con_mandatorycoinbase")) {
std::vector<unsigned char> man_bytes = ParseHex(args.GetArg("-con_mandatorycoinbase", ""));
consensus.mandatory_coinbase_destination = CScript(man_bytes.begin(), man_bytes.end()); // Blank script allows any coinbase destination
}
consensus.connect_genesis_outputs = args.GetIntArg("-con_connect_genesis_outputs", consensus.connect_genesis_outputs);
initialFreeCoins = args.GetIntArg("-initialfreecoins", initialFreeCoins);
anyonecanspend_aremine = args.GetBoolArg("-anyonecanspendaremine", anyonecanspend_aremine);
consensus.has_parent_chain = args.GetBoolArg("-con_has_parent_chain", consensus.has_parent_chain);
enforce_pak = args.GetBoolArg("-enforce_pak", enforce_pak);
Merge cc7aee39b9 into merged_master (Elements PR #1492)
2025-11-05 09:50:02 +02:00
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
multi_data_permitted = args.GetBoolArg("-multi_data_permitted", multi_data_permitted);
create_discount_ct = args.GetBoolArg("-creatediscountct", create_discount_ct);
accept_discount_ct = args.GetBoolArg("-acceptdiscountct", accept_discount_ct) || create_discount_ct;
Merge 7791d31bcf into merged_master (Elements PR #1499)
2026-02-11 15:45:21 +02:00
pegin_subsidy = ParsePeginSubsidy(args);
pegin_minimum = ParsePeginMinimum(args);
if (pegin_subsidy.threshold < pegin_minimum.amount) {
throw std::runtime_error(strprintf("Peg-in subsidy threshold (%s) must be greater than or equal to peg-in minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
}
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
if (args.IsArgSet("-parentgenesisblockhash")) {
parentGenesisBlockHash = uint256S(args.GetArg("-parentgenesisblockhash", ""));
}
// Either it has a parent chain or not
const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
assert(consensus.has_parent_chain != parent_genesis_is_null);
if (args.IsArgSet("-con_parentpowlimit")) {
consensus.parentChainPowLimit = uint256S(args.GetArg("-con_parentpowlimit", ""));
}
if (args.IsArgSet("-con_parent_chain_signblockscript")) {
consensus.parent_chain_signblockscript = StrHexToScriptWithDefault(args.GetArg("-con_parent_chain_signblockscript", ""), CScript());
}
consensus.pegin_min_depth = args.GetIntArg("-peginconfirmationdepth", consensus.pegin_min_depth);
if (args.IsArgSet("-fedpegscript")) {
consensus.fedpegScript = StrHexToScriptWithDefault(args.GetArg("-fedpegscript", ""), CScript());
}
consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
consensus.total_valid_epochs = args.GetIntArg("-total_valid_epochs", consensus.total_valid_epochs);
// Calculate pegged Bitcoin asset
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::vector<unsigned char> commit = CommitToArguments(consensus, m_chain_type.chain_name);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
uint256 entropy;
Merge b5a271334c into merged_master (Bitcoin PR bitcoin/bitcoin#28922)
2025-11-10 15:40:17 +02:00
GenerateAssetEntropy(entropy, COutPoint(Txid::FromUint256(uint256(commit)), 0), parentGenesisBlockHash);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
CalculateAsset(consensus.pegged_asset, entropy);
if (args.IsArgSet("-con_parent_pegged_asset")) {
consensus.parent_pegged_asset.SetHex(args.GetArg("-con_parent_pegged_asset", ""));
}
initial_reissuance_tokens = args.GetIntArg("-initialreissuancetokens", initial_reissuance_tokens);
if (args.IsArgSet("-subsidyasset")) {
consensus.subsidy_asset = CAsset(uint256S(args.GetArg("-subsidyasset", "")));
}
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
UpdateElementsActivationParametersFromArgs(consensus, args);
// END ELEMENTS fields
}
// XXX: This is copy-and-pasted from CCustomParams; sharing it would be better, but is annoying.
void SetGenesisBlock() {
if (consensus.genesis_style == "bitcoin") {
// For compatibility with bitcoin (regtest)
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN, consensus);
} else if (consensus.genesis_style == "elements") {
// Intended compatibility with Liquid v1 and elements-0.14.1
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::vector<unsigned char> commit = CommitToArguments(consensus, m_chain_type.chain_name);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
if (initialFreeCoins != 0 || initial_reissuance_tokens != 0) {
Merge b5a271334c into merged_master (Bitcoin PR bitcoin/bitcoin#28922)
2025-11-10 15:40:17 +02:00
AppendInitialIssuance(genesis, COutPoint(Txid::FromUint256(uint256(commit)), 0), parentGenesisBlockHash, (initialFreeCoins > 0) ? 1 : 0, initialFreeCoins, (initial_reissuance_tokens > 0) ? 1 : 0, initial_reissuance_tokens, CScript() << OP_TRUE);
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
}
} else if (consensus.genesis_style == "dynamic") {
// Liquid v2 HF, from genesis. Upgrading networks still use "elements".
// TODO fill out genesis block with special commitments including epoch
// length in nTime
throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
} else {
throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
}
};
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::unique_ptr<const CChainParams> CChainParams::Custom(const ChainTypeMeta chain, const ArgsManager& args, const RegTestOptions& options)
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
{
return std::make_unique<const CCustomParams>(chain, args, options);
}
Merge fc06881f13 into merged_master (Bitcoin PR bitcoin/bitcoin#27491)
2025-05-23 13:02:22 +02:00
std::unique_ptr<const CChainParams> CChainParams::LiquidTestNet(const ChainTypeMeta chain, const ArgsManager& args, const RegTestOptions& options)
Merge e695d8536e into merged_master (Bitcoin PR bitcoin/bitcoin#26177)
2025-04-11 12:02:49 +01:00
{
return std::make_unique<const CLiquidTestNetParams>(chain, args, options);
}
std::unique_ptr<const CChainParams> CChainParams::LiquidV1Test(const ArgsManager& args)
{
return std::make_unique<const CLiquidV1TestParams>(args);
}
std::unique_ptr<const CChainParams> CChainParams::LiquidV1(const ArgsManager& args)
{
return std::make_unique<const CLiquidV1Params>(args);
}
Split non/kernel chainparams Moves chainparams code not using the ArgsManager to the kernel. Subsequently use the kernel chainparams header now where possible in order to further decouple chainparams call sites from gArgs.
2022-03-10 22:13:58 -05:00
std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
{
return std::make_unique<const SigNetParams>(options);
}
std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
{
return std::make_unique<const CRegTestParams>(options);
}
std::unique_ptr<const CChainParams> CChainParams::Main()
{
return std::make_unique<const CMainParams>();
}
std::unique_ptr<const CChainParams> CChainParams::TestNet()
{
return std::make_unique<const CTestNetParams>();
}
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
testnet: Introduce Testnet4
2024-03-31 23:50:42 +02:00
std::unique_ptr<const CChainParams> CChainParams::TestNet4()
{
return std::make_unique<const CTestNet4Params>();
}
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
std::vector<int> CChainParams::GetAvailableSnapshotHeights() const
{
std::vector<int> heights;
heights.reserve(m_assumeutxo_data.size());
for (const auto& data : m_assumeutxo_data) {
heights.emplace_back(data.height);
}
return heights;
}
assumeutxo: Add network magic ctor param to SnapshotMetadata This prevents SnapshotMetadata from using any globals implicitly.
2024-05-24 11:41:42 +02:00
std::optional<ChainType> GetNetworkForMagic(const MessageStartChars& message)
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
{
const auto mainnet_msg = CChainParams::Main()->MessageStart();
const auto testnet_msg = CChainParams::TestNet()->MessageStart();
chainparams: Handle Testnet4 in GetNetworkForMagic
2024-08-10 22:19:42 +02:00
const auto testnet4_msg = CChainParams::TestNet4()->MessageStart();
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
const auto regtest_msg = CChainParams::RegTest({})->MessageStart();
const auto signet_msg = CChainParams::SigNet({})->MessageStart();
Merge 413844f1c2 into merged_master (Bitcoin PR bitcoin/bitcoin#29612)
2026-02-24 11:44:45 +00:00
// Elements
const auto liquid1_msg = CChainParams::LiquidV1({})->MessageStart();
const auto liquid1test_msg = CChainParams::LiquidV1Test({})->MessageStart();
const auto liquidtestnet_msg = CChainParams::LiquidTestNet({}, {}, {})->MessageStart();
const auto custom_msg = CChainParams::Custom(ChainTypeMetaFrom(ChainType::CUSTOM), {}, {})->MessageStart();
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
refactor: Use std::ranges::equal in GetNetworkForMagic Replace std::equal with std::ranges::equal, because it allows for shorter code, because no pointers or iterators have to be passed explicitly.
2024-08-13 08:01:04 +02:00
if (std::ranges::equal(message, mainnet_msg)) {
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
return ChainType::MAIN;
refactor: Use std::ranges::equal in GetNetworkForMagic Replace std::equal with std::ranges::equal, because it allows for shorter code, because no pointers or iterators have to be passed explicitly.
2024-08-13 08:01:04 +02:00
} else if (std::ranges::equal(message, testnet_msg)) {
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
return ChainType::TESTNET;
refactor: Use std::ranges::equal in GetNetworkForMagic Replace std::equal with std::ranges::equal, because it allows for shorter code, because no pointers or iterators have to be passed explicitly.
2024-08-13 08:01:04 +02:00
} else if (std::ranges::equal(message, testnet4_msg)) {
chainparams: Handle Testnet4 in GetNetworkForMagic
2024-08-10 22:19:42 +02:00
return ChainType::TESTNET4;
refactor: Use std::ranges::equal in GetNetworkForMagic Replace std::equal with std::ranges::equal, because it allows for shorter code, because no pointers or iterators have to be passed explicitly.
2024-08-13 08:01:04 +02:00
} else if (std::ranges::equal(message, regtest_msg)) {
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
return ChainType::REGTEST;
refactor: Use std::ranges::equal in GetNetworkForMagic Replace std::equal with std::ranges::equal, because it allows for shorter code, because no pointers or iterators have to be passed explicitly.
2024-08-13 08:01:04 +02:00
} else if (std::ranges::equal(message, signet_msg)) {
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
return ChainType::SIGNET;
Merge 413844f1c2 into merged_master (Bitcoin PR bitcoin/bitcoin#29612)
2026-02-24 11:44:45 +00:00
} else if (std::equal(message.begin(), message.end(), liquid1_msg.data())) {
return ChainType::LIQUID1;
} else if (std::equal(message.begin(), message.end(), liquid1test_msg.data())) {
return ChainType::LIQUID1TEST;
} else if (std::equal(message.begin(), message.end(), liquidtestnet_msg.data())) {
return ChainType::LIQUIDTESTNET;
} else if (std::equal(message.begin(), message.end(), custom_msg.data())) {
return ChainType::CUSTOM;
rpc: Enhance metadata of the dumptxoutset output The following data is added: - A newly introduced utxo set magic - A version number - The network magic - The block height
2024-04-22 14:52:40 +02:00
}
return std::nullopt;
}
Reference in a new issue Copy permalink