@typeberry/jam 0.5.1-b2fd1d5 → 0.5.1-eb84786

package/bootstrap-importer.mjs

@@ -20837,6 +20837,7 @@ class Provide {
         }
         const result = this.partialState.providePreimage(serviceId, preimage);
         logger_logger.trace `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${result_resultToString(result)}`;
+        logger_logger.insane `[${this.currentServiceId}] PROVIDE(${serviceId}, ${preimage}) <- ${result_resultToString(result)}`;
         if (result.isOk) {
             regs.set(provide_IN_OUT_REG, results_HostCallResult.OK);
             return;
@@ -21320,6 +21321,7 @@ class Fetch {
             return host_call_handler_PvmExecution.Panic;
         }
         logger_logger.trace `[${this.currentServiceId}] FETCH(${kind}) <- ${value?.toStringTruncated()}`;
+        logger_logger.insane `[${this.currentServiceId}] FETCH(${kind}) <- ${value}`;
         // write result
         regs.set(fetch_IN_OUT_REG, value === null ? results_HostCallResult.NONE : valueLength);
     }
@@ -21619,6 +21621,7 @@ class Lookup {
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
         logger_logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated() ?? "<missing>"}...`;
+        logger_logger.insane `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage ?? "<missing>"}`;
         const preImageLength = preImage === null ? numbers_tryAsU64(0) : numbers_tryAsU64(preImage.raw.length);
         const preimageBlobOffset = regs.get(10);
         const lengthToWrite = regs.get(11);
@@ -21725,6 +21728,7 @@ class Read {
         }
         if (chunk.length > 0) {
             logger_logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+            logger_logger.insane `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
         }
         else {
             // just a query for length of stored data
@@ -21790,6 +21794,7 @@ class Write {
         // a
         const result = this.account.write(storageKey, maybeValue);
         logger_logger.trace `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${result_resultToString(result)}`;
+        logger_logger.insane `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue ?? "remove"}) <- ${result_resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, results_HostCallResult.FULL);
             return;
@@ -21851,6 +21856,7 @@ class Export {
         // attempt to export a segment and fail if it's above the maximum.
         const segmentExported = this.refine.exportSegment(segment);
         logger.trace `[${this.currentServiceId}] EXPORT(${segment.toStringTruncated()}) <- ${resultToString(segmentExported)}`;
+        logger.insane `[${this.currentServiceId}] EXPORT(${segment}) <- ${resultToString(segmentExported)}`;
         if (segmentExported.isOk) {
             regs.set(export_IN_OUT_REG, tryAsU64(segmentExported.ok));
         }
@@ -22094,6 +22100,7 @@ class Machine {
         // NOTE: Highly unlikely, but machineId could potentially collide with HOST_CALL_RESULT.
         const machinInitResult = await this.refine.machineInit(code, entrypoint);
         logger.trace `[${this.currentServiceId}] MACHINE(${code.toStringTruncated()}, ${entrypoint}) <- ${resultToString(machinInitResult)}`;
+        logger.insane `[${this.currentServiceId}] MACHINE(${code}, ${entrypoint}) <- ${resultToString(machinInitResult)}`;
         if (machinInitResult.isError) {
             regs.set(machine_IN_OUT_REG, HostCallResult.HUH);
         }
@@ -25242,6 +25249,8 @@ class BandernsatchWasm {
 
 
 
+
+const safrole_logger = Logger.new(import.meta.filename, "safrole");
 const safrole_VALIDATOR_META_BYTES = 128;
 const ticketComparator = (a, b) => bytesBlobComparator(a.id, b.id);
 var SafroleErrorCode;
@@ -25329,6 +25338,14 @@ class Safrole {
     async prepareValidatorKeysForNextEpoch(postOffenders) {
         const stateEpoch = Math.floor(this.state.timeslot / this.chainSpec.epochLength);
         const nextEpochStart = (stateEpoch + 1) * this.chainSpec.epochLength;
+        /**
+         * In real life, this would occur around ~2840,
+         * but this scenario appears in tests, so we need to handle it.
+         */
+        if (nextEpochStart >= 2 ** 32) {
+            safrole_logger.warn `Timeslot overflow imminent, cannot prepare validator keys for next epoch.`;
+            return Result.ok(null);
+        }
         return await this.getValidatorKeys(common_tryAsTimeSlot(nextEpochStart), postOffenders);
     }
     async getValidatorKeys(timeslot, postOffenders) {
@@ -29070,6 +29087,7 @@ class Importer {
     logger;
     blocks;
     states;
+    options;
     verifier;
     stf;
     // TODO [ToDr] we cannot assume state reference does not change.
@@ -29077,11 +29095,12 @@ class Importer {
     // Hash of the block that we have the posterior state for in `state`.
     currentHash;
     metrics;
-    constructor(spec, pvm, hasher, logger, blocks, states) {
+    constructor(spec, pvm, hasher, logger, blocks, states, options = {}) {
         this.hasher = hasher;
         this.logger = logger;
         this.blocks = blocks;
         this.states = states;
+        this.options = options;
         this.metrics = createMetrics();
         const currentBestHeaderHash = this.blocks.getBestHeaderHash();
         const state = states.getState(currentBestHeaderHash);
@@ -29136,7 +29155,9 @@ class Importer {
         logger.log `🧱 Attempting to import a new block`;
         const timerVerify = measure("import:verify");
         const verifyStart = now();
-        const hash = await this.verifier.verifyBlock(block);
+        const hash = await this.verifier.verifyBlock(block, {
+            skipParentAndStateRoot: this.options.initGenesisFromAncestry ?? false,
+        });
         const verifyDuration = now() - verifyStart;
         logger.log `${timerVerify()}`;
         if (hash.isError) {
@@ -29239,14 +29260,14 @@ function extractTimeSlot(block) {
 const main_logger = Logger.new(import.meta.filename, "importer");
 const keccakHasher = KeccakHasher.create();
 const blake2b = Blake2b.createHasher();
-async function createImporter(config) {
+async function createImporter(config, options = {}) {
     const chainSpec = config.chainSpec;
     const db = config.openDatabase({ readonly: false });
     const pvm = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
     const hasher = new TransitionHasher(await keccakHasher, await blake2b);
-    const importer = new Importer(chainSpec, pvm, hasher, main_logger, blocks, states);
+    const importer = new Importer(chainSpec, pvm, hasher, main_logger, blocks, states, options);
     return {
         importer,
         db,