@aztec/stdlib 0.82.2 → 0.82.3-nightly.20250403

package/src/avm/avm.ts

@@ -6,34 +6,16 @@ import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { PublicKeys } from '../keys/public_keys.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
-export class AvmEnqueuedCallHint {
-  constructor(
-    public readonly msgSender: AztecAddress,
-    public readonly contractAddress: AztecAddress,
-    public readonly calldata: Fr[],
-    public isStaticCall: boolean,
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        msgSender: AztecAddress.schema,
-        contractAddress: AztecAddress.schema,
-        calldata: schemas.Fr.array(),
-        isStaticCall: z.boolean(),
-      })
-      .transform(
-        ({ msgSender, contractAddress, calldata, isStaticCall }) =>
-          new AvmEnqueuedCallHint(msgSender, contractAddress, calldata, isStaticCall),
-      );
-  }
-}
-
+////////////////////////////////////////////////////////////////////////////
+// Hints (contracts)
+////////////////////////////////////////////////////////////////////////////
 export class AvmContractClassHint {
   constructor(
     public readonly classId: Fr,
@@ -115,97 +97,192 @@ export class AvmContractInstanceHint {
   }
 }
 
-export class AvmAppendTreeHint {
-  constructor(public readonly leafIndex: Fr, public readonly value: Fr, public readonly siblingPath: Fr[]) {}
-
-  static get schema() {
-    return z
-      .object({
-        leafIndex: schemas.Fr,
-        value: schemas.Fr,
-        siblingPath: schemas.Fr.array(),
-      })
-      .transform(({ leafIndex, value, siblingPath }) => new AvmAppendTreeHint(leafIndex, value, siblingPath));
-  }
-}
-
-export class AvmNullifierWriteTreeHint {
-  constructor(public lowLeafRead: AvmNullifierReadTreeHint, public readonly insertionPath: Fr[]) {}
+////////////////////////////////////////////////////////////////////////////
+// Hints (merkle db)
+////////////////////////////////////////////////////////////////////////////
+// Hint for MerkleTreeDB.getSiblingPath.
+export class AvmGetSiblingPathHint {
+  constructor(
+    public readonly hintKey: AppendOnlyTreeSnapshot,
+    // params
+    public readonly treeId: MerkleTreeId,
+    public readonly index: bigint,
+    // return
+    public readonly path: Fr[],
+  ) {}
 
   static get schema() {
     return z
       .object({
-        lowLeafRead: AvmNullifierReadTreeHint.schema,
-        insertionPath: schemas.Fr.array(),
+        hintKey: AppendOnlyTreeSnapshot.schema,
+        treeId: z.number().int().nonnegative(),
+        index: schemas.BigInt,
+        path: schemas.Fr.array(),
       })
-      .transform(({ lowLeafRead, insertionPath }) => new AvmNullifierWriteTreeHint(lowLeafRead, insertionPath));
+      .transform(({ hintKey, treeId, index, path }) => new AvmGetSiblingPathHint(hintKey, treeId, index, path));
   }
 }
 
-export class AvmNullifierReadTreeHint {
+// Hint for MerkleTreeDB.getPreviousValueIndex.
+export class AvmGetPreviousValueIndexHint {
   constructor(
-    public readonly lowLeafPreimage: NullifierLeafPreimage,
-    public readonly lowLeafIndex: Fr,
-    public readonly lowLeafSiblingPath: Fr[],
+    public readonly hintKey: AppendOnlyTreeSnapshot,
+    // params
+    public readonly treeId: MerkleTreeId,
+    public readonly value: Fr,
+    // return
+    public readonly index: bigint,
+    public readonly alreadyPresent: boolean,
   ) {}
 
   static get schema() {
     return z
       .object({
-        lowLeafPreimage: NullifierLeafPreimage.schema,
-        lowLeafIndex: schemas.Fr,
-        lowLeafSiblingPath: schemas.Fr.array(),
+        hintKey: AppendOnlyTreeSnapshot.schema,
+        treeId: z.number().int().nonnegative(),
+        value: schemas.Fr,
+        index: schemas.BigInt,
+        alreadyPresent: z.boolean(),
       })
       .transform(
-        ({ lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath }) =>
-          new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath),
+        ({ hintKey, treeId, value, index, alreadyPresent }) =>
+          new AvmGetPreviousValueIndexHint(hintKey, treeId, value, index, alreadyPresent),
       );
   }
 }
 
-export class AvmPublicDataReadTreeHint {
+type IndexedTreeLeafPreimages = NullifierLeafPreimage | PublicDataTreeLeafPreimage;
+type IndexedTreeLeafPreimagesClasses = typeof NullifierLeafPreimage | typeof PublicDataTreeLeafPreimage;
+
+// Hint for MerkleTreeDB.getLeafPreimage.
+// NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
+// having the type doesn't suffice since TS does type erasure in the end.
+function AvmGetLeafPreimageHintFactory(klass: IndexedTreeLeafPreimagesClasses) {
+  return class AvmGetLeafPreimageHint {
+    constructor(
+      public readonly hintKey: AppendOnlyTreeSnapshot,
+      // params (tree id will be implicit)
+      public readonly index: bigint,
+      // return
+      public readonly leafPreimage: IndexedTreeLeafPreimages,
+    ) {}
+
+    static get schema() {
+      return z
+        .object({
+          hintKey: AppendOnlyTreeSnapshot.schema,
+          index: schemas.BigInt,
+          leafPreimage: klass.schema,
+        })
+        .transform(({ hintKey, index, leafPreimage }) => new AvmGetLeafPreimageHint(hintKey, index, leafPreimage));
+    }
+  };
+}
+
+// Note: only supported for PUBLIC_DATA_TREE and NULLIFIER_TREE.
+export class AvmGetLeafPreimageHintPublicDataTree extends AvmGetLeafPreimageHintFactory(PublicDataTreeLeafPreimage) {}
+export class AvmGetLeafPreimageHintNullifierTree extends AvmGetLeafPreimageHintFactory(NullifierLeafPreimage) {}
+
+// Hint for MerkleTreeDB.getLeafValue.
+// Note: only supported for NOTE_HASH_TREE and L1_TO_L2_MESSAGE_TREE.
+export class AvmGetLeafValueHint {
   constructor(
-    public readonly leafPreimage: PublicDataTreeLeafPreimage,
-    public readonly leafIndex: Fr,
-    public readonly siblingPath: Fr[],
+    public readonly hintKey: AppendOnlyTreeSnapshot,
+    // params
+    public readonly treeId: MerkleTreeId,
+    public readonly index: bigint,
+    // return
+    public readonly value: Fr,
   ) {}
 
-  static empty() {
-    return new AvmPublicDataReadTreeHint(PublicDataTreeLeafPreimage.empty(), Fr.ZERO, []);
-  }
-
   static get schema() {
     return z
       .object({
-        leafPreimage: PublicDataTreeLeafPreimage.schema,
-        leafIndex: schemas.Fr,
-        siblingPath: schemas.Fr.array(),
+        hintKey: AppendOnlyTreeSnapshot.schema,
+        treeId: z.number().int().nonnegative(),
+        index: schemas.BigInt,
+        value: schemas.Fr,
       })
-      .transform(
-        ({ leafPreimage, leafIndex, siblingPath }) =>
-          new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, siblingPath),
-      );
+      .transform(({ hintKey, treeId, index, value }) => new AvmGetLeafValueHint(hintKey, treeId, index, value));
   }
 }
 
-export class AvmPublicDataWriteTreeHint {
+// Hint for MerkleTreeDB.sequentialInsert.
+// NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
+// having the type doesn't suffice since TS does type erasure in the end.
+function AvmSequentialInsertHintFactory(klass: IndexedTreeLeafPreimagesClasses) {
+  return class AvmSequentialInsertHint {
+    constructor(
+      public readonly hintKey: AppendOnlyTreeSnapshot,
+      public readonly stateAfter: AppendOnlyTreeSnapshot,
+      // params
+      public readonly treeId: MerkleTreeId,
+      public readonly leaf: InstanceType<IndexedTreeLeafPreimagesClasses>['leaf'],
+      // return
+      public readonly lowLeavesWitnessData: {
+        leaf: IndexedTreeLeafPreimages;
+        index: bigint;
+        path: Fr[];
+      },
+      public readonly insertionWitnessData: {
+        leaf: IndexedTreeLeafPreimages;
+        index: bigint;
+        path: Fr[];
+      },
+    ) {}
+
+    static get schema() {
+      return z
+        .object({
+          hintKey: AppendOnlyTreeSnapshot.schema,
+          stateAfter: AppendOnlyTreeSnapshot.schema,
+          treeId: z.number().int().nonnegative(),
+          leaf: klass.leafSchema,
+          lowLeavesWitnessData: z.object({
+            leaf: klass.schema,
+            index: schemas.BigInt,
+            path: schemas.Fr.array(),
+          }),
+          insertionWitnessData: z.object({
+            leaf: klass.schema,
+            index: schemas.BigInt,
+            path: schemas.Fr.array(),
+          }),
+        })
+        .transform(
+          ({ hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData }) =>
+            new AvmSequentialInsertHint(hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData),
+        );
+    }
+  };
+}
+
+// Note: only supported for PUBLIC_DATA_TREE and NULLIFIER_TREE.
+export class AvmSequentialInsertHintPublicDataTree extends AvmSequentialInsertHintFactory(PublicDataTreeLeafPreimage) {}
+export class AvmSequentialInsertHintNullifierTree extends AvmSequentialInsertHintFactory(NullifierLeafPreimage) {}
+
+////////////////////////////////////////////////////////////////////////////
+// Hints (other)
+////////////////////////////////////////////////////////////////////////////
+export class AvmEnqueuedCallHint {
   constructor(
-    // To check the current slot has been written to
-    public readonly lowLeafRead: AvmPublicDataReadTreeHint,
-    public readonly newLeafPreimage: PublicDataTreeLeafPreimage,
-    public readonly insertionPath: Fr[],
+    public readonly msgSender: AztecAddress,
+    public readonly contractAddress: AztecAddress,
+    public readonly calldata: Fr[],
+    public isStaticCall: boolean,
   ) {}
 
   static get schema() {
     return z
       .object({
-        lowLeafRead: AvmPublicDataReadTreeHint.schema,
-        newLeafPreimage: PublicDataTreeLeafPreimage.schema,
-        insertionPath: schemas.Fr.array(),
+        msgSender: AztecAddress.schema,
+        contractAddress: AztecAddress.schema,
+        calldata: schemas.Fr.array(),
+        isStaticCall: z.boolean(),
       })
       .transform(
-        ({ lowLeafRead, newLeafPreimage, insertionPath }) =>
-          new AvmPublicDataWriteTreeHint(lowLeafRead, newLeafPreimage, insertionPath),
+        ({ msgSender, contractAddress, calldata, isStaticCall }) =>
+          new AvmEnqueuedCallHint(msgSender, contractAddress, calldata, isStaticCall),
       );
   }
 }
@@ -213,16 +290,18 @@ export class AvmPublicDataWriteTreeHint {
 export class AvmExecutionHints {
   constructor(
     public readonly enqueuedCalls: AvmEnqueuedCallHint[] = [],
+    // Contract hints.
     public readonly contractInstances: AvmContractInstanceHint[] = [],
     public readonly contractClasses: AvmContractClassHint[] = [],
     public readonly bytecodeCommitments: AvmBytecodeCommitmentHint[] = [],
-    public readonly publicDataReads: AvmPublicDataReadTreeHint[] = [],
-    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[] = [],
-    public readonly nullifierReads: AvmNullifierReadTreeHint[] = [],
-    public readonly nullifierWrites: AvmNullifierWriteTreeHint[] = [],
-    public readonly noteHashReads: AvmAppendTreeHint[] = [],
-    public readonly noteHashWrites: AvmAppendTreeHint[] = [],
-    public readonly l1ToL2MessageReads: AvmAppendTreeHint[] = [],
+    // Merkle DB hints.
+    public readonly getSiblingPathHints: AvmGetSiblingPathHint[] = [],
+    public readonly getPreviousValueIndexHints: AvmGetPreviousValueIndexHint[] = [],
+    public readonly getLeafPreimageHintsPublicDataTree: AvmGetLeafPreimageHintPublicDataTree[] = [],
+    public readonly getLeafPreimageHintsNullifierTree: AvmGetLeafPreimageHintNullifierTree[] = [],
+    public readonly getLeafValueHints: AvmGetLeafValueHint[] = [],
+    public readonly sequentialInsertHintsPublicDataTree: AvmSequentialInsertHintPublicDataTree[] = [],
+    public readonly sequentialInsertHintsNullifierTree: AvmSequentialInsertHintNullifierTree[] = [],
   ) {}
 
   static empty() {
@@ -236,13 +315,13 @@ export class AvmExecutionHints {
         contractInstances: AvmContractInstanceHint.schema.array(),
         contractClasses: AvmContractClassHint.schema.array(),
         bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
-        publicDataReads: AvmPublicDataReadTreeHint.schema.array(),
-        publicDataWrites: AvmPublicDataWriteTreeHint.schema.array(),
-        nullifierReads: AvmNullifierReadTreeHint.schema.array(),
-        nullifierWrites: AvmNullifierWriteTreeHint.schema.array(),
-        noteHashReads: AvmAppendTreeHint.schema.array(),
-        noteHashWrites: AvmAppendTreeHint.schema.array(),
-        l1ToL2MessageReads: AvmAppendTreeHint.schema.array(),
+        getSiblingPathHints: AvmGetSiblingPathHint.schema.array(),
+        getPreviousValueIndexHints: AvmGetPreviousValueIndexHint.schema.array(),
+        getLeafPreimageHintsPublicDataTree: AvmGetLeafPreimageHintPublicDataTree.schema.array(),
+        getLeafPreimageHintsNullifierTree: AvmGetLeafPreimageHintNullifierTree.schema.array(),
+        getLeafValueHints: AvmGetLeafValueHint.schema.array(),
+        sequentialInsertHintsPublicDataTree: AvmSequentialInsertHintPublicDataTree.schema.array(),
+        sequentialInsertHintsNullifierTree: AvmSequentialInsertHintNullifierTree.schema.array(),
       })
       .transform(
         ({
@@ -250,26 +329,26 @@ export class AvmExecutionHints {
           contractInstances,
           contractClasses,
           bytecodeCommitments,
-          publicDataReads,
-          publicDataWrites,
-          nullifierReads,
-          nullifierWrites,
-          noteHashReads,
-          noteHashWrites,
-          l1ToL2MessageReads,
+          getSiblingPathHints,
+          getPreviousValueIndexHints,
+          getLeafPreimageHintsPublicDataTree,
+          getLeafPreimageHintsNullifierTree,
+          getLeafValueHints,
+          sequentialInsertHintsPublicDataTree,
+          sequentialInsertHintsNullifierTree,
         }) =>
           new AvmExecutionHints(
             enqueuedCalls,
             contractInstances,
             contractClasses,
             bytecodeCommitments,
-            publicDataReads,
-            publicDataWrites,
-            nullifierReads,
-            nullifierWrites,
-            noteHashReads,
-            noteHashWrites,
-            l1ToL2MessageReads,
+            getSiblingPathHints,
+            getPreviousValueIndexHints,
+            getLeafPreimageHintsPublicDataTree,
+            getLeafPreimageHintsNullifierTree,
+            getLeafValueHints,
+            sequentialInsertHintsPublicDataTree,
+            sequentialInsertHintsNullifierTree,
           ),
       );
   }

package/src/block/l2_block_downloader/l2_block_stream.ts

@@ -9,6 +9,7 @@ import type { PublishedL2Block } from '../published_l2_block.js';
 export class L2BlockStream {
   private readonly runningPromise: RunningPromise;
   private isSyncing = false;
+  private hasStarted = false;
 
   constructor(
     private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
@@ -65,18 +66,31 @@ export class L2BlockStream {
 
       // Check if there was a reorg and emit a chain-pruned event if so.
       let latestBlockNumber = localTips.latest.number;
-      while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache: [sourceTips.latest] }))) {
+      const sourceCache = new BlockHashCache([sourceTips.latest]);
+      while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache }))) {
         latestBlockNumber--;
       }
+
       if (latestBlockNumber < localTips.latest.number) {
         this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.latest.number}.`);
-        await this.emitEvent({ type: 'chain-pruned', blockNumber: latestBlockNumber });
+        await this.emitEvent({
+          type: 'chain-pruned',
+          block: {
+            number: latestBlockNumber,
+            hash: sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber))!,
+          },
+        });
       }
 
       // If we are just starting, use the starting block number from the options.
       if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
         latestBlockNumber = Math.max(this.opts.startingBlock - 1, 0);
+      }
+
+      // Only log this entry once (for sanity)
+      if (!this.hasStarted) {
         this.log.verbose(`Starting sync from block number ${latestBlockNumber}`);
+        this.hasStarted = true;
       }
 
       // Request new blocks from the source.
@@ -94,10 +108,13 @@ export class L2BlockStream {
 
       // Update the proven and finalized tips.
       if (localTips.proven !== undefined && sourceTips.proven.number !== localTips.proven.number) {
-        await this.emitEvent({ type: 'chain-proven', blockNumber: sourceTips.proven.number });
+        await this.emitEvent({
+          type: 'chain-proven',
+          block: sourceTips.proven,
+        });
       }
       if (localTips.finalized !== undefined && sourceTips.finalized.number !== localTips.finalized.number) {
-        await this.emitEvent({ type: 'chain-finalized', blockNumber: sourceTips.finalized.number });
+        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized });
       }
     } catch (err: any) {
       if (err.name === 'AbortError') {
@@ -112,29 +129,31 @@ export class L2BlockStream {
    * @param blockNumber - The block number to test.
    * @param args - A cache of data already requested from source, to avoid re-requesting it.
    */
-  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: L2BlockId[] }) {
+  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
     const localBlockHash = await this.localData.getL2BlockHash(blockNumber);
-    const sourceBlockHash =
-      args.sourceCache.find(id => id.number === blockNumber && id.hash)?.hash ??
-      (await this.l2BlockSource
-        .getBlockHeader(blockNumber)
-        .then(h => h?.hash())
-        .then(hash => hash?.toString()));
-    this.log.trace(`Comparing block hashes for block ${blockNumber}`, {
-      localBlockHash,
-      sourceBlockHash,
-      sourceCacheNumber: args.sourceCache[0]?.number,
-      sourceCacheHash: args.sourceCache[0]?.hash,
-    });
+    const sourceBlockHashFromCache = args.sourceCache.get(blockNumber);
+    const sourceBlockHash = args.sourceCache.get(blockNumber) ?? (await this.getBlockHashFromSource(blockNumber));
+    if (!sourceBlockHashFromCache && sourceBlockHash) {
+      args.sourceCache.add({ number: blockNumber, hash: sourceBlockHash });
+    }
+
+    this.log.trace(`Comparing block hashes for block ${blockNumber}`, { localBlockHash, sourceBlockHash });
     return localBlockHash === sourceBlockHash;
   }
 
+  private getBlockHashFromSource(blockNumber: number) {
+    return this.l2BlockSource
+      .getBlockHeader(blockNumber)
+      .then(h => h?.hash())
+      .then(hash => hash?.toString());
+  }
+
   private async emitEvent(event: L2BlockStreamEvent) {
     this.log.debug(
-      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.blockNumber})`,
+      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.block.number})`,
     );
     await this.handler.handleBlockStreamEvent(event);
     if (!this.isRunning() && !this.isSyncing) {
@@ -143,6 +162,26 @@ export class L2BlockStream {
   }
 }
 
+class BlockHashCache {
+  private readonly cache: Map<number, string> = new Map();
+
+  constructor(initial: L2BlockId[] = []) {
+    for (const block of initial) {
+      this.add(block);
+    }
+  }
+
+  public add(block: L2BlockId) {
+    if (block.hash) {
+      this.cache.set(block.number, block.hash);
+    }
+  }
+
+  public get(blockNumber: number) {
+    return this.cache.get(blockNumber);
+  }
+}
+
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
 export interface L2BlockStreamLocalDataProvider {
   getL2BlockHash(number: number): Promise<string | undefined>;
@@ -155,23 +194,19 @@ export interface L2BlockStreamEventHandler {
 }
 
 export type L2BlockStreamEvent =
-  | {
+  | /** Emits blocks added to the chain. */ {
       type: 'blocks-added';
-      /** New blocks added to the chain. */
       blocks: PublishedL2Block[];
     }
-  | {
+  | /** Reports last correct block (new tip of the unproven chain). */ {
       type: 'chain-pruned';
-      /** Last correct block number (new tip of the unproven chain). */
-      blockNumber: number;
+      block: L2BlockId;
     }
-  | {
+  | /** Reports new proven block. */ {
       type: 'chain-proven';
-      /** New proven block number */
-      blockNumber: number;
+      block: L2BlockId;
     }
-  | {
+  | /** Reports new finalized block (proven and finalized on L1). */ {
       type: 'chain-finalized';
-      /** New finalized block number */
-      blockNumber: number;
+      block: L2BlockId;
     };

package/src/config/config.ts

@@ -1,5 +1,5 @@
 import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
-import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
@@ -7,7 +7,7 @@ export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from
 export const emptyChainConfig: ChainConfig = {
   l1ChainId: 0,
   l1Contracts: { rollupAddress: EthAddress.ZERO },
-  version: 0,
+  rollupVersion: 0,
 };
 
 export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
@@ -17,10 +17,10 @@ export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
     defaultValue: 31337,
     description: 'The chain ID of the ethereum host.',
   },
-  version: {
-    env: 'VERSION',
+  rollupVersion: {
+    env: 'ROLLUP_VERSION',
     description: 'The version of the rollup.',
-    ...numberConfigHelper(1),
+    parseEnv: (val: string) => (Number.isSafeInteger(parseInt(val, 10)) ? parseInt(val, 10) : undefined),
   },
   l1Contracts: {
     description: 'The deployed L1 contract addresses',
@@ -33,7 +33,7 @@ export type ChainConfig = {
   /** The chain id of the ethereum host. */
   l1ChainId: number;
   /** The version of the rollup. */
-  version: number;
+  rollupVersion: number;
   /** The address to the L1 contracts. */
   l1Contracts: {
     /** The address to rollup */

package/src/contract/interfaces/node-info.ts

@@ -11,8 +11,8 @@ export interface NodeInfo {
   nodeVersion: string;
   /** L1 chain id. */
   l1ChainId: number;
-  /** Protocol version. */
-  protocolVersion: number;
+  /** Rollup version. */
+  rollupVersion: number;
   /** The node's ENR. */
   enr: string | undefined;
   /** The deployed l1 contract addresses */
@@ -25,7 +25,7 @@ export const NodeInfoSchema: ZodFor<NodeInfo> = z
   .object({
     nodeVersion: z.string(),
     l1ChainId: z.number().int().nonnegative(),
-    protocolVersion: z.number().int().nonnegative(),
+    rollupVersion: z.number().int().nonnegative(),
     enr: z.string().optional(),
     l1ContractAddresses: L1ContractAddressesSchema,
     protocolContractAddresses: ProtocolContractAddressesSchema,

package/src/database-version/version_manager.ts

@@ -79,13 +79,15 @@ export class DatabaseVersion {
 
 export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'writeFile' | 'rm' | 'mkdir'>;
 
+export const DATABASE_VERSION_FILE_NAME = 'db_version';
+
 /**
  * A manager for handling database versioning and migrations.
  * This class will check the version of data in a directory and either
  * reset or upgrade based on version compatibility.
  */
 export class DatabaseVersionManager<T> {
-  public static readonly VERSION_FILE = 'db_version';
+  public static readonly VERSION_FILE = DATABASE_VERSION_FILE_NAME;
 
   private readonly versionFile: string;
   private readonly currentVersion: DatabaseVersion;
@@ -119,6 +121,11 @@ export class DatabaseVersionManager<T> {
     this.currentVersion = new DatabaseVersion(schemaVersion, rollupAddress);
   }
 
+  static async writeVersion(version: DatabaseVersion, dataDir: string, fileSystem: DatabaseVersionManagerFs = fs) {
+    await fileSystem.mkdir(dataDir, { recursive: true });
+    return fileSystem.writeFile(join(dataDir, DatabaseVersionManager.VERSION_FILE), version.toBuffer());
+  }
+
   /**
    * Checks the stored version against the current version and handles the outcome
    * by either resetting the data directory or calling an upgrade function
@@ -163,7 +170,7 @@ export class DatabaseVersionManager<T> {
         needsReset = true;
       }
     } else {
-      this.log.warn('Rollup address changed, resetting data directory');
+      this.log.warn('Rollup address changed, resetting data directory', { versionFile: this.versionFile });
       needsReset = true;
     }
 
@@ -181,17 +188,14 @@ export class DatabaseVersionManager<T> {
   /**
    * Writes the current version to the version file
    */
-  private async writeVersion(): Promise<void> {
-    // Ensure the directory exists
-    await this.fileSystem.mkdir(this.dataDirectory, { recursive: true });
-    // Write the version file
-    await this.fileSystem.writeFile(this.versionFile, this.currentVersion.toBuffer());
+  public writeVersion(dir?: string): Promise<void> {
+    return DatabaseVersionManager.writeVersion(this.currentVersion, dir ?? this.dataDirectory, this.fileSystem);
   }
 
   /**
    * Resets the data directory by deleting it and recreating it
    */
-  private async resetDataDirectory(): Promise<void> {
+  public async resetDataDirectory(): Promise<void> {
     try {
       await this.fileSystem.rm(this.dataDirectory, { recursive: true, force: true, maxRetries: 3 });
       await this.fileSystem.mkdir(this.dataDirectory, { recursive: true });