dragonx/src/pow.h

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin Core developers
// Copyright (c) 2016-2024 The Hush developers
// Distributed under the GPLv3 software license, see the accompanying
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
/******************************************************************************
 * Copyright © 2014-2019 The SuperNET Developers.                             *
 *                                                                            *
 * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
 * the top-level directory of this distribution for the individual copyright  *
 * holder information and the developer policies on copyright and licensing.  *
 *                                                                            *
 * Unless otherwise agreed in a custom licensing agreement, no part of the    *
 * SuperNET software, including this file may be copied, modified, propagated *
 * or distributed except according to the terms contained in the LICENSE file *
 *                                                                            *
 * Removal or modification of this copyright notice is prohibited.            *
 *                                                                            *
 ******************************************************************************/
#ifndef HUSH_POW_H
#define HUSH_POW_H

#include "chain.h"
#include "checkqueue.h"
#include "consensus/params.h"
#include <stdint.h>
#include <cstring>
#include <string>
#include <utility>
#include <vector>

class CBlockHeader;
class CBlockIndex;
class CChainParams;
class uint256;
class arith_uint256;

unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
                                       int64_t nLastBlockTime, int64_t nFirstBlockTime,
                                       const Consensus::Params&, int32_t height);

/** Check whether the Equihash solution in a block header is valid */
bool CheckEquihashSolution(const CBlockHeader *pblock, const CChainParams&);

/** Check whether a block header contains a valid RandomX solution */
bool CheckRandomXSolution(const CBlockHeader *pblock, int32_t height);

/** Whether a block at this height requires a RandomX hash check (shared gate used by both the
 *  inline CheckRandomXSolution and the parallel pre-verification pool). */
bool RandomXValidationRequired(int32_t height);

/** Serialize the RandomX hash input (block header without nSolution) — identical bytes to the
 *  inline CheckRandomXSolution path, so the parallel pool computes the same hash. */
std::vector<unsigned char> GetRandomXInput(const CBlockHeader& block);

/** Derive the RandomX key string for a block at `height`. MUST be called under cs_main (reads
 *  chainActive). Returns empty string if the key-height block is unavailable. */
std::string GetRandomXKey(int32_t height);

/** A single RandomX pre-verification work item for the parallel validator pool. Pure value type
 *  (no chainstate pointers) so workers need no cs_main. On a hash match it sets *presult=true; on
 *  any failure it leaves *presult untouched — the inline CheckRandomXSolution remains the
 *  consensus authority and re-verifies anything not pre-verified. operator() ALWAYS returns true,
 *  so one block's failure never short-circuits the rest of the CCheckQueue batch. */
class CRandomXCheck
{
private:
    std::string rxKey;                 // RandomX key for this block's height
    std::vector<unsigned char> input;  // serialized CRandomXInput(header)
    unsigned char expected[32];        // block.nSolution (claimed RandomX hash)
    bool* presult;                     // -> pindex->fRandomXVerified (set true only on a hash match)
public:
    CRandomXCheck() : presult(nullptr) { memset(expected, 0, sizeof(expected)); }
    CRandomXCheck(const std::string& keyIn, std::vector<unsigned char> inputIn,
                  const unsigned char* expectedIn, bool* presultIn)
        : rxKey(keyIn), input(std::move(inputIn)), presult(presultIn)
    { memcpy(expected, expectedIn, sizeof(expected)); }
    bool operator()();
    void swap(CRandomXCheck& c) {
        rxKey.swap(c.rxKey);
        input.swap(c.input);
        std::swap(presult, c.presult);
        for (int i = 0; i < 32; i++) std::swap(expected[i], c.expected[i]);
    }
};

/** The RandomX pre-verification check queue (parallel pool). */
extern CCheckQueue<CRandomXCheck> rxCheckQueue;
/** Worker entry point (spawn N at startup, mirrors ThreadScriptCheck). */
void ThreadRandomXVerify();
/** Load `rxKey` into the shared validator cache (alloc on first use); call before dispatching a
 *  same-key group of checks. Returns false on allocation failure. */
bool RandomXValidatorPrepareKey(const std::string& rxKey);
/** Release the shared validator cache at shutdown. */
void RandomXValidatorShutdown();

/** Set thread-local flag to skip RandomX validation (used by miner during TestBlockValidity) */
void SetSkipRandomXValidation(bool skip);
bool GetSkipRandomXValidation();

/** Return the RandomX key rotation interval in blocks */
int GetRandomXInterval();

/** Return the RandomX key change lag in blocks */
int GetRandomXBlockLag();

/** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t height, const Consensus::Params& params);
CChainPower GetBlockProof(const CBlockIndex& block);

/** Return the time it would take to redo the work difference between from and to, assuming the current hashrate corresponds to the difficulty at tip, in seconds. */
int64_t GetBlockProofEquivalentTime(const CBlockIndex& to, const CBlockIndex& from, const CBlockIndex& tip, const Consensus::Params&);

#endif // HUSH_POW_H