Krystie
7faf13dc31
Two fixes for the header cache exhaustion bug: 1. Block-accepted path: when hashBestHeaderSync==0 and we're still behind peers during IBD, send getheaders to all peers to refill the header cache. Previously the refill was gated on hashBestHeaderSync!=0, creating a dead loop once the cache drained. 2. Stall detection: also send getheaders alongside getblocks when a stall is detected. Previously only getblocks was sent, which cannot refill mapHeaderSync or restart the header planner. Root cause: getheaders returns 2000 headers per batch. Blocks are consumed from the cache faster than headers are fetched. Once mapHeaderSync empties, hashBestHeaderSync becomes 0, and the refill path is never taken again. See BUG_ANALYSIS_IBD_STALL.md for full details.
1038 lines
36 KiB
C++
1038 lines
36 KiB
C++
// Copyright (c) 2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2012 The Bitcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "main.h"
|
|
#include "net.h"
|
|
#include "trianglesrpc.h"
|
|
#include "addressindex.h"
|
|
#include "txdb.h"
|
|
#include "base58.h"
|
|
#include "utxosnapshot.h"
|
|
|
|
using namespace json_spirit;
|
|
using namespace std;
|
|
|
|
extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, json_spirit::Object& entry);
|
|
extern enum Checkpoints::CPMode CheckpointsMode;
|
|
|
|
double GetDifficulty(const CBlockIndex* blockindex)
|
|
{
|
|
// Floating point number that is a multiple of the minimum difficulty,
|
|
// minimum difficulty = 1.0.
|
|
if (blockindex == NULL)
|
|
{
|
|
if (pindexBest == NULL)
|
|
return 1.0;
|
|
else
|
|
blockindex = GetLastBlockIndex(pindexBest, false);
|
|
}
|
|
|
|
if (blockindex == NULL)
|
|
return 1.0;
|
|
|
|
int nShift = (blockindex->nBits >> 24) & 0xff;
|
|
|
|
double dDiff =
|
|
(double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);
|
|
|
|
while (nShift < 29)
|
|
{
|
|
dDiff *= 256.0;
|
|
nShift++;
|
|
}
|
|
while (nShift > 29)
|
|
{
|
|
dDiff /= 256.0;
|
|
nShift--;
|
|
}
|
|
|
|
return dDiff;
|
|
}
|
|
|
|
double GetPoWMHashPS()
|
|
{
|
|
if (pindexBest->nHeight >= CUTOFF_POW_BLOCK)
|
|
return 0;
|
|
|
|
int nPoWInterval = 72;
|
|
int64_t nTargetSpacingWorkMin = 30, nTargetSpacingWork = 30;
|
|
|
|
CBlockIndex* pindex = pindexGenesisBlock;
|
|
CBlockIndex* pindexPrevWork = pindexGenesisBlock;
|
|
|
|
while (pindex)
|
|
{
|
|
if (pindex->IsProofOfWork())
|
|
{
|
|
int64_t nActualSpacingWork = pindex->GetBlockTime() - pindexPrevWork->GetBlockTime();
|
|
nTargetSpacingWork = ((nPoWInterval - 1) * nTargetSpacingWork + nActualSpacingWork + nActualSpacingWork) / (nPoWInterval + 1);
|
|
nTargetSpacingWork = max(nTargetSpacingWork, nTargetSpacingWorkMin);
|
|
pindexPrevWork = pindex;
|
|
}
|
|
|
|
pindex = pindex->pnext;
|
|
}
|
|
|
|
return GetDifficulty() * 4294.967296 / nTargetSpacingWork;
|
|
}
|
|
|
|
double GetPoSKernelPS()
|
|
{
|
|
int nPoSInterval = 72;
|
|
double dStakeKernelsTriedAvg = 0;
|
|
int nStakesHandled = 0, nStakesTime = 0;
|
|
|
|
CBlockIndex* pindex = pindexBest;;
|
|
CBlockIndex* pindexPrevStake = NULL;
|
|
|
|
while (pindex && nStakesHandled < nPoSInterval)
|
|
{
|
|
if (pindex->IsProofOfStake())
|
|
{
|
|
dStakeKernelsTriedAvg += GetDifficulty(pindex) * 4294967296.0;
|
|
nStakesTime += pindexPrevStake ? (pindexPrevStake->nTime - pindex->nTime) : 0;
|
|
pindexPrevStake = pindex;
|
|
nStakesHandled++;
|
|
}
|
|
|
|
pindex = pindex->pprev;
|
|
}
|
|
|
|
return nStakesTime ? dStakeKernelsTriedAvg / nStakesTime : 0;
|
|
}
|
|
|
|
Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool fPrintTransactionDetail)
|
|
{
|
|
Object result;
|
|
result.push_back(Pair("hash", block.GetHash().GetHex()));
|
|
CMerkleTx txGen(block.vtx[0]);
|
|
txGen.SetMerkleBranch(&block);
|
|
result.push_back(Pair("confirmations", (int)txGen.GetDepthInMainChain()));
|
|
result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));
|
|
result.push_back(Pair("height", blockindex->nHeight));
|
|
result.push_back(Pair("version", block.nVersion));
|
|
result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));
|
|
result.push_back(Pair("mint", ValueFromAmount(blockindex->nMint)));
|
|
result.push_back(Pair("time", (boost::int64_t)block.GetBlockTime()));
|
|
result.push_back(Pair("nonce", (boost::uint64_t)block.nNonce));
|
|
result.push_back(Pair("bits", HexBits(block.nBits)));
|
|
result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
|
|
result.push_back(Pair("blocktrust", leftTrim(blockindex->GetBlockTrust().GetHex(), '0')));
|
|
result.push_back(Pair("chaintrust", leftTrim(blockindex->nChainTrust.GetHex(), '0')));
|
|
if (blockindex->pprev)
|
|
result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
|
|
if (blockindex->pnext)
|
|
result.push_back(Pair("nextblockhash", blockindex->pnext->GetBlockHash().GetHex()));
|
|
|
|
result.push_back(Pair("flags", strprintf("%s%s", blockindex->IsProofOfStake()? "proof-of-stake" : "proof-of-work", blockindex->GeneratedStakeModifier()? " stake-modifier": "")));
|
|
result.push_back(Pair("proofhash", blockindex->IsProofOfStake()? blockindex->hashProofOfStake.GetHex() : blockindex->GetBlockHash().GetHex()));
|
|
result.push_back(Pair("entropybit", (int)blockindex->GetStakeEntropyBit()));
|
|
result.push_back(Pair("modifier", strprintf("%016"PRIx64, blockindex->nStakeModifier)));
|
|
result.push_back(Pair("modifierchecksum", strprintf("%08x", blockindex->nStakeModifierChecksum)));
|
|
Array txinfo;
|
|
for (const CTransaction& tx : block.vtx)
|
|
{
|
|
if (fPrintTransactionDetail)
|
|
{
|
|
Object entry;
|
|
|
|
entry.push_back(Pair("txid", tx.GetHash().GetHex()));
|
|
TxToJSON(tx, 0, entry);
|
|
|
|
txinfo.push_back(entry);
|
|
}
|
|
else
|
|
txinfo.push_back(tx.GetHash().GetHex());
|
|
}
|
|
|
|
result.push_back(Pair("tx", txinfo));
|
|
|
|
if (block.IsProofOfStake())
|
|
result.push_back(Pair("signature", HexStr(block.vchBlockSig.begin(), block.vchBlockSig.end())));
|
|
|
|
return result;
|
|
}
|
|
|
|
Value getbestblockhash(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getbestblockhash\n"
|
|
"Returns the hash of the best block in the longest block chain.");
|
|
|
|
return hashBestChain.GetHex();
|
|
}
|
|
|
|
Value getblockcount(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getblockcount\n"
|
|
"Returns the number of blocks in the longest block chain.");
|
|
|
|
return nBestHeight;
|
|
}
|
|
|
|
|
|
Value getdifficulty(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getdifficulty\n"
|
|
"Returns the difficulty as a multiple of the minimum difficulty.");
|
|
|
|
Object obj;
|
|
obj.push_back(Pair("proof-of-work", GetDifficulty()));
|
|
obj.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
|
|
obj.push_back(Pair("search-interval", (int)nLastCoinStakeSearchInterval));
|
|
return obj;
|
|
}
|
|
|
|
|
|
Value settxfee(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 1 || AmountFromValue(params[0]) < MIN_TX_FEE)
|
|
throw runtime_error(
|
|
"settxfee <amount>\n"
|
|
"<amount> is a real and is rounded to the nearest 0.01");
|
|
|
|
nTransactionFee = AmountFromValue(params[0]);
|
|
nTransactionFee = (nTransactionFee / CENT) * CENT; // round to cent
|
|
|
|
return true;
|
|
}
|
|
|
|
Value getrawmempool(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getrawmempool\n"
|
|
"Returns all transaction ids in memory pool.");
|
|
|
|
vector<uint256> vtxid;
|
|
mempool.queryHashes(vtxid);
|
|
|
|
Array a;
|
|
for (const uint256& hash : vtxid)
|
|
a.push_back(hash.ToString());
|
|
|
|
return a;
|
|
}
|
|
|
|
Value getblockhash(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"getblockhash <index>\n"
|
|
"Returns hash of block in best-block-chain at <index>.");
|
|
|
|
int nHeight = params[0].get_int();
|
|
if (nHeight < 0 || nHeight > nBestHeight)
|
|
throw runtime_error("Block number out of range.");
|
|
|
|
CBlockIndex* pblockindex = FindBlockByHeight(nHeight);
|
|
return pblockindex->phashBlock->GetHex();
|
|
}
|
|
|
|
Value getblock(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getblock <hash> [txinfo]\n"
|
|
"txinfo optional to print more detailed tx info\n"
|
|
"Returns details of a block with given block-hash.");
|
|
|
|
std::string strHash = params[0].get_str();
|
|
uint256 hash(strHash);
|
|
|
|
if (mapBlockIndex.count(hash) == 0)
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
|
|
|
CBlock block;
|
|
CBlockIndex* pblockindex = mapBlockIndex[hash];
|
|
block.ReadFromDisk(pblockindex, true);
|
|
|
|
return blockToJSON(block, pblockindex, params.size() > 1 ? params[1].get_bool() : false);
|
|
}
|
|
|
|
Value getblockbynumber(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getblock <number> [txinfo]\n"
|
|
"txinfo optional to print more detailed tx info\n"
|
|
"Returns details of a block with given block-number.");
|
|
|
|
int nHeight = params[0].get_int();
|
|
if (nHeight < 0 || nHeight > nBestHeight)
|
|
throw runtime_error("Block number out of range.");
|
|
|
|
CBlock block;
|
|
CBlockIndex* pblockindex = mapBlockIndex[hashBestChain];
|
|
while (pblockindex->nHeight > nHeight)
|
|
pblockindex = pblockindex->pprev;
|
|
|
|
uint256 hash = *pblockindex->phashBlock;
|
|
|
|
pblockindex = mapBlockIndex[hash];
|
|
block.ReadFromDisk(pblockindex, true);
|
|
|
|
return blockToJSON(block, pblockindex, params.size() > 1 ? params[1].get_bool() : false);
|
|
}
|
|
|
|
Value getblockheader(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getblockheader <hash> [verbose=true]\n"
|
|
"If verbose is false, returns hex-encoded block header.\n"
|
|
"If verbose is true, returns an Object with block header information.");
|
|
|
|
std::string strHash = params[0].get_str();
|
|
uint256 hash(strHash);
|
|
|
|
if (mapBlockIndex.count(hash) == 0)
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
|
|
|
CBlockIndex* pblockindex = mapBlockIndex[hash];
|
|
|
|
bool fVerbose = true;
|
|
if (params.size() > 1)
|
|
fVerbose = params[1].get_bool();
|
|
|
|
if (!fVerbose)
|
|
{
|
|
CBlock blockHeader = pblockindex->GetBlockHeader();
|
|
CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
|
|
ssBlock << blockHeader;
|
|
return HexStr(ssBlock.begin(), ssBlock.end());
|
|
}
|
|
|
|
Object result;
|
|
result.push_back(Pair("hash", pblockindex->GetBlockHash().GetHex()));
|
|
result.push_back(Pair("confirmations", pindexBest->nHeight - pblockindex->nHeight + 1));
|
|
result.push_back(Pair("height", pblockindex->nHeight));
|
|
result.push_back(Pair("version", pblockindex->nVersion));
|
|
result.push_back(Pair("merkleroot", pblockindex->hashMerkleRoot.GetHex()));
|
|
result.push_back(Pair("mint", ValueFromAmount(pblockindex->nMint)));
|
|
result.push_back(Pair("time", (boost::int64_t)pblockindex->GetBlockTime()));
|
|
result.push_back(Pair("nonce", (boost::uint64_t)pblockindex->nNonce));
|
|
result.push_back(Pair("bits", HexBits(pblockindex->nBits)));
|
|
result.push_back(Pair("difficulty", GetDifficulty(pblockindex)));
|
|
result.push_back(Pair("blocktrust", leftTrim(pblockindex->GetBlockTrust().GetHex(), '0')));
|
|
result.push_back(Pair("chaintrust", leftTrim(pblockindex->nChainTrust.GetHex(), '0')));
|
|
result.push_back(Pair("flags", strprintf("%s%s",
|
|
pblockindex->IsProofOfStake() ? "proof-of-stake" : "proof-of-work",
|
|
pblockindex->GeneratedStakeModifier() ? " stake-modifier" : "")));
|
|
result.push_back(Pair("proofhash", pblockindex->IsProofOfStake() ? pblockindex->hashProofOfStake.GetHex() : pblockindex->GetBlockHash().GetHex()));
|
|
result.push_back(Pair("entropybit", (int)pblockindex->GetStakeEntropyBit()));
|
|
result.push_back(Pair("modifier", strprintf("%016"PRIx64, pblockindex->nStakeModifier)));
|
|
result.push_back(Pair("modifierchecksum", strprintf("%08x", pblockindex->nStakeModifierChecksum)));
|
|
if (pblockindex->pprev)
|
|
result.push_back(Pair("previousblockhash", pblockindex->pprev->GetBlockHash().GetHex()));
|
|
if (pblockindex->pnext)
|
|
result.push_back(Pair("nextblockhash", pblockindex->pnext->GetBlockHash().GetHex()));
|
|
|
|
return result;
|
|
}
|
|
|
|
Value estimatefee(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"estimatefee <nblocks>\n"
|
|
"Returns an estimated fee per kilobyte for a transaction to be\n"
|
|
"confirmed within nblocks blocks.\n"
|
|
"Triangles uses a static minimum fee structure.");
|
|
|
|
return ValueFromAmount(nTransactionFee > 0 ? nTransactionFee : MIN_TX_FEE);
|
|
}
|
|
|
|
Value gettxoutsetinfo(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"gettxoutsetinfo\n"
|
|
"Returns statistics about the unspent transaction output set.");
|
|
|
|
Object obj;
|
|
obj.push_back(Pair("height", (int)nBestHeight));
|
|
obj.push_back(Pair("bestblock", hashBestChain.GetHex()));
|
|
obj.push_back(Pair("total_amount", ValueFromAmount(pindexBest->nMoneySupply)));
|
|
return obj;
|
|
}
|
|
|
|
static void GetActiveChainVector(std::vector<CBlockIndex*>& chain)
|
|
{
|
|
chain.clear();
|
|
|
|
if (!pindexBest)
|
|
throw runtime_error("recalculatesupply: no best block");
|
|
|
|
for (CBlockIndex* pindex = pindexBest; pindex; pindex = pindex->pprev)
|
|
chain.push_back(pindex);
|
|
|
|
std::reverse(chain.begin(), chain.end());
|
|
}
|
|
|
|
static int64_t ComputeActiveChainSupplyFromBlocks(const std::vector<CBlockIndex*>& chain, int& nBlocksScanned, int& nTransactionsScanned)
|
|
{
|
|
nBlocksScanned = 0;
|
|
nTransactionsScanned = 0;
|
|
|
|
CTxDB txdb("r");
|
|
int64_t nSupply = 0;
|
|
|
|
for (std::vector<CBlockIndex*>::const_iterator pindexIt = chain.begin(); pindexIt != chain.end(); ++pindexIt)
|
|
{
|
|
CBlockIndex* pindex = *pindexIt;
|
|
if (!pindex)
|
|
throw runtime_error("recalculatesupply: null active-chain block index");
|
|
|
|
if (pindex->nHeight == 0)
|
|
{
|
|
nBlocksScanned++;
|
|
continue;
|
|
}
|
|
|
|
CBlock block;
|
|
int64_t nBlockValueIn = 0;
|
|
int64_t nBlockValueOut = 0;
|
|
|
|
if (!block.ReadFromDisk(pindex))
|
|
throw runtime_error(strprintf("recalculatesupply: failed reading block at height %d", pindex->nHeight));
|
|
|
|
for (std::vector<CTransaction>::const_iterator txIt = block.vtx.begin(); txIt != block.vtx.end(); ++txIt)
|
|
{
|
|
const CTransaction& tx = *txIt;
|
|
nTransactionsScanned++;
|
|
nBlockValueOut += tx.GetValueOut();
|
|
|
|
if (!tx.IsCoinBase())
|
|
{
|
|
for (std::vector<CTxIn>::const_iterator txinIt = tx.vin.begin(); txinIt != tx.vin.end(); ++txinIt)
|
|
{
|
|
const CTxIn& txin = *txinIt;
|
|
CTxIndex txindex;
|
|
CTransaction txPrev;
|
|
if (!txPrev.ReadFromDisk(txdb, txin.prevout, txindex))
|
|
throw runtime_error(strprintf(
|
|
"recalculatesupply: failed reading prevout %s:%u while processing height %d",
|
|
txin.prevout.hash.ToString().c_str(), txin.prevout.n, pindex->nHeight));
|
|
|
|
if (txin.prevout.n >= txPrev.vout.size())
|
|
throw runtime_error(strprintf(
|
|
"recalculatesupply: prevout index %u out of range for tx %s at height %d",
|
|
txin.prevout.n, txin.prevout.hash.ToString().c_str(), pindex->nHeight));
|
|
|
|
nBlockValueIn += txPrev.vout[txin.prevout.n].nValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
nSupply += (nBlockValueOut - nBlockValueIn);
|
|
nBlocksScanned++;
|
|
}
|
|
|
|
return nSupply;
|
|
}
|
|
|
|
Value recalculatesupply(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() > 1)
|
|
throw runtime_error(
|
|
"recalculatesupply [apply=false]\n"
|
|
"Rebuilds money supply by walking the active chain from genesis and summing (valueOut - valueIn) per block.\n"
|
|
"Also returns the current UTXO-set total for comparison.\n"
|
|
"If apply=true, rewrites nMoneySupply for every block on the active chain and persists the repaired values.\n"
|
|
"\nThis is intended for repairing corrupted money-supply tracking after chain/index incidents.");
|
|
|
|
bool fApply = false;
|
|
if (params.size() == 1)
|
|
fApply = params[0].get_bool();
|
|
|
|
LOCK(cs_main);
|
|
|
|
if (!pindexBest)
|
|
throw runtime_error("recalculatesupply: no best block");
|
|
|
|
CTxDB txdbRead("r");
|
|
int nUtxoCount = 0;
|
|
int64_t nUtxoSupply = txdbRead.SumUtxoValues(nUtxoCount);
|
|
|
|
std::vector<CBlockIndex*> activeChain;
|
|
GetActiveChainVector(activeChain);
|
|
|
|
int nBlocksScanned = 0;
|
|
int nTransactionsScanned = 0;
|
|
int64_t nHistoricalSupply = ComputeActiveChainSupplyFromBlocks(activeChain, nBlocksScanned, nTransactionsScanned);
|
|
|
|
int64_t nOldTipSupply = pindexBest->nMoneySupply;
|
|
|
|
if (fApply)
|
|
{
|
|
CTxDB txdbWrite;
|
|
int64_t nRunningSupply = 0;
|
|
|
|
for (std::vector<CBlockIndex*>::const_iterator pindexIt = activeChain.begin(); pindexIt != activeChain.end(); ++pindexIt)
|
|
{
|
|
CBlockIndex* pindex = *pindexIt;
|
|
if (!pindex)
|
|
throw runtime_error("recalculatesupply: null active-chain block index during apply");
|
|
|
|
if (pindex->nHeight == 0)
|
|
{
|
|
pindex->nMoneySupply = 0;
|
|
if (!txdbWrite.WriteBlockIndex(CDiskBlockIndex(pindex)))
|
|
throw runtime_error("recalculatesupply: failed to persist genesis block index during apply");
|
|
continue;
|
|
}
|
|
|
|
CBlock block;
|
|
int64_t nBlockValueIn = 0;
|
|
int64_t nBlockValueOut = 0;
|
|
|
|
if (!block.ReadFromDisk(pindex))
|
|
throw runtime_error(strprintf("recalculatesupply: failed reading block at height %d during apply", pindex->nHeight));
|
|
|
|
for (std::vector<CTransaction>::const_iterator txIt = block.vtx.begin(); txIt != block.vtx.end(); ++txIt)
|
|
{
|
|
const CTransaction& tx = *txIt;
|
|
nBlockValueOut += tx.GetValueOut();
|
|
|
|
if (!tx.IsCoinBase())
|
|
{
|
|
for (std::vector<CTxIn>::const_iterator txinIt = tx.vin.begin(); txinIt != tx.vin.end(); ++txinIt)
|
|
{
|
|
const CTxIn& txin = *txinIt;
|
|
CTxIndex txindex;
|
|
CTransaction txPrev;
|
|
if (!txPrev.ReadFromDisk(txdbWrite, txin.prevout, txindex))
|
|
throw runtime_error(strprintf(
|
|
"recalculatesupply: failed reading prevout %s:%u during apply at height %d",
|
|
txin.prevout.hash.ToString().c_str(), txin.prevout.n, pindex->nHeight));
|
|
if (txin.prevout.n >= txPrev.vout.size())
|
|
throw runtime_error(strprintf(
|
|
"recalculatesupply: prevout index %u out of range during apply for tx %s at height %d",
|
|
txin.prevout.n, txin.prevout.hash.ToString().c_str(), pindex->nHeight));
|
|
nBlockValueIn += txPrev.vout[txin.prevout.n].nValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
nRunningSupply += (nBlockValueOut - nBlockValueIn);
|
|
pindex->nMoneySupply = nRunningSupply;
|
|
|
|
if (!txdbWrite.WriteBlockIndex(CDiskBlockIndex(pindex)))
|
|
throw runtime_error(strprintf("recalculatesupply: failed to persist block index at height %d", pindex->nHeight));
|
|
}
|
|
}
|
|
|
|
Object result;
|
|
result.push_back(Pair("height", (int)nBestHeight));
|
|
result.push_back(Pair("tip_bestblock", hashBestChain.GetHex()));
|
|
result.push_back(Pair("old_tip_supply", ValueFromAmount(nOldTipSupply)));
|
|
result.push_back(Pair("recalculated_chain_supply", ValueFromAmount(nHistoricalSupply)));
|
|
result.push_back(Pair("utxo_supply", ValueFromAmount(nUtxoSupply)));
|
|
result.push_back(Pair("tip_vs_recalculated", ValueFromAmount(nHistoricalSupply - nOldTipSupply)));
|
|
result.push_back(Pair("utxo_vs_recalculated", ValueFromAmount(nHistoricalSupply - nUtxoSupply)));
|
|
result.push_back(Pair("blocks_scanned", nBlocksScanned));
|
|
result.push_back(Pair("transactions_scanned", nTransactionsScanned));
|
|
result.push_back(Pair("utxo_count", nUtxoCount));
|
|
result.push_back(Pair("applied", fApply));
|
|
return result;
|
|
}
|
|
|
|
|
|
// triangles: get information of sync-checkpoint
|
|
Value getcheckpoint(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getcheckpoint\n"
|
|
"Show info of synchronized checkpoint.\n");
|
|
|
|
Object result;
|
|
CBlockIndex* pindexCheckpoint;
|
|
|
|
result.push_back(Pair("synccheckpoint", Checkpoints::hashSyncCheckpoint.ToString().c_str()));
|
|
pindexCheckpoint = mapBlockIndex[Checkpoints::hashSyncCheckpoint];
|
|
result.push_back(Pair("height", pindexCheckpoint->nHeight));
|
|
result.push_back(Pair("timestamp", DateTimeStrFormat(pindexCheckpoint->GetBlockTime()).c_str()));
|
|
|
|
// Check that the block satisfies synchronized checkpoint
|
|
if (CheckpointsMode == Checkpoints::STRICT)
|
|
result.push_back(Pair("policy", "strict"));
|
|
|
|
if (CheckpointsMode == Checkpoints::ADVISORY)
|
|
result.push_back(Pair("policy", "advisory"));
|
|
|
|
if (CheckpointsMode == Checkpoints::PERMISSIVE)
|
|
result.push_back(Pair("policy", "permissive"));
|
|
|
|
if (mapArgs.count("-checkpointkey"))
|
|
result.push_back(Pair("checkpointmaster", true));
|
|
|
|
return result;
|
|
}
|
|
|
|
Value getblockchaininfo(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getblockchaininfo\n"
|
|
"Returns an object containing various state info regarding block chain processing.");
|
|
|
|
Object obj, diff;
|
|
obj.push_back(Pair("chain", fTestNet ? string("test") : string("main")));
|
|
obj.push_back(Pair("blocks", (int)nBestHeight));
|
|
obj.push_back(Pair("headers", (int)nBestHeight));
|
|
obj.push_back(Pair("bestblockhash", hashBestChain.GetHex()));
|
|
|
|
diff.push_back(Pair("proof-of-work", GetDifficulty()));
|
|
diff.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
|
|
obj.push_back(Pair("difficulty", diff));
|
|
|
|
obj.push_back(Pair("moneysupply", ValueFromAmount(pindexBest->nMoneySupply)));
|
|
obj.push_back(Pair("timeoffset", (boost::int64_t)GetTimeOffset()));
|
|
obj.push_back(Pair("connections", (int)vNodes.size()));
|
|
obj.push_back(Pair("errors", GetWarnings("statusbar")));
|
|
return obj;
|
|
}
|
|
|
|
Value gencheckpoints(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() > 1)
|
|
throw runtime_error(
|
|
"gencheckpoints [interval]\n"
|
|
"Generates hardcoded checkpoint entries for checkpoints.cpp.\n"
|
|
"Outputs C++ map entries for every <interval> blocks (default 5000)\n"
|
|
"from genesis to current tip, ready to paste into the source code.");
|
|
|
|
int nInterval = 5000;
|
|
if (params.size() > 0)
|
|
nInterval = params[0].get_int();
|
|
if (nInterval < 1)
|
|
throw runtime_error("Interval must be >= 1");
|
|
|
|
std::string result;
|
|
result += "// Generated by gencheckpoints RPC at height " + std::to_string(nBestHeight) + "\n";
|
|
result += "static MapCheckpoints mapCheckpoints = {\n";
|
|
|
|
// Always include genesis
|
|
CBlockIndex* pindex = mapBlockIndex[hashBestChain];
|
|
while (pindex->pprev)
|
|
pindex = pindex->pprev;
|
|
|
|
bool first = true;
|
|
while (pindex)
|
|
{
|
|
if (pindex->nHeight % nInterval == 0 || pindex->nHeight == nBestHeight)
|
|
{
|
|
if (!first)
|
|
result += ",\n";
|
|
result += " {" + std::to_string(pindex->nHeight) + ", uint256(\"0x"
|
|
+ pindex->GetBlockHash().GetHex() + "\")}";
|
|
first = false;
|
|
}
|
|
pindex = pindex->pnext;
|
|
}
|
|
result += "\n};\n";
|
|
|
|
return result;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Address index RPC commands
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Helper: parse an address string and return (nType, hashBytes).
|
|
* Throws JSONRPCError on invalid address.
|
|
*/
|
|
static bool ParseAddress(const std::string& strAddr, int& nType, uint160& hashBytes)
|
|
{
|
|
CTrianglesAddress addr(strAddr);
|
|
if (!addr.IsValid())
|
|
return false;
|
|
|
|
CTxDestination dest = addr.Get();
|
|
const CKeyID* keyId = std::get_if<CKeyID>(&dest);
|
|
if (keyId) {
|
|
nType = ADDR_TYPE_P2PKH;
|
|
hashBytes = *keyId;
|
|
return true;
|
|
}
|
|
const CScriptID* scriptId = std::get_if<CScriptID>(&dest);
|
|
if (scriptId) {
|
|
nType = ADDR_TYPE_P2SH;
|
|
hashBytes = *scriptId;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Value getaddressbalance(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"getaddressbalance {\"addresses\":[\"addr\",...]}\n"
|
|
"Returns the balance for address(es).\n"
|
|
"Requires -addressindex=1.\n"
|
|
"\nArguments:\n"
|
|
"1. {\"addresses\":[\"addr\",...]} (object) JSON object with address array\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"balance\" : n, (numeric) The current balance in satoshis\n"
|
|
" \"received\" : n (numeric) The total received in satoshis\n"
|
|
"}");
|
|
|
|
if (!fAddressIndex)
|
|
throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled. Start with -addressindex=1");
|
|
|
|
Object addrObj = params[0].get_obj();
|
|
Array addrArray = find_value(addrObj, "addresses").get_array();
|
|
|
|
int64_t nTotalBalance = 0;
|
|
|
|
for (unsigned int i = 0; i < addrArray.size(); i++)
|
|
{
|
|
std::string strAddr = addrArray[i].get_str();
|
|
int nType;
|
|
uint160 hashBytes;
|
|
if (!ParseAddress(strAddr, nType, hashBytes))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address: " + strAddr);
|
|
|
|
int64_t nBalance = 0;
|
|
CTxDB txdb("r");
|
|
txdb.ReadAddressBalance(nType, hashBytes, nBalance);
|
|
nTotalBalance += nBalance;
|
|
}
|
|
|
|
Object result;
|
|
result.push_back(Pair("balance", nTotalBalance));
|
|
return result;
|
|
}
|
|
|
|
Value getaddressutxos(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"getaddressutxos {\"addresses\":[\"addr\",...]}\n"
|
|
"Returns all unspent outputs for address(es).\n"
|
|
"Requires -addressindex=1.\n"
|
|
"\nArguments:\n"
|
|
"1. {\"addresses\":[\"addr\",...]} (object) JSON object with address array\n"
|
|
"\nResult:\n"
|
|
"[{\n"
|
|
" \"address\" : \"addr\", (string) The address\n"
|
|
" \"txid\" : \"hash\", (string) The transaction id\n"
|
|
" \"outputIndex\" : n, (numeric) The output index\n"
|
|
" \"satoshis\" : n, (numeric) The amount in satoshis\n"
|
|
" \"height\" : n (numeric) The block height\n"
|
|
"},...]");
|
|
|
|
if (!fAddressIndex)
|
|
throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled. Start with -addressindex=1");
|
|
|
|
Object addrObj = params[0].get_obj();
|
|
Array addrArray = find_value(addrObj, "addresses").get_array();
|
|
|
|
Array result;
|
|
CTxDB txdb("r");
|
|
|
|
for (unsigned int i = 0; i < addrArray.size(); i++)
|
|
{
|
|
std::string strAddr = addrArray[i].get_str();
|
|
int nType;
|
|
uint160 hashBytes;
|
|
if (!ParseAddress(strAddr, nType, hashBytes))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address: " + strAddr);
|
|
|
|
std::vector<std::pair<COutPoint, std::pair<int64_t, int> > > vUtxos;
|
|
txdb.GetAddressUtxos(nType, hashBytes, vUtxos);
|
|
|
|
for (unsigned int j = 0; j < vUtxos.size(); j++)
|
|
{
|
|
Object utxo;
|
|
utxo.push_back(Pair("address", strAddr));
|
|
utxo.push_back(Pair("txid", vUtxos[j].first.hash.GetHex()));
|
|
utxo.push_back(Pair("outputIndex", (int)vUtxos[j].first.n));
|
|
utxo.push_back(Pair("satoshis", vUtxos[j].second.first));
|
|
utxo.push_back(Pair("height", vUtxos[j].second.second));
|
|
result.push_back(utxo);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Value getaddresstxids(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"getaddresstxids {\"addresses\":[\"addr\",...],\"start\":n,\"end\":n}\n"
|
|
"Returns the transaction ids for address(es).\n"
|
|
"Requires -addressindex=1.\n"
|
|
"\nArguments:\n"
|
|
"1. {\"addresses\":[\"addr\",...], (object) JSON object\n"
|
|
" \"start\":n, (numeric, optional) Start block height (default 0)\n"
|
|
" \"end\":n} (numeric, optional) End block height (default current)\n"
|
|
"\nResult:\n"
|
|
"[\"txid\",...] (array of strings) Transaction ids");
|
|
|
|
if (!fAddressIndex)
|
|
throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled. Start with -addressindex=1");
|
|
|
|
Object addrObj = params[0].get_obj();
|
|
Array addrArray = find_value(addrObj, "addresses").get_array();
|
|
|
|
int nStartHeight = 0;
|
|
int nEndHeight = nBestHeight;
|
|
|
|
Value startVal = find_value(addrObj, "start");
|
|
if (startVal.type() == int_type)
|
|
nStartHeight = startVal.get_int();
|
|
|
|
Value endVal = find_value(addrObj, "end");
|
|
if (endVal.type() == int_type)
|
|
nEndHeight = endVal.get_int();
|
|
|
|
Array result;
|
|
CTxDB txdb("r");
|
|
|
|
// Use a set to deduplicate txids across multiple addresses
|
|
std::set<uint256> setTxIds;
|
|
|
|
for (unsigned int i = 0; i < addrArray.size(); i++)
|
|
{
|
|
std::string strAddr = addrArray[i].get_str();
|
|
int nType;
|
|
uint160 hashBytes;
|
|
if (!ParseAddress(strAddr, nType, hashBytes))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address: " + strAddr);
|
|
|
|
std::vector<uint256> vTxIds;
|
|
txdb.GetAddressTxIds(nType, hashBytes, nStartHeight, nEndHeight, vTxIds);
|
|
|
|
for (unsigned int j = 0; j < vTxIds.size(); j++)
|
|
{
|
|
if (setTxIds.insert(vTxIds[j]).second)
|
|
result.push_back(vTxIds[j].GetHex());
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Value getchaintips(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getchaintips\n"
|
|
"Return information about all known tips in the block tree,\n"
|
|
"including the main chain as well as orphaned branches.\n"
|
|
"Essential for diagnosing chain forks.");
|
|
|
|
// Collect all block indices that are tips (nothing points to them as pprev)
|
|
set<CBlockIndex*> setTips;
|
|
|
|
{
|
|
LOCK(cs_main);
|
|
for (const auto& item : mapBlockIndex)
|
|
setTips.insert(item.second);
|
|
|
|
for (const auto& item : mapBlockIndex) {
|
|
if (item.second->pprev)
|
|
setTips.erase(item.second->pprev);
|
|
}
|
|
}
|
|
|
|
Array res;
|
|
LOCK(cs_main);
|
|
for (CBlockIndex* tip : setTips)
|
|
{
|
|
Object obj;
|
|
obj.push_back(Pair("height", tip->nHeight));
|
|
obj.push_back(Pair("hash", tip->GetBlockHash().GetHex()));
|
|
obj.push_back(Pair("chaintrust", tip->nChainTrust.GetHex()));
|
|
|
|
int branchLen = 0;
|
|
CBlockIndex* pWalk = tip;
|
|
while (pWalk && !pWalk->IsInMainChain()) {
|
|
branchLen++;
|
|
pWalk = pWalk->pprev;
|
|
}
|
|
|
|
string status;
|
|
if (tip == pindexBest)
|
|
status = "active";
|
|
else if (branchLen > 0)
|
|
status = "valid-fork";
|
|
else
|
|
status = "unknown";
|
|
|
|
obj.push_back(Pair("branchlen", branchLen));
|
|
obj.push_back(Pair("status", status));
|
|
|
|
if (pWalk && !tip->IsInMainChain())
|
|
obj.push_back(Pair("forkpoint", pWalk->GetBlockHash().GetHex()));
|
|
|
|
res.push_back(obj);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
Value invalidateblock(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"invalidateblock <hash>\n"
|
|
"Permanently marks a block as invalid and rewinds the chain.\n"
|
|
"This forces the node to reorganize to the parent chain.\n"
|
|
"Use reconsiderblock to undo.");
|
|
|
|
string strHash = params[0].get_str();
|
|
uint256 hash(strHash);
|
|
|
|
LOCK(cs_main);
|
|
|
|
if (mapBlockIndex.count(hash) == 0)
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
|
|
|
CBlockIndex* pindex = mapBlockIndex[hash];
|
|
|
|
if (pindex->IsInMainChain())
|
|
{
|
|
CTxDB txdb;
|
|
if (!txdb.TxnBegin())
|
|
throw runtime_error("Failed to begin transaction.");
|
|
|
|
CBlockIndex* pindexWalk = pindexBest;
|
|
|
|
// Disconnect blocks from best back to (but not including) pindex's parent
|
|
while (pindexWalk && pindexWalk != pindex->pprev)
|
|
{
|
|
CBlock block;
|
|
if (!block.ReadFromDisk(pindexWalk))
|
|
throw runtime_error("Failed to read block from disk during invalidation.");
|
|
|
|
if (!block.DisconnectBlock(txdb, pindexWalk))
|
|
throw runtime_error("Failed to disconnect block during invalidation.");
|
|
|
|
// Remove disconnected PoS blocks from setStakeSeen
|
|
if (pindexWalk->IsProofOfStake())
|
|
{
|
|
extern set<pair<COutPoint, unsigned int> > setStakeSeen;
|
|
setStakeSeen.erase(make_pair(pindexWalk->prevoutStake, pindexWalk->nStakeTime));
|
|
}
|
|
|
|
pindexWalk->pprev->pnext = NULL;
|
|
pindexWalk = pindexWalk->pprev;
|
|
}
|
|
|
|
// Update best block to the fork point
|
|
if (pindex->pprev) {
|
|
pindexBest = pindex->pprev;
|
|
extern uint256 nBestChainTrust;
|
|
nBestChainTrust = pindexBest->nChainTrust;
|
|
nBestHeight = pindexBest->nHeight;
|
|
txdb.WriteHashBestChain(pindexBest->GetBlockHash());
|
|
if (!txdb.TxnCommit())
|
|
throw runtime_error("Failed to commit transaction.");
|
|
printf("invalidateblock: rewound chain to height %d hash %s\n",
|
|
pindexBest->nHeight, pindexBest->GetBlockHash().ToString().c_str());
|
|
}
|
|
}
|
|
|
|
return Value::null;
|
|
}
|
|
|
|
Value reconsiderblock(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"reconsiderblock <hash>\n"
|
|
"Reconsiders a previously invalidated block for activation.\n"
|
|
"If it has more chain trust than current best, triggers a reorg.");
|
|
|
|
string strHash = params[0].get_str();
|
|
uint256 hash(strHash);
|
|
|
|
LOCK(cs_main);
|
|
|
|
if (mapBlockIndex.count(hash) == 0)
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
|
|
|
CBlockIndex* pindex = mapBlockIndex[hash];
|
|
|
|
extern uint256 nBestChainTrust;
|
|
if (pindex->nChainTrust > nBestChainTrust)
|
|
{
|
|
CBlock block;
|
|
if (!block.ReadFromDisk(pindex))
|
|
throw runtime_error("Failed to read block from disk.");
|
|
|
|
CTxDB txdb;
|
|
block.SetBestChain(txdb, pindex);
|
|
printf("reconsiderblock: reconsidered block %s at height %d, new best height=%d\n",
|
|
hash.ToString().c_str(), pindex->nHeight, nBestHeight);
|
|
}
|
|
else
|
|
{
|
|
printf("reconsiderblock: block %s does not have more trust than current best\n",
|
|
hash.ToString().c_str());
|
|
}
|
|
|
|
return Value::null;
|
|
}
|
|
|
|
Value dumputxoset(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"dumputxoset <filename> [nheaders]\n"
|
|
"Dumps the current UTXO set and recent block headers to a binary snapshot file.\n"
|
|
"The snapshot can be used by new nodes to skip initial block download.\n"
|
|
"\nArguments:\n"
|
|
"1. filename (string, required) Destination file path\n"
|
|
"2. nheaders (int, optional, default=2000) Number of block headers to include\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"filename\": \"...\",\n"
|
|
" \"height\": n,\n"
|
|
" \"blockhash\": \"...\",\n"
|
|
" \"file_size\": n\n"
|
|
"}");
|
|
|
|
string filename = params[0].get_str();
|
|
unsigned int nHeaders = UTXO_SNAPSHOT_DEFAULT_HEADERS;
|
|
if (params.size() > 1)
|
|
nHeaders = params[1].get_int();
|
|
|
|
if (nHeaders < 100)
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "nheaders must be at least 100");
|
|
|
|
boost::filesystem::path destPath(filename);
|
|
std::string strError;
|
|
|
|
if (!UtxoSnapshot::DumpSnapshot(destPath, nHeaders, strError))
|
|
throw runtime_error("dumputxoset failed: " + strError);
|
|
|
|
// Get file size
|
|
int64_t nFileSize = 0;
|
|
if (boost::filesystem::exists(destPath))
|
|
nFileSize = (int64_t)boost::filesystem::file_size(destPath);
|
|
|
|
Object result;
|
|
result.push_back(Pair("filename", filename));
|
|
result.push_back(Pair("height", nBestHeight));
|
|
result.push_back(Pair("blockhash", hashBestChain.GetHex()));
|
|
result.push_back(Pair("file_size", nFileSize));
|
|
|
|
return result;
|
|
}
|