main_8h_source.html

// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2014 The Bitcoin developers

// Copyright (c) 2014-2015 The Dash developers

// Copyright (c) 2015-2018 The PIVX developers

// Copyright (c) 2018-2020 The DAPS Project developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.


#ifndef BITCOIN_MAIN_H

#define BITCOIN_MAIN_H


#if defined(HAVE_CONFIG_H)

#include "config/prcycoin-config.h"

#endif


#include "amount.h"

#include "chain.h"

#include "chainparams.h"

#include "coins.h"

#include "consensus/validation.h"

#include "net.h"

#include "poa.h"

#include "primitives/block.h"

#include "primitives/transaction.h"

#include "script/script.h"

#include "script/sigcache.h"

#include "script/standard.h"

#include "sync.h"

#include "tinyformat.h"

#include "txmempool.h"

#include "uint256.h"

#include "undo.h"

#include "bignum.h"


#include <algorithm>

#include <exception>

#include <map>

#include <set>

#include <stdint.h>

#include <string>

#include <utility>

#include <vector>


#include <boost/unordered_map.hpp>


#include "secp256k1_bulletproofs.h"

#include "secp256k1_commitment.h"

#include "secp256k1_generator.h"

#include "secp256k1.h"

#include "secp256k1-mw/src/hash_impl.h"


class CBlockIndex;

class CBlockTreeDB;

class CBloomFilter;

class CInv;

class CScriptCheck;

class CValidationInterface;

class CValidationState;


struct CBlockTemplate;

struct CNodeStateStats;


static const unsigned int DEFAULT_BLOCK_MAX_SIZE = 750000;

static const unsigned int DEFAULT_BLOCK_MIN_SIZE = 0;

static const unsigned int DEFAULT_BLOCK_PRIORITY_SIZE = 50000;

static const unsigned int MAX_STANDARD_TX_SIZE = 150000;

static const unsigned int MAX_P2SH_SIGOPS = 15;

static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 100;

static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB

static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB

static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB

static const int COINBASE_MATURITY = 100;

static const int MAX_SCRIPTCHECK_THREADS = 16;

static const int DEFAULT_SCRIPTCHECK_THREADS = 0;

static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;

static const unsigned int BLOCK_STALLING_TIMEOUT = 2;

static const unsigned int MAX_HEADERS_RESULTS = 2000;

static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;

static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;

static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;

static const unsigned int MAX_REJECT_MESSAGE_LENGTH = 111;

static const unsigned int AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL = 24 * 24 * 60;

static const unsigned int AVG_ADDRESS_BROADCAST_INTERVAL = 30;

static const unsigned int AVG_INVENTORY_BROADCAST_INTERVAL = 5;


 static const bool DEFAULT_PEERBLOOMFILTERS = true;


 static const bool DEFAULT_BLOCK_SPAM_FILTER = true;

 static const unsigned int DEFAULT_BLOCK_SPAM_FILTER_MAX_SIZE = COINBASE_MATURITY;

 static const unsigned int DEFAULT_BLOCK_SPAM_FILTER_MAX_AVG = 10;


static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;


//static const std::string FOUNDATION_WALLET = "PandirQr3T895NCsDrSKdCD4TJ324z3VDB8Amcj6wx2kKdB7LztTDefdvP4QTMdgGA72W7SHzQeFzLTo2sikmmbd19E5C8UZbbi";


struct BlockHasher {

    size_t operator()(const uint256& hash) const { return hash.GetCheapHash(); }

};


extern CScript COINBASE_FLAGS;

extern RecursiveMutex cs_main;

extern CTxMemPool mempool;

typedef boost::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;

extern BlockMap mapBlockIndex;

extern uint64_t nLastBlockTx;

extern uint64_t nLastBlockSize;

extern const std::string strMessageMagic;

extern int64_t nTimeBestReceived;


// Best block section

extern Mutex g_best_block_mutex;

extern std::condition_variable g_best_block_cv;

extern uint256 g_best_block;


extern std::atomic<bool> fImporting;

extern std::atomic<bool> fReindex;

extern int nScriptCheckThreads;

extern bool fTxIndex;

extern bool fIsBareMultisigStd;

extern bool fCheckBlockIndex;

extern size_t nCoinCacheUsage;

extern CFeeRate minRelayTxFee;

extern int64_t nMaxTipAge;

extern bool fVerifyingBlocks;

extern bool fGeneratePrcycoins;


extern bool fLargeWorkForkFound;

extern bool fLargeWorkInvalidChainFound;


extern int64_t nLastCoinStakeSearchInterval;

//extern int64_t nConsolidationTime;

extern int64_t nLastCoinStakeSearchTime;


extern int MIN_RING_SIZE;

extern int MAX_RING_SIZE;

extern const int MAX_TX_INPUTS;

extern const int MIN_TX_INPUTS_FOR_SWEEPING;


extern std::map<uint256, int64_t> mapRejectedBlocks;

extern std::map<unsigned int, unsigned int> mapHashedBlocks;

extern std::map<COutPoint, COutPoint> mapInvalidOutPoints;


extern CBlockIndex* pindexBestHeader;


static const uint64_t nMinDiskSpace = 52428800;


void RegisterNodeSignals(CNodeSignals& nodeSignals);

void UnregisterNodeSignals(CNodeSignals& nodeSignals);


secp256k1_context2* GetContext();

secp256k1_scratch_space2* GetScratch();

secp256k1_bulletproof_generators* GetGenerator();

bool VerifyBulletProofAggregate(const CTransaction& tx);

bool VerifyRingSignatureWithTxFee(const CTransaction& tx, CBlockIndex* pindex);

void DestroyContext();

bool VerifyDerivedAddress(const CTxOut& out, std::string stealth);

bool ReVerifyPoSBlock(CBlockIndex* pindex);


bool ProcessNewBlock(CValidationState& state, CNode* pfrom, CBlock* pblock, CDiskBlockPos* dbp = NULL);

bool CheckDiskSpace(uint64_t nAdditionalBytes = 0);

FILE* OpenBlockFile(const CDiskBlockPos& pos, bool fReadOnly = false);

FILE* OpenUndoFile(const CDiskBlockPos& pos, bool fReadOnly = false);

fs::path GetBlockPosFilename(const CDiskBlockPos& pos, const char* prefix);

bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos* dbp = NULL);

bool InitBlockIndex();

bool LoadBlockIndex(std::string& strError);

void UnloadBlockIndex();

int ActiveProtocol();

bool ProcessMessages(CNode* pfrom);

bool VerifyZeroBlindCommitment(const CTxOut& out);

bool SendMessages(CNode* pto);

void ThreadScriptCheck();


bool IsInitialBlockDownload();

std::string GetWarnings(std::string strFor);

bool GetTransaction(const uint256& hash, CTransaction& tx, uint256& hashBlock, bool fAllowSlow = false, CBlockIndex* blockIndex = nullptr);

bool CheckHaveInputs(const CCoinsViewCache& view, const CTransaction& tx);


// ***TODO***

double ConvertBitsToDouble(unsigned int nBits);

int64_t GetMasternodePayment(int nHeight, int64_t blockValue, int nMasternodeCount = 0);

unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader* pblock, bool fProofOfStake);


bool ActivateBestChain(CValidationState& state, CBlock* pblock = NULL, bool fAlreadyChecked = false);

CAmount GetBlockValue(int nHeight);


void RemoveInvalidTransactionsFromMempool();

void SetRingSize(int nHeight);


CBlockIndex* InsertBlockIndex(uint256 hash);

bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats);

void Misbehaving(NodeId nodeid, int howmuch) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

void FlushStateToDisk();


CAmount GetValueIn(CCoinsViewCache view, const CTransaction& tx);


bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState& state, const CTransaction& tx, bool fLimitFree, bool* pfMissingInputs, bool fRejectInsaneFee = false, bool ignoreFees = false);


bool AcceptableInputs(CTxMemPool& pool, CValidationState& state, const CTransaction& tx, bool fLimitFree, bool* pfMissingInputs, bool fRejectInsaneFee = false, bool isDSTX = false);


bool IsSpentKeyImage(const std::string& kiHex, const uint256& againsHash);

bool CheckKeyImageSpendInMainChain(const std::string& kiHex, int& confirmations);


double GetPriority(const CTransaction& tx, int nHeight);


uint256 GetTxSignatureHash(const CTransaction& tx);

uint256 GetTxInSignatureHash(const CTxIn& txin);

bool VerifyShnorrKeyImageTx(const CTransaction& tx);

bool VerifyShnorrKeyImageTxIn(const CTxIn& txin, uint256 sigHash);


int GetInputAge(CTxIn& vin);

int GetIXConfirmations(uint256 nTXHash);


struct CNodeStateStats {

    int nMisbehavior;

    int nSyncHeight;

    int nCommonHeight;

    std::vector<int> vHeightInFlight;

};


CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree);


bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs);


bool CheckInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& view, bool fScriptChecks, unsigned int flags, bool cacheStore, std::vector<CScriptCheck>* pvChecks = NULL);


void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo& txundo, int nHeight);


bool IsTransactionInChain(const uint256& txId, int& nHeightTx, CTransaction& tx);

bool IsTransactionInChain(const uint256& txId, int& nHeightTx);

bool IsBlockHashInChain(const uint256& hashBlock);

bool ValidOutPoint(const COutPoint out, int nHeight = 1);

bool RecalculatePRCYSupply(int nHeightStart);


bool CheckFinalTx(const CTransaction& tx, int flags = -1);


bool IsStandardTx(const CTransaction& tx, std::string& reason);


class CScriptCheck

{

private:

    CScript scriptPubKey;

    const CTransaction* ptxTo;

    unsigned int nIn;

    unsigned int nFlags;

    bool cacheStore;

    ScriptError error;


public:

    CScriptCheck() : ptxTo(0), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR) {}

    CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn) : scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),

                                                                                                                                ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), error(SCRIPT_ERR_UNKNOWN_ERROR) {}


    bool operator()();


    void swap(CScriptCheck& check)

    {

        scriptPubKey.swap(check.scriptPubKey);

        std::swap(ptxTo, check.ptxTo);

        std::swap(nIn, check.nIn);

        std::swap(nFlags, check.nFlags);

        std::swap(cacheStore, check.cacheStore);

        std::swap(error, check.error);

    }


    ScriptError GetScriptError() const { return error; }

};


bool WriteBlockToDisk(CBlock& block, CDiskBlockPos& pos);

bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos);

bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex);


bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);


bool DisconnectBlocks(int nBlocks);

void ReprocessBlocks(int nBlocks);


bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool fJustCheck, bool fAlreadyChecked = false);


bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, bool fCheckPOW = true);

bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckSig = true);

bool CheckWork(const CBlock block, CBlockIndex* const pindexPrev);


bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex* pindexPrev);

bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindexPrev);


bool TestBlockValidity(CValidationState& state, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);


bool AcceptBlock(CBlock& block, CValidationState& state, CBlockIndex** pindex, CDiskBlockPos* dbp = NULL, bool fAlreadyCheckedBlock = false);

bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex** ppindex = NULL);


class CVerifyDB

{

public:

    CVerifyDB();

    ~CVerifyDB();

    bool VerifyDB(CCoinsView* coinsview, int nCheckLevel, int nCheckDepth);

};


CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator);


bool InvalidateBlock(CValidationState& state, CBlockIndex* pindex);


bool ReconsiderBlock(CValidationState& state, CBlockIndex* pindex);


extern CChain chainActive;


extern CCoinsViewCache* pcoinsTip;


extern CBlockTreeDB* pblocktree;


#endif // BITCOIN_MAIN_H