@typeberry/jam 0.3.0-bf18f09 → 0.3.0-fd0344b

package/index.js

@@ -36587,15 +36587,19 @@ class InMemorySerializedStates {
     async updateAndSetState(header, state, update) {
         const blake2b = this.blake2b;
         const updatedValues = serializeStateUpdate(this.spec, blake2b, update);
-        const { values, leafs } = updateLeafs(state.backend.leafs, blake2b, updatedValues);
+        // make sure to clone the leafs before writing, since the collection is re-used.
+        const newLeafs = SortedSet.fromSortedArray(leafComparator, state.backend.leafs.array);
+        const { values, leafs } = updateLeafs(newLeafs, blake2b, updatedValues);
+        // make sure to reset the cache and re-create leafsdb lookup
+        state.updateBackend(LeafDb.fromLeaves(leafs, state.backend.db));
         // insert values to the db
         // valuesdb can be shared between all states because it's just
         // <valuehash> -> <value> mapping and existence is managed by trie leafs.
         for (const val of values) {
             this.valuesDb.set(val[0], val[1]);
         }
-        // make sure to clone the leafs before writing, since the collection is re-used.
-        this.db.set(header, SortedSet.fromSortedArray(leafComparator, leafs.slice()));
+        // store new set of leaves
+        this.db.set(header, leafs);
         return result_Result.ok(result_OK);
     }
     getState(header) {
@@ -36884,7 +36888,12 @@ class LmdbStates {
     async updateAndSetState(headerHash, state, update) {
         const updatedValues = serializeStateUpdate(this.spec, this.blake2b, update);
         // and finally we insert new values and store leaves in the DB.
-        return await this.updateAndCommit(headerHash, state.backend.leafs, updatedValues);
+        const res = await this.updateAndCommit(headerHash, state.backend.leafs, updatedValues);
+        if (res.isOk) {
+            // update the internal backend with new leaves.
+            state.updateBackend(LeafDb.fromLeaves(state.backend.leafs, state.backend.db));
+        }
+        return res;
     }
     async getStateRoot(state) {
         return state.backend.getStateRoot(this.blake2b);
@@ -49690,13 +49699,6 @@ class Importer {
             logger.error `🧱 Unable to update state: ${result_resultToString(updateResult)}`;
             return importerError(ImporterErrorKind.Update, updateResult);
         }
-        const newState = this.states.getState(headerHash);
-        if (newState === null) {
-            throw new Error("Freshly updated state not in the DB?");
-        }
-        // TODO [ToDr] This is a temporary measure. We should rather read
-        // the state of a parent block to support forks and create a fresh STF.
-        this.state.updateBackend(newState.backend);
         this.prepareForNextEpoch();
         this.currentHash = headerHash;
         logger.log `${timerState()}`;
@@ -49705,7 +49707,7 @@ class Importer {
         const writeBlocks = this.blocks.insertBlock(new hash_WithHash(headerHash, block));
         // Computation of the state root may happen asynchronously,
         // but we still need to wait for it before next block can be imported
-        const stateRoot = await this.states.getStateRoot(newState);
+        const stateRoot = await this.states.getStateRoot(this.state);
         logger.log `🧱 Storing post-state-root for ${headerHash}: ${stateRoot}.`;
         const writeStateRoot = this.blocks.setPostStateRoot(headerHash, stateRoot);
         await Promise.all([writeBlocks, writeStateRoot]);