@typeberry/convert 0.1.3-135961b → 0.1.3-3f7b9cf

package/index.js

@@ -20785,6 +20785,15 @@ var ResultValues;
     ResultValues[ResultValues["Ok"] = 0] = "Ok";
     ResultValues[ResultValues["Error"] = 1] = "Error";
 })(ResultValues || (ResultValues = {}));
+/**
+ * Getting a ring commitment is pretty expensive (hundreds of ms),
+ * yet the validators do not always change.
+ * For current benchmarks, we get a huge hit every epoch, hence
+ * to overcome that we cache the results of getting ring commitment.
+ * Note we can also tentatively populate this cache, before we even
+ * reach the epoch change block.
+ */
+const ringCommitmentCache = [];
 // TODO [ToDr] We export the entire object to allow mocking in tests.
 // Ideally we would just export functions and figure out how to mock
 // properly in ESM.
@@ -20800,9 +20809,27 @@ async function verifySeal(bandersnatch, authorKey, signature, payload, encodedUn
     }
     return result_Result.ok(bytes_Bytes.fromBlob(sealResult.subarray(1), hash_HASH_SIZE).asOpaque());
 }
-async function getRingCommitment(bandersnatch, validators) {
-    const keys = bytes_BytesBlob.blobFromParts(validators.map((x) => x.raw)).raw;
-    const commitmentResult = await bandersnatch.getRingCommitment(keys);
+function getRingCommitment(bandersnatch, validators) {
+    const keys = bytes_BytesBlob.blobFromParts(validators.map((x) => x.raw));
+    // We currently compare the large bytes blob, but the number of entries in the cache
+    // must be low. If the cache ever grows larger, we should rather consider hashing the keys.
+    const MAX_CACHE_ENTRIES = 3;
+    const cacheEntry = ringCommitmentCache.find((v) => v.keys.isEqualTo(keys));
+    if (cacheEntry !== undefined) {
+        return cacheEntry.value;
+    }
+    const value = getRingCommitmentNoCache(bandersnatch, keys);
+    ringCommitmentCache.push({
+        keys,
+        value,
+    });
+    if (ringCommitmentCache.length > MAX_CACHE_ENTRIES) {
+        ringCommitmentCache.shift();
+    }
+    return value;
+}
+async function getRingCommitmentNoCache(bandersnatch, keys) {
+    const commitmentResult = await bandersnatch.getRingCommitment(keys.raw);
     if (commitmentResult[RESULT_INDEX] === ResultValues.Error) {
         return result_Result.error(null);
     }
@@ -20928,6 +20955,18 @@ class safrole_Safrole {
         }
         return FixedSizeArray.new([newRandomnessAcc, ...rest], 4);
     }
+    /**
+     * Pre-populate cache for validator keys, and especially the ring commitment.
+     *
+     * NOTE the function is still doing quite some work, so it should only be used
+     *  once per epoch. The optimisation relies on the fact that the `bandersnatch.getRingCommitment`
+     * call will be cached.
+     */
+    async prepareValidatorKeysForNextEpoch(postOffenders) {
+        const stateEpoch = Math.floor(this.state.timeslot / this.chainSpec.epochLength);
+        const nextEpochStart = (stateEpoch + 1) * this.chainSpec.epochLength;
+        return await this.getValidatorKeys(tryAsTimeSlot(nextEpochStart), postOffenders);
+    }
     async getValidatorKeys(timeslot, postOffenders) {
         /**
          * Epoch is not changed so the previous state is returned
@@ -26225,6 +26264,7 @@ class chain_stf_OnChain {
     authorization;
     // chapter 13: https://graypaper.fluffylabs.dev/#/68eaa1f/18b60118b601?v=0.6.4
     statistics;
+    isReadyForNextEpoch = Promise.resolve(false);
     constructor(chainSpec, state, blocks, hasher) {
         this.chainSpec = chainSpec;
         this.state = state;
@@ -26243,6 +26283,14 @@ class chain_stf_OnChain {
         this.preimages = new Preimages(state);
         this.authorization = new Authorization(chainSpec, state);
     }
+    /** Pre-populate things worth caching for the next epoch. */
+    async prepareForNextEpoch() {
+        if (await this.isReadyForNextEpoch) {
+            return;
+        }
+        const ready = this.safrole.prepareValidatorKeysForNextEpoch(this.state.disputesRecords.punishSet);
+        this.isReadyForNextEpoch = ready.then((_) => true);
+    }
     async verifySeal(timeSlot, block) {
         const sealState = this.safrole.getSafroleSealState(timeSlot);
         return await this.safroleSeal.verifyHeaderSeal(block.header.view(), sealState);
@@ -26251,6 +26299,10 @@ class chain_stf_OnChain {
         const headerView = block.header.view();
         const header = block.header.materialize();
         const timeSlot = header.timeSlotIndex;
+        // reset the epoch cache state
+        if (headerView.epochMarker.view() !== null) {
+            this.isReadyForNextEpoch = Promise.resolve(false);
+        }
         // safrole seal
         let newEntropyHash;
         if (omitSealVerification) {