diff --git a/src/hashdb64/database_64.cpp b/src/hashdb64/database_64.cpp
index 6ee591d81..e8959d6be 100644
--- a/src/hashdb64/database_64.cpp
+++ b/src/hashdb64/database_64.cpp
@@ -21,15 +21,16 @@
 #include "tree_chunk.hpp"
 #include "key_value_page.hpp"
 #include "raw_data_page.hpp"
+#include "zkglobals.hpp"
 
 // Helper functions
 string removeBSXIfExists64(string s) {return ((s.at(0) == '\\') && (s.at(1) == 'x')) ? s.substr(2) : s;}
 
-Database64::Database64 (Goldilocks &fr, const Config &config) :
-        fr(fr),
-        config(config),
-        headerPageNumber(0)
+Database64::Database64 (Goldilocks &fr, const Config &config) : headerPageNumber(0), currentFlushId(0)
 {
+    // Init mutex
+    pthread_mutex_init(&mutex, NULL);
+
     zkresult zkr;
     headerPageNumber = 0;
     zkr = HeaderPage::InitEmptyPage(headerPageNumber);
@@ -38,9 +39,6 @@ Database64::Database64 (Goldilocks &fr, const Config &config) :
         zklog.error("Database64::Database64() failed calling HeaderPage::InitEmptyPage() result=" + zkresult2string(zkr));
         exitProcess();
     }
-    // Initialize semaphores
-    //sem_init(&senderSem, 0, 0);
-    //sem_init(&getFlushDataSem, 0, 0);
 };
 
 Database64::~Database64()
@@ -57,33 +55,16 @@ void Database64::init(void)
         exitProcess();
     }
 
-    // Configure the server, if configuration is provided
-    if (config.databaseURL != "local")
-    {
-        // Sender thread creation
-        //pthread_create(&senderPthread, NULL, dbSenderThread64, this);
-
-        // Cache synchronization thread creation
-        /*if (config.dbCacheSynchURL.size() > 0)
-        {
-            pthread_create(&cacheSynchPthread, NULL, dbCacheSynchThread64, this);
-
-        }*/
-
-        useRemoteDB = true;
-    }
-    else
-    {
-        useRemoteDB = false;
-    }
-
     // Mark the database as initialized
     bInitialized = true;
 }
 
 zkresult Database64::readKV(const Goldilocks::Element (&root)[4], const Goldilocks::Element (&key)[4], mpz_class &value, uint64_t &level ,DatabaseMap *dbReadLog)
 {
-    level = 128;
+    zkresult zkr;
+
+    level = 128; // TODO: Return the right level
+
     // Check that it has been initialized before
     if (!bInitialized)
     {
@@ -91,39 +72,52 @@ zkresult Database64::readKV(const Goldilocks::Element (&root)[4], const Goldiloc
         exitProcess();
     }
 
-    struct timeval t;
-    if (dbReadLog != NULL) gettimeofday(&t, NULL);
+    // Convert root to a byte array
+    string rootString = fea2string(fr, root);
+    string rootBa =  string2ba(rootString);
+
+    // Get the version associated to this root
+    uint64_t version;
+    zkr = HeaderPage::ReadRootVersion(headerPageNumber, rootBa, version);
+    if (zkr != ZKR_SUCCESS)
+    {
+        zklog.error("Database64::readKV() faile calling HeaderPage::ReadRootVersion() result=" + zkresult2string(zkr) + " root=" + rootString + " key=" + fea2string(fr, key));
+        return zkr;
+    }
 
-    zkresult rout = ZKR_UNSPECIFIED;
+    // Get the version data
+    VersionDataStruct versionData;
+    zkr = HeaderPage::ReadVersionData(headerPageNumber, version, versionData);
+    if (zkr != ZKR_SUCCESS)
+    {
+        zklog.error("Database64::readKV() faile calling HeaderPage::ReadVersionData() result=" + zkresult2string(zkr) + " root=" + rootString + " key=" + fea2string(fr, key));
+        return zkr;
+    }
+
+    // Get the value
+    string keyString = fea2string(fr, key);
+    string keyBa = string2ba(keyString);
+    zkr = HeaderPage::KeyValueHistoryRead(versionData.keyValueHistoryPage, keyBa, version, value);
+    if (zkr != ZKR_SUCCESS)
+    {
+        zklog.error("Database64::readKV() faile calling HeaderPage::KeyValueHistoryRead() result=" + zkresult2string(zkr) + " root=" + rootString + " key=" + fea2string(fr, key));
+        return zkr;
+    }
     
 #ifdef LOG_DB_READ
     {
         string s = "Database64::readKV()";
-        if (rout != ZKR_SUCCESS)
-            s += " ERROR=" + zkresult2string(rout);
+        if (zkr != ZKR_SUCCESS)
+            s += " ERROR=" + zkresult2string(zkr);
         s += " key=" + keyStr;
         s += " value=";
         s += value.get_str(16) + ";";
         zklog.info(s);
     }
 #endif
-    return rout;
 
+    return zkr;
 }
-/*
-zkresult Database64::readKV(const Goldilocks::Element (&root)[4], vector<KeyValueLevel> &KVLs, DatabaseMap *dbReadLog){
-    zkresult zkr;
-    for (uint64_t i=0; i<KVLs.size(); i++)
-    {
-        zkr = readKV(root, KVLs[i].key, KVLs[i].value, KVLs[i].level, dbReadLog);
-        if (zkr != ZKR_SUCCESS)
-        {
-            zklog.error("Database64::readKV(KBs) failed calling read() result=" + zkresult2string(zkr) + " key=" + fea2string(fr, KVLs[i].key) );
-            return zkr;
-        }
-    }
-    return ZKR_SUCCESS;
-}*/
 
 zkresult Database64::setProgram (const string &key, const vector<uint8_t> &data, const bool persistent)
 {
@@ -202,236 +196,35 @@ zkresult Database64::getProgram(const string &key, vector<uint8_t> &data, Databa
     
 zkresult Database64::flush(uint64_t &thisBatch, uint64_t &lastSentBatch)
 {
-    #if 0
-    if (!config.dbMultiWrite)
-    {
-        return ZKR_SUCCESS;
-    }
-
-    // If we are connected to a read-only database, just free memory and pretend to have sent all the data
-    if (config.dbReadOnly)
-    {
-        multiWrite.Lock();
-        multiWrite.data[multiWrite.pendingToFlushDataIndex].Reset();
-        multiWrite.Unlock();
-
-        return ZKR_SUCCESS;
-    }
-
-    //TimerStart(DATABASE_FLUSH);
-
-    multiWrite.Lock();
-
-    // Accept all intray data
-    multiWrite.data[multiWrite.pendingToFlushDataIndex].acceptIntray();
-
-    // Increase the last processed batch id and return the last sent batch id
-    multiWrite.lastFlushId++;
-    thisBatch = multiWrite.lastFlushId;
-    lastSentBatch = multiWrite.storedFlushId;
+    Lock();
+    currentFlushId++;
+    thisBatch = currentFlushId;
+    lastSentBatch = currentFlushId;
 
 #ifdef LOG_DB_FLUSH
     zklog.info("Database64::flush() thisBatch=" + to_string(thisBatch) + " lastSentBatch=" + to_string(lastSentBatch) + " multiWrite=[" + multiWrite.print() + "]");
 #endif
 
-    // Notify the thread
-    sem_post(&senderSem);
+    Unlock();
 
-    multiWrite.Unlock();
-#endif
     return ZKR_SUCCESS;
 }
 
 zkresult Database64::getFlushStatus(uint64_t &storedFlushId, uint64_t &storingFlushId, uint64_t &lastFlushId, uint64_t &pendingToFlushNodes, uint64_t &pendingToFlushProgram, uint64_t &storingNodes, uint64_t &storingProgram)
 {
-    /*multiWrite.Lock();
-    storedFlushId = multiWrite.storedFlushId;
-    storingFlushId = multiWrite.storingFlushId;
-    lastFlushId = multiWrite.lastFlushId;
-    pendingToFlushNodes = multiWrite.data[multiWrite.pendingToFlushDataIndex].nodes.size();
-    pendingToFlushProgram = multiWrite.data[multiWrite.pendingToFlushDataIndex].program.size();
-    storingNodes = multiWrite.data[multiWrite.storingDataIndex].nodes.size();
-    storingProgram = multiWrite.data[multiWrite.storingDataIndex].program.size();
-    multiWrite.Unlock();*/
-
-    return ZKR_SUCCESS;
-}
-
-
-// Get flush data, written to database by dbSenderThread; it blocks
-zkresult Database64::getFlushData(uint64_t flushId, uint64_t &storedFlushId, unordered_map<string, string> (&nodes), unordered_map<string, string> (&program), string &nodesStateRoot)
-{
-#if 0
-    //zklog.info("--> getFlushData()");
-
-    // Set the deadline to now + 60 seconds
-    struct timespec deadline;
-    clock_gettime(CLOCK_REALTIME, &deadline);
-	deadline.tv_sec += 60;
-
-    // Try to get the semaphore
-    int iResult;
-    iResult = sem_timedwait(&getFlushDataSem, &deadline);
-    if (iResult != 0)
-    {
-        zklog.info("Database64::getFlushData() timed out");
-        return ZKR_SUCCESS;
-    }
-
-    multiWrite.Lock();
-    MultiWriteData64 &data = multiWrite.data[multiWrite.synchronizingDataIndex];
-
-    zklog.info("Database64::getFlushData woke up: pendingToFlushDataIndex=" + to_string(multiWrite.pendingToFlushDataIndex) +
-        " storingDataIndex=" + to_string(multiWrite.storingDataIndex) +
-        " synchronizingDataIndex=" + to_string(multiWrite.synchronizingDataIndex) +
-        " nodes=" + to_string(data.nodes.size()) +
-        " program=" + to_string(data.program.size()) +
-        " nodesStateRoot=" + data.nodesStateRoot);
-
-    if (data.nodes.size() > 0)
-    {
-        nodes = data.nodes;
-    }
-
-    if (data.program.size() > 0)
-    {
-        program = data.program;
-    }
-
-    if (data.nodesStateRoot.size() > 0)
-    {
-        nodesStateRoot = data.nodesStateRoot;
-    }
-
-    multiWrite.Unlock();
-
-    //zklog.info("<-- getFlushData()");
-#endif
+    Lock();
+    storedFlushId = currentFlushId;
+    storingFlushId = currentFlushId;
+    lastFlushId = currentFlushId;
+    pendingToFlushNodes = 0;
+    pendingToFlushProgram = 0;
+    storingNodes = 0;
+    storingProgram = 0;
+    Unlock();
 
     return ZKR_SUCCESS;
 }
 
-void Database64::clearCache (void)
-{
-}
-
-#if 0
-void *dbSenderThread64 (void *arg)
-{
-    Database64 *pDatabase = (Database64 *)arg;
-    zklog.info("dbSenderThread64() started");
-    MultiWrite64 &multiWrite = pDatabase->multiWrite;
-
-    while (true)
-    {
-        // Wait for the sending semaphore to be released, if there is no more data to send
-        struct timespec currentTime;
-        int iResult = clock_gettime(CLOCK_REALTIME, &currentTime);
-        if (iResult == -1)
-        {
-            zklog.error("dbSenderThread64() failed calling clock_gettime()");
-            exitProcess();
-        }
-
-        currentTime.tv_sec += 5;
-        sem_timedwait(&pDatabase->senderSem, &currentTime);
-
-        multiWrite.Lock();
-
-        bool bDataEmpty = false;
-
-        // If sending data is not empty (it failed before) then try to send it again
-        if (!multiWrite.data[multiWrite.storingDataIndex].multiQuery.isEmpty())
-        {
-            zklog.warning("dbSenderThread64() found sending data index not empty, probably because of a previous error; resuming...");
-        }
-        // If processing data is empty, then simply pretend to have sent data
-        else if (multiWrite.data[multiWrite.pendingToFlushDataIndex].IsEmpty())
-        {
-            //zklog.warning("dbSenderThread() found pending to flush data empty");
-
-            // Mark as if we sent all batches
-            multiWrite.storedFlushId = multiWrite.lastFlushId;
-#ifdef LOG_DB_SENDER_THREAD
-            zklog.info("dbSenderThread64() found multi write processing data empty, so ignoring");
-#endif
-            multiWrite.Unlock();
-            continue;
-        }
-        // Else, switch data indexes
-        else
-        {
-            // Accept all intray data
-            multiWrite.data[multiWrite.pendingToFlushDataIndex].acceptIntray(true);
-
-            // Advance processing and sending indexes
-            multiWrite.storingDataIndex = (multiWrite.storingDataIndex + 1) % 3;
-            multiWrite.pendingToFlushDataIndex = (multiWrite.pendingToFlushDataIndex + 1) % 3;
-            multiWrite.data[multiWrite.pendingToFlushDataIndex].Reset();
-#ifdef LOG_DB_SENDER_THREAD
-            zklog.info("dbSenderThread64() updated: multiWrite=[" + multiWrite.print() + "]");
-#endif
-
-            // Record the last processed batch included in this data set
-            multiWrite.storingFlushId = multiWrite.lastFlushId;
-
-            // If there is no data to send, just pretend to have sent it
-            if (multiWrite.data[multiWrite.storingDataIndex].IsEmpty())
-            {
-                // Update stored flush ID
-                multiWrite.storedFlushId = multiWrite.storingFlushId;
-
-                // Advance synchronizing index
-                multiWrite.synchronizingDataIndex = (multiWrite.synchronizingDataIndex + 1) % 3;
-#ifdef LOG_DB_SENDER_THREAD
-                zklog.info("dbSenderThread64() no data to send: multiWrite=[" + multiWrite.print() + "]");
-#endif
-                bDataEmpty = true;
-            }
-
-        }
-
-        // Unlock to let more processing batch data in
-        multiWrite.Unlock();
-
-        if (!bDataEmpty)
-        {
-#ifdef LOG_DB_SENDER_THREAD
-            zklog.info("dbSenderThread64() starting to send data, multiWrite=[" + multiWrite.print() + "]");
-#endif
-            zkresult zkr;
-            zkr = pDatabase->sendData();
-            if (zkr == ZKR_SUCCESS)
-            {
-                multiWrite.Lock();
-                multiWrite.storedFlushId = multiWrite.storingFlushId;
-#ifdef LOG_DB_SENDER_THREAD
-                zklog.info("dbSenderThread64() successfully sent data, multiWrite=[]" + multiWrite.print() + "]");
-#endif
-                // Advance synchronizing index
-                multiWrite.synchronizingDataIndex = (multiWrite.synchronizingDataIndex + 1) % 3;
-#ifdef LOG_DB_SENDER_THREAD
-                zklog.info("dbSenderThread64() updated: multiWrite=[" + multiWrite.print() + "]");
-#endif
-                sem_post(&pDatabase->getFlushDataSem);
-#ifdef LOG_DB_SENDER_THREAD
-                zklog.info("dbSenderThread64() successfully called sem_post(&pDatabase->getFlushDataSem)");
-#endif
-                multiWrite.Unlock();
-            }
-            else
-            {
-                zklog.error("dbSenderThread64() failed calling sendData() error=" + zkresult2string(zkr));
-                usleep(1000000);
-            }
-        }
-    }
-
-    zklog.info("dbSenderThread64() done");
-    return NULL;
-}
-#endif
-
 zkresult Database64::consolidateBlock (uint64_t blockNumber)
 {
     return ZKR_UNSPECIFIED;
@@ -587,58 +380,11 @@ zkresult Database64::WriteTree (const Goldilocks::Element (&oldRoot)[4], const v
     return ZKR_SUCCESS;
 }
 
-zkresult Database64::CalculateHash (Child &result, vector<TreeChunk *> &chunks, vector<DB64Query> &dbQueries, int chunkId, int level, vector<HashValueGL> *hashValues)
-{
-    zkresult zkr;
-    vector<Child> results(64);
-
-    // Convert all TREE_CHUNK children into something else, typically INTERMEDIATE children,
-    // but they could also be LEAF (only one child below this level) or ZERO (no children below this level)
-    for (uint64_t i=0; i<64; i++)
-    {
-        if (chunks[chunkId]->getChild(i).type == TREE_CHUNK)
-        {
-            CalculateHash(result, chunks, dbQueries, chunks[chunkId]->getChild(i).treeChunkId, level + 6, hashValues);
-            chunks[chunkId]->setChild(i, result);
-        }
-    }
-
-    // Calculate the hash of this chunk
-    zkr = chunks[chunkId]->calculateHash(hashValues);
-    if (zkr != ZKR_SUCCESS)
-    {
-        zklog.error("Database64::CalculateHash() failed calling chunks[chunkId]->calculateHash() result=" + zkresult2string(zkr));
-        return zkr;
-    }
-
-    // Copy the result child
-    result = chunks[chunkId]->getChild1();
-
-    // Add to the database queries
-    if (result.type != ZERO)
-    {
-        // Encode the 64 children into database format
-        zkr = chunks[chunkId]->children2data();
-        if (zkr != ZKR_SUCCESS)
-        {
-            zklog.error("Database64::CalculateHash() failed calling chunks[chunkId]->children2data() result=" + zkresult2string(zkr));
-            return zkr;
-        }
-
-        Goldilocks::Element hash[4];
-        chunks[chunkId]->getHash(hash);
-        DB64Query dbQuery(fea2string(fr, hash), hash, chunks[chunkId]->data);
-        dbQueries.emplace_back(dbQuery);
-    }
-
-    return ZKR_SUCCESS;
-}
-
 zkresult Database64::ReadTree (const Goldilocks::Element (&root)[4], vector<KeyValue> &keyValues, vector<HashValueGL> *hashValues)
 {
     zkresult zkr;
 
-    HeaderPage::Print(headerPageNumber, true);
+    //HeaderPage::Print(headerPageNumber, true);
 
     if (keyValues.size() == 0)
     {
@@ -671,6 +417,15 @@ zkresult Database64::ReadTree (const Goldilocks::Element (&root)[4], vector<KeyV
         return zkr;
     }
 
+    // Get the version data
+    VersionDataStruct versionData;
+    zkr = HeaderPage::ReadVersionData(headerPageNumber, version, versionData);
+    if (zkr != ZKR_SUCCESS)
+    {
+        zklog.error("Database64::ReadTree() failed calling HeaderPage::ReadVersionData() result=" + zkresult2string(zkr) + " rootString=" + rootString);
+        return zkr;
+    }
+
     // Read all key-values
     string keyString;
     string key;
@@ -678,7 +433,7 @@ zkresult Database64::ReadTree (const Goldilocks::Element (&root)[4], vector<KeyV
     {
         keyString = fea2string(fr, keyValues[i].key);
         key = string2ba(keyString);
-        zkr = HeaderPage::KeyValueHistoryRead(headerPageNumber, key, version, keyValues[i].value);
+        zkr = HeaderPage::KeyValueHistoryRead(versionData.keyValueHistoryPage, key, version, keyValues[i].value);
         if (zkr != ZKR_SUCCESS)
         {
             zklog.error("Database64::ReadTree() failed calling HeaderPage::KeyValueHistoryRead() result=" + zkresult2string(zkr) + " rootString=" + rootString + " version=" + to_string(version));
diff --git a/src/hashdb64/database_64.hpp b/src/hashdb64/database_64.hpp
index 0b5756581..d018859c0 100644
--- a/src/hashdb64/database_64.hpp
+++ b/src/hashdb64/database_64.hpp
@@ -23,7 +23,7 @@ using namespace std;
 
 /*
 
-A Tree (state) is made of a set of TreeChunks:
+A Tree (state) is made of a set of TreeChunks, each of them stored in one 4kB page:
 
       /\
      /__\
@@ -35,12 +35,12 @@ A Tree (state) is made of a set of TreeChunks:
        /__\
 
 When we want to read [key, value] for a given root:
-    - we call db.read(treeChunk.hash, treeChunk.data) starting from the root until we reach the [key, value] leaf node
+    - we search for the right page starting from the root until we reach the [key, value] leaf node in the final page
 
 When we want to write a new leaf node [key, newValue] on a given root and get the resulting newStateRoot
-    - we calculate the new position of [key, newValue], creating new chunks if needed
+    - we calculate the new position of [key, newValue], creating new pages if needed
     - we recalculate the hashes of all the modified and new chunks
-    - we call db.write(treeChunk.hash, treeChunk.data) of all the modified and new chunks
+    - we write every resulting hash in the proper position of the proper page
 
 Every time we write a [key, newValue] we are potentially creating a new Tree = SUM(TreeChunks) if newValue != oldValue
 Every new Tree represents a newer version of the state
@@ -60,43 +60,14 @@ The Forest takes note of the latest Tree hash to keep track of the current state
 
 */
 
-class DB64Query
-{
-public:
-    string key;
-    Goldilocks::Element keyFea[4];
-    string &value; // value can be an input in multiWrite(), or an output in multiRead()
-    DB64Query(const string &_key, const Goldilocks::Element (&_keyFea)[4], string &_value) : key(_key), value(_value)
-    {
-        keyFea[0] = _keyFea[0];
-        keyFea[1] = _keyFea[1];
-        keyFea[2] = _keyFea[2];
-        keyFea[3] = _keyFea[3];
-    }
-};
-
 class Database64
 {
-public:
-    Goldilocks &fr;
-    const Config &config;
-    PoseidonGoldilocks poseidon;
-
-    // Basic flags
-    bool bInitialized = false;
-    bool useRemoteDB = false;
-
-    uint64_t headerPageNumber;
-
-public:
-    //sem_t senderSem; // Semaphore to wakeup database sender thread when flush() is called
-    //sem_t getFlushDataSem; // Semaphore to unblock getFlushData() callers when new data is available
 private:
-    //pthread_t senderPthread; // Database sender thread
-    //pthread_t cacheSynchPthread; // Cache synchronization thread
 
-    // Tree64
-    zkresult CalculateHash (Child &result, std::vector<TreeChunk *> &chunks, vector<DB64Query> &dbQueries, int idChunk, int level, vector<HashValueGL> *hashValues);
+    bool     bInitialized = false;
+    uint64_t headerPageNumber;
+    pthread_mutex_t mutex;
+    uint64_t currentFlushId;
 
 public:
 
@@ -104,7 +75,6 @@ class Database64
     Database64(Goldilocks &fr, const Config &config);
     ~Database64();
 
-public:
     // Basic methods
     void init(void);
     
@@ -124,24 +94,13 @@ class Database64
     zkresult consolidateBlock (uint64_t blockNumber); // TODO: Who reports this block number?
     zkresult revertBlock      (uint64_t blockNumber);
 
-public:
     // Flush data pending to be stored permamently
     zkresult flush(uint64_t &flushId, uint64_t &lastSentFlushId);
     zkresult getFlushStatus(uint64_t &storedFlushId, uint64_t &storingFlushId, uint64_t &lastFlushId, uint64_t &pendingToFlushNodes, uint64_t &pendingToFlushProgram, uint64_t &storingNodes, uint64_t &storingProgram);
 
-    // Get flush data, written to database by dbSenderThread; it blocks
-    zkresult getFlushData(uint64_t flushId, uint64_t &lastSentFlushId, unordered_map<string, string> (&nodes), unordered_map<string, string> (&program), string &nodesStateRoot);
-
-    // Clear cache
-    void clearCache(void);
-
-   
+    // Lock/Unlock
+    void Lock(void) { pthread_mutex_lock(&mutex); };
+    void Unlock(void) { pthread_mutex_unlock(&mutex); };
 };
 
-// Thread to send data to database
-//void *dbSenderThread64(void *arg);
-
-// Thread to synchronize cache from master hash DB server
-//void *dbCacheSynchThread64(void *arg);
-
 #endif
\ No newline at end of file
diff --git a/src/hashdb64/page/header_page.cpp b/src/hashdb64/page/header_page.cpp
index cd953bf07..376335a0b 100644
--- a/src/hashdb64/page/header_page.cpp
+++ b/src/hashdb64/page/header_page.cpp
@@ -180,13 +180,10 @@ zkresult HeaderPage::WriteVersionData (uint64_t &headerPageNumber, const uint64_
     return KeyValuePage::Write(headerPage->versionDataPage, version2key(version), versionData2value(versionData), headerPageNumber);
 }
 
-zkresult HeaderPage::KeyValueHistoryRead (const uint64_t headerPageNumber, const string &key, const uint64_t version, mpz_class &value)
+zkresult HeaderPage::KeyValueHistoryRead (const uint64_t keyValueHistoryPage, const string &key, const uint64_t version, mpz_class &value)
 {
-    // Get header page
-    HeaderStruct * headerPage = (HeaderStruct *)pageManager.getPageAddress(headerPageNumber);
-
     // Call the specific method
-    return KeyValueHistoryPage::Read(headerPage->keyValueHistoryPage, key, version, value);
+    return KeyValueHistoryPage::Read(keyValueHistoryPage, key, version, value);
 }
 
 zkresult HeaderPage::KeyValueHistoryWrite (uint64_t &headerPageNumber, const string &key, const uint64_t version, const mpz_class &value)
diff --git a/src/hashdb64/page/header_page.hpp b/src/hashdb64/page/header_page.hpp
index d67c7dc1f..60a308bca 100644
--- a/src/hashdb64/page/header_page.hpp
+++ b/src/hashdb64/page/header_page.hpp
@@ -53,7 +53,7 @@ class HeaderPage
     static zkresult WriteVersionData (      uint64_t &headerPageNumber, const uint64_t &version, const VersionDataStruct &versionData);
 
     // Key-Value-History methods
-    static zkresult KeyValueHistoryRead  (const uint64_t headerPageNumber,  const string &key, const uint64_t version,       mpz_class &value);
+    static zkresult KeyValueHistoryRead  (const uint64_t keyValueHistoryPage,  const string &key, const uint64_t version,       mpz_class &value);
     static zkresult KeyValueHistoryWrite (      uint64_t &headerPageNumber, const string &key, const uint64_t version, const mpz_class &value);
     static zkresult KeyValueHistoryCalculateHash (uint64_t &headerPageNumber, Goldilocks::Element (&hash)[4]);
 
diff --git a/src/hashdb64/page/key_value_history_page.cpp b/src/hashdb64/page/key_value_history_page.cpp
index dca8f6ca4..232902196 100644
--- a/src/hashdb64/page/key_value_history_page.cpp
+++ b/src/hashdb64/page/key_value_history_page.cpp
@@ -168,7 +168,6 @@ zkresult KeyValueHistoryPage::Write (uint64_t &pageNumber, const string &key, co
 
             uint64_t insertionRawDataPage = headerPage->rawDataPage;
             uint64_t insertionRawDataOffset = RawDataPage::GetOffset(insertionRawDataPage);
-            uint64_t rawDataPage = insertionRawDataPage;
 
             string keyAndValue = key + scalar2ba32(value);  // TODO: Check that value size=32
             zkr = RawDataPage::Write(headerPage->rawDataPage, keyAndValue);
@@ -183,9 +182,6 @@ zkresult KeyValueHistoryPage::Write (uint64_t &pageNumber, const string &key, co
             page->keyValueEntry[index][1] = (insertionRawDataOffset << 48) + insertionRawDataPage;
             page->keyValueEntry[index][2] = 0; // Mask as no hash has been calculated
 
-            // Update header
-            headerPage->rawDataPage = rawDataPage;
-
             return ZKR_SUCCESS;            
         }
         // Leaf node
@@ -254,10 +250,9 @@ zkresult KeyValueHistoryPage::Write (uint64_t &pageNumber, const string &key, co
                 // Get the current rawDataPage and offset
                 uint64_t insertionRawDataPage = headerPage->rawDataPage;
                 uint64_t insertionRawDataOffset = RawDataPage::GetOffset(headerPage->rawDataPage);
-                uint64_t rawDataPage = insertionRawDataPage;
 
                 string keyAndValue = key + valueBa;
-                zkr = RawDataPage::Write(rawDataPage, keyAndValue);
+                zkr = RawDataPage::Write(headerPage->rawDataPage, keyAndValue);
                 if (zkr != ZKR_SUCCESS)
                 {
                     zklog.error("KeyValueHistoryPage::Write() failed calling RawDataPage.Write result=" + zkresult2string(zkr) + " rawDataPage=" + to_string(rawDataPage) + " rawDataOffset=" + to_string(rawDataOffset) + " key=" + ba2string(key) + " version=" + to_string(version) + " level=" + to_string(level) + " index=" + to_string(index));
@@ -269,9 +264,6 @@ zkresult KeyValueHistoryPage::Write (uint64_t &pageNumber, const string &key, co
                 page->keyValueEntry[index][1] = (insertionRawDataOffset << 48) + (insertionRawDataPage & U64Mask48);
                 page->keyValueEntry[index][2] = 0;
 
-                // Update header
-                headerPage->rawDataPage = rawDataOffset;
-
                 return ZKR_SUCCESS;
             }
 
@@ -418,13 +410,12 @@ zkresult KeyValueHistoryPage::calculatePageHash (const uint64_t pageNumber, cons
                     // Get the current rawDataPage and offset
                     uint64_t insertionRawDataPage = headerPage->rawDataPage;
                     uint64_t insertionRawDataOffset = RawDataPage::GetOffset(headerPage->rawDataPage);
-                    uint64_t rawDataPage = insertionRawDataPage;
 
                     // Store the hash in raw page
                     string hashBa;
                     hashBa = string2ba(fea2string(fr, hash));
                     zkassert(hashBa.size() == 32);
-                    zkr = RawDataPage::Write(rawDataPage, hashBa);
+                    zkr = RawDataPage::Write(headerPage->rawDataPage, hashBa);
                     if (zkr != ZKR_SUCCESS)
                     {
                         zklog.error("KeyValueHistoryPage::calculatePageHash() failed calling RawDataPage.Write result=" + zkresult2string(zkr) + " insertionRawDataPage=" + to_string(insertionRawDataPage) + " insertionRawDataOffset=" + to_string(insertionRawDataOffset) + " level=" + to_string(level) + " index=" + to_string(index));
@@ -433,9 +424,6 @@ zkresult KeyValueHistoryPage::calculatePageHash (const uint64_t pageNumber, cons
 
                     // Record the new hash and its raw data
                     page->keyValueEntry[index][2] = (insertionRawDataOffset << 48) | (insertionRawDataPage & U64Mask48);
-
-                    // Update the header
-                    headerPage->rawDataPage = rawDataPage;
                 }
                 // If hash was calculated, get it from raw data
                 else
@@ -499,13 +487,12 @@ zkresult KeyValueHistoryPage::calculatePageHash (const uint64_t pageNumber, cons
             // Get the current rawDataPage and offset
             uint64_t insertionRawDataPage = headerPage->rawDataPage;
             uint64_t insertionRawDataOffset = RawDataPage::GetOffset(headerPage->rawDataPage);
-            uint64_t rawDataPage = insertionRawDataPage;
 
             // Store the hash in raw page
             string hashBa;
             hashBa = string2ba(fea2string(fr, hash));
             zkassert(hashBa.size() == 32);
-            zkr = RawDataPage::Write(rawDataPage, hashBa);
+            zkr = RawDataPage::Write(headerPage->rawDataPage, hashBa);
             if (zkr != ZKR_SUCCESS)
             {
                 zklog.error("KeyValueHistoryPage::calculatePageHash() failed calling RawDataPage.Write result=" + zkresult2string(zkr) + " insertionRawDataPage=" + to_string(insertionRawDataPage) + " insertionRawDataOffset=" + to_string(insertionRawDataOffset) + " level=" + to_string(level) + " index=" + to_string(index));
@@ -514,9 +501,6 @@ zkresult KeyValueHistoryPage::calculatePageHash (const uint64_t pageNumber, cons
 
             // Record the new hash and its raw data
             page->keyValueEntry[index][2] = (insertionRawDataOffset << 48) | (insertionRawDataPage & U64Mask48);
-
-            // Update header page
-            headerPage->rawDataPage = rawDataPage;
         }
     }
 
diff --git a/src/hashdb64/state_manager_64.cpp b/src/hashdb64/state_manager_64.cpp
index a7ec61dc5..ffa0e8154 100644
--- a/src/hashdb64/state_manager_64.cpp
+++ b/src/hashdb64/state_manager_64.cpp
@@ -5,6 +5,7 @@
 #include "timer.hpp"
 #include "persistence.hpp"
 #include "definitions.hpp"
+#include "zkglobals.hpp"
 
 Goldilocks frSM64;
 PoseidonGoldilocks poseidonSM64;
@@ -638,7 +639,7 @@ zkresult StateManager64::purge (const string &batchUUID, const string &_newState
                 continue;
             }
 
-            zkr = purgeTxPersistence(txState.persistence[persistence], db.config);
+            zkr = purgeTxPersistence(txState.persistence[persistence], config);
             if (zkr != ZKR_SUCCESS)
             {
                 zklog.error("StateManager64::purge() failed calling purgeTxPersistence() zkr=" + zkresult2string(zkr) +
@@ -1019,7 +1020,7 @@ zkresult StateManager64::set (const string &batchUUID, uint64_t tx, Database64 &
 
     zkresult zkr;
 
-    bool bUseStateManager = db.config.stateManager && (batchUUID.size() > 0);
+    bool bUseStateManager = config.stateManager && (batchUUID.size() > 0);
 
     if (bUseStateManager)
     {
@@ -1081,7 +1082,7 @@ zkresult StateManager64::get (const string &batchUUID, Database64 &db, const Gol
     zklog.info("StateManager64::get() called with root=" + fea2string(fr,root) + " and key=" + fea2string(fr,key));
 #endif
 
-    bool bUseStateManager = db.config.stateManager && (batchUUID.size() > 0);
+    bool bUseStateManager = config.stateManager && (batchUUID.size() > 0);
 
     string keyString = fea2string(fr, key);
     mpz_class value;
diff --git a/src/service/hashdb/hashdb.cpp b/src/service/hashdb/hashdb.cpp
index 882d91d4b..2f51866f0 100644
--- a/src/service/hashdb/hashdb.cpp
+++ b/src/service/hashdb/hashdb.cpp
@@ -399,7 +399,8 @@ zkresult HashDB::getFlushData(uint64_t flushId, uint64_t &lastSentFlushId, unord
 
     if (config.hashDB64)
     {
-        zkr = db64.getFlushData(flushId, lastSentFlushId, nodes, program, nodesStateRoot);
+        zklog.error("HashDB::getFlushData() called with config.hashDB64=true");
+        return ZKR_DB_ERROR;
     }
     else
     {
@@ -413,7 +414,7 @@ void HashDB::clearCache(void)
 {
     if (config.hashDB64)
     {
-        db64.clearCache();
+        // We don't use cache in HashDB64
     }
     else
     {
diff --git a/test/service/executor/executor_client.cpp b/test/service/executor/executor_client.cpp
index 37316f0a1..56ab1ff21 100644
--- a/test/service/executor/executor_client.cpp
+++ b/test/service/executor/executor_client.cpp
@@ -196,7 +196,6 @@ bool ExecutorClient::ProcessBatch (void)
         if (config.hashDB64)
         {
             Database64 &db = hashDB.db64;
-            db.clearCache();
 
             CheckTreeCounters64 checkTreeCounters;
 
diff --git a/test/service/hashdb/hashdb64_workflow_test.cpp b/test/service/hashdb/hashdb64_workflow_test.cpp
index b21ab803c..137d2eb23 100644
--- a/test/service/hashdb/hashdb64_workflow_test.cpp
+++ b/test/service/hashdb/hashdb64_workflow_test.cpp
@@ -128,7 +128,7 @@ uint64_t HashDB64WorkflowTest (const Config& config)
             for (uint64_t i=0; i<4; i++) root[i] = consolidatedStateRoot[i];
 
             // Wait for data to be sent
-            /*while (true)
+            while (true)
             {
                 uint64_t storedFlushId, storingFlushId, lastFlushId, pendingToFlushNodes, pendingToFlushProgram, storingNodes, storingProgram;
                 string proverId;
@@ -141,7 +141,7 @@ uint64_t HashDB64WorkflowTest (const Config& config)
                 }
                 sleep(1);
             }
-            zklog.info("FLUSHED");*/
+            zklog.info("FLUSHED");
 
             // Call ReadTree with the old state root to get the hashes of the initial values of all read or written keys
             /*vector<HashValueGL> oldHashValues;
diff --git a/test/utils/check_tree_64.cpp b/test/utils/check_tree_64.cpp
index 30debb57c..a022fef14 100644
--- a/test/utils/check_tree_64.cpp
+++ b/test/utils/check_tree_64.cpp
@@ -2,6 +2,7 @@
 #include "zkmax.hpp"
 #include "scalar.hpp"
 #include "tree_chunk.hpp"
+#include "zkglobals.hpp"
 
 zkresult CheckTree64 (Database64 &db, const string &key, uint64_t level, CheckTreeCounters64 &checkTreeCounters)
 {
@@ -11,7 +12,7 @@ zkresult CheckTree64 (Database64 &db, const string &key, uint64_t level, CheckTr
 
     TreeChunk treeChunk(poseidon);
     Goldilocks::Element keyFea[4];
-    string2fea(db.fr, key, keyFea);
+    string2fea(fr, key, keyFea);
     zkresult result = ZKR_UNSPECIFIED; // = db.read(key, keyFea, treeChunk.data, NULL, false);
     if (result != ZKR_SUCCESS)
     {
@@ -38,7 +39,7 @@ zkresult CheckTree64 (Database64 &db, const string &key, uint64_t level, CheckTr
             case INTERMEDIATE:
             {
                 checkTreeCounters.intermediateNodes++;
-                result = CheckTree64(db, fea2string(db.fr, treeChunk.getChild(i).intermediate.hash), level+1, checkTreeCounters);
+                result = CheckTree64(db, fea2string(fr, treeChunk.getChild(i).intermediate.hash), level+1, checkTreeCounters);
                 if (zkr != ZKR_SUCCESS)
                 {
                     return zkr;