@typeberry/jam 0.5.1-7188620 → 0.5.1-7d23ab3

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());
@@ -164379,6 +164376,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 +164465,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 +166618,7 @@ class Importer {
     logger;
     blocks;
     states;
+    options;
     verifier;
     stf;
     // TODO [ToDr] we cannot assume state reference does not change.
@@ -166618,11 +166626,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 +166686,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 +166791,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 +170134,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 +170164,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 +170269,7 @@ async function mainFuzz(fuzzConfig, withRelPath) {
                 },
                 ancestry,
                 network: null,
-            }, withRelPath);
+            }, withRelPath, { initGenesisFromAncestry: fuzzConfig.initGenesisFromAncestry });
             runningNode = newNode;
             return await newNode.getBestStateRootHash();
         },
@@ -170486,6 +170501,7 @@ const jam_package_namespaceObject = {"rE":"0.5.1"};
 
 
 
+
 const HELP = `
 @typeberry/jam ${jam_package_namespaceObject.rE} by Fluffy Labs.
 
@@ -170574,6 +170590,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 +170603,7 @@ function parseArgs(input, withRelPath) {
                     ...data,
                     version,
                     socket,
+                    initGenesisFromAncestry,
                 },
             };
         }
@@ -170781,7 +170803,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) {