@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/validators/errors.ts

@@ -0,0 +1,84 @@
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { TxHash } from '@aztec-labs/stdlib/tx';
+
+export class ValidatorError extends Error {
+  constructor(message: string) {
+    super(`Validator Error: ${message}`);
+  }
+}
+
+export class InvalidValidatorPrivateKeyError extends ValidatorError {
+  constructor() {
+    super('Invalid validator private key provided');
+  }
+}
+
+export class AttestationTimeoutError extends ValidatorError {
+  constructor(
+    public readonly collectedCount: number,
+    public readonly requiredCount: number,
+    public readonly slot: SlotNumber,
+  ) {
+    super(`Timeout collecting attestations for slot ${slot}: ${collectedCount}/${requiredCount}`);
+  }
+}
+
+export class TransactionsNotAvailableError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Transactions not available: ${txHashes.join(', ')}`);
+  }
+}
+
+/**
+ * Thrown when a tx carried in a block proposal fails minimum integrity validation (metadata, size, data,
+ * contract instances, or proof). The proposer signs both the tx hashes and the tx objects, so this is
+ * proposer misbehavior rather than a local failure, and callers classify it as an invalid block proposal.
+ */
+export class InvalidBlockProposalTxsError extends ValidatorError {
+  constructor(public readonly invalidTxs: { txHash: TxHash; reasons: string[] }[]) {
+    super(
+      `Invalid txs in block proposal: ${invalidTxs
+        .map(({ txHash, reasons }) => `${txHash} (${reasons.join(', ')})`)
+        .join('; ')}`,
+    );
+    // Set so `isErrorClass` can recognize this error across package instances, where `instanceof` fails.
+    this.name = 'InvalidBlockProposalTxsError';
+  }
+}
+
+export class FailedToReExecuteTransactionsError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);
+  }
+}
+
+export class ReExInitialStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super('Re-execution initial state mismatch');
+  }
+}
+
+export class ReExStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super('Re-execution state mismatch');
+  }
+}
+
+export class ReExFailedTxsError extends ValidatorError {
+  constructor(numFailedTxs: number) {
+    super(`Re-execution failed to process ${numFailedTxs} txs`);
+  }
+}
+
+export class ReExTimeoutError extends ValidatorError {
+  constructor() {
+    super('Re-execution timed out or failed to process all txs in the proposal');
+  }
+}

package/src/validators/index.ts

@@ -0,0 +1,3 @@
+export * from './errors.js';
+export * from './schemas.js';
+export type * from './types.js';

package/src/validators/schemas.ts

@@ -0,0 +1,89 @@
+import { schemas, zodFor } from '@aztec-labs/foundation/schemas';
+import { z } from 'zod';
+
+import type {
+  SingleValidatorStats,
+  ValidatorMissedStats,
+  ValidatorStats,
+  ValidatorStatusHistory,
+  ValidatorStatusInSlot,
+  ValidatorsStats,
+} from './types.js';
+
+export const ValidatorStatusInSlotSchema = zodFor<ValidatorStatusInSlot>()(
+  z.enum([
+    'checkpoint-mined',
+    'checkpoint-valid',
+    'checkpoint-invalid',
+    'checkpoint-unvalidated',
+    'checkpoint-missed',
+    'blocks-missed',
+    'attestation-sent',
+    'attestation-missed',
+  ]),
+);
+
+export const ValidatorStatusHistorySchema = zodFor<ValidatorStatusHistory>()(
+  z.array(
+    z.object({
+      slot: schemas.SlotNumber,
+      status: ValidatorStatusInSlotSchema,
+    }),
+  ),
+);
+
+export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
+
+export const ValidatorStatusHistorySchemaMap = z.record(z.string(), ValidatorStatusHistorySchemaArray);
+
+const ValidatorTimeStatSchema = z.object({
+  timestamp: schemas.BigInt,
+  slot: schemas.SlotNumber,
+  date: z.string(),
+});
+
+const ValidatorMissedStatsSchema = zodFor<ValidatorMissedStats>()(
+  z.object({
+    currentStreak: schemas.Integer,
+    rate: z.number().optional(),
+    count: schemas.Integer,
+    total: schemas.Integer,
+  }),
+);
+
+export const ValidatorStatsSchema = zodFor<ValidatorStats>()(
+  z.object({
+    address: schemas.EthAddress,
+    lastProposal: ValidatorTimeStatSchema.optional(),
+    lastAttestation: ValidatorTimeStatSchema.optional(),
+    totalSlots: schemas.Integer,
+    missedProposals: ValidatorMissedStatsSchema,
+    missedAttestations: ValidatorMissedStatsSchema,
+    history: ValidatorStatusHistorySchema,
+  }),
+);
+
+export const ValidatorsStatsSchema = zodFor<ValidatorsStats>()(
+  z.object({
+    stats: z.record(z.string(), ValidatorStatsSchema),
+    lastProcessedSlot: schemas.SlotNumber.optional(),
+    initialSlot: schemas.SlotNumber.optional(),
+    slotWindow: schemas.Integer,
+  }),
+);
+
+export const SingleValidatorStatsSchema = zodFor<SingleValidatorStats>()(
+  z.object({
+    validator: ValidatorStatsSchema,
+    allTimeEpochPerformance: z.array(
+      z.object({
+        missed: schemas.Integer,
+        total: schemas.Integer,
+        epoch: schemas.EpochNumber,
+      }),
+    ),
+    lastProcessedSlot: schemas.SlotNumber.optional(),
+    initialSlot: schemas.SlotNumber.optional(),
+    slotWindow: schemas.Integer,
+  }),
+);

package/src/validators/types.ts

@@ -0,0 +1,67 @@
+import type { EpochNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+
+export type ValidatorStatusType = 'proposer' | 'attestation';
+
+/**
+ * Per-slot status for a validator.
+ *
+ * Proposer statuses (six-case taxonomy):
+ * - `blocks-missed`           — no block proposals seen for the slot (case 1).
+ * - `checkpoint-missed`       — block proposals seen but no checkpoint proposal (case 2).
+ * - `checkpoint-unvalidated`  — checkpoint proposal seen but local re-execution couldn't
+ *                               validate (missing txs, timeouts, etc.) (case 3).
+ * - `checkpoint-invalid`      — checkpoint proposal re-executed and rejected as invalid (case 4).
+ * - `checkpoint-valid`        — checkpoint proposal re-executed locally as valid (case 5).
+ * - `checkpoint-mined`        — checkpoint published on L1 (case 6).
+ *
+ * Attestor statuses:
+ * - `attestation-sent`        — attestation observed on P2P or in the published checkpoint.
+ * - `attestation-missed`      — committee member did not attest to a checkpoint proposal that
+ *                               was observed locally or published on L1.
+ */
+export type ValidatorStatusInSlot =
+  | 'checkpoint-mined'
+  | 'checkpoint-valid'
+  | 'checkpoint-invalid'
+  | 'checkpoint-unvalidated'
+  | 'checkpoint-missed'
+  | 'blocks-missed'
+  | 'attestation-sent'
+  | 'attestation-missed';
+
+export type ValidatorStatusHistory = { slot: SlotNumber; status: ValidatorStatusInSlot }[];
+
+export type ValidatorMissedStats = {
+  currentStreak: number;
+  rate?: number;
+  count: number;
+  total: number;
+};
+
+export type ValidatorStats = {
+  address: EthAddress;
+  lastProposal?: { timestamp: bigint; slot: SlotNumber; date: string };
+  lastAttestation?: { timestamp: bigint; slot: SlotNumber; date: string };
+  totalSlots: number;
+  missedProposals: ValidatorMissedStats;
+  missedAttestations: ValidatorMissedStats;
+  history: ValidatorStatusHistory;
+};
+
+export type ValidatorsStats = {
+  stats: Record<string, ValidatorStats>;
+  lastProcessedSlot?: SlotNumber;
+  initialSlot?: SlotNumber;
+  slotWindow: number;
+};
+
+export type ValidatorsEpochPerformance = Record<`0x${string}`, { missed: number; total: number }>;
+
+export type SingleValidatorStats = {
+  validator: ValidatorStats;
+  allTimeEpochPerformance: { missed: number; total: number; epoch: EpochNumber }[];
+  lastProcessedSlot?: SlotNumber;
+  initialSlot?: SlotNumber;
+  slotWindow: number;
+};

package/src/versioning/index.ts

@@ -0,0 +1 @@
+export * from './versioning.js';

package/src/versioning/versioning.ts

@@ -0,0 +1,151 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type Koa from 'koa';
+
+import type { ChainConfig } from '../config/chain-config.js';
+
+/** Fields that identify a version of the Aztec protocol. Any mismatch between these fields should signal an incompatibility between nodes. */
+export type ComponentsVersions = {
+  l1ChainId: number;
+  // TODO: Consider using governance address instead to support migrations.
+  // Note that we are using the rollup address as identifier in multiple places
+  // such as the keystore, we need to change it so we can handle updates.
+  l1RollupAddress: EthAddress;
+  rollupVersion: number;
+  l2ProtocolContractsHash: string;
+  l2CircuitsVkTreeRoot: string;
+};
+
+/** Returns components versions from chain config. */
+export function getComponentsVersionsFromConfig(
+  config: ChainConfig,
+  l2ProtocolContractsHash: string | Fr,
+  l2CircuitsVkTreeRoot: string | Fr,
+): ComponentsVersions {
+  return {
+    l1ChainId: config.l1ChainId,
+    l1RollupAddress: config.rollupAddress,
+    rollupVersion: config.rollupVersion,
+    l2ProtocolContractsHash: l2ProtocolContractsHash.toString(),
+    l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString(),
+  };
+}
+
+/** Returns a compressed string representation of the version (around 32 chars). Used in p2p ENRs. */
+export function compressComponentVersions(versions: ComponentsVersions): string {
+  if (
+    versions.l1RollupAddress === undefined ||
+    versions.l2ProtocolContractsHash === undefined ||
+    versions.l2CircuitsVkTreeRoot === undefined
+  ) {
+    throw new Error(`Component versions are not set: ${jsonStringify(versions)}`);
+  }
+
+  return [
+    '00',
+    versions.l1ChainId,
+    versions.l1RollupAddress.toString().slice(2, 10),
+    versions.rollupVersion,
+    versions.l2ProtocolContractsHash.toString().slice(2, 10),
+    versions.l2CircuitsVkTreeRoot.toString().slice(2, 10),
+  ].join('-');
+}
+
+export class ComponentsVersionsError extends Error {
+  constructor(key: string, expected: string, value: string) {
+    super(`Expected component version ${key} to be ${expected} but received ${value}`);
+    this.name = 'ComponentsVersionsError';
+  }
+}
+
+/** Checks if the compressed string matches against the expected versions. Throws on mismatch. */
+export function checkCompressedComponentVersion(compressed: string, expected: ComponentsVersions) {
+  const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsHash, l2CircuitsVkTreeRoot] =
+    compressed.split('-');
+  if (versionVersion !== '00') {
+    throw new ComponentsVersionsError('version', '00', versionVersion);
+  }
+  if (l1ChainId !== expected.l1ChainId.toString()) {
+    throw new ComponentsVersionsError(`L1 chain ID`, expected.l1ChainId.toString(), l1ChainId);
+  }
+  if (l1RollupAddress !== expected.l1RollupAddress.toString().slice(2, 10)) {
+    throw new ComponentsVersionsError(`L1 address`, expected.l1RollupAddress.toString(), l1RollupAddress);
+  }
+  if (rollupVersion !== expected.rollupVersion.toString()) {
+    throw new ComponentsVersionsError('L2 chain version', expected.rollupVersion.toString(), rollupVersion);
+  }
+  if (l2ProtocolContractsHash !== expected.l2ProtocolContractsHash.toString().slice(2, 10)) {
+    throw new ComponentsVersionsError(
+      `L2 protocol contracts vk tree root`,
+      expected.l2ProtocolContractsHash.toString(),
+      l2ProtocolContractsHash,
+    );
+  }
+  if (l2CircuitsVkTreeRoot !== expected.l2CircuitsVkTreeRoot.toString().slice(2, 10)) {
+    throw new ComponentsVersionsError(
+      'L2 circuits vk tree root',
+      expected.l2CircuitsVkTreeRoot.toString(),
+      l2CircuitsVkTreeRoot,
+    );
+  }
+}
+
+/** Checks that two component versions match. Undefined fields are ignored. */
+export function validatePartialComponentVersionsMatch(
+  expected: Partial<ComponentsVersions>,
+  actual: Partial<ComponentsVersions>,
+) {
+  for (const key of [
+    'l1RollupAddress',
+    'l2ProtocolContractsHash',
+    'l2CircuitsVkTreeRoot',
+    'l1ChainId',
+    'rollupVersion',
+  ] as const) {
+    const actualValue = actual[key];
+    const expectedValue = expected[key];
+    if (expectedValue !== undefined && actualValue !== undefined) {
+      if (typeof actualValue === 'object' ? !actualValue.equals(expectedValue as any) : actualValue !== expectedValue) {
+        throw new Error(`Expected ${key} to be ${expectedValue} but received ${actualValue}`);
+      }
+    }
+  }
+}
+
+/** Returns a Koa middleware that injects the versioning info as headers. */
+export function getVersioningMiddleware(versions: Partial<ComponentsVersions>, opts?: { packageVersion?: string }) {
+  return async (ctx: Koa.Context, next: () => Promise<void>) => {
+    try {
+      await next();
+    } finally {
+      // Always add version headers, even if there was an error
+      // This allows the client to detect version mismatches before processing other errors
+      for (const key in versions) {
+        const value = versions[key as keyof ComponentsVersions];
+        if (value !== undefined) {
+          ctx.set(`x-aztec-${key}`, value.toString());
+        }
+      }
+      if (opts?.packageVersion) {
+        ctx.set('x-aztec-packageVersion', opts.packageVersion);
+      }
+    }
+  };
+}
+
+/** Returns a json rpc client handler that rejects responses with mismatching versions. */
+export function getVersioningResponseHandler(versions: Partial<ComponentsVersions>) {
+  return ({ headers }: { headers: { get: (header: string) => string | null | undefined } }) => {
+    for (const key in versions) {
+      const value = versions[key as keyof ComponentsVersions];
+      if (value !== undefined) {
+        const headerValue = headers.get(`x-aztec-${key}`);
+        if (headerValue !== undefined && headerValue !== null && headerValue !== value.toString()) {
+          throw new ComponentsVersionsError(key, value.toString(), headerValue);
+        }
+      }
+    }
+    return Promise.resolve();
+  };
+}

package/src/vks/index.ts

@@ -0,0 +1,2 @@
+export * from './verification_key.js';
+export * from './vk_data.js';

package/src/vks/verification_key.ts

@@ -0,0 +1,171 @@
+import { ULTRA_VK_LENGTH_IN_FIELDS } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+
+import { hashVK } from '../hash/index.js';
+
+// TODO: find better home for these constants
+export const CIRCUIT_SIZE_INDEX = 0;
+export const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
+
+/**
+ * Provides a 'fields' representation of a circuit's verification key
+ */
+export class VerificationKeyAsFields {
+  constructor(
+    public key: Fr[],
+    public hash: Fr,
+  ) {}
+
+  static async fromKey(key: Fr[]) {
+    const hash = await hashVK(key);
+    return new VerificationKeyAsFields(key, hash);
+  }
+
+  public get numPublicInputs() {
+    return Number(this.key[CIRCUIT_PUBLIC_INPUTS_INDEX]);
+  }
+
+  public get circuitSize() {
+    return Number(this.key[CIRCUIT_SIZE_INDEX]);
+  }
+
+  static get schema() {
+    // TODO(palla/schemas): Should we verify the hash matches the key when deserializing?
+    return bufferSchemaFor(VerificationKeyAsFields);
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...this.toFields());
+  }
+
+  toFields() {
+    return [this.key.length, ...this.key, this.hash];
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer to read from.
+   * @returns The VerificationKeyAsFields.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): VerificationKeyAsFields {
+    const reader = BufferReader.asReader(buffer);
+    return new VerificationKeyAsFields(reader.readVector(Fr), reader.readObject(Fr));
+  }
+
+  static fromFrBuffer(vkBytes: Buffer): Promise<VerificationKeyAsFields> {
+    const numFields = vkBytes.length / Fr.SIZE_IN_BYTES;
+    const reader = BufferReader.asReader(vkBytes);
+    const fields = reader.readArray(numFields, Fr);
+    return VerificationKeyAsFields.fromKey(fields);
+  }
+
+  /**
+   * Builds a fake verification key that should be accepted by circuits.
+   * @returns A fake verification key.
+   */
+  static makeFake(size: number, seed = 1): VerificationKeyAsFields {
+    return new VerificationKeyAsFields(makeTuple(size, Fr.random, seed), Fr.random());
+  }
+
+  static makeFakeHonk(seed = 1): VerificationKeyAsFields {
+    return new VerificationKeyAsFields(makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, Fr.random, seed), Fr.random());
+  }
+
+  static makeFakeRollupHonk(seed = 1): VerificationKeyAsFields {
+    return new VerificationKeyAsFields(
+      makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, i => new Fr(i), seed),
+      new Fr(seed + 1),
+    );
+  }
+
+  /**
+   * Builds an 'empty' verification key
+   * @returns An 'empty' verification key
+   */
+  static makeEmpty(size: number): VerificationKeyAsFields {
+    return new VerificationKeyAsFields(makeTuple(size, Fr.zero), Fr.zero());
+  }
+}
+
+export class VerificationKeyData {
+  constructor(
+    public readonly keyAsFields: VerificationKeyAsFields,
+    public readonly keyAsBytes: Buffer,
+  ) {}
+
+  public get numPublicInputs() {
+    return this.keyAsFields.numPublicInputs;
+  }
+
+  public get circuitSize() {
+    return this.keyAsFields.circuitSize;
+  }
+
+  static empty() {
+    return new VerificationKeyData(VerificationKeyAsFields.makeEmpty(0), Buffer.alloc(0));
+  }
+
+  static makeFakeHonk(): VerificationKeyData {
+    const keyAsFields = VerificationKeyAsFields.makeFakeHonk();
+    return new VerificationKeyData(keyAsFields, keyAsFields.toBuffer());
+  }
+
+  static makeFakeRollupHonk(): VerificationKeyData {
+    const keyAsFields = VerificationKeyAsFields.makeFakeRollupHonk();
+    return new VerificationKeyData(keyAsFields, keyAsFields.toBuffer());
+  }
+
+  /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.keyAsFields, this.keyAsBytes.length, this.keyAsBytes);
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): VerificationKeyData {
+    const reader = BufferReader.asReader(buffer);
+    const verificationKeyAsFields = reader.readObject(VerificationKeyAsFields);
+    const length = reader.readNumber();
+    const bytes = reader.readBytes(length);
+    return new VerificationKeyData(verificationKeyAsFields, bytes);
+  }
+
+  static async fromFrBuffer(vkBytes: Buffer): Promise<VerificationKeyData> {
+    return new VerificationKeyData(await VerificationKeyAsFields.fromFrBuffer(vkBytes), vkBytes);
+  }
+
+  static fromString(str: string): VerificationKeyData {
+    return VerificationKeyData.fromBuffer(hexToBuffer(str));
+  }
+
+  public clone() {
+    return VerificationKeyData.fromBuffer(this.toBuffer());
+  }
+
+  /** Returns a hex representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(VerificationKeyData);
+  }
+}

package/src/vks/vk_data.ts

@@ -0,0 +1,43 @@
+import { VK_TREE_HEIGHT } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex } from '@aztec-labs/foundation/string';
+
+import type { UInt32 } from '../types/shared.js';
+import { VerificationKeyData } from './verification_key.js';
+
+export class VkData {
+  constructor(
+    public vk: VerificationKeyData,
+    /**
+     * Index of the vk in the vk tree.
+     */
+    public leafIndex: UInt32,
+    /**
+     * Sibling path of the vk in the vk tree.
+     */
+    public siblingPath: Tuple<Fr, typeof VK_TREE_HEIGHT>,
+  ) {}
+
+  static empty() {
+    return new VkData(VerificationKeyData.empty(), 0, makeTuple(VK_TREE_HEIGHT, Fr.zero));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new VkData(
+      reader.readObject(VerificationKeyData),
+      reader.readNumber(),
+      reader.readArray(VK_TREE_HEIGHT, Fr),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.vk, this.leafIndex, this.siblingPath);
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+}

package/src/world-state/genesis_data.ts

@@ -0,0 +1,37 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { PublicDataTreeLeaf } from '../trees/index.js';
+
+/** Data used to initialize the genesis block, including prefilled public state and an optional timestamp. */
+export type GenesisData = {
+  /** Public data tree leaves to pre-populate in the genesis state (e.g. fee juice balances). */
+  prefilledPublicData: PublicDataTreeLeaf[];
+  /**
+   * Nullifiers to pre-insert into the genesis nullifier tree. Optional; defaults to an empty list, which leaves the
+   * nullifier tree at its canonical empty-genesis state so that production genesis roots are unchanged. When non-empty,
+   * the leaves must be unique and strictly increasing in field value (the native world state enforces this before
+   * construction). Test networks pass a non-empty list to seed e.g. standard-contract registration nullifiers.
+   */
+  prefilledNullifiers?: Fr[];
+  /** Timestamp for the genesis block header. Defaults to 0 (canonical empty genesis) in production. */
+  genesisTimestamp: bigint;
+};
+
+/** An empty genesis data with no prefilled state and a zero timestamp. */
+export const EMPTY_GENESIS_DATA: GenesisData = {
+  prefilledPublicData: [],
+  prefilledNullifiers: [],
+  genesisTimestamp: 0n,
+};
+
+/** Returns if an object looks like genesis data */
+export function isGenesisData(obj: any): obj is GenesisData {
+  return (
+    obj &&
+    typeof obj === 'object' &&
+    'prefilledPublicData' in obj &&
+    Array.isArray(obj.prefilledPublicData) &&
+    'genesisTimestamp' in obj &&
+    typeof obj.genesisTimestamp === 'bigint'
+  );
+}

package/src/world-state/index.ts

@@ -0,0 +1,2 @@
+export * from './genesis_data.js';
+export * from './world_state_revision.js';