Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
| e82f3bf2b7 | |||
| 997aaf5716 | |||
|
|
9db541e445 | ||
|
b052e6e0da |
29 changed files with 606 additions and 160 deletions
126
README.md
126
README.md
|
|
@ -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.
|
||||
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -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" +
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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
|
|
@ -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";
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue