@typeberry/jam 0.5.3-aa4626d → 0.5.3-edc7483

package/index.js

@@ -153709,6 +153709,7 @@ const DEFAULT_DEV_CONFIG = {
  */
 class JamConfig {
     isAuthoring;
+    isFastForward;
     nodeName;
     node;
     pvmBackend;
@@ -153716,12 +153717,14 @@ class JamConfig {
     network;
     ancestry;
     devValidatorIndex;
-    static new({ isAuthoring, nodeName, nodeConfig, pvmBackend, devConfig = null, networkConfig = null, ancestry = [], devValidatorIndex = null, }) {
-        return new JamConfig(isAuthoring ?? false, nodeName, nodeConfig, pvmBackend, devConfig, networkConfig, ancestry, devValidatorIndex);
+    static new({ isAuthoring, isFastForward, nodeName, nodeConfig, pvmBackend, devConfig = null, networkConfig = null, ancestry = [], devValidatorIndex = null, }) {
+        return new JamConfig(isAuthoring ?? false, isFastForward ?? false, nodeName, nodeConfig, pvmBackend, devConfig, networkConfig, ancestry, devValidatorIndex);
     }
     constructor(
     /** Whether we should be authoring blocks. */
     isAuthoring, 
+    /** Fast forward mode - generate blocks as fast as possible without waiting for real time. */
+    isFastForward, 
     /** Node name. */
     nodeName, 
     /** Node starting configuration. */
@@ -153737,6 +153740,7 @@ class JamConfig {
     /** Validator index for dev mode authorship. Use "all" to author as all validators. */
     devValidatorIndex) {
         this.isAuthoring = isAuthoring;
+        this.isFastForward = isFastForward;
         this.nodeName = nodeName;
         this.node = node;
         this.pvmBackend = pvmBackend;
@@ -169931,6 +169935,8 @@ async function block_authorship_main_main(config, comms) {
         }
         return result_Result.ok(state.sealingKeySeries);
     }
+    const isFastForward = config.workerParams.isFastForward;
+    let lastGeneratedSlot = startTimeSlot;
     while (!isFinished) {
         const hash = blocks.getBestHeaderHash();
         const state = states.getState(hash);
@@ -169938,10 +169944,20 @@ async function block_authorship_main_main(config, comms) {
         if (state === null) {
             continue;
         }
-        const time = getTime();
-        /** Assuming `slotDuration` is 6 sec it is safe till year 2786. If `slotDuration` is 1 sec then it is safe till 2106   */
-        const timeSlot = tryAsTimeSlot(Number(time / 1000n / BigInt(chainSpec.slotDuration)));
         const lastTimeSlot = state.timeslot;
+        /**
+         * In fastForward mode, use simulated time (next slot after current state).
+         * In normal mode, use wall clock time.
+         * Assuming `slotDuration` is 6 sec it is safe till year 2786.
+         * If `slotDuration` is 1 sec then it is safe till 2106.
+         */
+        const timeSlot = isFastForward === true
+            ? tryAsTimeSlot(lastTimeSlot + 1)
+            : tryAsTimeSlot(Number(getTime() / 1000n / BigInt(chainSpec.slotDuration)));
+        // In fastForward mode, skip if we already generated for this slot (waiting for import)
+        if (isFastForward === true && timeSlot <= lastGeneratedSlot) {
+            continue;
+        }
         const isNewEpoch = isEpochChanged(lastTimeSlot, timeSlot);
         const selingKeySeriesResult = await getSealingKeySeries(isNewEpoch, timeSlot, state);
         if (selingKeySeriesResult.isError) {
@@ -169958,10 +169974,17 @@ async function block_authorship_main_main(config, comms) {
             const sealPayload = getSealPayload(selingKeySeriesResult.ok, entropy);
             const newBlock = await generator.nextBlockView(validatorIndex, key.bandersnatchSecret, sealPayload, timeSlot);
             counter += 1;
+            lastGeneratedSlot = timeSlot;
             block_authorship_main_logger.trace `Sending block ${counter}`;
             await comms.sendBlock(newBlock);
         }
-        await (0,promises_namespaceObject.setTimeout)(chainSpec.slotDuration * 1000);
+        else if (isFastForward === true) {
+            // In fast-forward mode, if this slot is not ours, wait briefly for other validators to produce blocks
+            await (0,promises_namespaceObject.setTimeout)(10);
+        }
+        if (isFastForward === false) {
+            await (0,promises_namespaceObject.setTimeout)(chainSpec.slotDuration * 1000);
+        }
     }
     block_authorship_main_logger.info `🎁 Block Authorship finished. Closing channel.`;
     await db.close();
@@ -170003,14 +170026,17 @@ class ValidatorSecrets {
 }
 class BlockAuthorshipConfig {
     keys;
+    isFastForward;
     static Codec = codec_codec.Class(BlockAuthorshipConfig, {
         keys: codec_codec.sequenceVarLen(ValidatorSecrets.Codec),
+        isFastForward: codec_codec.bool,
     });
-    static create({ keys }) {
-        return new BlockAuthorshipConfig(keys);
+    static create({ keys, isFastForward }) {
+        return new BlockAuthorshipConfig(keys, isFastForward);
     }
-    constructor(keys) {
+    constructor(keys, isFastForward) {
         this.keys = keys;
+        this.isFastForward = isFastForward;
     }
 }
 
@@ -170191,7 +170217,7 @@ async function node_main_main(config, withRelPath, telemetry) {
                 },
             ],
     };
-    const closeAuthorship = await initAuthorship(importer, config.isAuthoring, rootDb, baseConfig, authorshipKeys, isInMemory);
+    const closeAuthorship = await initAuthorship(importer, config.isAuthoring, config.isFastForward, rootDb, baseConfig, authorshipKeys, isInMemory);
     // Networking initialization
     const closeNetwork = await initNetwork(importer, rootDb, baseConfig, genesisHeaderHash, config.network, bestHeader, isInMemory);
     const api = {
@@ -170227,22 +170253,23 @@ async function node_main_main(config, withRelPath, telemetry) {
     };
     return api;
 }
-const initAuthorship = async (importer, isAuthoring, rootDb, baseConfig, authorshipKeys, isInMemory) => {
+const initAuthorship = async (importer, isAuthoring, isFastForward, rootDb, baseConfig, authorshipKeys, isInMemory) => {
     if (!isAuthoring) {
         common_logger.log `✍️  Authorship off: disabled`;
         return () => Promise.resolve();
     }
     common_logger.info `✍️  Starting block generator.`;
+    const workerParams = { ...authorshipKeys, isFastForward };
     const { generator, finish } = isInMemory
         ? await startBlockGenerator(DirectWorkerConfig.new({
             ...baseConfig,
             blocksDb: rootDb.getBlocksDb(),
             statesDb: rootDb.getStatesDb(),
-            workerParams: authorshipKeys,
+            workerParams,
         }))
         : await spawnBlockGeneratorWorker(config_LmdbWorkerConfig.new({
             ...baseConfig,
-            workerParams: authorshipKeys,
+            workerParams,
         }));
     // relay blocks from generator to importer
     generator.setOnBlock(async (block) => {
@@ -170674,7 +170701,7 @@ const HELP = `
 
 Usage:
   jam [options]
-  jam [options] dev <dev-validator-index>
+  jam [options] dev <dev-validator-index> [--fast-forward]
   jam [options] import <bin-or-json-blocks>
   jam [options] export <output-directory-or-file>
   jam [options] [--version=1] fuzz-target [socket-path=/tmp/jam_target.sock]
@@ -170694,6 +170721,7 @@ Options:
                         [default: ${NODE_DEFAULTS.config}]
   --pvm                 PVM Backend, one of: [${PvmBackendNames.join(", ")}].
                         [default: ${PvmBackendNames[NODE_DEFAULTS.pvm]}]
+  --fast-forward        (dev mode only) Generate blocks as fast as possible without waiting for real time.
 `;
 /** Command to execute. */
 var Command;
@@ -170744,15 +170772,18 @@ function parseArgs(input, withRelPath) {
             if (indexOrAll === undefined) {
                 throw new Error("Missing dev-validator index.");
             }
+            const isFastForward = args["fast-forward"] === true;
+            delete args["fast-forward"];
             if (indexOrAll === "all") {
-                return { command: Command.Dev, args: { ...data, index: "all" } };
+                assertNoMoreArgs(args);
+                return { command: Command.Dev, args: { ...data, index: indexOrAll, isFastForward } };
             }
             const numIndex = Number(indexOrAll);
             if (!isU16(numIndex)) {
                 throw new Error(`Invalid dev-validator index: ${numIndex}, need U16 or "all"`);
             }
             assertNoMoreArgs(args);
-            return { command: Command.Dev, args: { ...data, index: numIndex } };
+            return { command: Command.Dev, args: { ...data, index: numIndex, isFastForward } };
         }
         case Command.FuzzTarget: {
             const data = parseSharedOptions(args);
@@ -170943,8 +170974,12 @@ async function prepareConfigFile(args, blake2b, withRelPath) {
             return new Bootnode(opaque_asOpaqueType(peerId), "127.0.0.1", port);
         }))
         : [];
+    const isDevMode = args.command === Command.Dev;
+    const devIndex = isDevMode ? args.args.index : null;
+    const isFastForward = isDevMode ? args.args.isFastForward : false;
     return JamConfig.new({
-        isAuthoring: args.command === Command.Dev,
+        isAuthoring: isDevMode,
+        isFastForward,
         nodeName,
         nodeConfig,
         pvmBackend: args.args.pvm,
@@ -170954,7 +170989,7 @@ async function prepareConfigFile(args, blake2b, withRelPath) {
             port: devPort(devPortShift),
             bootnodes: devBootnodes.concat(nodeConfig.chainSpec.bootnodes ?? []),
         },
-        devValidatorIndex: args.command === Command.Dev ? args.args.index : null,
+        devValidatorIndex: devIndex,
     });
 }
 async function startNode(args, withRelPath) {