@typeberry/jam 0.5.1-b2fd1d5 → 0.5.1-eb84786

package/index.js

@@ -152591,12 +152591,7 @@ function getDatabasePath(blake2b, nodeName, genesisHeader, databaseBasePath) {
         genesisHeaderHash,
     };
 }
-/**
- * Initialize the database unless it's already initialized.
- *
- * The function checks the genesis header
- */
-async function initializeDatabase(spec, blake2b, genesisHeaderHash, rootDb, config, ancestry) {
+async function initializeDatabase(spec, blake2b, genesisHeaderHash, rootDb, config, ancestry, options = {}) {
     const blocks = rootDb.getBlocksDb();
     const states = rootDb.getStatesDb();
     const header = blocks.getBestHeaderHash();
@@ -152617,14 +152612,16 @@ async function initializeDatabase(spec, blake2b, genesisHeaderHash, rootDb, conf
     common_logger.log `🧬 Writing genesis block #${genesisHeader.timeSlotIndex}: ${genesisHeaderHash}`;
     const { genesisStateSerialized, genesisStateRootHash } = loadGenesisState(spec, blake2b, config.genesisState);
     // write to db
-    await blocks.insertBlock(new WithHash(genesisHeaderHash, blockView));
+    // When initGenesisFromAncestry is set, use ancestry[0][0] as the initial block hash (for fuzz-target mode)
+    const initialBlockHash = (options.initGenesisFromAncestry ?? false) && ancestry.length > 0 ? ancestry[0][0] : genesisHeaderHash;
+    await blocks.insertBlock(new WithHash(initialBlockHash, blockView));
     // insert fake blocks for ancestry data
     for (const [hash, slot] of ancestry) {
         await blocks.insertBlock(new WithHash(hash, reencodeAsView(Block.Codec, emptyBlock(slot), spec)));
     }
-    await states.insertInitialState(genesisHeaderHash, genesisStateSerialized);
-    await blocks.setPostStateRoot(genesisHeaderHash, genesisStateRootHash);
-    await blocks.setBestHeaderHash(genesisHeaderHash);
+    await states.insertInitialState(initialBlockHash, genesisStateSerialized);
+    await blocks.setPostStateRoot(initialBlockHash, genesisStateRootHash);
+    await blocks.setBestHeaderHash(initialBlockHash);
 }
 function loadGenesisState(spec, blake2b, data) {
     const stateEntries = state_entries_StateEntries.fromEntriesUnsafe(data.entries());
@@ -159974,6 +159971,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;
@@ -160457,6 +160455,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);
     }
@@ -160756,6 +160755,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);
@@ -160862,6 +160862,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
@@ -160927,6 +160928,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;
@@ -160988,6 +160990,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));
         }
@@ -161231,6 +161234,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);
         }
@@ -164379,6 +164383,8 @@ class BandernsatchWasm {
 
 
 
+
+const safrole_logger = logger_Logger.new(import.meta.filename, "safrole");
 const safrole_VALIDATOR_META_BYTES = 128;
 const ticketComparator = (a, b) => bytesBlobComparator(a.id, b.id);
 var SafroleErrorCode;
@@ -164466,6 +164472,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_Result.ok(null);
+        }
         return await this.getValidatorKeys(tryAsTimeSlot(nextEpochStart), postOffenders);
     }
     async getValidatorKeys(timeslot, postOffenders) {
@@ -166611,6 +166625,7 @@ class Importer {
     logger;
     blocks;
     states;
+    options;
     verifier;
     stf;
     // TODO [ToDr] we cannot assume state reference does not change.
@@ -166618,11 +166633,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 = metrics_createMetrics();
         const currentBestHeaderHash = this.blocks.getBestHeaderHash();
         const state = states.getState(currentBestHeaderHash);
@@ -166677,7 +166693,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) {
@@ -166780,14 +166798,14 @@ function extractTimeSlot(block) {
 const main_logger = logger_Logger.new(import.meta.filename, "importer");
 const keccakHasher = KeccakHasher.create();
 const blake2b = 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,
@@ -170123,7 +170141,7 @@ const initNetwork = async (importer, rootDb, baseConfig, genesisHeaderHash, netw
 
 
 const zeroHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
-async function mainImporter(config, withRelPath) {
+async function mainImporter(config, withRelPath, options = {}) {
     await initAll();
     common_logger.info `🫐 Typeberry ${node_package_namespaceObject.rE}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
     common_logger.info `🎸 Starting importer: ${config.nodeName}.`;
@@ -170153,9 +170171,13 @@ async function mainImporter(config, withRelPath) {
     // Initialize the database with genesis state and block if there isn't one.
     common_logger.info `🛢️ Opening database at ${dbPath}`;
     const rootDb = workerConfig.openDatabase({ readonly: false });
-    await initializeDatabase(chainSpec, blake2b, genesisHeaderHash, rootDb, config.node.chainSpec, config.ancestry);
+    await initializeDatabase(chainSpec, blake2b, genesisHeaderHash, rootDb, config.node.chainSpec, config.ancestry, {
+        initGenesisFromAncestry: options.initGenesisFromAncestry,
+    });
     await rootDb.close();
-    const { db, importer } = await createImporter(workerConfig);
+    const { db, importer } = await createImporter(workerConfig, {
+        initGenesisFromAncestry: options.initGenesisFromAncestry,
+    });
     await importer.prepareForNextEpoch();
     const api = {
         chainSpec,
@@ -170254,7 +170276,7 @@ async function mainFuzz(fuzzConfig, withRelPath) {
                 },
                 ancestry,
                 network: null,
-            }, withRelPath);
+            }, withRelPath, { initGenesisFromAncestry: fuzzConfig.initGenesisFromAncestry });
             runningNode = newNode;
             return await newNode.getBestStateRootHash();
         },
@@ -170486,6 +170508,7 @@ const jam_package_namespaceObject = {"rE":"0.5.1"};
 
 
 
+
 const HELP = `
 @typeberry/jam ${jam_package_namespaceObject.rE} by Fluffy Labs.
 
@@ -170574,6 +170597,11 @@ function parseArgs(input, withRelPath) {
         case Command.FuzzTarget: {
             const data = parseSharedOptions(args);
             const { version } = parseValueOption(args, "version", "number", parseFuzzVersion, 1);
+            const initGenesisFromAncestry = args["init-genesis-from-ancestry"] === true;
+            delete args["init-genesis-from-ancestry"];
+            if (initGenesisFromAncestry) {
+                common_logger.warn `Init genesis from ancestry is enabled. Parent hash and state root verification is skipped.`;
+            }
             const socket = args._.shift() ?? null;
             assertNoMoreArgs(args);
             return {
@@ -170582,6 +170610,7 @@ function parseArgs(input, withRelPath) {
                     ...data,
                     version,
                     socket,
+                    initGenesisFromAncestry,
                 },
             };
         }
@@ -170781,7 +170810,8 @@ async function startNode(args, withRelPath) {
     if (args.command === Command.FuzzTarget) {
         const version = args.args.version;
         const socket = args.args.socket;
-        return mainFuzz({ jamNodeConfig, version, socket }, withRelPath);
+        const initGenesisFromAncestry = args.args.initGenesisFromAncestry;
+        return mainFuzz({ jamNodeConfig, version, socket, initGenesisFromAncestry }, withRelPath);
     }
     // Just import a bunch of blocks
     if (args.command === Command.Import) {