test

[VerusCoin.git] / src / txdb.cpp

diff --git a/src/txdb.cpp b/src/txdb.cpp
index da271bd5d1a11c95a16d7139a0241ff738b78dba..95964f1a868d2ae49467dd1653085872bf2c77b8 100644 (file)
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -5,6 +5,9 @@
 
 #include "txdb.h"
 
+#include "chainparams.h"
+#include "hash.h"
+#include "main.h"
 #include "pow.h"
 #include "uint256.h"
 
@@ -14,17 +17,39 @@
 
 using namespace std;
 
+static const char DB_ANCHOR = 'A';
+static const char DB_NULLIFIER = 's';
 static const char DB_COINS = 'c';
 static const char DB_BLOCK_FILES = 'f';
 static const char DB_TXINDEX = 't';
 static const char DB_BLOCK_INDEX = 'b';
 
 static const char DB_BEST_BLOCK = 'B';
+static const char DB_BEST_ANCHOR = 'a';
 static const char DB_FLAG = 'F';
 static const char DB_REINDEX_FLAG = 'R';
 static const char DB_LAST_BLOCK = 'l';
 
 
+void static BatchWriteAnchor(CLevelDBBatch &batch,
+                             const uint256 &croot,
+                             const ZCIncrementalMerkleTree &tree,
+                             const bool &entered)
+{
+    if (!entered)
+        batch.Erase(make_pair(DB_ANCHOR, croot));
+    else {
+        batch.Write(make_pair(DB_ANCHOR, croot), tree);
+    }
+}
+
+void static BatchWriteNullifier(CLevelDBBatch &batch, const uint256 &nf, const bool &entered) {
+    if (!entered)
+        batch.Erase(make_pair(DB_NULLIFIER, nf));
+    else
+        batch.Write(make_pair(DB_NULLIFIER, nf), true);
+}
+
 void static BatchWriteCoins(CLevelDBBatch &batch, const uint256 &hash, const CCoins &coins) {
     if (coins.IsPruned())
         batch.Erase(make_pair(DB_COINS, hash));
@@ -36,9 +61,33 @@ void static BatchWriteHashBestChain(CLevelDBBatch &batch, const uint256 &hash) {
     batch.Write(DB_BEST_BLOCK, hash);
 }
 
+void static BatchWriteHashBestAnchor(CLevelDBBatch &batch, const uint256 &hash) {
+    batch.Write(DB_BEST_ANCHOR, hash);
+}
+
 CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe) {
 }
 
+
+bool CCoinsViewDB::GetAnchorAt(const uint256 &rt, ZCIncrementalMerkleTree &tree) const {
+    if (rt == ZCIncrementalMerkleTree::empty_root()) {
+        ZCIncrementalMerkleTree new_tree;
+        tree = new_tree;
+        return true;
+    }
+
+    bool read = db.Read(make_pair(DB_ANCHOR, rt), tree);
+
+    return read;
+}
+
+bool CCoinsViewDB::GetNullifier(const uint256 &nf) const {
+    bool spent = false;
+    bool read = db.Read(make_pair(DB_NULLIFIER, nf), spent);
+
+    return read;
+}
+
 bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const {
     return db.Read(make_pair(DB_COINS, txid), coins);
 }
@@ -54,7 +103,18 @@ uint256 CCoinsViewDB::GetBestBlock() const {
     return hashBestChain;
 }
 
-bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
+uint256 CCoinsViewDB::GetBestAnchor() const {
+    uint256 hashBestAnchor;
+    if (!db.Read(DB_BEST_ANCHOR, hashBestAnchor))
+        return ZCIncrementalMerkleTree::empty_root();
+    return hashBestAnchor;
+}
+
+bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins,
+                              const uint256 &hashBlock,
+                              const uint256 &hashAnchor,
+                              CAnchorsMap &mapAnchors,
+                              CNullifiersMap &mapNullifiers) {
     CLevelDBBatch batch;
     size_t count = 0;
     size_t changed = 0;
@@ -67,8 +127,29 @@ bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
         CCoinsMap::iterator itOld = it++;
         mapCoins.erase(itOld);
     }
+
+    for (CAnchorsMap::iterator it = mapAnchors.begin(); it != mapAnchors.end();) {
+        if (it->second.flags & CAnchorsCacheEntry::DIRTY) {
+            BatchWriteAnchor(batch, it->first, it->second.tree, it->second.entered);
+            // TODO: changed++?
+        }
+        CAnchorsMap::iterator itOld = it++;
+        mapAnchors.erase(itOld);
+    }
+
+    for (CNullifiersMap::iterator it = mapNullifiers.begin(); it != mapNullifiers.end();) {
+        if (it->second.flags & CNullifiersCacheEntry::DIRTY) {
+            BatchWriteNullifier(batch, it->first, it->second.entered);
+            // TODO: changed++?
+        }
+        CNullifiersMap::iterator itOld = it++;
+        mapNullifiers.erase(itOld);
+    }
+
     if (!hashBlock.IsNull())
         BatchWriteHashBestChain(batch, hashBlock);
+    if (!hashAnchor.IsNull())
+        BatchWriteHashBestAnchor(batch, hashAnchor);
 
     LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
     return db.WriteBatch(batch);
@@ -185,6 +266,8 @@ bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
     return true;
 }
 
+void komodo_index2pubkey33(uint8_t *pubkey33,CBlockIndex *pindex,int32_t height);
+
 bool CBlockTreeDB::LoadBlockIndexGuts()
 {
     boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator());
@@ -214,17 +297,19 @@ bool CBlockTreeDB::LoadBlockIndexGuts()
                 pindexNew->nFile          = diskindex.nFile;
                 pindexNew->nDataPos       = diskindex.nDataPos;
                 pindexNew->nUndoPos       = diskindex.nUndoPos;
+                pindexNew->hashAnchor     = diskindex.hashAnchor;
                 pindexNew->nVersion       = diskindex.nVersion;
                 pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
                 pindexNew->nTime          = diskindex.nTime;
                 pindexNew->nBits          = diskindex.nBits;
                 pindexNew->nNonce         = diskindex.nNonce;
+                pindexNew->nSolution      = diskindex.nSolution;
                 pindexNew->nStatus        = diskindex.nStatus;
                 pindexNew->nTx            = diskindex.nTx;
-
-                if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits))
+                uint8_t pubkey33[33];
+                komodo_index2pubkey33(pubkey33,pindexNew,pindexNew->nHeight);
+                if (!CheckProofOfWork(pindexNew->nHeight,pubkey33,pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
                     return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
-
                 pcursor->Next();
             } else {
                 break; // if shutdown requested or finished loading block index