Compare commits

...
Author SHA1 Message Date
e82f3bf2b7 docs: update README for Vexta Core v0.3.1
Some checks are pending
Vexta CI / Ubuntu build smoke test (push) Waiting to run
2026-11-16 18:36:14 +00:00
997aaf5716 Vexta Core v0.3.1 release
Some checks failed
Vexta CI / Ubuntu build smoke test (push) Has been cancelled
2026-11-15 20:44:09 +00:00
VextaProject
9db541e445 Docs: update VextaHub links and RandomX status
Some checks failed
Vexta CI / Ubuntu build smoke test (push) Has been cancelled
2026-10-26 09:41:41 +00:00
b052e6e0da
Fix Vexta subsidy halving interval
Some checks failed
Vexta CI / Ubuntu build smoke test (push) Has been cancelled
2026-09-19 00:09:55 +00:00
29 changed files with 606 additions and 160 deletions

126
README.md
View file

@ -2,13 +2,31 @@
Vexta Core is the reference implementation of the Vexta blockchain.
Vexta is an open-source, UTXO-based proof-of-work cryptocurrency built on the Bitcoin Core architecture. Vexta uses a multi-algorithm proof-of-work system combining **SHA256D** and **RandomX** on a single blockchain.
Vexta is an open-source, UTXO-based proof-of-work cryptocurrency built on the Bitcoin Core architecture. Vexta uses a **multi-algorithm proof-of-work system combining SHA256D and RandomX on a single blockchain**.
## Vexta Core v0.3.0
## Vexta Core v0.3.1
Vexta Core v0.3.0 introduces Vexta's multi-algorithm mining architecture.
**Vexta Core v0.3.1** is the current stable release.
RandomX activates on mainnet at **block 8,099**. SHA256D remains fully supported, with both algorithms sharing the same blockchain, transactions, addresses, block rewards, and consensus history.
This release focuses on node stability, synchronization reliability, and improvements to the multi-algorithm implementation while preserving compatibility with the existing Vexta mainnet.
Vexta Core supports both SHA256D and RandomX mining, with both algorithms contributing blocks to the same blockchain.
### Release Highlights
- Continued support for SHA256D and RandomX mining.
- Node stability and synchronization improvements.
- Maintenance and reliability improvements for the multi-algorithm implementation.
- Continued compatibility with the existing Vexta blockchain.
- Windows and Linux builds available through the official release page.
**Node operators and wallet users are encouraged to use the latest stable release.**
### Multi-Algorithm Architecture
Vexta Core v0.3.0 introduced Vexta's multi-algorithm mining architecture.
RandomX activated on mainnet at **block 8,099**. SHA256D remains fully supported, with both algorithms sharing the same blockchain, transactions, addresses, block rewards, and consensus history.
Each mining algorithm maintains its own difficulty while contributing normalized chainwork to the same chain.
@ -17,24 +35,25 @@ Each mining algorithm maintains its own difficulty while contributing normalized
| Algorithm | Type | Status |
|---|---|---|
| SHA256D | ASIC-oriented proof of work | Active |
| RandomX | CPU-oriented proof of work | Activates at block 8,099 |
| RandomX | CPU-oriented proof of work | Active since block 8,099 |
The network targets an average **10-minute global block interval** across both algorithms.
## Download
Official Windows and Linux builds are published on the GitHub Releases page:
Official Windows and Linux builds are published on VextaHub:
https://github.com/VextaProject/Vexta/releases
**[Download Vexta Core — Official Releases](https://vextaproject.org/vextahub/VextaProject/Vexta/releases)**
Vexta Core v0.3.0 release packages:
- `vexta-v0.3.0-linux64.tar.gz`
- `vexta-v0.3.0-linux64-gui.tar.gz`
- `vexta-v0.3.0-win64.zip`
Select the latest stable release, **Vexta Core v0.3.1**, and download the appropriate package for your operating system.
Always verify downloaded release files against the SHA-256 checksums published with the release.
### Additional Official Software
- [Vexta CPU Miner](https://vextaproject.org/vextahub/VextaProject/Vexta-CPU-Miner)
- [Vexta Android Wallet](https://vextaproject.org/vextahub/VextaProject/Vexta-Android-Wallet)
## Included Programs
| Program | Description |
@ -55,7 +74,7 @@ Always verify downloaded release files against the SHA-256 checksums published w
- **RandomX mainnet activation:** Block 8,099
- **Target block time:** 10 minutes globally
- **Initial block reward:** 50 VTX
- **Subsidy halving interval:** 210,240 blocks
- **Subsidy halving interval:** 210,000 blocks
- **SegWit:** Enabled
- **Taproot:** Enabled
- **URI scheme:** `vexta:`
@ -68,27 +87,39 @@ Vexta uses two independent proof-of-work algorithms on one blockchain.
SHA256D and RandomX blocks:
- share the same chain
- use the same transaction set and address system
- receive the same block subsidy rules
- maintain separate per-algorithm mining difficulty
- contribute normalized proof of work to the common chain
- Share the same blockchain and consensus history.
- Use the same transaction set and address system.
- Follow the same block subsidy rules.
- Maintain separate per-algorithm mining difficulty.
- Contribute normalized proof of work to the common chain.
This allows different classes of mining hardware to participate without separating Vexta into independent chains.
Both algorithms are supported by Vexta Core v0.3.1.
## RandomX
RandomX is integrated as Vexta's second proof-of-work algorithm.
The implementation uses algorithm-aware block validation, independent RandomX difficulty tracking, deterministic RandomX seed selection, and normalized chainwork accounting.
The implementation uses:
Mainnet RandomX activation occurs at block **8,099**.
- Algorithm-aware block validation.
- Independent RandomX difficulty tracking.
- Deterministic RandomX seed selection.
- Normalized chainwork accounting.
- Shared blockchain consensus with SHA256D.
RandomX has been active on mainnet since **block 8,099**.
SHA256D remains fully supported alongside RandomX.
## Difficulty Adjustment
Vexta uses algorithm-aware difficulty handling so SHA256D and RandomX can respond independently to changes in mining power while remaining part of the same chain.
Vexta uses algorithm-aware difficulty handling so SHA256D and RandomX can respond independently to changes in mining power while remaining part of the same blockchain.
The network continues to target an average global block interval of approximately 10 minutes.
Each algorithm maintains its own mining difficulty.
The network continues to target an average global block interval of approximately **10 minutes**.
## Post-Quantum Development
@ -112,15 +143,17 @@ https://vextaproject.org/whitepaper.pdf
Official Vexta mining pool:
https://vexta-pool.co.uk
**[Vexta-pool](https://vexta-pool.co.uk)**
Vexta-pool supports both SHA256D and RandomX mining with PPLNS and SOLO payout modes.
## Community
Discord:
**Discord:**
https://discord.gg/zzpm7ghN3e
Official website:
**Official website:**
https://vextaproject.org
@ -130,9 +163,9 @@ Vexta Core uses its own data directory and configuration.
The default configuration filename is:
```text
vexta.conf
```
`vexta.conf`
When upgrading an existing installation, preserve your wallet files and configuration and follow the instructions provided with the official release.
## Building from Source
@ -148,27 +181,44 @@ make -j"$(nproc)"
Project dependencies can also be built using the included `depends` system.
Vexta Core v0.3.0 additionally requires RandomX when building the multi-algorithm implementation.
The multi-algorithm implementation requires RandomX build dependencies.
Refer to the build instructions and the requirements for your operating system before compiling Vexta Core v0.3.1.
## Testing
Unit tests can be built and run using the project test targets.
The Vexta v0.3.0 release was validated with targeted proof-of-work, blockchain, RandomX, multi-algorithm chainwork, difficulty, and block-validation tests.
Development and validation of Vexta Core's multi-algorithm implementation include targeted testing of:
- SHA256D proof-of-work validation.
- RandomX proof-of-work validation.
- Multi-algorithm chainwork accounting.
- Independent difficulty adjustment.
- Blockchain and block validation.
- Node synchronization and compatibility.
Functional tests are located in:
```text
test/functional
```
`test/functional`
Release-specific changes and testing information should be reviewed alongside the corresponding release.
## Source Code
Official repository:
**Official repository (VextaHub):**
https://github.com/VextaProject/Vexta
https://vextaproject.org/vextahub/VextaProject/Vexta
Release workflow documentation:
**GitLab source mirror:**
https://gitlab.com/vextaproject1/Vexta
**Official releases:**
https://vextaproject.org/vextahub/VextaProject/Vexta/releases
**Release workflow documentation:**
[RELEASE_WORKFLOW.md](RELEASE_WORKFLOW.md)
@ -180,8 +230,10 @@ Changes should prioritize security, stability, compatibility, maintainability, a
Consensus changes should be reviewed especially carefully because they can affect compatibility with the live Vexta network.
Contributors should test their changes before submitting them for review.
## License
Vexta Core is released under the MIT License. See [COPYING](COPYING) for details.
Vexta Core is derived from DigiByte Core and retains the applicable historical copyright and license notices.
Vexta Core is derived from DigiByte Core and retains the applicable historical copyright and license notices.

View file

@ -20,11 +20,15 @@ It is used for development, testing, consensus work, and release builds.
~/vexta-public
```
This repository contains the public Vexta source tree and is the **only repository allowed to push to GitHub**.
This repository contains the public Vexta source tree used to prepare releases. VextaHub is the primary public repository, and GitLab is a secondary source-code mirror.
Official GitHub repository:
Official VextaHub repository:
https://github.com/VextaProject/Vexta
https://vextaproject.org/vextahub/VextaProject/Vexta
GitLab mirror:
https://gitlab.com/vextaproject1/Vexta
## Release Process
@ -73,9 +77,9 @@ vexta-v0.3.0
10. Verify that the release tag points to the intended release commit.
11. Push the release branch and Vexta release tag to GitHub **only from `~/vexta-public`**.
11. Push verified public release commits and tags to VextaHub from the approved public release repository, then synchronize them to the GitLab mirror.
12. Create the GitHub Release.
12. Create the official VextaHub Release.
13. Attach the official release archives and publish their SHA-256 checksums.

View file

@ -1,13 +1,13 @@
AC_PREREQ([2.69])
define(_CLIENT_VERSION_MAJOR, 0)
define(_CLIENT_VERSION_MINOR, 3)
define(_CLIENT_VERSION_BUILD, 0)
define(_CLIENT_VERSION_BUILD, 1)
define(_CLIENT_VERSION_RC, 1)
define(_CLIENT_VERSION_IS_RELEASE, true)
define(_COPYRIGHT_YEAR, 2026)
define(_COPYRIGHT_HOLDERS,[The %s developers])
define(_COPYRIGHT_HOLDERS_SUBSTITUTION,[[Vexta Core]])
AC_INIT([Vexta Core],m4_join([.], _CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MINOR, _CLIENT_VERSION_BUILD),[https://github.com/VextaProject/vexta/issues],[vexta],[https://vextaproject.org/])
AC_INIT([Vexta Core],m4_join([.], _CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MINOR, _CLIENT_VERSION_BUILD),[https://vextaproject.org/vextahub/VextaProject/Vexta/issues],[vexta],[https://vextaproject.org/])
AC_CONFIG_SRCDIR([src/validation.cpp])
AC_CONFIG_HEADERS([src/config/vexta-config.h])
AC_CONFIG_AUX_DIR([build-aux])

View file

@ -124,7 +124,7 @@ Copyright (C) 2009-2018 The Vexta Core developers
Please contribute if you find Vexta Core useful. Visit
<https://vexta.org> for further information about the software.
The source code is available from <https://github.com/vexta/vexta>.
The source code is available from <https://vextaproject.org/vextahub/VextaProject/Vexta>.
This is experimental software.
Distributed under the MIT software license, see the accompanying file COPYING

View file

@ -608,7 +608,7 @@ Copyright (C) 2009-2018 The DigiByte Core developers
Please contribute if you find DigiByte Core useful. Visit
<https://vexta-pool.co.uk> for further information about the software.
The source code is available from <https://github.com/Vexta-Core/vexta>.
The source code is available from <https://vextaproject.org/vextahub/VextaProject/Vexta>.
This is experimental software.
Distributed under the MIT software license, see the accompanying file COPYING

View file

@ -109,7 +109,7 @@ Copyright (C) 2009-2018 The Vexta Core developers
Please contribute if you find Vexta Core useful. Visit
<https://vexta.org> for further information about the software.
The source code is available from <https://github.com/vexta/vexta>.
The source code is available from <https://vextaproject.org/vextahub/VextaProject/Vexta>.
This is experimental software.
Distributed under the MIT software license, see the accompanying file COPYING

View file

@ -585,7 +585,7 @@ Copyright (C) 2009-2018 The Vexta Core developers
Please contribute if you find Vexta Core useful. Visit
<https://vexta.org> for further information about the software.
The source code is available from <https://github.com/vexta/vexta>.
The source code is available from <https://vextaproject.org/vextahub/VextaProject/Vexta>.
This is experimental software.
Distributed under the MIT software license, see the accompanying file COPYING

View file

@ -9,17 +9,42 @@ struct VextaRandomXHasher::Impl
Impl(const void* key, std::size_t key_size)
{
cache = randomx_alloc_cache(RANDOMX_FLAG_DEFAULT);
// JIT is an execution optimization, not a consensus rule.
// Use the portable interpreter if JIT is unavailable.
randomx_flags flags = RANDOMX_FLAG_DEFAULT;
if (randomx_get_flags() & RANDOMX_FLAG_JIT) {
flags = RANDOMX_FLAG_JIT;
}
cache = randomx_alloc_cache(flags);
if (cache == nullptr && flags == RANDOMX_FLAG_JIT) {
flags = RANDOMX_FLAG_DEFAULT;
cache = randomx_alloc_cache(flags);
}
if (cache == nullptr) {
return;
}
randomx_init_cache(cache, key, key_size);
vm = randomx_create_vm(
RANDOMX_FLAG_DEFAULT,
cache,
nullptr);
vm = randomx_create_vm(flags, cache, nullptr);
if (vm == nullptr && flags == RANDOMX_FLAG_JIT) {
// Reinitialize a portable cache before fallback.
randomx_release_cache(cache);
flags = RANDOMX_FLAG_DEFAULT;
cache = randomx_alloc_cache(flags);
if (cache == nullptr) {
return;
}
randomx_init_cache(cache, key, key_size);
vm = randomx_create_vm(flags, cache, nullptr);
}
if (vm == nullptr) {
randomx_release_cache(cache);

View file

@ -31,8 +31,8 @@ private:
/**
* Calculate a RandomX hash using an explicit key.
*
* This wrapper intentionally uses RANDOMX_FLAG_DEFAULT so consensus hashing
* does not depend on CPU-specific runtime feature detection.
* JIT may accelerate execution when supported, with an interpreted fallback.
* All execution modes must produce identical consensus hashes.
*
* Returns false if RandomX cache or VM allocation fails.
*/

View file

@ -571,7 +571,7 @@ void SetupServerArgs(ArgsManager& argsman)
std::string LicenseInfo()
{
const std::string URL_SOURCE_CODE = "<https://github.com/VextaProject/vexta>";
const std::string URL_SOURCE_CODE = "<https://vextaproject.org/vextahub/VextaProject/Vexta>";
return CopyrightHolders(strprintf(_("Copyright (C) %i").translated, COPYRIGHT_YEAR) + " ") + "\n" +
"\n" +

View file

@ -3018,7 +3018,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
LogPrint(BCLog::NET, "got inv: %s %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId());
if ((!m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
m_connman.isDandelionInbound(&pfrom)) || inv.hash != DANDELION_DISCOVERYHASH) {
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETDATA, inv));
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETDATA, std::vector<CInv>{inv}));
}
} else if (inv.IsMsgBlk()) {
const bool fAlreadyHave = AlreadyHaveBlock(inv.hash);
@ -3057,7 +3057,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
LogPrint(BCLog::NET, "got inv: %s %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId());
if ((!fAlreadyHave && !m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
m_connman.isDandelionInbound(&pfrom)) || (inv.hash == DANDELION_DISCOVERYHASH)) {
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETDATA, inv));
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETDATA, std::vector<CInv>{inv}));
}
} else {
LogPrint(BCLog::NET, "Unknown inv type \"%s\" received from peer=%d\n", inv.ToString(), pfrom.GetId());

View file

@ -388,7 +388,13 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
}
} else if (block.GetAlgo() != ALGO_RANDOMX) {
return error("ReadBlockFromDisk: Unknown proof-of-work algorithm at %s", pos.ToString());
// Historical SHA256D blocks may contain version-rolling bits
// that predate the multi-algo encoding. Verify their SHA256D
// PoW here; height-dependent acceptance is checked elsewhere.
if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) {
return error("ReadBlockFromDisk: Historical SHA256D proof of work failed at %s",
pos.ToString());
}
}
// Signet only: check block solution
@ -411,7 +417,24 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus
pindex->ToString(), block_pos.ToString());
}
if (block.GetHash() != consensusParams.hashGenesisBlock &&
// Preserve SHA256D proof-of-work for every pre-activation block,
// including historical versions with RandomX algorithm bits.
if (pindex->nHeight < consensusParams.randomXActivationHeight &&
block.GetHash() != consensusParams.hashGenesisBlock &&
block.GetAlgo() == ALGO_RANDOMX &&
!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) {
return error("ReadBlockFromDisk: Historical SHA256D proof of work failed");
}
// Reject unknown algorithm encodings after multi-algo activation.
if (pindex->nHeight >= consensusParams.randomXActivationHeight &&
block.GetAlgo() != ALGO_SHA256D &&
block.GetAlgo() != ALGO_RANDOMX) {
return error("ReadBlockFromDisk: Unknown post-activation proof-of-work algorithm");
}
if (pindex->nHeight >= consensusParams.randomXActivationHeight &&
block.GetHash() != consensusParams.hashGenesisBlock &&
block.GetAlgo() == ALGO_RANDOMX) {
if (pindex->pprev == nullptr) {
return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): RandomX block has no previous block index for %s at %s",

View file

@ -12,7 +12,7 @@
#include <string>
const std::string CURRENCY_UNIT = "DGB"; // One formatted unit
const std::string CURRENCY_UNIT = "VTX"; // One formatted unit
const std::string CURRENCY_ATOM = "sat"; // One indivisible minimum value unit
/* Used to determine type of fee estimation requested */

View file

@ -5,6 +5,7 @@
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <primitives/block.h>
#include <memory>
#include <crypto/randomx_hash.h>
#include <crypto/common.h>
#include <consensus/consensus.h>
@ -34,13 +35,24 @@ int CBlockHeader::GetAlgo() const
bool CBlockHeader::GetRandomXPoWHash(const uint256& seed, uint256& result) const
{
VextaRandomXHasher hasher(seed.data(), seed.size());
// Keep an independent RandomX VM per thread and reuse its initialized
// cache while the deterministic epoch seed remains unchanged.
static thread_local uint256 cached_seed;
static thread_local std::unique_ptr<VextaRandomXHasher> cached_hasher;
if (!hasher.IsValid()) {
return false;
if (!cached_hasher || cached_seed != seed) {
auto replacement = std::make_unique<VextaRandomXHasher>(
seed.data(), seed.size());
if (!replacement->IsValid()) {
return false;
}
cached_hasher = std::move(replacement);
cached_seed = seed;
}
return GetRandomXPoWHash(hasher, result);
return GetRandomXPoWHash(*cached_hasher, result);
}
bool CBlockHeader::GetRandomXPoWHash(

View file

@ -137,6 +137,20 @@ double GetDifficulty(const CBlockIndex* blockindex)
return dDiff;
}
int GetRPCBlockAlgo(
const CBlockIndex* blockindex,
const Consensus::Params& consensusParams)
{
assert(blockindex != nullptr);
// Before RandomX activation every block used SHA256D consensus,
// regardless of historical version-rolling bits.
if (blockindex->nHeight < consensusParams.randomXActivationHeight)
return ALGO_SHA256D;
return blockindex->GetBlockHeader().GetAlgo();
}
double GetAlgoDifficulty(
const CBlockIndex* blockindex,
const Consensus::Params& consensusParams,
@ -234,16 +248,18 @@ UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex
result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
result.pushKV("nonce", (uint64_t)blockindex->nNonce);
result.pushKV("bits", strprintf("%08x", blockindex->nBits));
result.pushKV("difficulty", GetDifficulty(blockindex));
result.pushKV("chainwork", blockindex->nChainWork.GetHex());
result.pushKV("nTx", (uint64_t)blockindex->nTx);
const Consensus::Params& consensusParams = Params().GetConsensus();
const CBlockHeader block = blockindex->GetBlockHeader();
const int algo =
blockindex->GetBlockHash() == consensusParams.hashGenesisBlock
? ALGO_SHA256D
: block.GetAlgo();
// Historical blocks before RandomX activation always used SHA256D,
// regardless of version-rolling bits in their block headers.
const int algo = GetRPCBlockAlgo(blockindex, consensusParams);
result.pushKV(
"difficulty",
GetAlgoDifficulty(blockindex, consensusParams, algo));
result.pushKV("pow_algo_id", algo);

View file

@ -46,6 +46,14 @@ double GetDifficulty(const CBlockIndex* blockindex);
* SHA256D preserves the legacy GetDifficulty() scale.
* RandomX uses randomXInitialTarget as difficulty 1.0.
*/
/**
* Determine the PoW algorithm for RPC block statistics.
* Historical blocks always used SHA256D before RandomX activation.
*/
int GetRPCBlockAlgo(
const CBlockIndex* blockindex,
const Consensus::Params& consensusParams);
double GetAlgoDifficulty(
const CBlockIndex* blockindex,
const Consensus::Params& consensusParams,

View file

@ -704,17 +704,17 @@ static RPCHelpMan getmininginfo()
UniValue networkhashesps(UniValue::VOBJ);
networkhashesps.pushKV(
GetMiningAlgoName(ALGO_SHA256D),
GetNetworkHashPS(120, -1, active_chain, ALGO_SHA256D));
GetNetworkHashPS(-1, -1, active_chain, ALGO_SHA256D));
if (tip->nHeight + 1 >= consensusParams.randomXActivationHeight) {
networkhashesps.pushKV(
GetMiningAlgoName(ALGO_RANDOMX),
GetNetworkHashPS(120, -1, active_chain, ALGO_RANDOMX));
GetNetworkHashPS(-1, -1, active_chain, ALGO_RANDOMX));
}
obj.pushKV(
"networkhashps",
GetNetworkHashPS(120, -1, active_chain, ALGO_SHA256D));
GetNetworkHashPS(-1, -1, active_chain, ALGO_SHA256D));
obj.pushKV("networkhashesps", networkhashesps);
obj.pushKV("pooledtx", (uint64_t)mempool.size());
obj.pushKV("chain", Params().NetworkIDString());

View file

@ -107,4 +107,45 @@ BOOST_AUTO_TEST_CASE(get_algo_difficulty)
2.0);
}
BOOST_AUTO_TEST_CASE(historical_rpc_algo_classification)
{
const auto chainParams =
CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
const auto& consensus = chainParams->GetConsensus();
BOOST_REQUIRE_EQUAL(consensus.randomXActivationHeight, 8099);
CBlockIndex block;
block.nVersion = 0x7fffffff;
block.nHeight = 5150;
// Historical version-rolling bits do not select a mining algorithm.
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_SHA256D);
block.nHeight = 8098;
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_SHA256D);
// From activation onward, use the explicit algorithm version bits.
block.nHeight = 8099;
block.nVersion = BLOCK_VERSION_DEFAULT | BLOCK_VERSION_SHA256D;
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_SHA256D);
block.nVersion = BLOCK_VERSION_DEFAULT | BLOCK_VERSION_RANDOMX;
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_RANDOMX);
block.nHeight = 9000;
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_RANDOMX);
// Unknown algorithm encoding must remain unknown after activation.
block.nVersion = 0x7fffffff;
BOOST_CHECK_EQUAL(
GetRPCBlockAlgo(&block, consensus), ALGO_UNKNOWN);
}
BOOST_AUTO_TEST_SUITE_END()

View file

@ -76,8 +76,13 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
{
std::string strSecret = std::string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");
CKey key = DecodeSecret(strSecret);
// Original Bitcoin WIF test vector, decoded to its 32-byte secret.
// Avoid Bitcoin-specific WIF prefixes in Vexta's Bloom filter test.
const auto secret = ParseHex(
"f49addfd726a59abde172c86452f5f73038a02f4415878dc14934175e8418aff");
CKey key;
key.Set(secret.begin(), secret.end(), false);
BOOST_REQUIRE(key.IsValid());
CPubKey pubkey = key.GetPubKey();
std::vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());

File diff suppressed because one or more lines are too long

View file

@ -17,14 +17,14 @@
#include <vector>
#include <boost/test/unit_test.hpp>
static const std::string strSecret1 = "5HwoXVkHoRM8sL2KmNRS217n1g8mPPBomrY7yehCuXC1115WWsh";
static const std::string strSecret2 = "5J5KUK3VXP8HUefNVYPxwxVRokScZdWXpu1Tj8LfaAXMqHzMmbk";
static const std::string strSecret1C = "KwntMbt59tTsj8xqpqYqRRWufyjGunvhSyeMo3NTYpFYzZbXJ5Hp";
static const std::string strSecret2C = "KxN4XYdzu6f9j3EMryaMwZvUVLk3y29M4QZ2xwPoFP2zwka1aWxU";
static const std::string addr1 = "DS1P3gwq6MFtatWprr2e2J32xGPd89n75C";
static const std::string addr2 = "DMQ3t1L7BmTwL5wpZ9mek1KUaCRLJSXJWV";
static const std::string addr1C = "DU9umLs2Ze8eNRo69wbSj5HeufphJawFPh";
static const std::string addr2C = "DCiLe5VAcdLpGXURTDsaoryMWdMVBP9NoN";
static const std::string strSecret1 = "7e1usjAXTCgzJkhhDwsNnT5z7fF2tgB6rbVf48qxVPf9YXTaAs1";
static const std::string strSecret2 = "7e9RpYTjBAU8v5Ljx7quiQTdujYt4vVpudxzocVRA2zWNpHPvsU";
static const std::string strSecret1C = "WJP2Nu73QebVwMtcY9BM9c916PnwM5uaquFUxqd5vK1NhjXYRYaH";
static const std::string strSecret2C = "WJxCYqry9rnmwGA8aHCsfkYZukoiQK8ETLAA8jeRcsnpevTtrSCQ";
static const std::string addr1 = "VXXWS2sMVZnwJE6HqdMPRJvW8ShMT9xKWi";
static const std::string addr2 = "VSvBGMFdayzz3RXHXw6Q92CwkNj4he22C5";
static const std::string addr1C = "VZg39gnYxrfh5mNZ8ivC86B85r8Ron95sz";
static const std::string addr2C = "VJEU2RQh1qsrys3tS1CLCsrpgofDdvYt1Q";
static const std::string strAddressBad = "1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF";

View file

@ -1,3 +1,6 @@
#include <crypto/randomx_hash.h>
#include <thread>
#include <array>
// Copyright (c) 2009-2020 The Bitcoin Core developers
// Copyright (c) 2014-2020 The DigiByte Core developers
// Distributed under the MIT/X11 software license, see the accompanying
@ -1259,4 +1262,72 @@ BOOST_AUTO_TEST_CASE(RandomX_header_hash_vector_test)
"3c658cf690b31329ec4d1621bd579bc932ebfc7a02b26674184512be64ce94a6");
}
BOOST_AUTO_TEST_CASE(RandomX_cache_reuse_test)
{
CBlockHeader header;
header.nVersion = BLOCK_VERSION_DEFAULT | BLOCK_VERSION_RANDOMX;
header.nTime = 1783641600;
header.nBits = 0x1d00ffff;
header.nNonce = 12345;
const uint256 seedA = uint256S(
"00112233445566778899aabbccddeeff102132435465768798a9bacbdcedfe0f");
const uint256 seedB = uint256S(
"ffeeddccbbaa998877665544332211000123456789abcdef0123456789abcdef");
auto independentHash = [&](const uint256& seed, uint256& result) {
VextaRandomXHasher fresh(seed.data(), seed.size());
return fresh.IsValid() && header.GetRandomXPoWHash(fresh, result);
};
uint256 expectedA;
uint256 expectedB;
BOOST_REQUIRE(independentHash(seedA, expectedA));
BOOST_REQUIRE(independentHash(seedB, expectedB));
BOOST_CHECK(expectedA != expectedB);
uint256 actual;
BOOST_REQUIRE(header.GetRandomXPoWHash(seedA, actual));
BOOST_CHECK(actual == expectedA);
BOOST_REQUIRE(header.GetRandomXPoWHash(seedA, actual));
BOOST_CHECK(actual == expectedA);
BOOST_REQUIRE(header.GetRandomXPoWHash(seedB, actual));
BOOST_CHECK(actual == expectedB);
BOOST_REQUIRE(header.GetRandomXPoWHash(seedA, actual));
BOOST_CHECK(actual == expectedA);
// Each worker has its own thread-local cache and VM.
constexpr size_t workerCount = 4;
std::array<bool, workerCount> passed{};
std::vector<std::thread> workers;
for (size_t i = 0; i < workerCount; ++i) {
workers.emplace_back([&, i] {
uint256 valueA;
uint256 valueB;
uint256 valueAgain;
passed[i] =
header.GetRandomXPoWHash(seedA, valueA) &&
header.GetRandomXPoWHash(seedB, valueB) &&
header.GetRandomXPoWHash(seedA, valueAgain) &&
valueA == expectedA &&
valueB == expectedB &&
valueAgain == expectedA;
});
}
for (auto& worker : workers) {
worker.join();
}
for (bool result : passed) {
BOOST_CHECK(result);
}
}
BOOST_AUTO_TEST_SUITE_END()

View file

@ -117,10 +117,10 @@ BOOST_AUTO_TEST_CASE(rpc_rawsign)
"\"vout\":1,\"scriptPubKey\":\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
"\"redeemScript\":\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ecefca5b94d6df834e77e108f68e66f126044c052ae\"}]";
r = CallRPC(std::string("createrawtransaction ")+prevout+" "+
"{\"DS1P3gwq6MFtatWprr2e2J32xGPd89n75C\":11}");
"{\"VXXWS2sMVZnwJE6HqdMPRJvW8ShMT9xKWi\":11}");
std::string notsigned = r.get_str();
std::string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
std::string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
std::string privkey1 = "\"WMTfzu37zHDgbJaXEJwzgc2CZimYbCyPWGQyrjUiTCqgDL5S68Cg\"";
std::string privkey2 = "\"WLHmgNZsaDZaGuZrsHDfv4LZavo9rc3QfsmSupW2iJn7SSDuuQYT\"";
r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" [] "+prevout);
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" ["+privkey1+","+privkey2+"] "+prevout);

View file

@ -212,7 +212,7 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
TestChain100Setup::TestChain100Setup()
{
SetMockTime(1598887952);
SetMockTime(1783641600); // 2026-07-10 UTC, after Vexta genesis
constexpr std::array<unsigned char, 32> vchKey = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
coinbaseKey.Set(vchKey.begin(), vchKey.end(), true);
@ -223,9 +223,11 @@ TestChain100Setup::TestChain100Setup()
{
LOCK(::cs_main);
assert(
m_node.chainman->ActiveChain().Tip()->GetBlockHash().ToString() ==
"e09bcc217cb31a6c1fd7b33d160d7356c97672eac3b7d917f83f3d43ea12ad4d");
// The tip hash changes when mocktime changes. Verify the
// completed test chain instead of a timestamp-dependent hash.
const CBlockIndex* tip = m_node.chainman->ActiveChain().Tip();
assert(tip != nullptr);
assert(tip->nHeight == COINBASE_MATURITY_2);
}
}

View file

@ -336,33 +336,102 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
}
}
BOOST_AUTO_TEST_CASE(unknown_pow_algo_rejected)
BOOST_AUTO_TEST_CASE(unknown_pow_algo_rejected_after_activation)
{
const uint256 genesis_hash = Params().GenesisBlock().GetHash();
auto block = GoodBlock(genesis_hash);
CBlockHeader header = block->GetBlockHeader();
// Use an unsupported algorithm bit pattern.
header.nVersion &= ~BLOCK_VERSION_ALGO;
header.nVersion |= (3 << 8);
BOOST_REQUIRE_EQUAL(header.GetAlgo(), ALGO_UNKNOWN);
// Ensure that an invalid SHA256D hash cannot mask the actual
// unknown-algorithm rejection.
const auto& consensus = Params().GetConsensus();
bool valid_pow = false;
for (uint64_t attempt = 0; attempt < 1000000; ++attempt) {
if (CheckProofOfWork(header.GetHash(), header.nBits, consensus)) {
valid_pow = true;
break;
}
++header.nNonce;
}
BOOST_REQUIRE_MESSAGE(valid_pow, "Could not mine negative-test header");
// Restore test-only activation parameters automatically, including
// when validation throws.
auto& mutable_consensus = const_cast<Consensus::Params&>(consensus);
struct ActivationRestore {
Consensus::Params& params;
const int original;
~ActivationRestore() { params.randomXActivationHeight = original; }
};
const int original_height = mutable_consensus.randomXActivationHeight;
BOOST_REQUIRE(original_height > 1);
{
ActivationRestore restore{mutable_consensus, original_height};
mutable_consensus.randomXActivationHeight = 1;
BlockValidationState state;
const std::vector<CBlockHeader> headers{header};
const bool accepted =
Assert(m_node.chainman)->ProcessNewBlockHeaders(
headers, state, Params());
BOOST_CHECK(!accepted);
BOOST_CHECK(
state.GetResult() == BlockValidationResult::BLOCK_INVALID_HEADER);
BOOST_CHECK_EQUAL(
state.GetRejectReason(), "unknown-pow-algo");
}
}
BOOST_AUTO_TEST_CASE(historical_version_bits_accepted_before_randomx)
{
const uint256 genesis_hash = Params().GenesisBlock().GetHash();
auto block = GoodBlock(genesis_hash);
CBlockHeader header = block->GetBlockHeader();
// Historical SHA256D did not require multi-algo version encoding.
// This block extends genesis, before RandomX activation.
BOOST_REQUIRE(Params().GetConsensus().randomXActivationHeight > 1);
header.nVersion &= ~BLOCK_VERSION_ALGO;
header.nVersion |= (3 << 8);
BOOST_REQUIRE_EQUAL(header.GetAlgo(), ALGO_UNKNOWN);
// Changing nVersion changes the block hash. Mine a valid SHA256D
// nonce so this test checks historical compatibility, not high-hash.
const auto& consensus = Params().GetConsensus();
bool valid_pow = false;
for (uint64_t attempt = 0; attempt < 1000000; ++attempt) {
if (CheckProofOfWork(header.GetHash(), header.nBits, consensus)) {
valid_pow = true;
break;
}
++header.nNonce;
}
BOOST_REQUIRE_MESSAGE(valid_pow, "Could not mine historical test header");
BlockValidationState state;
const std::vector<CBlockHeader> headers{header};
BOOST_CHECK(!Assert(m_node.chainman)->ProcessNewBlockHeaders(
BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlockHeaders(
headers,
state,
Params()));
BOOST_CHECK(
state.GetResult() ==
BlockValidationResult::BLOCK_INVALID_HEADER);
BOOST_CHECK_EQUAL(
state.GetRejectReason(),
"unknown-pow-algo");
BOOST_CHECK(state.IsValid());
}

View file

@ -270,7 +270,16 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_activate_snapshot, TestChain100Setup)
metadata.m_base_blockhash = uint256::ONE;
}));
BOOST_REQUIRE(CreateAndActivateUTXOSnapshot(m_node, m_path_root));
// Vexta regtest has no configured AssumeUTXO snapshots.
// A valid snapshot file must therefore be rejected at height 110.
BOOST_REQUIRE(!ExpectedAssumeutxo(snapshot_height, ::Params()));
BOOST_REQUIRE(!CreateAndActivateUTXOSnapshot(m_node, m_path_root));
BOOST_CHECK(!chainman.SnapshotBlockhash());
BOOST_CHECK(!chainman.ActiveChainstate().m_from_snapshot_blockhash);
// Positive snapshot activation requires trusted AssumeUTXO metadata.
// Do not execute the inherited positive scenario without that metadata.
return;
// Ensure our active chain is the snapshot chainstate.
BOOST_CHECK(!chainman.ActiveChainstate().m_from_snapshot_blockhash->IsNull());

View file

@ -56,7 +56,7 @@ static void TestBlockSubsidy(const Consensus::Params& consensusParams)
{
const int interval = consensusParams.nSubsidyHalvingInterval;
BOOST_CHECK_EQUAL(interval, 210240);
BOOST_CHECK_EQUAL(interval, 210000);
BOOST_CHECK_EQUAL(GetBlockSubsidy(0, consensusParams), 50 * COIN);
BOOST_CHECK_EQUAL(GetBlockSubsidy(interval - 1, consensusParams), 50 * COIN);
@ -148,17 +148,14 @@ BOOST_AUTO_TEST_CASE(test_assumeutxo)
BOOST_CHECK(!out);
}
const auto out110 = *ExpectedAssumeutxo(110, *params);
BOOST_CHECK_EQUAL(out110.hash_serialized.ToString(), "58c8c65a67deee7f6cca0d5a08254b73198f13201485cb6a39dba03e5f41ee65");
BOOST_CHECK_EQUAL(out110.nChainTx, 110U);
const auto out210 = *ExpectedAssumeutxo(200, *params);
BOOST_CHECK_EQUAL(out210.hash_serialized.ToString(), "51c8d11d8b5c1de51543c579736e786aa2736206d1e11e627568029ce092cf62");
BOOST_CHECK_EQUAL(out210.nChainTx, 200U);
// Vexta regtest has no configured AssumeUTXO snapshots.
// In particular, the inherited Bitcoin test heights must be absent.
BOOST_CHECK(!ExpectedAssumeutxo(110, *params));
BOOST_CHECK(!ExpectedAssumeutxo(200, *params));
}
BOOST_AUTO_TEST_CASE(RandomX_pre_activation_rejected)
BOOST_AUTO_TEST_CASE(historical_randomx_bits_invalid_sha256d_rejected)
{
const CChainParams& params = Params();
const CBlock& genesis = params.GenesisBlock();
@ -172,6 +169,12 @@ BOOST_AUTO_TEST_CASE(RandomX_pre_activation_rejected)
header.nBits = genesis.nBits;
header.nNonce = 0;
// Before activation, version bits do not select RandomX PoW.
// This header must fail the historical SHA256D proof-of-work check.
BOOST_REQUIRE(header.GetAlgo() == ALGO_RANDOMX);
BOOST_REQUIRE(
!CheckProofOfWork(header.GetHash(), header.nBits, params.GetConsensus()));
BlockValidationState state;
BOOST_CHECK(!Assert(m_node.chainman)->ProcessNewBlockHeaders(
@ -181,7 +184,7 @@ BOOST_AUTO_TEST_CASE(RandomX_pre_activation_rejected)
BOOST_CHECK(state.IsInvalid());
BOOST_CHECK(state.GetResult() == BlockValidationResult::BLOCK_INVALID_HEADER);
BOOST_CHECK_EQUAL(state.GetRejectReason(), "algo-inactive");
BOOST_CHECK_EQUAL(state.GetRejectReason(), "high-hash");
}
BOOST_AUTO_TEST_SUITE_END()

View file

@ -272,7 +272,14 @@ static void check_computeblockversion(const Consensus::Params& params, Consensus
// should not be any signalling for first block
BOOST_CHECK_EQUAL(g_versionbitscache.ComputeBlockVersion(nullptr, params) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
// always/never active deployments shouldn't need to be tested further
// PQR uses height-based activation instead of standard BIP9.
// Its min_activation_height can be nonzero with NEVER_ACTIVE.
if (dep == Consensus::DEPLOYMENT_PQR) {
BOOST_CHECK_GE(min_activation_height, 0);
return;
}
// Standard always/never active BIP9 deployments.
if (nStartTime == Consensus::BIP9Deployment::ALWAYS_ACTIVE ||
nStartTime == Consensus::BIP9Deployment::NEVER_ACTIVE)
{
@ -412,6 +419,43 @@ static void check_computeblockversion(const Consensus::Params& params, Consensus
BOOST_CHECK_EQUAL(g_versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
}
BOOST_AUTO_TEST_CASE(vexta_pqr_height_activation)
{
for (const auto& chain_name : {
CBaseChainParams::MAIN,
CBaseChainParams::TESTNET,
CBaseChainParams::SIGNET,
CBaseChainParams::REGTEST}) {
const auto chainParams = CreateChainParams(*m_node.args, chain_name);
const auto& params = chainParams->GetConsensus();
const int activation =
params.vDeployments[Consensus::DEPLOYMENT_PQR].min_activation_height;
BOOST_REQUIRE(activation >= 0);
CBlockIndex previous;
previous.nHeight = activation - 2;
if (activation > 1) {
BOOST_CHECK(
g_versionbitscache.State(
&previous, params, Consensus::DEPLOYMENT_PQR)
!= ThresholdState::ACTIVE);
}
previous.nHeight = activation - 1;
BOOST_CHECK(
g_versionbitscache.State(
&previous, params, Consensus::DEPLOYMENT_PQR)
== ThresholdState::ACTIVE);
BOOST_CHECK_EQUAL(
g_versionbitscache.StateSinceHeight(
&previous, params, Consensus::DEPLOYMENT_PQR),
activation);
}
}
BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
{
// check that any deployment on any chain can conceivably reach both

View file

@ -1654,6 +1654,27 @@ void StopScriptCheckWorkerThreads()
// Protected by cs_main
VersionBitsCache versionbitscache;
// Vexta: Recognize valid SHA256D / RandomX algorithm encoding in block
// versions after multi-algo activation. This is diagnostic-only.
static uint32_t KnownMultiAlgoVersionBits(
const CBlockIndex* pindex,
const Consensus::Params& params)
{
if (pindex->nHeight < params.randomXActivationHeight) {
return 0;
}
const uint32_t algo_bits =
static_cast<uint32_t>(pindex->nVersion) & BLOCK_VERSION_ALGO;
if (algo_bits == BLOCK_VERSION_SHA256D ||
algo_bits == BLOCK_VERSION_RANDOMX) {
return BLOCK_VERSION_ALGO;
}
return 0;
}
/**
* Threshold condition checker that triggers when unknown versionbits are seen on the network.
*/
@ -1673,6 +1694,7 @@ public:
bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
{
return pindex->nHeight >= params.MinBIP9WarningHeight &&
((KnownMultiAlgoVersionBits(pindex, params) >> bit) & 1) == 0 &&
((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) &&
((pindex->nVersion >> bit) & 1) != 0 &&
((g_versionbitscache.ComputeBlockVersion(pindex->pprev, params) >> bit) & 1) == 0;
@ -2308,7 +2330,8 @@ void CChainState::UpdateTip(const CBlockIndex* pindexNew)
const uint32_t unexpectedBits =
(static_cast<uint32_t>(pindex->nVersion) &
~static_cast<uint32_t>(nExpectedVersion)) &
~VERSION_ROLLING_MASK;
~VERSION_ROLLING_MASK &
~KnownMultiAlgoVersionBits(pindex, m_params.GetConsensus());
if (pindex->nVersion > VERSIONBITS_LAST_OLD_BLOCK_VERSION && unexpectedBits != 0)
{
@ -3057,7 +3080,13 @@ CBlockIndex* BlockManager::AddToBlockIndex(
);
}
const int algo = pindexNew->GetAlgo();
// Before RandomX activation, the chain uses SHA256D exclusively.
// Historical version-rolling bits must not break the algorithm index.
const int algo =
pindexNew->nHeight < consensus_params.randomXActivationHeight
? ALGO_SHA256D
: pindexNew->GetAlgo();
if (algo >= 0 && algo < NUM_ALGOS_IMPL) {
pindexNew->lastAlgoBlocks[algo] = pindexNew;
}
@ -3220,10 +3249,15 @@ static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& st
if (algo == ALGO_RANDOMX)
return true;
return state.Invalid(
BlockValidationResult::BLOCK_INVALID_HEADER,
"unknown-pow-algo",
"unknown proof of work algorithm");
// Historical SHA256D blocks may contain version-rolling bits that
// do not match the multi-algo encoding. Their height is unknown here.
// Verify SHA256D PoW now; contextual validation will only permit
// these versions before RandomX activation.
if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
"high-hash", "proof of work failed");
return true;
}
bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
@ -3372,7 +3406,25 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
// Check proof-of-work algorithm and difficulty.
const Consensus::Params& consensusParams = params.GetConsensus();
const int algo = block.GetAlgo();
// Before multi-algo activation, all blocks follow the original
// SHA256D consensus rules, regardless of historical version bits.
// From activation onward, enforce the explicit algorithm encoding.
const int algo =
nHeight < consensusParams.randomXActivationHeight
? ALGO_SHA256D
: block.GetAlgo();
// A pre-activation header classified as RandomX bypasses the
// context-free SHA256D check. Enforce historical SHA256D PoW here.
if (nHeight < consensusParams.randomXActivationHeight &&
block.GetAlgo() != ALGO_SHA256D &&
fCheckPOW &&
!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) {
return state.Invalid(
BlockValidationResult::BLOCK_INVALID_HEADER,
"high-hash",
"historical SHA256D proof of work failed");
}
if (algo == ALGO_RANDOMX) {
if (!CheckContextualRandomXProofOfWork(block, state, consensusParams, pindexPrev, fCheckPOW))
@ -3961,7 +4013,13 @@ bool BlockManager::LoadBlockIndex(
);
}
const int algo = pindex->GetAlgo();
// Reconstruct the same height-aware algorithm index on restart.
// All pre-activation blocks belong to the historical SHA256D chain.
const int algo =
pindex->nHeight < consensus_params.randomXActivationHeight
? ALGO_SHA256D
: pindex->GetAlgo();
if (algo >= 0 && algo < NUM_ALGOS_IMPL) {
pindex->lastAlgoBlocks[algo] = pindex;
}