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

1573 lines
85 KiB
C++
Raw Normal View History

Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
// Copyright (c) 2010 Satoshi Nakamoto
scripted-diff: Bump copyright headers -BEGIN VERIFY SCRIPT- ./contrib/devtools/copyright_header.py update ./ -END VERIFY SCRIPT- Commits of previous years: * 2020: fa0074e2d82928016a43ca408717154a1c70a4db * 2019: aaaaad6ac95b402fe18d019d67897ced6b316ee0
2021-12-30 19:36:57 +02:00
// Copyright (c) 2009-2021 The Bitcoin Core developers
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
// Distributed under the MIT software license, see the accompanying
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
scripted-diff: Replace #include "" with #include <> (ryanofsky) -BEGIN VERIFY SCRIPT- for f in \ src/*.cpp \ src/*.h \ src/bench/*.cpp \ src/bench/*.h \ src/compat/*.cpp \ src/compat/*.h \ src/consensus/*.cpp \ src/consensus/*.h \ src/crypto/*.cpp \ src/crypto/*.h \ src/crypto/ctaes/*.h \ src/policy/*.cpp \ src/policy/*.h \ src/primitives/*.cpp \ src/primitives/*.h \ src/qt/*.cpp \ src/qt/*.h \ src/qt/test/*.cpp \ src/qt/test/*.h \ src/rpc/*.cpp \ src/rpc/*.h \ src/script/*.cpp \ src/script/*.h \ src/support/*.cpp \ src/support/*.h \ src/support/allocators/*.h \ src/test/*.cpp \ src/test/*.h \ src/wallet/*.cpp \ src/wallet/*.h \ src/wallet/test/*.cpp \ src/wallet/test/*.h \ src/zmq/*.cpp \ src/zmq/*.h do base=${f%/*}/ relbase=${base#src/} sed -i "s:#include \"\(.*\)\"\(.*\):if test -e \$base'\\1'; then echo \"#include <\"\$relbase\"\\1>\\2\"; else echo \"#include <\\1>\\2\"; fi:e" $f done -END VERIFY SCRIPT-
2017-11-10 13:57:53 +13:00
#include <chainparams.h>
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 00:13:08 -05:00
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
#include <chainparamsseeds.h>
doxygen: Remove misleading checkpoints comment in CMainParams
2018-09-04 13:43:19 -04:00
#include <consensus/merkle.h>
[move-only] Rename versionbitsinfo to deploymentinfo
2021-03-11 12:17:22 +10:00
#include <deploymentinfo.h>
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
#include <hash.h> // for signet block challenge hash
Add new arguments
2019-03-19 20:02:02 +00:00
#include <issuance.h>
Add -con_elementswitness flag and global variable
2019-01-29 12:24:13 +00:00
#include <primitives/transaction.h>
Enforce Taproot script flags whenever WITNESS is set
2021-11-16 14:40:19 +01:00
#include <script/interpreter.h>
scripted-diff: Move util files to separate directory. -BEGIN VERIFY SCRIPT- mkdir -p src/util git mv src/util.h src/util/system.h git mv src/util.cpp src/util/system.cpp git mv src/utilmemory.h src/util/memory.h git mv src/utilmoneystr.h src/util/moneystr.h git mv src/utilmoneystr.cpp src/util/moneystr.cpp git mv src/utilstrencodings.h src/util/strencodings.h git mv src/utilstrencodings.cpp src/util/strencodings.cpp git mv src/utiltime.h src/util/time.h git mv src/utiltime.cpp src/util/time.cpp sed -i 's/<util\.h>/<util\/system\.h>/g' $(git ls-files 'src/*.h' 'src/*.cpp') sed -i 's/<utilmemory\.h>/<util\/memory\.h>/g' $(git ls-files 'src/*.h' 'src/*.cpp') sed -i 's/<utilmoneystr\.h>/<util\/moneystr\.h>/g' $(git ls-files 'src/*.h' 'src/*.cpp') sed -i 's/<utilstrencodings\.h>/<util\/strencodings\.h>/g' $(git ls-files 'src/*.h' 'src/*.cpp') sed -i 's/<utiltime\.h>/<util\/time\.h>/g' $(git ls-files 'src/*.h' 'src/*.cpp') sed -i 's/BITCOIN_UTIL_H/BITCOIN_UTIL_SYSTEM_H/g' src/util/system.h sed -i 's/BITCOIN_UTILMEMORY_H/BITCOIN_UTIL_MEMORY_H/g' src/util/memory.h sed -i 's/BITCOIN_UTILMONEYSTR_H/BITCOIN_UTIL_MONEYSTR_H/g' src/util/moneystr.h sed -i 's/BITCOIN_UTILSTRENCODINGS_H/BITCOIN_UTIL_STRENCODINGS_H/g' src/util/strencodings.h sed -i 's/BITCOIN_UTILTIME_H/BITCOIN_UTIL_TIME_H/g' src/util/time.h sed -i 's/ util\.\(h\|cpp\)/ util\/system\.\1/g' src/Makefile.am sed -i 's/utilmemory\.\(h\|cpp\)/util\/memory\.\1/g' src/Makefile.am sed -i 's/utilmoneystr\.\(h\|cpp\)/util\/moneystr\.\1/g' src/Makefile.am sed -i 's/utilstrencodings\.\(h\|cpp\)/util\/strencodings\.\1/g' src/Makefile.am sed -i 's/utiltime\.\(h\|cpp\)/util\/time\.\1/g' src/Makefile.am sed -i 's/-> util ->/-> util\/system ->/' test/lint/lint-circular-dependencies.sh sed -i 's/src\/util\.cpp/src\/util\/system\.cpp/g' test/lint/lint-format-strings.py test/lint/lint-locale-dependence.sh sed -i 's/src\/utilmoneystr\.cpp/src\/util\/moneystr\.cpp/g' test/lint/lint-locale-dependence.sh sed -i 's/src\/utilstrencodings\.\(h\|cpp\)/src\/util\/strencodings\.\1/g' test/lint/lint-locale-dependence.sh sed -i 's/src\\utilstrencodings\.cpp/src\\util\\strencodings\.cpp/' build_msvc/libbitcoinconsensus/libbitcoinconsensus.vcxproj -END VERIFY SCRIPT-
2018-10-22 15:51:11 -07:00
#include <util/system.h>
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
#include <crypto/sha256.h>
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
cleanup include of assert.h
2014-08-28 22:56:53 +02:00
#include <assert.h>
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +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;
}
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
// 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());
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
sha2.Write((const unsigned char*)HexStr(params.fedpegScript).c_str(), HexStr(params.fedpegScript).length());
elements style genesis block commits to signblockscript in CommitToArguments
2018-12-18 17:25:50 -05:00
sha2.Write((const unsigned char*)HexStr(params.signblockscript).c_str(), HexStr(params.signblockscript).length());
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
sha2.Finalize(commitment);
return std::vector<unsigned char>(commitment, commitment + 32);
}
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
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)
Chainparams: Introduce CreateGenesisBlock() static function
2015-07-03 14:29:57 +02:00
{
CMutableTransaction txNew;
txNew.nVersion = 1;
txNew.vin.resize(1);
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
txNew.vin[0].scriptSig = genesisScriptSig;
[BROKEN] Introduce CA in data structures
2019-03-19 20:26:39 +00:00
txNew.vout.push_back(CTxOut(CAsset(), genesisReward, genesisOutputScript));
Chainparams: Introduce CreateGenesisBlock() static function
2015-07-03 14:29:57 +02:00
CBlock genesis;
genesis.nTime = nTime;
genesis.nBits = nBits;
genesis.nNonce = nNonce;
genesis.nVersion = nVersion;
Introduce convenience type CTransactionRef
2016-11-10 17:34:17 -08:00
genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
Chainparams: Introduce CreateGenesisBlock() static function
2015-07-03 14:29:57 +02:00
genesis.hashPrevBlock.SetNull();
Switch blocks to a constant-space Merkle root/branch algorithm. This switches the Merkle tree logic for blocks to one that runs in constant (small) space. The old code is moved to tests, and a new test is added that for various combinations of block sizes, transaction positions to compute a branch for, and mutations: * Verifies that the old code and new code agree for the Merkle root. * Verifies that the old code and new code agree for the Merkle branch. * Verifies that the computed Merkle branch is valid. * Verifies that mutations don't change the Merkle root. * Verifies that mutations are correctly detected.
2015-11-17 17:35:44 +01:00
genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
if (g_signed_blocks) {
genesis.proof = CProof(params.signblockscript, CScript());
}
Chainparams: Introduce CreateGenesisBlock() static function
2015-07-03 14:29:57 +02: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
*/
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward, const Consensus::Params& params)
Chainparams: Introduce CreateGenesisBlock() static function
2015-07-03 14:29:57 +02:00
{
const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
const CScript genesisScriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
Clean up chainparams some more. Clean up the code in chainparams a bit more after the recent refactorings. In particular, make sure the structure of the "RegTest" params matches the structure of the other classes. This makes the code clearer to read. Also remove redundant values of the genesis block in always-specified optional arguments and mark variable/argument as "const".
2015-07-29 21:13:36 +02:00
const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
return CreateGenesisBlock(params, genesisScriptSig, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
Add initialfreecoins option, default of 0 - Add CommitToArgument without fedpegScript or signblockscript - Modify CreateGenesisBlock to take in the genesis scriptSig - Add AppendInitialIssuace without assets support - AppendInitialIssuance to genesis block for Custom chain only - Add -initialfreecoins option - Modify tests to work with initialfreecoins
2018-12-07 10:40:51 -08:00
}
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
/**
* 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;
Make sure command line takes precedence when processing evbparams
2021-10-30 09:35:07 +00:00
std::map<std::string,int> map_deployments;
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
for (const std::string& strDeployment : args.GetArgs("-evbparams")) {
std::vector<std::string> vDeploymentParams;
boost::split(vDeploymentParams, strDeployment, boost::is_any_of(":"));
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) {
Make sure command line takes precedence when processing evbparams
2021-10-30 09:35:07 +00:00
if(map_deployments[vDeploymentParams[0]]) {
found = true;
LogPrintf("Ignoring duplicated version bits activation parameters for \"%s\"\n", strDeployment.c_str());
break;
}
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
std::string extra_logging;
Make sure command line takes precedence when processing evbparams
2021-10-30 09:35:07 +00:00
map_deployments[vDeploymentParams[0]]=1;
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
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]));
}
}
}
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
/**
[doc] correct comment in chainparams There are more than 3 networks.
2021-03-23 13:29:17 -07:00
* Main network on which people trade goods and services.
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
*/
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
class CMainParams : public CChainParams {
public:
CMainParams() {
Chainparams: Use name constants in chainparams initialization
2019-10-29 20:27:30 +01:00
strNetworkID = CBaseChainParams::MAIN;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.nSubsidyHalvingInterval = 210000;
Enforce Taproot script flags whenever WITNESS is set
2021-11-16 14:40:19 +01:00
consensus.script_flag_exceptions.emplace( // BIP16 exception
uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"), SCRIPT_VERIFY_NONE);
consensus.script_flag_exceptions.emplace( // Taproot exception
uint256S("0x0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS);
Make skipping BIP30 check chain agnostic
2015-11-02 16:41:55 -05:00
consensus.BIP34Height = 227931;
consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
Consensus: Remove ISM
2016-07-22 08:27:55 +09:00
consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
[Consensus] Bury CSV deployment height Hard code CSV deployment height to 419328 for mainnet.
2019-05-20 14:58:44 -04:00
consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
fix uninitialized variable nMinerConfirmationWindow fix uninitialized variable hard code the MinBIP9WarningHeight fix uninitialized var hard code the MinBIP9WarningHeight instead
2019-11-11 21:48:51 -06:00
consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
consensus: don't use arith_uint256 in consensus.h Requiring arith_uint256 at such a base level is not good for modularity.
2015-03-25 15:00:32 -04:00
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = false;
Added fPowNoRetargeting field to Consensus::Params that disables nBits recalculation.
2015-10-19 08:25:29 -04:00
consensus.fPowNoRetargeting = false;
chainparams: drop versionbits threshold to 90% for mainnnet and signet
2021-03-06 18:42:58 +10:00
consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
BIP9 Implementation Inspired by former implementations by Eric Lombrozo and Rusty Russell, and based on code by Jorge Timon.
2016-02-15 05:13:27 +01:00
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
Add testing of ComputeBlockVersion
2016-03-09 16:00:53 -05:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
versionbits: Add explicit NEVER_ACTIVE deployments Previously we used deployments that would timeout prior to Bitcoin's invention, which allowed the deployment to still be activated in unit tests. This switches those deployments to be truly never active.
2021-03-27 23:00:14 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
lint: fix non-pylint linter errors Includes fixing all the spelling mistakes that are our fault, but not those present upstream in Core.
2021-10-14 21:48:49 +00:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
ci: fix benchmarks, fuzztests and unit tests Includes a memory leak in the checkqueue unit test (but not in the actual code). WE really need to switch our checkqueue to use std::unique_pointer rather than bare pointers. But this would be invasive enough that I want to do it in a followup PR. Also pretty-much disable the validation_flush_cache unit test. This is a stupid and irritating test which tries to unit-test exact memory usage of std containers. It already has at least one "remove wrong assumptions" update upstream and after many tries I was unable to change all the magic numbers in a way that'd consistently pass CI for Elements. Also adds a couple ubsan suppressions about perfectly-legitimate conversions of integer types.
2020-12-08 03:37:52 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
Merge 2cd834e6c09 into merged_master (Bitcoin PR #21377)
2021-06-30 16:24:18 +00:00
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
Add CHECKSEQUENCEVERIFY softfork through BIP9
2016-02-20 23:37:13 +01:00
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
// Deployment of Taproot (BIPs 340-342)
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
Add mainnet and testnet taproot activation params
2021-04-14 22:36:19 -04:00
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
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
Update nMinimumChainWork, defaultAssumeValid for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:36:50 +01:00
consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000002927cdceccbd5209e81e80db");
consensus.defaultAssumeValid = uint256S("0x000000000000000000052d314a259755ca65944e68df6b12a067ea8f1f5a7091"); // 724466
Introduce assumevalid setting to skip presumed valid scripts. This disentangles the script validation skipping from checkpoints. A new option is introduced "assumevalid" which specifies a block whos ancestors we assume all have valid scriptsigs and so we do not check them when they are also burried under the best header by two weeks worth of work. Unlike checkpoints this has no influence on consensus unless you set it to a block with an invalid history. Because of this it can be easily be updated without risk of influencing the network consensus. This results in a massive IBD speedup. This approach was independently recommended by Peter Todd and Luke-Jr since POW based signature skipping (see PR#9180) does not have the verifiable properties of a specific hash and may create bad incentives. The downside is that, like checkpoints, the defaults bitrot and older releases will sync slower. On the plus side users can provide their own value here, and if they set it to something crazy all that will happen is more time will be spend validating signatures. Checkblocks and checklevel are also moved to the hidden debug options: Especially now that checkblocks has a low default there is little need to change these settings, and users frequently misunderstand them as influencing security or IBD speed. By hiding them we offset the space added by this new option.
2017-01-06 11:49:59 +00:00
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
consensus.genesis_subsidy = 50*COIN;
connect genesis block transaction outputs to coin db
2018-10-12 13:13:56 -04:00
consensus.connect_genesis_outputs = false;
Add new arguments
2019-03-19 20:02:02 +00:00
consensus.subsidy_asset = CAsset();
Add TX_TRUE output format, accept in wallet with `anyonecanspendaremine`
2018-11-14 22:50:48 -05:00
anyonecanspend_aremine = false;
PAK enforcement via standardness, drop multi-op_return restriction
2018-12-17 10:58:30 -05:00
enforce_pak = false;
-multi_data_permitted: Allow >1 op_return output by policy
2018-12-17 12:57:18 -05:00
multi_data_permitted = false;
MERGE FIX: instantiate consensus.has_parent_chain for all chains
2019-01-29 13:46:23 +00:00
consensus.has_parent_chain = false;
MERGE FIX: Prevent mainnet unit tests from thinking they have signed blocks after custom tests
2019-01-31 10:48:18 +00:00
g_signed_blocks = false;
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
g_con_elementsmode = false;
Add new arguments
2019-03-19 20:02:02 +00:00
g_con_blockheightinheader = false;
Generalize the number of epochs old a peg-in can be and still be valid
2019-08-19 15:21:30 -04:00
consensus.total_valid_epochs = 0;
Change elements mode to activating BIP9 signaling based on height
2019-11-13 16:07:29 -05:00
consensus.elements_mode = g_con_elementsmode;
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
Add CHECKSEQUENCEVERIFY softfork through BIP9
2016-02-20 23:37:13 +01:00
/**
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08: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
Non-grammatical language improvements
2015-04-28 14:47:17 +00:00
* a large 32-bit integer with any alignment.
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
*/
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
pchMessageStart[0] = 0xf9;
pchMessageStart[1] = 0xbe;
pchMessageStart[2] = 0xb4;
pchMessageStart[3] = 0xd9;
nDefaultPort = 8333;
Add block pruning functionality This adds a -prune=N option to bitcoind, which if set to N>0 will enable block file pruning. When pruning is enabled, block and undo files will be deleted to try to keep total space used by those files to below the prune target (N, in MB) specified by the user, subject to some constraints: - The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP), - N must be at least 550MB (chosen as a value for the target that could reasonably be met, with some assumptions about block sizes, orphan rates, etc; see comment in main.h), - No blocks are pruned until chainActive is at least 100,000 blocks long (on mainnet; defined separately for mainnet, testnet, and regtest in chainparams as nPruneAfterHeight). This unsets NODE_NETWORK if pruning is enabled. Also included is an RPC test for pruning (pruning.py). Thanks to @rdponticelli for earlier work on this feature; this is based in part off that work.
2015-02-23 14:27:44 -05:00
nPruneAfterHeight = 100000;
Update m_assumed_* chain parameters for 23.x - `m_assumed_chain_state_size` doesn't seem to need to be changed for mainnet. - No change needed for testnet/signet. Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:17:32 +01:00
m_assumed_blockchain_size = 460;
Update assumed chain params
2020-10-29 20:25:15 +01:00
m_assumed_chain_state_size = 6;
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN, consensus);
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
String conversions uint256 -> uint256S If uint256() constructor takes a string, uint256(0) will become dangerous when uint256 does not take integers anymore (it will go through std::string(const char*) making a NULL string, and the explicit keyword is no help).
2014-12-16 14:50:05 +01:00
assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Update chainparams comment for more info on service bits per dnsseed
2018-01-17 11:18:27 -10:00
// Note that of those which support the service bits prefix, most only support a subset of
// possible options.
scripted-diff: Rename OneShot to AddrFetch -BEGIN VERIFY SCRIPT- sed -i 's/a oneshot/an addrfetch/g' src/chainparams.cpp #comment sed -i 's/oneshot/addrfetch/g' src/net.cpp #comment sed -i 's/AddOneShot/AddAddrFetch/g' src/net.h src/net.cpp sed -i 's/cs_vOneShots/m_addr_fetches_mutex/g' src/net.h src/net.cpp sed -i 's/vOneShots/m_addr_fetches/g' src/net.h src/net.cpp sed -i 's/fOneShot/m_addr_fetch/g' src/net.h src/net.cpp src/net_processing.cpp sed -i 's/ProcessOneShot/ProcessAddrFetch/g' src/net.h src/net.cpp -END VERIFY SCRIPT-
2020-07-17 14:56:34 -07:00
// This is fine at runtime as we'll fall back to using them as an addrfetch if they don't support the
Update chainparams comment for more info on service bits per dnsseed
2018-01-17 11:18:27 -10:00
// 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.
Use absolute FQDN for DNS seed domains
2021-10-14 17:49:52 +05:30
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
vSeeds.emplace_back("dnsseed.bitcoin.dashjr.org."); // Luke Dashjr
vSeeds.emplace_back("seed.bitcoinstats.com."); // Christian Decker, supports x1 - xf
vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
vSeeds.emplace_back("seed.btc.petertodd.org."); // Peter Todd, only supports x1, x5, x9, and xd
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
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
build: fix newer boost build with c++11
2014-11-24 17:25: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);
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Implement BIP173 addresses and tests
2017-08-25 19:55:52 -07:00
bech32_hrp = "bc";
Fix nit in blech32_hrp assignment in Bitcoin chains
2019-09-11 16:21:49 +01:00
blech32_hrp = bech32_hrp;
Implement BIP173 addresses and tests
2017-08-25 19:55:52 -07:00
net: Deserialize hardcoded seeds from BIP155 blob Switch from IPv6 slot-based format to more compact and flexible BIP155 format.
2021-03-31 13:29:24 +02:00
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Add a consistency check for the block chain data structures This adds a -checkblockindex (defaulting to true for regtest), which occasionally does a full consistency check for mapBlockIndex, setBlockIndexCandidates, chainActive, and mapBlocksUnlinked.
2015-03-13 09:25:34 -07:00
fDefaultConsistencyChecks = false;
Replace virtual methods with static attributes, chainparams.h depends on protocol.h instead of the other way around
2014-06-04 12:51:29 +02:00
fRequireStandard = true;
test: Require standard txs in regtest
2019-04-24 17:55:58 -04:00
m_is_test_chain = false;
[test] add chainparams property to indicate chain allows time mocking
2020-02-06 20:17:28 -08:00
m_is_mockable_chain = false;
Move checkpoint data selection to chainparams
2014-08-31 21:32:23 +02:00
Minimal code changes to allow msvc compilation.
2017-11-10 07:06:49 +11:00
checkpointData = {
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
{
{ 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
{ 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
{ 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
{105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
{134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
{168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
{193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
{210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
{216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
{225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
{250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
{279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
{295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983")},
}
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
};
chainparams: add allowed assumeutxo values Values for mainnet and testnet will be specified in a follow-up PR that can be scrutinized accordingly. This structure is required for use in snapshot activation logic.
2019-04-25 11:09:29 -04:00
m_assumeutxo_data = MapAssumeutxo{
// TODO to be specified in a future patch.
};
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
chainTxData = ChainTxData{
Update chainTxData for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:28:13 +01:00
// Data from RPC: getchaintxstats 4096 000000000000000000052d314a259755ca65944e68df6b12a067ea8f1f5a7091
/* nTime */ 1645542140,
/* nTxCount */ 712531200,
/* dTxRate */ 2.891036496010309,
checkpoints: make checkpoints a member of CChainParams This drops the virtual call and simplifies the logic
2015-04-23 18:30:55 -04:00
};
Move checkpoint data selection to chainparams
2014-08-31 21:32:23 +02:00
}
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
};
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
/**
[doc] correct comment in chainparams There are more than 3 networks.
2021-03-23 13:29:17 -07:00
* Testnet (v3): public test network which is reset from time to time.
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
*/
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02:00
class CTestNetParams : public CChainParams {
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
public:
CTestNetParams() {
Chainparams: Use name constants in chainparams initialization
2019-10-29 20:27:30 +01:00
strNetworkID = CBaseChainParams::TESTNET;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02:00
consensus.nSubsidyHalvingInterval = 210000;
Enforce Taproot script flags whenever WITNESS is set
2021-11-16 14:40:19 +01:00
consensus.script_flag_exceptions.emplace( // BIP16 exception
uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"), SCRIPT_VERIFY_NONE);
Make skipping BIP30 check chain agnostic
2015-11-02 16:41:55 -05:00
consensus.BIP34Height = 21111;
consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
Consensus: Remove ISM
2016-07-22 08:27:55 +09:00
consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
[Consensus] Bury CSV deployment height Hard code CSV deployment height to 419328 for mainnet.
2019-05-20 14:58:44 -04:00
consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
fix uninitialized variable nMinerConfirmationWindow fix uninitialized variable hard code the MinBIP9WarningHeight fix uninitialized var hard code the MinBIP9WarningHeight instead
2019-11-11 21:48:51 -06:00
consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02:00
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.fPowAllowMinDifficultyBlocks = true;
Added fPowNoRetargeting field to Consensus::Params that disables nBits recalculation.
2015-10-19 08:25:29 -04:00
consensus.fPowNoRetargeting = false;
BIP9 Implementation Inspired by former implementations by Eric Lombrozo and Rusty Russell, and based on code by Jorge Timon.
2016-02-15 05:13:27 +01:00
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
Add testing of ComputeBlockVersion
2016-03-09 16:00:53 -05:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
versionbits: Add explicit NEVER_ACTIVE deployments Previously we used deployments that would timeout prior to Bitcoin's invention, which allowed the deployment to still be activated in unit tests. This switches those deployments to be truly never active.
2021-03-27 23:00:14 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
test: add dynafed params for testnet (only used in unit tests, fix needed for uninit mem linter)
2021-10-14 23:53:36 +00: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
Add CHECKSEQUENCEVERIFY softfork through BIP9
2016-02-20 23:37:13 +01:00
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
// Deployment of Taproot (BIPs 340-342)
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
Add mainnet and testnet taproot activation params
2021-04-14 22:36:19 -04:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
Update nMinimumChainWork, defaultAssumeValid for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:36:50 +01:00
consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000064728c7be6fe4b2f961");
consensus.defaultAssumeValid = uint256S("0x00000000000163cfb1f97c4e4098a3692c8053ad9cab5ad9c86b338b5c00b8b7"); // 2143398
Introduce assumevalid setting to skip presumed valid scripts. This disentangles the script validation skipping from checkpoints. A new option is introduced "assumevalid" which specifies a block whos ancestors we assume all have valid scriptsigs and so we do not check them when they are also burried under the best header by two weeks worth of work. Unlike checkpoints this has no influence on consensus unless you set it to a block with an invalid history. Because of this it can be easily be updated without risk of influencing the network consensus. This results in a massive IBD speedup. This approach was independently recommended by Peter Todd and Luke-Jr since POW based signature skipping (see PR#9180) does not have the verifiable properties of a specific hash and may create bad incentives. The downside is that, like checkpoints, the defaults bitrot and older releases will sync slower. On the plus side users can provide their own value here, and if they set it to something crazy all that will happen is more time will be spend validating signatures. Checkblocks and checklevel are also moved to the hidden debug options: Especially now that checkblocks has a low default there is little need to change these settings, and users frequently misunderstand them as influencing security or IBD speed. By hiding them we offset the space added by this new option.
2017-01-06 11:49:59 +00:00
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
consensus.genesis_subsidy = 50*COIN;
connect genesis block transaction outputs to coin db
2018-10-12 13:13:56 -04:00
consensus.connect_genesis_outputs = false;
Add new arguments
2019-03-19 20:02:02 +00:00
consensus.subsidy_asset = CAsset();
Add TX_TRUE output format, accept in wallet with `anyonecanspendaremine`
2018-11-14 22:50:48 -05:00
anyonecanspend_aremine = false;
PAK enforcement via standardness, drop multi-op_return restriction
2018-12-17 10:58:30 -05:00
enforce_pak = false;
-multi_data_permitted: Allow >1 op_return output by policy
2018-12-17 12:57:18 -05:00
multi_data_permitted = false;
MERGE FIX: instantiate consensus.has_parent_chain for all chains
2019-01-29 13:46:23 +00:00
consensus.has_parent_chain = false;
Add new arguments
2019-03-19 20:02:02 +00:00
g_signed_blocks = false;
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
g_con_elementsmode = false;
Add new arguments
2019-03-19 20:02:02 +00:00
g_con_blockheightinheader = false;
Generalize the number of epochs old a peg-in can be and still be valid
2019-08-19 15:21:30 -04:00
consensus.total_valid_epochs = 0;
Change elements mode to activating BIP9 signaling based on height
2019-11-13 16:07:29 -05:00
consensus.elements_mode = g_con_elementsmode;
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
pchMessageStart[0] = 0x0b;
pchMessageStart[1] = 0x11;
pchMessageStart[2] = 0x09;
pchMessageStart[3] = 0x07;
nDefaultPort = 18333;
Add block pruning functionality This adds a -prune=N option to bitcoind, which if set to N>0 will enable block file pruning. When pruning is enabled, block and undo files will be deleted to try to keep total space used by those files to below the prune target (N, in MB) specified by the user, subject to some constraints: - The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP), - N must be at least 550MB (chosen as a value for the target that could reasonably be met, with some assumptions about block sizes, orphan rates, etc; see comment in main.h), - No blocks are pruned until chainActive is at least 100,000 blocks long (on mainnet; defined separately for mainnet, testnet, and regtest in chainparams as nPruneAfterHeight). This unsets NODE_NETWORK if pruning is enabled. Also included is an RPC test for pruning (pruning.py). Thanks to @rdponticelli for earlier work on this feature; this is based in part off that work.
2015-02-23 14:27:44 -05:00
nPruneAfterHeight = 1000;
chainparams: Bump assumed valid hash
2020-04-02 04:46:31 +08:00
m_assumed_blockchain_size = 40;
implements different disk sizes for different networks on intro - Creates m_assumed_blockchain_size and m_assumed_chain_state_size on CChainParams. - Implements access to CChainParams' m_assumed_blockchain_size and m_assumed_chain_state_size on node interface. - Implements m_assumed_blockchain_size and m_assumed_chain_state_size on qt/intro via node interface. - Updates release process document with the new CChainParam's values.
2018-10-07 13:11:36 +01:00
m_assumed_chain_state_size = 2;
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN, consensus);
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
Clean up chainparams some more. Clean up the code in chainparams a bit more after the recent refactorings. In particular, make sure the structure of the "RegTest" params matches the structure of the other classes. This makes the code clearer to read. Also remove redundant values of the genesis block in always-specified optional arguments and mark variable/argument as "const".
2015-07-29 21:13:36 +02:00
assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
vFixedSeeds.clear();
vSeeds.clear();
Add support for dnsseeds with option to filter by servicebits
2016-05-21 23:55:22 +02:00
// nodes with support for servicebits filtering should be at the top
Use absolute FQDN for DNS seed domains
2021-10-14 17:49:52 +05:30
vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch.");
vSeeds.emplace_back("seed.tbtc.petertodd.org.");
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
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
build: fix newer boost build with c++11
2014-11-24 17:25: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);
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
Add AllowMinDifficultyBlocks chain parameter
2014-03-22 20:09:12 +01:00
Implement BIP173 addresses and tests
2017-08-25 19:55:52 -07:00
bech32_hrp = "tb";
Fix nit in blech32_hrp assignment in Bitcoin chains
2019-09-11 16:21:49 +01:00
blech32_hrp = bech32_hrp;
Implement BIP173 addresses and tests
2017-08-25 19:55:52 -07:00
net: Deserialize hardcoded seeds from BIP155 blob Switch from IPv6 slot-based format to more compact and flexible BIP155 format.
2021-03-31 13:29:24 +02:00
vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
Add built-in seeds for .onion This makes it possible for a node with `-onlynet=tor` to bootstrap itself. It also adds the base infrastructure for adding IPv6 seed nodes. Also represent IPv4 fixed seed addresses in 16-byte format.
2014-07-24 13:52:57 +02:00
Add a consistency check for the block chain data structures This adds a -checkblockindex (defaulting to true for regtest), which occasionally does a full consistency check for mapBlockIndex, setBlockIndexCandidates, chainActive, and mapBlocksUnlinked.
2015-03-13 09:25:34 -07:00
fDefaultConsistencyChecks = false;
Replace virtual methods with static attributes, chainparams.h depends on protocol.h instead of the other way around
2014-06-04 12:51:29 +02:00
fRequireStandard = false;
test: Require standard txs in regtest
2019-04-24 17:55:58 -04:00
m_is_test_chain = true;
[test] add chainparams property to indicate chain allows time mocking
2020-02-06 20:17:28 -08:00
m_is_mockable_chain = false;
IBD check uses minimumchain work instead of checkpoints. This introduces a 'minimum chain work' chainparam which is intended to be the known amount of work in the chain for the network at the time of software release. If you don't have this much work, you're not yet caught up. This is used instead of the count of blocks test from checkpoints. This criteria is trivial to keep updated as there is no element of subjectivity, trust, or position dependence to it. It is also a more reliable metric of sync status than a block count.
2016-10-22 05:33:25 +00:00
Minimal code changes to allow msvc compilation.
2017-11-10 07:06:49 +11:00
checkpointData = {
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
{
{546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
}
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
};
chainparams: add allowed assumeutxo values Values for mainnet and testnet will be specified in a follow-up PR that can be scrutinized accordingly. This structure is required for use in snapshot activation logic.
2019-04-25 11:09:29 -04:00
m_assumeutxo_data = MapAssumeutxo{
// TODO to be specified in a future patch.
};
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
chainTxData = ChainTxData{
Update chainTxData for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:28:13 +01:00
// Data from RPC: getchaintxstats 4096 00000000d18cfe81cbeea665076807789bd8f831d557632e635bc6e3c003069e
/* nTime */ 1645635119,
/* nTxCount */ 62226341,
/* dTxRate */ 0.07717997442177152,
checkpoints: make checkpoints a member of CChainParams This drops the virtual call and simplifies the logic
2015-04-23 18:30:55 -04:00
};
Move checkpoint data selection to chainparams
2014-08-31 21:32:23 +02:00
}
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
};
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
/**
[doc] correct comment in chainparams There are more than 3 networks.
2021-03-23 13:29:17 -07:00
* Signet: test network with an additional consensus parameter (see BIP325).
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
*/
class SigNetParams : public CChainParams {
public:
explicit SigNetParams(const ArgsManager& args) {
std::vector<uint8_t> bin;
vSeeds.clear();
if (!args.IsArgSet("-signetchallenge")) {
signet: hard-coded parameters for Signet Global Network VI (2020-09-07) Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 16:51:00 +09:00
bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
Use absolute FQDN for DNS seed domains
2021-10-14 17:49:52 +05:30
vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
net: switch to signet DNS seed This commit also drops a seed node that no longer exists.
2021-09-17 21:22:32 +02:00
doc: Remove un-actionable TODO from chainparams.cpp
2021-09-28 20:18:27 +02:00
// Hardcoded nodes can be removed once there are more DNS seeds
signet: hard-coded parameters for Signet Global Network VI (2020-09-07) Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 16:51:00 +09:00
vSeeds.emplace_back("178.128.221.177");
Move signet onion seed from v2 to v3
2020-12-15 14:12:01 +01:00
vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
signet: Add assumed values for default signet
2020-09-29 14:59:13 +02:00
Update nMinimumChainWork, defaultAssumeValid for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:36:50 +01:00
consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000000000000de26b0e471");
consensus.defaultAssumeValid = uint256S("0x00000112852484b5fe3451572368f93cfd2723279af3464e478aee35115256ef"); // 78788
signet: Add assumed values for default signet
2020-09-29 14:59:13 +02:00
m_assumed_blockchain_size = 1;
m_assumed_chain_state_size = 0;
chainTxData = ChainTxData{
Update chainTxData for 23.x Co-authored-by: Suhas Daftuar <sdaftuar@gmail.com>
2022-02-22 16:28:13 +01:00
// Data from RPC: getchaintxstats 4096 0000003d9144c56ac110ae04a0c271a0acce2f14f426b39fdf0d938c96d2eb09
/* nTime */ 1645631279,
/* nTxCount */ 1257429,
/* dTxRate */ 0.1389638742514995,
signet: Add assumed values for default signet
2020-09-29 14:59:13 +02:00
};
signet: hard-coded parameters for Signet Global Network VI (2020-09-07) Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 16:51:00 +09:00
} else {
const auto signet_challenge = args.GetArgs("-signetchallenge");
if (signet_challenge.size() != 1) {
throw std::runtime_error(strprintf("%s: -signetchallenge cannot be multiple values.", __func__));
}
bin = ParseHex(signet_challenge[0]);
Initialize default-initialized uint256 consensus params to zero explicitly
2020-09-30 15:23:17 +02:00
consensus.nMinimumChainWork = uint256{};
consensus.defaultAssumeValid = uint256{};
signet: Add assumed values for default signet
2020-09-29 14:59:13 +02:00
m_assumed_blockchain_size = 0;
m_assumed_chain_state_size = 0;
chainTxData = ChainTxData{
0,
0,
0,
};
signet: hard-coded parameters for Signet Global Network VI (2020-09-07) Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 16:51:00 +09:00
LogPrintf("Signet with challenge %s\n", signet_challenge[0]);
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
}
signet: hard-coded parameters for Signet Global Network VI (2020-09-07) Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 16:51:00 +09:00
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
if (args.IsArgSet("-signetseednode")) {
vSeeds = args.GetArgs("-signetseednode");
}
strNetworkID = CBaseChainParams::SIGNET;
consensus.signet_blocks = true;
consensus.signet_challenge.assign(bin.begin(), bin.end());
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 1;
Initialize default-initialized uint256 consensus params to zero explicitly
2020-09-30 15:23:17 +02:00
consensus.BIP34Hash = uint256{};
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
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;
consensus.fPowNoRetargeting = false;
chainparams: drop versionbits threshold to 90% for mainnnet and signet
2021-03-06 18:42:58 +10:00
consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
doc: Missing comments for signet parameters
2020-10-25 12:49:46 -04:00
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
signet: Fix uninitialized read in validation
2020-09-29 14:47:51 +02:00
consensus.MinBIP9WarningHeight = 0;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
versionbits: Add explicit NEVER_ACTIVE deployments Previously we used deployments that would timeout prior to Bitcoin's invention, which allowed the deployment to still be activated in unit tests. This switches those deployments to be truly never active.
2021-03-27 23:00:14 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
lint: fix non-pylint linter errors Includes fixing all the spelling mistakes that are our fault, but not those present upstream in Core.
2021-10-14 21:48:49 +00:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
ci: fix benchmarks, fuzztests and unit tests Includes a memory leak in the checkqueue unit test (but not in the actual code). WE really need to switch our checkqueue to use std::unique_pointer rather than bare pointers. But this would be invasive enough that I want to do it in a followup PR. Also pretty-much disable the validation_flush_cache unit test. This is a stupid and irritating test which tries to unit-test exact memory usage of std containers. It already has at least one "remove wrong assumptions" update upstream and after many tries I was unable to change all the magic numbers in a way that'd consistently pass CI for Elements. Also adds a couple ubsan suppressions about perfectly-legitimate conversions of integer types.
2020-12-08 03:37:52 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
Merge 2cd834e6c09 into merged_master (Bitcoin PR #21377)
2021-06-30 16:24:18 +00:00
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
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
Bugfix: chainparams: Add missing (disabled) Taproot deployment for Signet
2020-10-15 14:46:02 +00: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;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
Bugfix: chainparams: Add missing (disabled) Taproot deployment for Signet
2020-10-15 14:46:02 +00:00
Merge 8c5f68118c into merged_master (Bitcoin PR #18267) This commit adds signet support, which is a little bit silly/redundant for us :) Was a surprisingly easy merge to handle, and hopefully in future Core is more mindful of signed blocks when they are changing code architecture. I had to change a couple lines of src/signet.cpp to add blank assets to the CTxOuts and to find transaction input scriptWitnesses. No need to add any other tx witness data (and the CAsset()s that I did add to make things compile won't be used..) because signet will always have g_con_elementsmode off.
2020-11-29 16:57:55 +00:00
// ELEMENTS: copied from Main
consensus.genesis_subsidy = 50*COIN;
consensus.connect_genesis_outputs = false;
consensus.subsidy_asset = CAsset();
anyonecanspend_aremine = false;
enforce_pak = false;
multi_data_permitted = false;
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;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
// message start is defined as the first 4 bytes of the sha256d of the block script
CHashWriter h(SER_DISK, 0);
h << consensus.signet_challenge;
uint256 hash = h.GetHash();
memcpy(pchMessageStart, hash.begin(), 4);
nDefaultPort = 38333;
nPruneAfterHeight = 1000;
Merge 8c5f68118c into merged_master (Bitcoin PR #18267) This commit adds signet support, which is a little bit silly/redundant for us :) Was a surprisingly easy merge to handle, and hopefully in future Core is more mindful of signed blocks when they are changing code architecture. I had to change a couple lines of src/signet.cpp to add blank assets to the CTxOuts and to find transaction input scriptWitnesses. No need to add any other tx witness data (and the CAsset()s that I did add to make things compile won't be used..) because signet will always have g_con_elementsmode off.
2020-11-29 16:57:55 +00:00
genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN, consensus);
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vFixedSeeds.clear();
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 8c5f68118c into merged_master (Bitcoin PR #18267) This commit adds signet support, which is a little bit silly/redundant for us :) Was a surprisingly easy merge to handle, and hopefully in future Core is more mindful of signed blocks when they are changing code architecture. I had to change a couple lines of src/signet.cpp to add blank assets to the CTxOuts and to find transaction input scriptWitnesses. No need to add any other tx witness data (and the CAsset()s that I did add to make things compile won't be used..) because signet will always have g_con_elementsmode off.
2020-11-29 16:57:55 +00:00
blech32_hrp = bech32_hrp;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
fDefaultConsistencyChecks = false;
fRequireStandard = true;
m_is_test_chain = true;
m_is_mockable_chain = false;
}
};
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
/**
[doc] correct comment in chainparams There are more than 3 networks.
2021-03-23 13:29:17 -07:00
* Regression test: intended for private networks only. Has minimal difficulty to ensure that
* blocks can be found instantly.
Update comments in chainparams to be doxygen compatible
2014-10-25 17:24:16 +08:00
*/
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02:00
class CRegTestParams : public CChainParams {
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
public:
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
explicit CRegTestParams(const ArgsManager& args) {
Chainparams: Use name constants in chainparams initialization
2019-10-29 20:27:30 +01:00
strNetworkID = CBaseChainParams::REGTEST;
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
consensus.signet_blocks = false;
consensus.signet_challenge.clear();
Consensus: Refactor: Introduce Consensus::Params class
2015-02-11 11:58:11 +01:00
consensus.nSubsidyHalvingInterval = 150;
test: Activate all regtest softforks at height 1, unless overridden
2021-08-27 16:53:11 +02:00
consensus.BIP34Height = 1; // Always active unless overridden
Make skipping BIP30 check chain agnostic
2015-11-02 16:41:55 -05:00
consensus.BIP34Hash = uint256();
test: Activate all regtest softforks at height 1, unless overridden
2021-08-27 16:53:11 +02:00
consensus.BIP65Height = 1; // Always active unless overridden
consensus.BIP66Height = 1; // Always active unless overridden
consensus.CSVHeight = 1; // Always active unless overridden
test: set segwit height back to 0 on regtest This was changed in #22818 from 0 to 1. Since it changes BLOCK_OPT_WIT of the genesis block, older versions of bitcoin core would not read regtest directories created with newer versions without a reindex.
2022-03-10 20:24:11 +01:00
consensus.SegwitHeight = 0; // Always active unless overridden
Ignore old versionbit activations Adds a hardcoded height to the consensus chain parameters for ignoring versionbit activations prior to a fixed height.
2019-09-06 00:28:52 +10:00
consensus.MinBIP9WarningHeight = 0;
consensus: don't use arith_uint256 in consensus.h Requiring arith_uint256 at such a base level is not good for modularity.
2015-03-25 15:00:32 -04:00
consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02:00
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
Added fPowNoRetargeting field to Consensus::Params that disables nBits recalculation.
2015-10-19 08:25:29 -04:00
consensus.fPowNoRetargeting = true;
BIP9 Implementation Inspired by former implementations by Eric Lombrozo and Rusty Russell, and based on code by Jorge Timon.
2016-02-15 05:13:27 +01:00
consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
Add testing of ComputeBlockVersion
2016-03-09 16:00:53 -05:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
Improve handling of BIP9Deployment limits Small tweaks by Pieter Wuille.
2017-10-17 18:47:57 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
lint: fix non-pylint linter errors Includes fixing all the spelling mistakes that are our fault, but not those present upstream in Core.
2021-10-14 21:48:49 +00:00
// DynaFed: never activate (but set to avoid use of uninitialized memory in tests)
ci: fix benchmarks, fuzztests and unit tests Includes a memory leak in the checkqueue unit test (but not in the actual code). WE really need to switch our checkqueue to use std::unique_pointer rather than bare pointers. But this would be invasive enough that I want to do it in a followup PR. Also pretty-much disable the validation_flush_cache unit test. This is a stupid and irritating test which tries to unit-test exact memory usage of std containers. It already has at least one "remove wrong assumptions" update upstream and after many tries I was unable to change all the magic numbers in a way that'd consistently pass CI for Elements. Also adds a couple ubsan suppressions about perfectly-legitimate conversions of integer types.
2020-12-08 03:37:52 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
Merge 2cd834e6c09 into merged_master (Bitcoin PR #21377)
2021-06-30 16:24:18 +00:00
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
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
Activate Taproot/Tapscript on regtest (BIP 341, BIP 342) Define a versionbits-based activation for the new consensus rules on regtest. No activation or activation mechanism is defined for testnet or mainnet.
2020-09-11 14:34:17 -07:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
chainparams: add undocumented regtest/testnet only -con_taproot_signal_start option
2021-09-15 18:41:36 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nPeriod = 128; // test ability to change from default
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nThreshold = 128;
Clean up chainparams some more. Clean up the code in chainparams a bit more after the recent refactorings. In particular, make sure the structure of the "RegTest" params matches the structure of the other classes. This makes the code clearer to read. Also remove redundant values of the genesis block in always-specified optional arguments and mark variable/argument as "const".
2015-07-29 21:13:36 +02:00
Initialize default-initialized uint256 consensus params to zero explicitly
2020-09-30 15:23:17 +02:00
consensus.nMinimumChainWork = uint256{};
consensus.defaultAssumeValid = uint256{};
Introduce assumevalid setting to skip presumed valid scripts. This disentangles the script validation skipping from checkpoints. A new option is introduced "assumevalid" which specifies a block whos ancestors we assume all have valid scriptsigs and so we do not check them when they are also burried under the best header by two weeks worth of work. Unlike checkpoints this has no influence on consensus unless you set it to a block with an invalid history. Because of this it can be easily be updated without risk of influencing the network consensus. This results in a massive IBD speedup. This approach was independently recommended by Peter Todd and Luke-Jr since POW based signature skipping (see PR#9180) does not have the verifiable properties of a specific hash and may create bad incentives. The downside is that, like checkpoints, the defaults bitrot and older releases will sync slower. On the plus side users can provide their own value here, and if they set it to something crazy all that will happen is more time will be spend validating signatures. Checkblocks and checklevel are also moved to the hidden debug options: Especially now that checkblocks has a low default there is little need to change these settings, and users frequently misunderstand them as influencing security or IBD speed. By hiding them we offset the space added by this new option.
2017-01-06 11:49:59 +00:00
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
consensus.genesis_subsidy = 50*COIN;
connect genesis block transaction outputs to coin db
2018-10-12 13:13:56 -04:00
consensus.connect_genesis_outputs = false;
Add new arguments
2019-03-19 20:02:02 +00:00
consensus.subsidy_asset = CAsset();
Add TX_TRUE output format, accept in wallet with `anyonecanspendaremine`
2018-11-14 22:50:48 -05:00
anyonecanspend_aremine = false;
PAK enforcement via standardness, drop multi-op_return restriction
2018-12-17 10:58:30 -05:00
enforce_pak = false;
-multi_data_permitted: Allow >1 op_return output by policy
2018-12-17 12:57:18 -05:00
multi_data_permitted = false;
MERGE FIX: instantiate consensus.has_parent_chain for all chains
2019-01-29 13:46:23 +00:00
consensus.has_parent_chain = false;
Add new arguments
2019-03-19 20:02:02 +00:00
g_signed_blocks = false;
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
g_con_elementsmode = false;
Change elements mode to activating BIP9 signaling based on height
2019-11-13 16:07:29 -05:00
consensus.elements_mode = g_con_elementsmode;
Add new arguments
2019-03-19 20:02:02 +00:00
g_con_blockheightinheader = false;
Generalize the number of epochs old a peg-in can be and still be valid
2019-08-19 15:21:30 -04:00
consensus.total_valid_epochs = 0;
add block subsidy argument to allow different/non-inflation chains
2018-10-22 15:24:50 -04:00
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
pchMessageStart[0] = 0xfa;
pchMessageStart[1] = 0xbf;
pchMessageStart[2] = 0xb5;
pchMessageStart[3] = 0xda;
nDefaultPort = 18444;
CRegTestParams: Use `args` instead of `gArgs`.
2021-06-02 22:35:10 +02:00
nPruneAfterHeight = args.GetBoolArg("-fastprune", false) ? 100 : 1000;
implements different disk sizes for different networks on intro - Creates m_assumed_blockchain_size and m_assumed_chain_state_size on CChainParams. - Implements access to CChainParams' m_assumed_blockchain_size and m_assumed_chain_state_size on node interface. - Implements m_assumed_blockchain_size and m_assumed_chain_state_size on qt/intro via node interface. - Updates release process document with the new CChainParam's values.
2018-10-07 13:11:36 +01:00
m_assumed_blockchain_size = 0;
m_assumed_chain_state_size = 0;
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
UpdateActivationParametersFromArgs(args);
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN, consensus);
Clean up chainparams some more. Clean up the code in chainparams a bit more after the recent refactorings. In particular, make sure the structure of the "RegTest" params matches the structure of the other classes. This makes the code clearer to read. Also remove redundant values of the genesis block in always-specified optional arguments and mark variable/argument as "const".
2015-07-29 21:13:36 +02:00
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
[doc] Fix doxygen comments for members
2016-04-03 11:49:36 +02:00
vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
[test] Introduce test logic to query DNS seeds This commit introduces a DNS seed to the regest chain params in order to add coverage to the DNS querying logic. The first test checks that we do not query DNS seeds if we are able to succesfully connect to 2 outbound connections. Since we participate in ADDR relay with those connections, including sending a GETADDR message during the VERSION handshake, querying the DNS seeds is unnecessary. Co-authored-by: Martin Zumsande <mzumsande@gmail.com>
2021-05-28 13:45:15 -07:00
vSeeds.clear();
vSeeds.emplace_back("dummySeed.invalid.");
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
Add a consistency check for the block chain data structures This adds a -checkblockindex (defaulting to true for regtest), which occasionally does a full consistency check for mapBlockIndex, setBlockIndexCandidates, chainActive, and mapBlocksUnlinked.
2015-03-13 09:25:34 -07:00
fDefaultConsistencyChecks = true;
test: Require standard txs in regtest
2019-04-24 17:55:58 -04:00
fRequireStandard = true;
m_is_test_chain = true;
[test] add chainparams property to indicate chain allows time mocking
2020-02-06 20:17:28 -08:00
m_is_mockable_chain = true;
checkpoints: make checkpoints a member of CChainParams This drops the virtual call and simplifies the logic
2015-04-23 18:30:55 -04:00
Minimal code changes to allow msvc compilation.
2017-11-10 07:06:49 +11:00
checkpointData = {
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
{
{0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
}
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
};
chainparams: add allowed assumeutxo values Values for mainnet and testnet will be specified in a follow-up PR that can be scrutinized accordingly. This structure is required for use in snapshot activation logic.
2019-04-25 11:09:29 -04:00
m_assumeutxo_data = MapAssumeutxo{
{
110,
Merge ee9befe8b4b into merged_master (Bitcoin PR bitcoin/bitcoin#21584)
2021-07-09 21:14:15 +00:00
{AssumeutxoHash{uint256S("0x09a3e443dbf48f3b95207c9ce529062d9764395232c482aa7d3a0bf274d282d9")}, 110},
chainparams: add allowed assumeutxo values Values for mainnet and testnet will be specified in a follow-up PR that can be scrutinized accordingly. This structure is required for use in snapshot activation logic.
2019-04-25 11:09:29 -04:00
},
{
fuzz: Add utxo_snapshot target
2021-04-03 13:39:42 +02:00
200,
{AssumeutxoHash{uint256S("0x51c8d11d8b5c1de51543c579736e786aa2736206d1e11e627568029ce092cf62")}, 200},
chainparams: add allowed assumeutxo values Values for mainnet and testnet will be specified in a follow-up PR that can be scrutinized accordingly. This structure is required for use in snapshot activation logic.
2019-04-25 11:09:29 -04:00
},
};
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
chainTxData = ChainTxData{
checkpoints: make checkpoints a member of CChainParams This drops the virtual call and simplifies the logic
2015-04-23 18:30:55 -04:00
0,
0,
0
};
Move tx estimation data out of CCheckPointData
2017-01-04 07:31:56 -08:00
Chainparams: CTestNetParams and CRegTestParams extend directly from CChainParams ...instead of CMainParams and CTestNetParams respectively Do the same for CBaseChainParams. The inheritance was only reducing readibility in this case
2015-07-03 14:30:18 +02: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);
Use list initialization (C++11) for maps/vectors instead of boost::assign::map_list_of/list_of
2017-06-06 21:15:28 +02:00
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
Implement BIP173 addresses and tests
2017-08-25 19:55:52 -07:00
bech32_hrp = "bcrt";
Fix nit in blech32_hrp assignment in Bitcoin chains
2019-09-11 16:21:49 +01:00
blech32_hrp = bech32_hrp;
Move checkpoint data selection to chainparams
2014-08-31 21:32:23 +02:00
}
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
/**
* Allows modifying the Version Bits regtest parameters.
*/
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout, int min_activation_height)
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
{
consensus.vDeployments[d].nStartTime = nStartTime;
consensus.vDeployments[d].nTimeout = nTimeout;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
consensus.vDeployments[d].min_activation_height = min_activation_height;
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
}
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
void UpdateActivationParametersFromArgs(const ArgsManager& args);
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
};
Introduce -testactivationheight=name@height setting
2021-08-27 12:54:24 +02:00
static void MaybeUpdateHeights(const ArgsManager& args, Consensus::Params& consensus)
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
{
Introduce -testactivationheight=name@height setting
2021-08-27 12:54:24 +02:00
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};
test: Activate all regtest softforks at height 1, unless overridden
2021-08-27 16:53:11 +02:00
} 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};
Introduce -testactivationheight=name@height setting
2021-08-27 12:54:24 +02:00
} else {
throw std::runtime_error(strprintf("Invalid name (%s) for -testactivationheight=name@height.", arg));
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
}
}
Introduce -testactivationheight=name@height setting
2021-08-27 12:54:24 +02:00
}
void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
{
MaybeUpdateHeights(args, consensus);
[Consensus] Bury segwit deployment Hardcode segwit deployment height to 481824 for mainnet.
2019-05-20 14:59:07 -04:00
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
if (!args.IsArgSet("-vbparams")) return;
for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
std::vector<std::string> vDeploymentParams;
boost::split(vDeploymentParams, strDeployment, boost::is_any_of(":"));
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {
throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
}
int64_t nStartTime, nTimeout;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
int min_activation_height = 0;
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
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]));
}
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
if (vDeploymentParams.size() >= 4 && !ParseInt32(vDeploymentParams[3], &min_activation_height)) {
throw std::runtime_error(strprintf("Invalid min_activation_height (%s)", vDeploymentParams[3]));
}
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
bool found = false;
for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
UpdateVersionBitsParameters(Consensus::DeploymentPos(j), nStartTime, nTimeout, min_activation_height);
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
found = true;
versionbits: Add support for delayed activation
2021-03-06 18:18:49 +10:00
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);
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
break;
}
}
if (!found) {
throw std::runtime_error(strprintf("Invalid deployment (%s)", vDeploymentParams[0]));
}
}
}
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
/**
* Custom params for testing.
*/
class CCustomParams : public CRegTestParams {
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
protected:
std::string default_magic_str = "5319F20E";
std::string default_signblockscript = "51";
Merge 3487e421a7 into merged_master (Bitcoin PR #20004)
2020-11-30 03:25:50 +00:00
void UpdateFromArgs(const ArgsManager& args)
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
{
Merge 1bf2ff2bf8 into merged_master (Bitcoin PR #16060)
2020-11-09 21:20:15 +00:00
UpdateActivationParametersFromArgs(args);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nSubsidyHalvingInterval = args.GetIntArg("-con_nsubsidyhalvinginterval", consensus.nSubsidyHalvingInterval);
consensus.BIP34Height = args.GetIntArg("-con_bip34height", 0);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
consensus.BIP34Hash = uint256S(args.GetArg("-con_bip34hash", "0x0"));
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.BIP65Height = args.GetIntArg("-con_bip65height", 0);
consensus.BIP66Height = args.GetIntArg("-con_bip66height", 0);
consensus.CSVHeight = args.GetIntArg("-con_csv_deploy_start", 1);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
consensus.powLimit = uint256S(args.GetArg("-con_powlimit", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nPowTargetTimespan = args.GetIntArg("-con_npowtargettimespan", consensus.nPowTargetTimespan);
consensus.nPowTargetSpacing = args.GetIntArg("-con_npowtargetspacing", consensus.nPowTargetSpacing);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
consensus.fPowAllowMinDifficultyBlocks = args.GetBoolArg("-con_fpowallowmindifficultyblocks", consensus.fPowAllowMinDifficultyBlocks);
consensus.fPowNoRetargeting = args.GetBoolArg("-con_fpownoretargeting", consensus.fPowNoRetargeting);
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nRuleChangeActivationThreshold = (uint32_t)args.GetIntArg("-con_nrulechangeactivationthreshold", consensus.nRuleChangeActivationThreshold);
consensus.nMinerConfirmationWindow = (uint32_t)args.GetIntArg("-con_nminerconfirmationwindow", consensus.nMinerConfirmationWindow);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
consensus.nMinimumChainWork = uint256S(args.GetArg("-con_nminimumchainwork", "0x0"));
consensus.defaultAssumeValid = uint256S(args.GetArg("-con_defaultassumevalid", "0x00"));
Create epoch length chainparam
2019-05-31 13:38:34 -04:00
// TODO: Embed in genesis block in nTime field with new genesis block type
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.dynamic_epoch_length = args.GetIntArg("-dynamic_epoch_length", consensus.dynamic_epoch_length);
Add legacy pak arg for custom chains
2019-09-25 09:10:13 -04:00
// Default junk keys for testing
Add dynafed helper functions
2019-05-31 11:19:46 -04:00
consensus.first_extension_space = {ParseHex("02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f")};
Add legacy pak arg for custom chains
2019-09-25 09:10:13 -04:00
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));
}
}
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
nPruneAfterHeight = (uint64_t)args.GetIntArg("-npruneafterheight", nPruneAfterHeight);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
fDefaultConsistencyChecks = args.GetBoolArg("-fdefaultconsistencychecks", fDefaultConsistencyChecks);
Merge 24dbcf3808 into merged_master (Bitcoin PR #15891) Disabled a test that `-acceptnonstdtxn` is disabled on mainnet, because I couldn't figure out how to make the test jig choose mainnet.
2020-11-09 21:20:06 +00:00
m_is_test_chain = args.GetBoolArg("-fmineblocksondemand", m_is_test_chain);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
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);
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
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));
Adapt Elements default adress prefix bytes to elements-0.14 style
2019-04-08 09:16:32 -04:00
parent_bech32_hrp = args.GetArg("-parent_bech32_hrp", "bcrt");
parent_blech32_hrp = args.GetArg("-parent_blech32_hrp", "bcrt");
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
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);
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
const std::string magic_str = args.GetArg("-pchmessagestart", default_magic_str);
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
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);
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart);
vSeeds.clear();
Merge 10fbb37268 into merged_master (Bitcoin PR bitcoin/bitcoin#22098)
2023-04-04 12:14:55 +02:00
vSeeds.emplace_back("dummySeed.invalid.");
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
if (args.IsArgSet("-seednode")) {
const auto seednodes = args.GetArgs("-seednode");
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
if (seednodes.size() != 1 || seednodes[0] != "0") {
vSeeds = seednodes;
}
}
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
//
// ELEMENTS fields
// Determines type of genesis block
Change stray uses of global gArgs to args in CCustomParams
2021-04-07 15:49:07 -07:00
consensus.genesis_style = args.GetArg("-con_genesis_style", "elements");
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// Block signing encumberance script, default of 51 aka OP_TRUE
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
std::vector<unsigned char> sign_bytes = ParseHex(args.GetArg("-signblockscript", default_signblockscript));
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.max_block_signature_size = args.GetIntArg("-con_max_block_sig_size", consensus.max_block_signature_size);
Change stray uses of global gArgs to args in CCustomParams
2021-04-07 15:49:07 -07:00
g_signed_blocks = args.GetBoolArg("-con_signed_blocks", true);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
Add -con_elementswitness flag and global variable
2019-01-29 12:24:13 +00:00
// Note: These globals are needed to avoid circular dependencies.
// Default to true for custom chains.
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
g_con_blockheightinheader = args.GetBoolArg("-con_blockheightinheader", true);
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
g_con_elementsmode = args.GetBoolArg("-con_elementsmode", true);
Change elements mode to activating BIP9 signaling based on height
2019-11-13 16:07:29 -05:00
consensus.elements_mode = g_con_elementsmode;
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// No subsidy for custom chains by default
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.genesis_subsidy = args.GetIntArg("-con_blocksubsidy", 0);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// 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
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.connect_genesis_outputs = args.GetIntArg("-con_connect_genesis_outputs", true);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
initialFreeCoins = args.GetIntArg("-initialfreecoins", initialFreeCoins);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
anyonecanspend_aremine = args.GetBoolArg("-anyonecanspendaremine", anyonecanspend_aremine);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
consensus.has_parent_chain = args.GetBoolArg("-con_has_parent_chain", consensus.has_parent_chain);
PAK enforcement via standardness, drop multi-op_return restriction
2018-12-17 10:58:30 -05:00
enforce_pak = args.GetBoolArg("-enforce_pak", false);
-multi_data_permitted: Allow >1 op_return output by policy
2018-12-17 12:57:18 -05:00
// Allow multiple op_return outputs by relay policy
Set default of multi_data_permitted to enforce_pak
2019-05-31 13:36:24 -04:00
multi_data_permitted = args.GetBoolArg("-multi_data_permitted", enforce_pak);
-multi_data_permitted: Allow >1 op_return output by policy
2018-12-17 12:57:18 -05:00
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// bitcoin regtest is the parent chain by default
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00:00
parentGenesisBlockHash = uint256S(args.GetArg("-parentgenesisblockhash", parentGenesisBlockHash.GetHex()));
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// 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"));
Add support for signed-blocks parent chains
2018-12-20 12:32:29 +01:00
consensus.parent_chain_signblockscript = StrHexToScriptWithDefault(args.GetArg("-con_parent_chain_signblockscript", ""), CScript());
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.pegin_min_depth = args.GetIntArg("-peginconfirmationdepth", DEFAULT_PEGIN_CONFIRMATION_DEPTH);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
const CScript default_script(CScript() << OP_TRUE);
consensus.fedpegScript = StrHexToScriptWithDefault(args.GetArg("-fedpegscript", ""), default_script);
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
Add new arguments
2019-03-19 20:02:02 +00:00
// Calculate pegged Bitcoin asset
std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
uint256 entropy;
GenerateAssetEntropy(entropy, COutPoint(uint256(commit), 0), parentGenesisBlockHash);
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.total_valid_epochs = args.GetIntArg("-total_valid_epochs", 2);
Generalize the number of epochs old a peg-in can be and still be valid
2019-08-19 15:21:30 -04:00
Add new arguments
2019-03-19 20:02:02 +00:00
// Elements serialization uses derivation, bitcoin serialization uses 0x00
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
if (g_con_elementsmode) {
Add new arguments
2019-03-19 20:02:02 +00:00
CalculateAsset(consensus.pegged_asset, entropy);
} else {
assert(consensus.pegged_asset == CAsset());
}
consensus.parent_pegged_asset.SetHex(args.GetArg("-con_parent_pegged_asset", "0x00"));
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
initial_reissuance_tokens = args.GetIntArg("-initialreissuancetokens", 0);
Add new arguments
2019-03-19 20:02:02 +00:00
// Subsidy asset, like policyAsset, defaults to the pegged_asset
consensus.subsidy_asset = consensus.pegged_asset;
Change stray uses of global gArgs to args in CCustomParams
2021-04-07 15:49:07 -07:00
if (args.IsArgSet("-subsidyasset")) {
consensus.subsidy_asset = CAsset(uint256S(args.GetArg("-subsidyasset", "0x00")));
Add new arguments
2019-03-19 20:02:02 +00:00
}
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
UpdateElementsActivationParametersFromArgs(consensus, args);
Add arguments for parent chain characteristics
2018-12-11 12:38:46 +01:00
// END ELEMENTS fields
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
}
restore bitcoin regtest gen block using -genesis_style - also regenerate test data for getblockstats
2018-12-11 10:44:05 -05:00
void SetGenesisBlock() {
if (consensus.genesis_style == "bitcoin") {
// For compatibility with bitcoin (regtest)
Set genesis block CProof to signblockscript if signed blocks active
2018-12-11 11:14:07 -05:00
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN, consensus);
restore bitcoin regtest gen block using -genesis_style - also regenerate test data for getblockstats
2018-12-11 10:44:05 -05:00
} else if (consensus.genesis_style == "elements") {
// Intended compatibility with Liquid v1 and elements-0.14.1
std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
Merge c799976c86 into merged_master (Bitcoin PR #16128)
2020-11-09 03:58:20 +00:00
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
[BROKEN] Introduce CA in data structures
2019-03-19 20:26:39 +00:00
if (initialFreeCoins != 0 || initial_reissuance_tokens != 0) {
AppendInitialIssuance(genesis, COutPoint(uint256(commit), 0), parentGenesisBlockHash, (initialFreeCoins > 0) ? 1 : 0, initialFreeCoins, (initial_reissuance_tokens > 0) ? 1 : 0, initial_reissuance_tokens, CScript() << OP_TRUE);
restore bitcoin regtest gen block using -genesis_style - also regenerate test data for getblockstats
2018-12-11 10:44:05 -05:00
}
Add unused dynamic genesis block style in chainparams
2019-05-31 13:39:28 -04: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));
restore bitcoin regtest gen block using -genesis_style - also regenerate test data for getblockstats
2018-12-11 10:44:05 -05:00
} else {
throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
}
}
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
public:
Merge 3487e421a7 into merged_master (Bitcoin PR #20004)
2020-11-30 03:25:50 +00:00
CCustomParams(const std::string& chain, const ArgsManager& args) : CRegTestParams(args)
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
{
strNetworkID = chain;
CCustomParams: Move some defaults away from UpdateFromArgs
2021-11-28 13:15:35 +00: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
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
UpdateFromArgs(args);
restore bitcoin regtest gen block using -genesis_style - also regenerate test data for getblockstats
2018-12-11 10:44:05 -05:00
SetGenesisBlock();
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
consensus.hashGenesisBlock = genesis.GetHash();
}
};
liquidtestnet: Add chainparams
2021-11-28 13:20:14 +00:00
/**
* Liquid testnet (customparams with a few defaults).
*/
class CLiquidTestNetParams : public CCustomParams {
public:
CLiquidTestNetParams(const std::string& chain, const ArgsManager& args) : CCustomParams(chain, args)
{
strNetworkID = chain;
// 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]);
// disable automatic dynafed
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = 0;
liquidtestnet: Add seed nodes
2021-12-06 17:01:32 +00:00
nDefaultPort = 18891;
vSeeds.clear();
liquidtestnet: Add fixed seeds
2022-09-08 13:46:58 +00:00
vFixedSeeds = std::vector<uint8_t>(std::begin(pnSeed6_liquidtestnet), std::end(pnSeed6_liquidtestnet));
liquidtestnet: Add seed nodes
2021-12-06 17:01:32 +00:00
liquidtestnet: Add chainparams
2021-11-28 13:20:14 +00:00
default_magic_str = "410EDD62";
default_signblockscript = "51210217e403ddb181872c32a0cd468c710040b2f53d8cac69f18dad07985ee37e9a7151ae";
UpdateFromArgs(args);
liquidtestnet: Accept multi OP_RETURN
2021-12-23 18:06:06 +00:00
multi_data_permitted = true;
liquidtestnet: Add chainparams
2021-11-28 13:20:14 +00:00
SetGenesisBlock();
consensus.hashGenesisBlock = genesis.GetHash();
liquidtestnet: Add seed nodes
2021-12-06 17:01:32 +00:00
if (!args.IsArgSet("-seednode")) {
vSeeds.emplace_back("seed.liquid-testnet.blockstream.com");
vSeeds.emplace_back("seed.liquidtestnet.com");
}
liquidtestnet: Add chainparams
2021-11-28 13:20:14 +00:00
}
};
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
/**
* Liquid v1
*/
class CLiquidV1Params : public CChainParams {
public:
CLiquidV1Params()
{
strNetworkID = "liquidv1";
consensus.nSubsidyHalvingInterval = 150;
consensus.BIP34Height = 0;
consensus.BIP34Hash = uint256();
consensus.BIP65Height = 0;
consensus.BIP66Height = 0;
Merge 1bf2ff2bf8 into merged_master (Bitcoin PR #16060)
2020-11-09 21:20:15 +00:00
consensus.CSVHeight = 0;
consensus.SegwitHeight = 0;
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
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;
fRequireStandard = true;
Merge 24dbcf3808 into merged_master (Bitcoin PR #15891) Disabled a test that `-acceptnonstdtxn` is disabled on mainnet, because I couldn't figure out how to make the test jig choose mainnet.
2020-11-09 21:20:06 +00:00
m_is_test_chain = false;
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
Fill out expected liquidv1 chain size Currently it is 1.1 GB according to my local machine. Overshooting by 3x to account for growth.
2019-11-19 10:30:40 -05:00
m_assumed_blockchain_size = 3;
m_assumed_chain_state_size = 1;
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
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 9be7fe48493 into merged_master (Bitcoin PR #21560)
2021-06-29 19:13:43 +00:00
vFixedSeeds = std::vector<uint8_t>(std::begin(pnSeed6_liquidv1), std::end(pnSeed6_liquidv1));
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
//
// 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());
HF: Simplify legacy->dynafed transition max sig size
2019-11-08 09:27:12 -05:00
// 11 signatures, 15 pubkeys, plus wiggle room
consensus.max_block_signature_size = 12*74+16*33;
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
g_signed_blocks = true;
g_con_blockheightinheader = true;
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
g_con_elementsmode = true;
Change elements mode to activating BIP9 signaling based on height
2019-11-13 16:07:29 -05:00
consensus.elements_mode = g_con_elementsmode;
Fix liquidv1 sync A single field wasn't given a positive value which meant it considers no peg-ins to be valid.
2019-09-25 21:01:55 -04:00
consensus.total_valid_epochs = 2;
Specify the dynafed epoch length for liquidv1
2021-03-11 17:34:37 +00:00
consensus.dynamic_epoch_length = 20160;
Fix liquidv1 sync A single field wasn't given a positive value which meant it considers no peg-ins to be valid.
2019-09-25 21:01:55 -04:00
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
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;
multi_data_permitted = true;
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
std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
uint256 entropy;
GenerateAssetEntropy(entropy, COutPoint(uint256(commit), 0), parentGenesisBlockHash);
// Elements serialization uses derivation, bitcoin serialization uses 0x00
Rename con_elementswitness to con_elementsmode It will have effect on more than just witness structure from now on.
2019-03-20 11:50:26 +00:00
if (g_con_elementsmode) {
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
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;
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
// Legacy PAK list
consensus.first_extension_space = {
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
ParseHex("02555f97c44ad9286ef060a02b00e8e6be2626ed3eb9230705d3ca2f977daae61e"
"03cddbc847f64f898b883d717a7f637bedf9ac2ecd243721eada223f1b1790f75b"),
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
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"),
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
ParseHex("029797b15de24dc43a6556e58159c5aa0b69ea390ccdebcd7be10751d8085da08f"
"03248e52371b2c3bce2478a3c3aaf37e4f0d6ba711e058ba407f44fdaaf280ac95"),
ParseHex("03d6a14ab496777401e2eae7992404011537860af7b46c3a8fdea65d29fe4bf26c"
"02dca82e552228f3808b1ea9b38b3342b51e9453dcb1414c551ce08bd726311e30"),
ParseHex("035c9c770ed88e29b364038d68b1c623fbf71e93e6d5357e278e9b64160984ed3c"
"02659aabb69b8413bc46026830ad1e2284901350a75c2bc97906f49cff01503f0f"),
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
ParseHex("02a8300f0cff92b23e402459e83c52ec5824de82ee4004cf9d254e788304027ef6"
"0389cbda672fa9efea51706863f1d7ae5e5015b2e519003ef0178c99f71be6e8be"),
ParseHex("03fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f"
"02b0fb4fe4670c68329441e47acaaa954ff00e3fd547b9ff4e0fe547df2e775ec5"),
ParseHex("0335f807a1bdc0906adda1a4166f9cdc2aa974a78b15fc29d79a8d7ca529a96008"
"02228dfd7ff95506dd67b1118803eb8ab49352b2e24cd5f38da043847e722009ba"),
ParseHex("03fcc2963daaf8249bfd220e52c693626254b9295ac4f947ae2e0cddb3046724c1"
"02dac03530ac9712a71eafb87766644b61cf4be85d0fdc6a859875b41e7a1dc8e6"),
ParseHex("02d67fcb027c5d8fe354fb36235192cb4fffabffdcc6ce74be255fe869f62d8675"
"03d61d857b2a8cb060fd4b9a98a862f250df5825068665a3c8d93f2ac8a7085888"),
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
ParseHex("02cddb51ea42acf38762418939be0a9227f0212ff96a870a2c1d85ec65905a7629"
"03d986a2181a38cfef5b5e2a1915aa2d37f193fcbafab9bf311d6138209f316f5b"),
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
ParseHex("029ec6dd0c310513b3720800025a7ad9013d60a7fb041f6e9b9d3963485ba28657"
"0277247f28eb9481dd21d664093a2bc19a496c7ffebeca0026a1726a5041e671ba"),
ParseHex("03f9dea372c4a667dcfe234ff8e0410c22341149ff7d8780c46954ff74998fbe44"
"0340c4e534906c06b73874cef00a880ab602641c7883de94296f0f601e6517ae7e"),
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
ParseHex("027661f1530dfc88b34b0c8f606d215f30fb0edfa116b331ff44b2fbe040893c6f"
"029d3160731eddc316121b2a31c82270baa4bbe7f08549891af3b444eb690b2df1"),
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
ParseHex("03f79461a5559f360c407069b92a8075958bf1f70918872d9dd702db145bccbd42"
"0395058fc702f126176ae13e0ebed05107288900a5a35b121f62923e58798b7b2f"),
ParseHex("02d7f049d9e87c861fc9decfbe167cb13ccc87cce99113f69e3a5dca8bb71b6aed"
"03e82197b2e9cc0ee11a59808cfdb52e824445f8fa99e44dc9c30d1e49950ff9d6"),
ParseHex("0281bfeffcc6841d1355dce039f5d64f72714a4c3adc4d351eaf3c28acbcee15f0"
"0270a16ee1cdfc78755a783efbdb66fe822605cc5f53af707e5038615e22b288e2"),
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
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"),
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
ParseHex("025651f14b6347a000e15473eaf631fd78c9307e07db85e177e31fcde0b3f2a574"
"03d5303909fe1c6665cbc96a538b17274068c8e79757705f68db3df2b561a4c110"),
ParseHex("03627a4855be1edc657927f30a4a869ad830041c1f0e74ab4670588af9532b8de8"
"03444cb85aef9fbba10b3e2662d533858db771010b57b7aedb1ecaa1c5a34918f1"),
Update hardcoded PAK list for Liquid v1
2020-07-02 13:10:12 -07:00
ParseHex("032d9af13c8d5f5316fd27a14bafb8ec55684ef2e3b5c64b2645e088f570e5d2cb"
"0239590f39508465decfd8a1bdc61b42333297e80588ed826ddd43678edfa6caae")
Correctly seed the liquidv1 paklist pre-dynafed
2019-11-05 10:39:22 -05:00
};
Add testdummy deployment for versionbits to squash warnings
2019-04-20 15:19:36 -04:00
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
add missing taproot activation params for Liquid v1
2021-09-14 20:19:32 +00:00
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
dynafed: Support changing mainnet dynafed activation This should obviously only be done by blocksigners. The flag used is not documented.
2021-02-09 13:10:04 +01:00
// Activated from block 1,000,000.
Speficy dynafed deployment for Liquidv1 Bit: 25 Start: block 1,000,000 (recent past) Timeout: never
2020-09-30 18:57:47 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].bit = 25;
dynafed: Support changing mainnet dynafed activation This should obviously only be done by blocksigners. The flag used is not documented.
2021-02-09 13:10:04 +01:00
// Allow blocksigners to delay activation.
Dynafed is already activated in liquidv1, remove start argument parsing
2021-10-29 17:02:41 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nStartTime = 1000000;
Speficy dynafed deployment for Liquidv1 Bit: 25 Start: block 1,000,000 (recent past) Timeout: never
2020-09-30 18:57:47 +02:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
Merge 2cd834e6c09 into merged_master (Bitcoin PR #21377)
2021-06-30 16:24:18 +00:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Don't activate dynafed like custom chains
2019-09-26 09:06:20 -04:00
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
// Finally, create genesis block
Merge c799976c86 into merged_master (Bitcoin PR #16128)
2020-11-09 03:58:20 +00:00
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
consensus.hashGenesisBlock = genesis.GetHash();
assert(consensus.hashGenesisBlock.GetHex() == "1466275836220db2944ca059a3a10ef6fd2ea684b0688d2c379296888a206003");
}
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
};
/**
* New: Liquid v1 testing, as close to prod as possible while still being customizable.
*/
class CLiquidV1TestParams : public CLiquidV1Params {
public:
Fix compilation errors after rebase onto master
2021-04-29 15:00:54 -07:00
explicit CLiquidV1TestParams(const ArgsManager& args)
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
{
// 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.
strNetworkID = "liquidv1test";
Fix compilation errors after rebase onto master
2021-04-29 15:00:54 -07:00
m_is_test_chain = true;
m_is_mockable_chain = false;
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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")};
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
// Don't use liquidv1's height to enable taproot
consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 0;
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
// Use all regtest rather than mainchain magic numbers:
bech32_hrp = args.GetArg("-bech32_hrp", "ert");
blech32_hrp = args.GetArg("-blech32_hrp", "el");
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
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));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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);
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart);
// END magic numbers
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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.
Fix compilation errors after rebase onto master
2021-04-29 15:00:54 -07:00
void UpdateFromArgs(const ArgsManager& args)
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
{
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nSubsidyHalvingInterval = args.GetIntArg("-con_nsubsidyhalvinginterval", consensus.nSubsidyHalvingInterval);
consensus.BIP34Height = args.GetIntArg("-con_bip34height", consensus.BIP34Height);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
if (args.IsArgSet("-con_bip34hash")) {
consensus.BIP34Hash = uint256S(args.GetArg("-con_bip34hash", ""));
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.BIP65Height = args.GetIntArg("-con_bip65height", consensus.BIP65Height);
consensus.BIP66Height = args.GetIntArg("-con_bip66height", consensus.BIP66Height);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
if (args.IsArgSet("-con_powlimit")) {
consensus.powLimit = uint256S(args.GetArg("-con_powlimit", ""));
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nPowTargetTimespan = args.GetIntArg("-con_npowtargettimespan", consensus.nPowTargetTimespan);
consensus.nPowTargetSpacing = args.GetIntArg("-con_npowtargetspacing", consensus.nPowTargetSpacing);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
consensus.fPowAllowMinDifficultyBlocks = args.GetBoolArg("-con_fpowallowmindifficultyblocks", consensus.fPowAllowMinDifficultyBlocks);
consensus.fPowNoRetargeting = args.GetBoolArg("-con_fpownoretargeting", consensus.fPowNoRetargeting);
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.nRuleChangeActivationThreshold = (uint32_t)args.GetIntArg("-con_nrulechangeactivationthreshold", consensus.nRuleChangeActivationThreshold);
consensus.nMinerConfirmationWindow = (uint32_t)args.GetIntArg("-con_nminerconfirmationwindow", consensus.nMinerConfirmationWindow);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.dynamic_epoch_length = args.GetIntArg("-dynamic_epoch_length", consensus.dynamic_epoch_length);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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));
}
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
nPruneAfterHeight = (uint64_t)args.GetIntArg("-npruneafterheight", nPruneAfterHeight);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
fDefaultConsistencyChecks = args.GetBoolArg("-fdefaultconsistencychecks", fDefaultConsistencyChecks);
Fix compilation errors after rebase onto master
2021-04-29 15:00:54 -07:00
m_is_test_chain = args.GetBoolArg("-fmineblocksondemand", m_is_test_chain);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
bech32_hrp = args.GetArg("-bech32_hrp", bech32_hrp);
blech32_hrp = args.GetArg("-blech32_hrp", blech32_hrp);
if (args.IsArgSet("-pubkeyprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-pubkeyprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
if (args.IsArgSet("-scriptprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-scriptprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
if (args.IsArgSet("-blindedprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-blindedprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
if (args.IsArgSet("-secretprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, args.GetIntArg("-secretprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
if (args.IsArgSet("-parentpubkeyprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentpubkeyprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
if (args.IsArgSet("-parentscriptprefix")) {
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetIntArg("-parentscriptprefix", 0));
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
}
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);
chainparams: change magic bytes for liquidv1test This is basically a Liquid-prod-ish version of regtest. Its default magic should not collide with that for Liquid prod.
2021-09-28 17:29:13 +00:00
const std::string magic_str = args.GetArg("-pchmessagestart", "143EFCB1");
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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);
std::copy(begin(magic_byte), end(magic_byte), pchMessageStart);
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());
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.max_block_signature_size = args.GetIntArg("-con_max_block_sig_size", consensus.max_block_signature_size);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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;
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.genesis_subsidy = args.GetIntArg("-con_blocksubsidy", consensus.genesis_subsidy);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
// 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
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.connect_genesis_outputs = args.GetIntArg("-con_connect_genesis_outputs", consensus.connect_genesis_outputs);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
initialFreeCoins = args.GetIntArg("-initialfreecoins", initialFreeCoins);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
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);
multi_data_permitted = args.GetBoolArg("-multi_data_permitted", multi_data_permitted);
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());
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.pegin_min_depth = args.GetIntArg("-peginconfirmationdepth", consensus.pegin_min_depth);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
if (args.IsArgSet("-fedpegscript")) {
consensus.fedpegScript = StrHexToScriptWithDefault(args.GetArg("-fedpegscript", ""), CScript());
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
consensus.total_valid_epochs = args.GetIntArg("-total_valid_epochs", consensus.total_valid_epochs);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
// Calculate pegged Bitcoin asset
std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
uint256 entropy;
GenerateAssetEntropy(entropy, COutPoint(uint256(commit), 0), parentGenesisBlockHash);
CalculateAsset(consensus.pegged_asset, entropy);
if (args.IsArgSet("-con_parent_pegged_asset")) {
consensus.parent_pegged_asset.SetHex(args.GetArg("-con_parent_pegged_asset", ""));
}
elements: fixes for bitcoin/bitcoin#22976
2023-04-24 12:05:24 +00:00
initial_reissuance_tokens = args.GetIntArg("-initialreissuancetokens", initial_reissuance_tokens);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
if (args.IsArgSet("-subsidyasset")) {
consensus.subsidy_asset = CAsset(uint256S(args.GetArg("-subsidyasset", "")));
}
Deprecate con_dyna_deploy_start in favor of evbparams
2021-10-29 17:23:07 +00:00
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;
Merge 586e5c7dd7 into merged_master (Elements PR ElementsProject/elements#1062)
2022-04-20 21:51:53 -07:00
consensus.vDeployments[Consensus::DEPLOYMENT_DYNA_FED].min_activation_height = 0; // No activation delay
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
Implement vbparams for Elements (evbparams)
2021-10-28 11:26:53 +00:00
UpdateElementsActivationParametersFromArgs(consensus, args);
chainparams: add undocumented regtest/testnet only -con_taproot_signal_start option
2021-09-15 18:41:36 +00:00
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
// 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
std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
Fix compilation errors after rebase onto master
2021-04-29 15:00:54 -07:00
genesis = CreateGenesisBlock(consensus, CScript() << commit, CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
if (initialFreeCoins != 0 || initial_reissuance_tokens != 0) {
AppendInitialIssuance(genesis, COutPoint(uint256(commit), 0), parentGenesisBlockHash, (initialFreeCoins > 0) ? 1 : 0, initialFreeCoins, (initial_reissuance_tokens > 0) ? 1 : 0, initial_reissuance_tokens, CScript() << OP_TRUE);
}
} 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));
}
}
Add liquidv1 chainparams
2019-03-15 12:18:18 -04:00
};
Don't edit Chainparams after initialization
2018-06-16 22:38:13 +02:00
static std::unique_ptr<const CChainParams> globalChainParams;
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
const CChainParams &Params() {
Chainparams: Use a regular factory for creating chainparams
2015-05-22 03:50:01 +02:00
assert(globalChainParams);
return *globalChainParams;
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
}
Remove gArgs global from CreateChainParams to aid testing
2020-09-24 15:11:27 +02:00
std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, const std::string& chain)
Chainparams: Replace CBaseChainParams::Network enum with string constants (suggested by Wladimir)
2015-06-30 21:39:49 +02:00
{
Testchains: Introduce custom chain whose constructor... ...reads params from regular arguments
2016-10-21 19:15:26 +02:00
// Reserved names for non-custom chains
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
if (chain == CBaseChainParams::MAIN) {
Chainparams: Use a regular factory for creating chainparams
2015-05-22 03:50:01 +02:00
return std::unique_ptr<CChainParams>(new CMainParams());
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
} else if (chain == CBaseChainParams::TESTNET) {
Chainparams: Use a regular factory for creating chainparams
2015-05-22 03:50:01 +02:00
return std::unique_ptr<CChainParams>(new CTestNetParams());
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
} else if (chain == CBaseChainParams::SIGNET) {
Remove gArgs global from CreateChainParams to aid testing
2020-09-24 15:11:27 +02:00
return std::unique_ptr<CChainParams>(new SigNetParams(args));
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
} else if (chain == CBaseChainParams::REGTEST) {
Remove gArgs global from CreateChainParams to aid testing
2020-09-24 15:11:27 +02:00
return std::unique_ptr<CChainParams>(new CRegTestParams(args));
Merge 8c5f68118c into merged_master (Bitcoin PR #18267) This commit adds signet support, which is a little bit silly/redundant for us :) Was a surprisingly easy merge to handle, and hopefully in future Core is more mindful of signed blocks when they are changing code architecture. I had to change a couple lines of src/signet.cpp to add blank assets to the CTxOuts and to find transaction input scriptWitnesses. No need to add any other tx witness data (and the CAsset()s that I did add to make things compile won't be used..) because signet will always have g_con_elementsmode off.
2020-11-29 16:57:55 +00:00
} else if (chain == CBaseChainParams::LIQUID1) {
Whitespace and tab linting
2019-03-20 11:15:45 -04:00
return std::unique_ptr<CChainParams>(new CLiquidV1Params());
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
} else if (chain == CBaseChainParams::LIQUID1TEST) {
return std::unique_ptr<CChainParams>(new CLiquidV1TestParams(args));
liquidtestnet: Add chainparams
2021-11-28 13:20:14 +00:00
} else if (chain == CBaseChainParams::LIQUIDTESTNET) {
return std::unique_ptr<CChainParams>(new CLiquidTestNetParams(chain, args));
add signet chain and accompanying parameters Co-authored-by: Anthony Towns <aj@erisian.com.au>
2020-03-05 15:58:30 +09:00
}
Add liquidv1test chainparams.
2021-04-07 15:52:57 -07:00
Merge 3487e421a7 into merged_master (Bitcoin PR #20004)
2020-11-30 03:25:50 +00:00
return std::unique_ptr<CChainParams>(new CCustomParams(chain, args));
Chainparams: Use a regular factory for creating chainparams
2015-05-22 03:50:01 +02:00
}
Chainparams: Replace CBaseChainParams::Network enum with string constants (suggested by Wladimir)
2015-06-30 21:39:49 +02:00
void SelectParams(const std::string& network)
{
Broken addresses on command line no longer trigger testnet. When passing a bitcoin: URI on the command line, invalid addresses do not incorrectly send the user to the test network.
2014-08-02 19:54:57 +01:00
SelectBaseParams(network);
Remove gArgs global from CreateChainParams to aid testing
2020-09-24 15:11:27 +02:00
globalChainParams = CreateChainParams(gArgs, network);
Broken addresses on command line no longer trigger testnet. When passing a bitcoin: URI on the command line, invalid addresses do not incorrectly send the user to the test network.
2014-08-02 19:54:57 +01:00
}
Reference in a new issue Copy permalink