diff --git a/src/chain.h b/src/chain.h index f564a9a3c..b596ad75a 100644 --- a/src/chain.h +++ b/src/chain.h @@ -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) diff --git a/src/main.cpp b/src/main.cpp index a695a3a64..b137a04c9 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -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. diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp index 8b2976bf6..0ff5a1b40 100644 --- a/src/rpc/blockchain.cpp +++ b/src/rpc/blockchain.cpp @@ -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; diff --git a/src/txdb.cpp b/src/txdb.cpp index a2ae3fb21..334977f2d 100644 --- a/src/txdb.cpp +++ b/src/txdb.cpp @@ -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; - -//fprintf(stderr,"loadguts ht.%d\n",pindexNew->GetHeight()); + 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()); // Consistency checks auto header = pindexNew->GetBlockHeader(); if (header.GetHash() != pindexNew->GetBlockHash())