@typeberry/jam 0.0.4 → 0.0.5-0f1acee

package/importer/index.js

@@ -9984,6 +9984,7 @@ function legacyServiceNested(serviceId, hash) {
 ;// CONCATENATED MODULE: ./packages/jam/state/accumulation-output.ts
 
 
+
 /**
  * Single service-indexed commitment to accumulation output
  *
@@ -10004,6 +10005,16 @@ class AccumulationOutput {
         this.output = output;
     }
 }
+function accumulationOutputComparator(a, b) {
+    const result = a.serviceId - b.serviceId;
+    if (result < 0) {
+        return Ordering.Less;
+    }
+    if (result > 0) {
+        return Ordering.Greater;
+    }
+    return Ordering.Equal;
+}
 
 ;// CONCATENATED MODULE: ./packages/jam/state/assurances.ts
 
@@ -11109,6 +11120,7 @@ class StatisticsData {
 
 
 
+
 
 var in_memory_state_UpdateError;
 (function (UpdateError) {
@@ -11512,7 +11524,7 @@ class InMemoryState extends WithDebug {
                 validatorsManager: tryAsServiceId(0),
                 autoAccumulateServices: [],
             }),
-            accumulationOutputLog: [],
+            accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
             services: new Map(),
         });
     }
@@ -11711,7 +11723,7 @@ var serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        Codec: descriptors_codec.sequenceVarLen(AccumulationOutput.Codec),
+        Codec: descriptors_codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
         extract: (s) => s.accumulationOutputLog,
     };
     /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
@@ -13383,7 +13395,6 @@ const GLOBAL_CONFIG = {
  */
 class Logger {
     moduleName;
-    fileName;
     config;
     /**
      * Create a new logger instance given filename and an optional module name.
@@ -13396,7 +13407,8 @@ class Logger {
      */
     static new(fileName, moduleName) {
         const fName = fileName ?? "unknown";
-        return new Logger(moduleName ?? fName, fName, GLOBAL_CONFIG);
+        const module = moduleName ?? fName;
+        return new Logger(module.padStart(8, " "), GLOBAL_CONFIG);
     }
     /**
      * Return currently configured level for given module. */
@@ -13433,9 +13445,8 @@ class Logger {
         const options = parseLoggerOptions(input, defaultLevel, workingDir);
         Logger.configureAllFromOptions(options);
     }
-    constructor(moduleName, fileName, config) {
+    constructor(moduleName, config) {
         this.moduleName = moduleName;
-        this.fileName = fileName;
         this.config = config;
     }
     /** Log a message with `INSANE` level. */
@@ -20155,14 +20166,14 @@ function compareWithEncoding(chainSpec, error, actual, expected, codec) {
     if (actual === null || expected === null) {
         // if one of them is `null`, both need to be.
         if (actual !== expected) {
-            return result_Result.error(error, `Expected: ${expected}, got: ${actual}`);
+            return result_Result.error(error, `${SafroleErrorCode[error]} Expected: ${expected}, got: ${actual}`);
         }
         return result_Result.ok(result_OK);
     }
     // compare the literal encoding.
     const encoded = encoder_Encoder.encodeObject(codec, actual, chainSpec);
     if (!encoded.isEqualTo(expected.encoded())) {
-        return result_Result.error(error, `Expected: ${expected.encoded()}, got: ${encoded}`);
+        return result_Result.error(error, `${SafroleErrorCode[error]} Expected: ${expected.encoded()}, got: ${encoded}`);
     }
     return result_Result.ok(result_OK);
 }
@@ -20241,7 +20252,7 @@ class SafroleSeal {
         const index = timeSlot % keys.length;
         const sealingKey = keys[index];
         if (!sealingKey.isEqualTo(authorKey.bandersnatch)) {
-            return result_Result.error(SafroleSealError.InvalidValidator, `Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
+            return result_Result.error(SafroleSealError.InvalidValidator, `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
         }
         // verify seal correctness
         const payload = bytes_BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw);
@@ -20258,6 +20269,32 @@ class SafroleSeal {
 
 
 
+;// CONCATENATED MODULE: ./packages/jam/transition/accumulate/accumulate-output.ts
+
+
+
+
+
+class AccumulateOutput {
+    async transition({ accumulationOutputLog }) {
+        const rootHash = await getRootHash(accumulationOutputLog);
+        return rootHash;
+    }
+}
+/**
+ * Returns a new root hash
+ *
+ * https://graypaper.fluffylabs.dev/#/38c4e62/3c9d013c9d01?v=0.7.0
+ */
+async function getRootHash(yieldedRoots) {
+    const keccakHasher = await KeccakHasher.create();
+    const trieHasher = getKeccakTrieHasher(keccakHasher);
+    const values = yieldedRoots.array.map(({ serviceId, output }) => {
+        return bytes_BytesBlob.blobFromParts([numbers_u32AsLeBytes(serviceId), output.raw]);
+    });
+    return binaryMerkleization(values, trieHasher);
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/jam-host-calls/externalities/state-update.ts
 
 
@@ -23352,9 +23389,6 @@ class pvm_executor_PvmExecutor {
 
 
 
-
-
-
 
 
 
@@ -23608,10 +23642,10 @@ class Accumulate {
         const { services, yieldedRoots, transfers, validatorsData, privilegedServices, authorizationQueues, ...stateUpdateRest } = state;
         assertEmpty(stateUpdateRest);
         const accStateUpdate = this.getAccumulationStateUpdate(accumulated, toAccumulateLater, slot, Array.from(statistics.keys()), services);
-        const accumulationOutput = Array.from(yieldedRoots.entries()).map(([serviceId, root]) => {
+        const accumulationOutputUnsorted = Array.from(yieldedRoots.entries()).map(([serviceId, root]) => {
             return { serviceId, output: root.asOpaque() };
         });
-        const rootHash = await getRootHash(accumulationOutput);
+        const accumulationOutput = SortedArray.fromArray(accumulationOutputComparator, accumulationOutputUnsorted);
         const authQueues = (() => {
             if (authorizationQueues.size === 0) {
                 return {};
@@ -23623,7 +23657,6 @@ class Accumulate {
             return { authQueues: tryAsPerCore(updatedAuthQueues, this.chainSpec) };
         })();
         return result_Result.ok({
-            root: rootHash,
             stateUpdate: {
                 ...accStateUpdate,
                 ...(validatorsData === null ? {} : { designatedValidatorData: validatorsData }),
@@ -23636,20 +23669,6 @@ class Accumulate {
         });
     }
 }
-/**
- * Returns a new root hash
- *
- * https://graypaper.fluffylabs.dev/#/38c4e62/3c9d013c9d01?v=0.7.0
- */
-async function getRootHash(yieldedRoots) {
-    const keccakHasher = await KeccakHasher.create();
-    const trieHasher = getKeccakTrieHasher(keccakHasher);
-    const yieldedRootsSortedByServiceId = yieldedRoots.sort((a, b) => a.serviceId - b.serviceId);
-    const values = yieldedRootsSortedByServiceId.map(({ serviceId, output }) => {
-        return bytes_BytesBlob.blobFromParts([numbers_u32AsLeBytes(serviceId), output.raw]);
-    });
-    return binaryMerkleization(values, trieHasher);
-}
 
 ;// CONCATENATED MODULE: ./packages/jam/transition/accumulate/deferred-transfers.ts
 
@@ -25045,6 +25064,7 @@ class Statistics {
 
 
 
+
 class DbHeaderChain {
     blocks;
     constructor(blocks) {
@@ -25088,6 +25108,7 @@ class OnChain {
     assurances;
     // chapter 12: https://graypaper.fluffylabs.dev/#/68eaa1f/159f02159f02?v=0.6.4
     accumulate;
+    accumulateOutput;
     // chapter 12.3: https://graypaper.fluffylabs.dev/#/68eaa1f/178203178203?v=0.6.4
     deferredTransfers;
     // chapter 12.4: https://graypaper.fluffylabs.dev/#/68eaa1f/18cc0018cc00?v=0.6.4
@@ -25112,6 +25133,7 @@ class OnChain {
         this.reports = new Reports(chainSpec, state, new DbHeaderChain(blocks));
         this.assurances = new Assurances(chainSpec, state);
         this.accumulate = new Accumulate(chainSpec, state);
+        this.accumulateOutput = new AccumulateOutput();
         this.deferredTransfers = new DeferredTransfers(chainSpec, state);
         this.preimages = new Preimages(state);
         this.authorization = new Authorization(chainSpec, state);
@@ -25220,7 +25242,7 @@ class OnChain {
         if (accumulateResult.isError) {
             return stfError(StfErrorKind.Accumulate, accumulateResult);
         }
-        const { root: accumulateRoot, stateUpdate: accumulateUpdate, accumulationStatistics, pendingTransfers, accumulationOutputLog, ...accumulateRest } = accumulateResult.ok;
+        const { stateUpdate: accumulateUpdate, accumulationStatistics, pendingTransfers, accumulationOutputLog, ...accumulateRest } = accumulateResult.ok;
         assertEmpty(accumulateRest);
         const { privilegedServices: maybePrivilegedServices, authQueues: maybeAuthorizationQueues, designatedValidatorData: maybeDesignatedValidatorData, preimages: accumulatePreimages, accumulationQueue, recentlyAccumulated, ...servicesUpdate } = accumulateUpdate;
         const deferredTransfersResult = await this.deferredTransfers.transition({
@@ -25234,8 +25256,9 @@ class OnChain {
         }
         const { servicesUpdate: newServicesUpdate, transferStatistics, ...deferredTransfersRest } = deferredTransfersResult.ok;
         assertEmpty(deferredTransfersRest);
+        const accumulateRoot = await this.accumulateOutput.transition({ accumulationOutputLog });
         // recent history
-        const recentHistoryUpdate = this.recentHistory.transition({
+        const recentHistoryUpdate = await this.recentHistory.transition({
             partial: recentHistoryPartialUpdate,
             headerHash,
             accumulateRoot,
@@ -25330,6 +25353,8 @@ class Importer {
     stf;
     // TODO [ToDr] we cannot assume state reference does not change.
     state;
+    // Hash of the block that we have the posterior state for in `state`.
+    currentHash;
     constructor(spec, hasher, logger, blocks, states) {
         this.logger = logger;
         this.blocks = blocks;
@@ -25342,6 +25367,7 @@ class Importer {
         this.verifier = new BlockVerifier(hasher, blocks);
         this.stf = new OnChain(spec, state, blocks, hasher, { enableParallelSealVerification: true });
         this.state = state;
+        this.currentHash = currentBestHeaderHash;
         logger.info(`😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`);
     }
     /** Attempt to pre-verify the seal to speed up importing. */
@@ -25368,6 +25394,20 @@ class Importer {
         if (hash.isError) {
             return importerError(ImporterErrorKind.Verifier, hash);
         }
+        // TODO [ToDr] This is incomplete/temporary fork support!
+        const parentHash = block.header.view().parentHeaderHash.materialize();
+        if (!this.currentHash.isEqualTo(parentHash)) {
+            const state = this.states.getState(parentHash);
+            if (state === null) {
+                const e = result_Result.error(BlockVerifierError.StateRootNotFound);
+                if (!e.isError) {
+                    throw new Error("unreachable, just adding to make compiler happy");
+                }
+                return importerError(ImporterErrorKind.Verifier, e);
+            }
+            this.state.updateBackend(state?.backend);
+            this.currentHash = parentHash;
+        }
         const timeSlot = block.header.view().timeSlotIndex.materialize();
         const headerHash = hash.ok;
         logger.log(`🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`);
@@ -25392,6 +25432,7 @@ class Importer {
         // 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.currentHash = headerHash;
         logger.log(timerState());
         // insert new state and the block to DB.
         const timerDb = measure("import:db");
@@ -25697,7 +25738,7 @@ class ImporterReady extends State {
             const timeSlot = headerView.timeSlotIndex.materialize();
             let response;
             try {
-                const res = await this.importer.importBlock(blockView, null);
+                const res = await this.importer.importBlock(blockView, null, config.omitSealVerification);
                 if (res.isOk) {
                     state_machine_logger.info(`🧊 Best block: #${timeSlot} (${res.ok.hash})`);
                     response = result_Result.ok(this.importer.getBestStateRootHash() ?? bytes_Bytes.zero(hash_HASH_SIZE).asOpaque());
@@ -25803,7 +25844,7 @@ async function main(channel) {
                 importer_logger.trace(`🧊 Already queued block: #${details.ok.data.timeSlot}.`);
                 return;
             }
-            importer_logger.log(`🧊 Queued block: #${details.ok.data.timeSlot}`);
+            importer_logger.log(`🧊 Queued block: #${details.ok.data.timeSlot} (skip seal: ${config.omitSealVerification})`);
             if (isProcessing) {
                 return;
             }