@typeberry/jam 0.5.1-b2fd1d5 → 0.5.1-ddf0ef6

package/bootstrap-generator.mjs

@@ -14907,6 +14907,8 @@ class bandersnatch_wasm_BandernsatchWasm {
 
 
 
+
+const safrole_logger = Logger.new(import.meta.filename, "safrole");
 const safrole_VALIDATOR_META_BYTES = 128;
 const ticketComparator = (a, b) => bytes_bytesBlobComparator(a.id, b.id);
 var SafroleErrorCode;
@@ -14994,6 +14996,14 @@ class safrole_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_Result.ok(null);
+        }
         return await this.getValidatorKeys(common_tryAsTimeSlot(nextEpochStart), postOffenders);
     }
     async getValidatorKeys(timeslot, postOffenders) {
@@ -20768,6 +20778,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;
@@ -21251,6 +21262,7 @@ class Fetch {
             return PvmExecution.Panic;
         }
         logger.trace `[${this.currentServiceId}] FETCH(${kind}) <- ${value?.toStringTruncated()}`;
+        logger.insane `[${this.currentServiceId}] FETCH(${kind}) <- ${value}`;
         // write result
         regs.set(fetch_IN_OUT_REG, value === null ? HostCallResult.NONE : valueLength);
     }
@@ -21550,6 +21562,7 @@ class Lookup {
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
         logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated() ?? "<missing>"}...`;
+        logger.insane `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage ?? "<missing>"}`;
         const preImageLength = preImage === null ? tryAsU64(0) : tryAsU64(preImage.raw.length);
         const preimageBlobOffset = regs.get(10);
         const lengthToWrite = regs.get(11);
@@ -21656,6 +21669,7 @@ class Read {
         }
         if (chunk.length > 0) {
             logger.trace `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- ${BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+            logger.insane `[${this.currentServiceId}] READ(${serviceId}, ${rawKey}) <- ${BytesBlob.blobFrom(chunk)}`;
         }
         else {
             // just a query for length of stored data
@@ -21721,6 +21735,7 @@ class Write {
         // a
         const result = this.account.write(storageKey, maybeValue);
         logger.trace `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue?.toStringTruncated() ?? "remove"}) <- ${resultToString(result)}`;
+        logger.insane `[${this.currentServiceId}] WRITE(${storageKey}, ${maybeValue ?? "remove"}) <- ${resultToString(result)}`;
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;
@@ -21782,6 +21797,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));
         }
@@ -22025,6 +22041,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);
         }