DragonX/hush3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Port zindex code from old patches; compiles and seems to work when zindex is disabled

Browse Source
This commit is contained in:
Duke Leto
2019-12-17 12:08:14 -05:00
parent 2492ac8c3a
commit fbfdc8f40f
4 changed files with 301 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
src/chain.h
View File

@@ -138,6 +138,7 @@ class CBlockIndex;
// that involves mining in secret completely ineffective, even before dPOW, unless a large part
// of the staking supply is also controlled. It also enables a faster deterministic convergence,
// aided by both POS and POW.
// TODO: delete this junk
class CChainPower
{
public:
@@ -260,11 +261,59 @@ public:
//! Note: in a potential headers-first mode, this number cannot be relied upon
unsigned int nTx;
//! Number of notarization transactions in this block.
unsigned int nNotarizations;
//! (memory only) Number of payments (shielded or transparent) in the block
//! up to and including this block. One transaction can contain one or more
//! payments. This stat allows us to calculate ratios of shielded/transparent
//! when combined with shielded payment stats
unsigned int nPayments;
//! (memory only) Number of shielded transactions (of any kind) in the block up to and including this block.
//! A shielded transaction is defined as a transaction that contains at least 1 JoinSplit, which includes
//! shielding/de-shielding and other complex transaction possibilties including multiple taddrs/zaddrs as
//! inputs and outputs.
unsigned int nShieldedTx;
//! (memory only) Number of fully shielded transactions. A fully shielded transaction is defined
//! as a transaction containing JoinSplits and only shielded inputs and outputs, i.e. no transparent
// inputs or outputs: z->z or z->(z,z) or z->(z,z,z,) etc...
unsigned int nFullyShieldedTx;
//! (memory only) Number of shielding payments. A shielding payment is defined
//! as having a shielded output but transparent input: t->z
unsigned int nShieldingPayments;
//! (memory only) Number of shielded payments. A shielded payment is defined
//! as having a shielded input or output: t->z or z->t
unsigned int nShieldedPayments;
//! (memory only) Number of fully shielded payments. A fully shielded payment is defined
//! as having a shielded input and shielded output: z->z
unsigned int nFullyShieldedPayments;
//! (memory only) Number of deshielding transactions. A deshielding transaction is defined
//! as a transaction containing JoinSplits and at least one transparent output.
unsigned int nDeshieldingTx;
//! (memory only) Number of deshielding payments. A deshielding payment is defined
//! as one transparent input and one shielded output: z->t
unsigned int nDeshieldingPayments;
//! (memory only) Number of shielding transactions. A shielding transaction is defined
//! as a transaction containing JoinSplits and at least one transparent input
// i.e. t->z or t->(z,t) or z->(z,z,t)
unsigned int nShieldingTx;
//! (memory only) Number of transactions in the chain up to and including this block.
//! This value will be non-zero only if and only if transactions for this block and all its parents are available.
//! Change to 64-bit type when necessary; won't happen before 2030
unsigned int nChainTx;
//! Number of notarization transactions in this chain
int64_t nChainNotarizations;
//! (memory only) Number of payments (shielded or transparent) in the chain
//! up to and including this block. One transaction can contain one or more
//! payments. This stat allows us to calculate ratios of shielded/transparent
@@ -275,41 +324,37 @@ public:
//! A shielded transaction is defined as a transaction that contains at least 1 JoinSplit, which includes
//! shielding/de-shielding and other complex transaction possibilties including multiple taddrs/zaddrs as
//! inputs and outputs.
int64_t nShieldedTx;
int64_t nChainShieldedTx;
//! (memory only) Number of fully shielded transactions. A fully shielded transaction is defined
//! as a transaction containing JoinSplits and only shielded inputs and outputs, i.e. no transparent
// inputs or outputs: z->z or z->(z,z) or z->(z,z,z,) etc...
int64_t nFullyShieldedTx;
int64_t nChainFullyShieldedTx;
//! (memory only) Number of shielding payments. A shielding payment is defined
//! as having a shielded output but transparent input: t->z
int64_t nShieldingPayments;
int64_t nChainShieldingPayments;
//! (memory only) Number of shielded payments. A shielded payment is defined
//! as having a shielded input or output: t->z or z->t
int64_t nShieldedPayments;
int64_t nChainShieldedPayments;
//! (memory only) Number of fully shielded payments. A fully shielded payment is defined
//! as having a shielded input and shielded output: z->z
int64_t nFullyShieldedPayments;
int64_t nChainFullyShieldedPayments;
//! (memory only) Number of deshielding transactions. A deshielding transaction is defined
//! as a transaction containing JoinSplits and at least one transparent output.
int64_t nDeshieldingTx;
int64_t nChainDeshieldingTx;
//! (memory only) Number of deshielding payments. A deshielding payment is defined
//! as one transparent input and one shielded output: z->t
int64_t nDeshieldingPayments;
int64_t nChainDeshieldingPayments;
//! (memory only) Number of shielding transactions. A shielding transaction is defined
//! as a transaction containing JoinSplits and at least one transparent input
// i.e. t->z or t->(z,t) or z->(z,z,t)
int64_t nShieldingTx;
//! (memory only) Number of shielded transactions which contain multiple shielded input notes
//! z_sendmany cannot make these and so it indicates raw shielded transaction usage currently
int64_t nMultipleShieldedInputsTx;
int64_t nChainShieldingTx;
//! Verification status of this block. See enum BlockStatus
unsigned int nStatus;
@@ -369,6 +414,16 @@ public:
chainPower = CChainPower();
nTx = 0;
nChainTx = 0;
nChainPayments = 0;
nChainShieldedTx = 0;
nChainShieldingTx = 0;
nChainDeshieldingTx = 0;
nChainNotarizations = 0;
nChainFullyShieldedTx = 0;
nChainShieldedPayments = 0;
nChainShieldingPayments = 0;
nChainDeshieldingPayments = 0;
nChainFullyShieldedPayments = 0;
nShieldedTx = 0;
nShieldingTx = 0;
nDeshieldingTx = 0;
@@ -377,7 +432,6 @@ public:
nShieldingPayments = 0;
nDeshieldingPayments = 0;
nFullyShieldedPayments = 0;
nMultipleShieldedInputsTx = 0;
nStatus = 0;
nCachedBranchId = boost::none;
hashSproutAnchor = uint256();
@@ -553,6 +607,21 @@ public:
READWRITE(VARINT(nStatus));
READWRITE(VARINT(nTx));
// These values only serialized when -zindex enabled
if((s.GetType() & SER_DISK) && fZindex) {
READWRITE(VARINT(nShieldedTx));
READWRITE(VARINT(nShieldingTx));
READWRITE(VARINT(nDeshieldingTx));
READWRITE(VARINT(nFullyShieldedTx));
READWRITE(VARINT(nShieldedPayments));
READWRITE(VARINT(nShieldingPayments));
READWRITE(VARINT(nDeshieldingPayments));
READWRITE(VARINT(nFullyShieldedPayments));
READWRITE(VARINT(nNotarizations));
}
if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
READWRITE(VARINT(nFile));
if (nStatus & BLOCK_HAVE_DATA)

133
src/main.cpp
View File

@@ -4717,6 +4717,10 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
CAmount sproutValue = 0;
CAmount saplingValue = 0;
bool isShieldedTx = false;
unsigned int nShieldedSpends=0,nShieldedOutputs=0,nPayments=0;
unsigned int nShieldedTx=0,nFullyShieldedTx=0,nDeshieldingTx=0,nShieldingTx=0;
unsigned int nShieldedPayments=0,nFullyShieldedPayments=0,nShieldingPayments=0,nDeshieldingPayments=0;
unsigned int nNotarizations=0;
for (auto tx : block.vtx) {
// Negative valueBalance "takes" money from the transparent value pool
@@ -4729,6 +4733,69 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
sproutValue += js.vpub_old;
sproutValue -= js.vpub_new;
}
// Ignore following stats unless -zindex enabled
if (!fZindex)
continue;
nShieldedSpends = tx.vShieldedSpend.size();
nShieldedOutputs = tx.vShieldedOutput.size();
isShieldedTx = (nShieldedSpends + nShieldedOutputs) > 0 ? true : false;
// We want to avoid full verification with a low false-positive rate
if(tx.vin.size()==13 && tx.vout.size()==2 && tx.vout[1].scriptPubKey.IsOpReturn() && tx.vout[1].nValue==0) {
nNotarizations++;
}
if(isShieldedTx) {
nShieldedTx++;
if(tx.vin.size()==0 && tx.vout.size()==0) {
nFullyShieldedTx++;
} else if(tx.vin.size()>0) {
nShieldingTx++;
} else if(tx.vout.size()>0) {
nDeshieldingTx++;
}
//NOTE: These are at best heuristics. Improve them as much as possible.
// You cannot compare stats generated from different sets of heuristics, so
// if you change this code, you must delete and resync from scratch, or you
// will be mixing together data from two set of heuristics.
if (nShieldedOutputs >= 1) {
// If there are shielded outputs, count each as a payment
// By default, if there is more than 1 output, we assume 1 change output which is not a payment.
// In the case of multiple outputs which spend inputs exactly, there is no change output and this
// heuristic will undercount payments. Since this edge case is rare, this seems acceptable.
// t->(t,t,z) = 1 shielded payment
// z->(z,z) = 1 shielded payment + shielded change
// t->(z,z) = 1 shielded payment + shielded change
// t->(t,z) = 1 shielded payment + transparent change
// (z,z)->z = 1 shielded payment (has this xtn ever occurred?)
// z->(z,z,z) = 2 shielded payments + shielded change
// Assume that there is always 1 change output when there are more than one
nShieldedPayments += nShieldedOutputs > 1 ? (nShieldedOutputs-1) : 1;
// Fully shielded do not count toward shielding/deshielding
if(tx.vin.size()==0 && tx.vout.size()==0) {
nFullyShieldedPayments += nShieldedOutputs > 1 ? (nShieldedOutputs-1) : 1;
} else {
nShieldingPayments += nShieldedOutputs > 1 ? (nShieldedOutputs-1) : 1;
}
} else if (nShieldedSpends >=1) {
// Shielded inputs with no shielded outputs. We know none are change output because
// change would flow back to the zaddr
// z->t = 1 shielded payment
// z->(t,t) = 2 shielded payments
// z->(t,t,t) = 3 shielded payments
nShieldedPayments += tx.vout.size();
nDeshieldingPayments += tx.vout.size() > 1 ? tx.vout.size()-1 : tx.vout.size();
}
//TODO: correctly add shielded payments to total chain payments
nPayments += nShieldedPayments;
} else {
// No shielded payments, add transparent payments minus a change address
nPayments += tx.vout.size() > 1 ? tx.vout.size()-1 : tx.vout.size();
}
}
pindexNew->nSproutValue = sproutValue;
pindexNew->nChainSproutValue = boost::none;
@@ -4739,6 +4806,19 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
pindexNew->nUndoPos = 0;
pindexNew->nStatus |= BLOCK_HAVE_DATA;
pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS);
if (fZindex) {
pindexNew->nPayments = nPayments;
pindexNew->nShieldedTx = nShieldedTx;
pindexNew->nFullyShieldedTx = nFullyShieldedTx;
pindexNew->nDeshieldingTx = nDeshieldingTx;
pindexNew->nShieldingTx = nShieldingTx;
pindexNew->nShieldedPayments = nShieldedPayments;
pindexNew->nFullyShieldedPayments = nFullyShieldedPayments;
pindexNew->nDeshieldingPayments = nDeshieldingPayments;
pindexNew->nShieldingPayments = nShieldingPayments;
pindexNew->nNotarizations = nNotarizations;
}
setDirtyBlockIndex.insert(pindexNew);
if (pindexNew->pprev == NULL || pindexNew->pprev->nChainTx) {
@@ -4751,6 +4831,22 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
CBlockIndex *pindex = queue.front();
queue.pop_front();
pindex->nChainTx = (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
if (fZindex) {
fprintf(stderr,"%s: setting chain zstats\n", __FUNCTION__);
pindex->nChainNotarizations = (pindex->pprev ? pindex->pprev->nChainNotarizations : 0) + pindex->nNotarizations;
pindex->nChainShieldedTx = (pindex->pprev ? pindex->pprev->nChainShieldedTx : 0) + pindex->nShieldedTx;
pindex->nChainFullyShieldedTx = (pindex->pprev ? pindex->pprev->nChainFullyShieldedTx : 0) + pindex->nFullyShieldedTx;
pindex->nChainShieldingTx = (pindex->pprev ? pindex->pprev->nChainShieldingTx : 0) + pindex->nShieldingTx;
pindex->nChainDeshieldingTx = (pindex->pprev ? pindex->pprev->nChainDeshieldingTx : 0) + pindex->nDeshieldingTx;
pindex->nChainPayments = (pindex->pprev ? pindex->pprev->nChainPayments : 0) + pindex->nPayments;
pindex->nChainShieldedPayments = (pindex->pprev ? pindex->pprev->nChainShieldedPayments : 0) + pindex->nShieldedPayments;
pindex->nChainFullyShieldedPayments = (pindex->pprev ? pindex->pprev->nChainFullyShieldedPayments : 0) + pindex->nFullyShieldedPayments;
pindex->nChainShieldingPayments = (pindex->pprev ? pindex->pprev->nChainShieldingPayments : 0) + pindex->nShieldingPayments;
pindex->nChainDeshieldingPayments = (pindex->pprev ? pindex->pprev->nChainDeshieldingPayments : 0) + pindex->nDeshieldingPayments;
}
if (pindex->pprev) {
if (pindex->pprev->nChainSproutValue && pindex->nSproutValue) {
pindex->nChainSproutValue = *pindex->pprev->nChainSproutValue + *pindex->nSproutValue;
@@ -4787,6 +4883,9 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
}
}
if (fZindex)
fprintf(stderr, "ht.%d, ShieldedPayments=%d, ShieldedTx=%d, FullyShieldedTx=%d, ntz=%d\n", pindexNew->GetHeight(), nShieldedPayments, nShieldedTx, nFullyShieldedTx, nNotarizations );
return true;
}
@@ -6035,6 +6134,19 @@ bool static LoadBlockIndexDB()
if (pindex->pprev) {
if (pindex->pprev->nChainTx) {
pindex->nChainTx = pindex->pprev->nChainTx + pindex->nTx;
if (fZindex) {
pindex->nChainNotarizations = pindex->pprev->nChainNotarizations + pindex->nNotarizations;
pindex->nChainShieldedTx = pindex->pprev->nChainShieldedTx + pindex->nShieldedTx;
pindex->nChainShieldedPayments = pindex->pprev->nChainShieldedPayments + pindex->nShieldedPayments;
pindex->nChainShieldingTx = pindex->pprev->nChainShieldingTx + pindex->nShieldingTx;
pindex->nChainShieldingPayments = pindex->pprev->nChainShieldingPayments + pindex->nShieldingPayments;
pindex->nChainDeshieldingTx = pindex->pprev->nChainShieldedTx + pindex->nShieldedTx;
pindex->nChainDeshieldingPayments = pindex->pprev->nChainShieldedPayments + pindex->nShieldedPayments;
pindex->nChainFullyShieldedTx = pindex->pprev->nChainFullyShieldedTx + pindex->nFullyShieldedTx;
pindex->nChainFullyShieldedPayments = pindex->pprev->nChainFullyShieldedPayments + pindex->nFullyShieldedPayments;
}
if (pindex->pprev->nChainSproutValue && pindex->nSproutValue) {
pindex->nChainSproutValue = *pindex->pprev->nChainSproutValue + *pindex->nSproutValue;
} else {
@@ -6047,6 +6159,17 @@ bool static LoadBlockIndexDB()
}
} else {
pindex->nChainTx = 0;
if (fZindex) {
pindex->nChainNotarizations = 0;
pindex->nChainShieldedTx = 0;
pindex->nChainFullyShieldedTx = 0;
pindex->nChainShieldedPayments = 0;
pindex->nChainShieldingPayments = 0;
pindex->nChainDeshieldingTx = 0;
pindex->nChainDeshieldingPayments = 0;
pindex->nChainFullyShieldedTx = 0;
pindex->nChainFullyShieldedPayments = 0;
}
pindex->nChainSproutValue = boost::none;
pindex->nChainSaplingValue = boost::none;
mapBlocksUnlinked.insert(std::make_pair(pindex->pprev, pindex));
@@ -6055,6 +6178,16 @@ bool static LoadBlockIndexDB()
pindex->nChainTx = pindex->nTx;
pindex->nChainSproutValue = pindex->nSproutValue;
pindex->nChainSaplingValue = pindex->nSaplingValue;
if (fZindex) {
pindex->nChainNotarizations = pindex->nNotarizations;
pindex->nChainShieldedTx = pindex->nShieldedTx;
pindex->nChainShieldedPayments = pindex->nShieldedPayments;
pindex->nChainShieldingTx = pindex->nShieldingTx;
pindex->nChainShieldingPayments = pindex->nShieldingPayments;
pindex->nChainDeshieldingTx = pindex->nDeshieldingTx;
pindex->nChainDeshieldingPayments = pindex->nDeshieldingPayments;
pindex->nChainFullyShieldedPayments = pindex->nFullyShieldedPayments;
}
}
}
// Construct in-memory chain of branch IDs.

76
src/rpc/blockchain.cpp
View File

@@ -1929,20 +1929,90 @@ UniValue getchaintxstats(const UniValue& params, bool fHelp, const CPubKey& mypk
}
const CBlockIndex* pindexPast = pindex->GetAncestor(pindex->GetHeight() - blockcount);
int nTimeDiff = pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
int nTxDiff = pindex->nChainTx - pindexPast->nChainTx;
int nTimeDiff = pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
int nTxDiff = pindex->nChainTx - pindexPast->nChainTx;
UniValue ret(UniValue::VOBJ);
ret.pushKV("time", (int64_t)pindex->nTime);
ret.pushKV("txcount", (int64_t)pindex->nChainTx);
ret.pushKV("window_final_block_hash", pindex->GetBlockHash().GetHex());
ret.pushKV("window_final_block_height", pindex->GetHeight());
ret.pushKV("window_block_count", blockcount);
if (fZindex) {
ret.pushKV("notarizations", (int64_t)pindex->nChainNotarizations);
ret.pushKV("shielded_txcount", (int64_t)pindex->nChainShieldedTx);
ret.pushKV("fully_shielded_txcount", (int64_t)pindex->nChainFullyShieldedTx);
ret.pushKV("deshielding_txcount", (int64_t)pindex->nChainDeshieldingTx);
ret.pushKV("shielding_txcount", (int64_t)pindex->nChainShieldingTx);
ret.pushKV("shielded_payments", (int64_t)pindex->nChainShieldedPayments);
ret.pushKV("fully_shielded_payments", (int64_t)pindex->nChainFullyShieldedPayments);
ret.pushKV("deshielding_payments", (int64_t)pindex->nChainDeshieldingPayments);
ret.pushKV("shielding_payments", (int64_t)pindex->nChainShieldingPayments);
}
if (blockcount > 0) {
ret.pushKV("window_tx_count", nTxDiff);
ret.pushKV("window_interval", nTimeDiff);
int64_t nPaymentsDiff = pindex->nChainPayments - pindexPast->nChainPayments;
int64_t nShieldedTxDiff = pindex->nChainShieldedTx - pindexPast->nChainShieldedTx;
int64_t nShieldingTxDiff = pindex->nChainShieldingTx - pindexPast->nChainShieldingTx;
int64_t nDeshieldingTxDiff = pindex->nChainDeshieldingTx - pindexPast->nChainDeshieldingTx;
int64_t nFullyShieldedTxDiff = pindex->nChainFullyShieldedTx - pindexPast->nChainFullyShieldedTx;
int64_t nShieldedPaymentsDiff = pindex->nChainShieldedPayments - pindexPast->nChainShieldedPayments;
int64_t nShieldingPaymentsDiff = pindex->nChainShieldingPayments - pindexPast->nChainShieldingPayments;
int64_t nDeshieldingPaymentsDiff = pindex->nChainDeshieldingPayments - pindexPast->nChainDeshieldingPayments;
int64_t nFullyShieldedPaymentsDiff = pindex->nChainFullyShieldedPayments - pindexPast->nChainFullyShieldedPayments;
int64_t nNotarizationsDiff = pindex->nChainNotarizations - pindexPast->nChainNotarizations;
ret.pushKV("window_payments", (int) nPaymentsDiff);
ret.pushKV("window_notarizations", (int) nNotarizationsDiff);
if (nTimeDiff > 0) {
ret.pushKV("txrate", ((double)nTxDiff) / nTimeDiff);
ret.pushKV("txrate", ((double)nTxDiff) / nTimeDiff);
if (fZindex) {
ret.pushKV("notarization_txrate", ((double)nNotarizationsDiff) / nTimeDiff);
ret.pushKV("shielded_txrate", ((double)nShieldedTxDiff) / nTimeDiff);
ret.pushKV("fully_shielded_txrate", ((double)nFullyShieldedTxDiff) / nTimeDiff);
ret.pushKV("paymentrate", ((double)nPaymentsDiff) / nTimeDiff);
ret.pushKV("shielded_paymentrate", ((double)nShieldedPaymentsDiff) / nTimeDiff);
ret.pushKV("fully_shielded_paymentrate", ((double)nFullyShieldedPaymentsDiff) / nTimeDiff);
}
}
if (fZindex) {
ret.pushKV("window_fully_shielded_payments", nFullyShieldedPaymentsDiff);
ret.pushKV("window_shielded_payments", nShieldedPaymentsDiff);
ret.pushKV("window_shielding_payments", nShieldingPaymentsDiff);
ret.pushKV("window_deshielding_payments", nDeshieldingPaymentsDiff);
if (nTxDiff > 0) {
ret.pushKV("shielded_tx_percent", ((double)nShieldedTxDiff) / nTxDiff);
ret.pushKV("fully_shielded_tx_percent", ((double)nFullyShieldedTxDiff) / nTxDiff);
ret.pushKV("shielding_tx_percent", ((double)nShieldingTxDiff) / nTxDiff);
ret.pushKV("deshielding_tx_percent", ((double)nDeshieldingTxDiff) / nTxDiff);
}
if (nPaymentsDiff > 0) {
ret.pushKV("shielded_payments_percent", ((double)nShieldedPaymentsDiff) / nPaymentsDiff);
ret.pushKV("fully_shielded_payments_percent", ((double)nFullyShieldedPaymentsDiff) / nPaymentsDiff);
ret.pushKV("shielding_payments_percent", ((double)nShieldingPaymentsDiff) / nPaymentsDiff);
ret.pushKV("deshielding_payments_percent", ((double)nDeshieldingPaymentsDiff) / nPaymentsDiff);
}
// Shielded statistics
UniValue shielded(UniValue::VOBJ);
if (nShieldedTxDiff > 0) {
shielded.pushKV("fully_shielded_tx_percent", ((double)nFullyShieldedTxDiff) / nShieldedTxDiff );
shielded.pushKV("shielding_tx_percent", ((double)nShieldingTxDiff) / nShieldedTxDiff );
shielded.pushKV("deshielding_tx_percent", ((double)nDeshieldingTxDiff) / nShieldedTxDiff );
}
if (nShieldedPaymentsDiff > 0) {
shielded.pushKV("fully_shielded_payments_percent", ((double)nFullyShieldedPaymentsDiff) / nShieldedPaymentsDiff );
shielded.pushKV("shielding_payments_percent", ((double)nShieldingPaymentsDiff) / nShieldedPaymentsDiff );
shielded.pushKV("deshielding_payments_percent", ((double)nDeshieldingPaymentsDiff) / nShieldedPaymentsDiff );
}
if(nShieldedTxDiff+nShieldedPaymentsDiff > 0)
ret.pushKV("shielded", shielded);
}
}
return ret;

15
src/txdb.cpp
View File

@@ -1,5 +1,7 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin Core developers
// Copyright (c) 2019 The Hush developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -33,7 +35,7 @@
using namespace std;
// NOTE: Per issue #3277, do not use the prefix 'X' or 'x' as they were
// NOTE: Per zcash issue #3277, do not use the prefix 'X' or 'x' as they were
// previously used by DB_SAPLING_ANCHOR and DB_BEST_SAPLING_ANCHOR.
static const char DB_SPROUT_ANCHOR = 'A';
static const char DB_SAPLING_ANCHOR = 'Z';
@@ -720,8 +722,17 @@ bool CBlockTreeDB::LoadBlockIndexGuts()
pindexNew->nSaplingValue = diskindex.nSaplingValue;
pindexNew->segid = diskindex.segid;
pindexNew->nNotaryPay = diskindex.nNotaryPay;
pindexNew->nShieldedTx = diskindex.nShieldedTx;
pindexNew->nShieldedPayments = diskindex.nShieldedPayments;
pindexNew->nShieldingTx = diskindex.nShieldingTx;
pindexNew->nShieldingPayments = diskindex.nShieldingPayments;
pindexNew->nDeshieldingTx = diskindex.nDeshieldingTx;
pindexNew->nDeshieldingPayments = diskindex.nDeshieldingPayments;
pindexNew->nFullyShieldedTx = diskindex.nFullyShieldedTx;
pindexNew->nFullyShieldedPayments = diskindex.nFullyShieldedPayments;
pindexNew->nNotarizations = diskindex.nNotarizations;
//fprintf(stderr,"loadguts ht.%d\n",pindexNew->GetHeight());
fprintf(stderr,"loadguts ht.%d\n",pindexNew->GetHeight());
// Consistency checks
auto header = pindexNew->GetBlockHeader();
if (header.GetHash() != pindexNew->GetBlockHash())