@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/validators/schemas.ts

@@ -0,0 +1,81 @@
+import { schemas, zodFor } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import type {
+  SingleValidatorStats,
+  ValidatorMissedStats,
+  ValidatorStats,
+  ValidatorStatusHistory,
+  ValidatorStatusInSlot,
+  ValidatorsStats,
+} from './types.js';
+
+export const ValidatorStatusInSlotSchema = zodFor<ValidatorStatusInSlot>()(
+  z.enum(['block-mined', 'block-proposed', 'block-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(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(ValidatorStatsSchema),
+    lastProcessedSlot: schemas.SlotNumber.optional(),
+    initialSlot: schemas.SlotNumber.optional(),
+    slotWindow: schemas.Integer,
+  }),
+);
+
+export const SingleValidatorStatsSchema = zodFor<SingleValidatorStats>()(
+  z.object({
+    validator: ValidatorStatsSchema,
+    allTimeProvenPerformance: 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,47 @@
+import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+export type ValidatorStatusType = 'block' | 'attestation';
+
+export type ValidatorStatusInSlot =
+  | 'block-mined'
+  | 'block-proposed'
+  | 'block-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;
+  allTimeProvenPerformance: { missed: number; total: number; epoch: EpochNumber }[];
+  lastProcessedSlot?: SlotNumber;
+  initialSlot?: SlotNumber;
+  slotWindow: number;
+};

package/src/versioning/versioning.ts

@@ -1,13 +1,10 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import type Koa from 'koa';
 
-import type { ChainConfig } from '../config/config.js';
-
-// REFACTOR: This file is not a circuit-type, but at the moment we don't have any other
-// package common to all components that we can use for this shared code.
+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 = {
@@ -16,22 +13,22 @@ export type ComponentsVersions = {
   // 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;
-  l2ChainVersion: number;
-  l2ProtocolContractsTreeRoot: string;
+  rollupVersion: number;
+  l2ProtocolContractsHash: string;
   l2CircuitsVkTreeRoot: string;
 };
 
 /** Returns components versions from chain config. */
 export function getComponentsVersionsFromConfig(
   config: ChainConfig,
-  l2ProtocolContractsTreeRoot: string | Fr,
+  l2ProtocolContractsHash: string | Fr,
   l2CircuitsVkTreeRoot: string | Fr,
 ): ComponentsVersions {
   return {
     l1ChainId: config.l1ChainId,
     l1RollupAddress: config.l1Contracts?.rollupAddress, // This should not be undefined, but sometimes the config lies to us and it is...
-    l2ChainVersion: config.version,
-    l2ProtocolContractsTreeRoot: l2ProtocolContractsTreeRoot.toString(),
+    rollupVersion: config.rollupVersion,
+    l2ProtocolContractsHash: l2ProtocolContractsHash.toString(),
     l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString(),
   };
 }
@@ -40,7 +37,7 @@ export function getComponentsVersionsFromConfig(
 export function compressComponentVersions(versions: ComponentsVersions): string {
   if (
     versions.l1RollupAddress === undefined ||
-    versions.l2ProtocolContractsTreeRoot === undefined ||
+    versions.l2ProtocolContractsHash === undefined ||
     versions.l2CircuitsVkTreeRoot === undefined
   ) {
     throw new Error(`Component versions are not set: ${jsonStringify(versions)}`);
@@ -50,8 +47,8 @@ export function compressComponentVersions(versions: ComponentsVersions): string
     '00',
     versions.l1ChainId,
     versions.l1RollupAddress.toString().slice(2, 10),
-    versions.l2ChainVersion,
-    versions.l2ProtocolContractsTreeRoot.toString().slice(2, 10),
+    versions.rollupVersion,
+    versions.l2ProtocolContractsHash.toString().slice(2, 10),
     versions.l2CircuitsVkTreeRoot.toString().slice(2, 10),
   ].join('-');
 }
@@ -65,14 +62,8 @@ export class ComponentsVersionsError extends Error {
 
 /** Checks if the compressed string matches against the expected versions. Throws on mismatch. */
 export function checkCompressedComponentVersion(compressed: string, expected: ComponentsVersions) {
-  const [
-    versionVersion,
-    l1ChainId,
-    l1RollupAddress,
-    l2ChainVersion,
-    l2ProtocolContractsTreeRoot,
-    l2CircuitsVkTreeRoot,
-  ] = compressed.split('-');
+  const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsHash, l2CircuitsVkTreeRoot] =
+    compressed.split('-');
   if (versionVersion !== '00') {
     throw new ComponentsVersionsError('version', '00', versionVersion);
   }
@@ -82,14 +73,14 @@ export function checkCompressedComponentVersion(compressed: string, expected: Co
   if (l1RollupAddress !== expected.l1RollupAddress.toString().slice(2, 10)) {
     throw new ComponentsVersionsError(`L1 address`, expected.l1RollupAddress.toString(), l1RollupAddress);
   }
-  if (l2ChainVersion !== expected.l2ChainVersion.toString()) {
-    throw new ComponentsVersionsError('L2 chain version', expected.l2ChainVersion.toString(), l2ChainVersion);
+  if (rollupVersion !== expected.rollupVersion.toString()) {
+    throw new ComponentsVersionsError('L2 chain version', expected.rollupVersion.toString(), rollupVersion);
   }
-  if (l2ProtocolContractsTreeRoot !== expected.l2ProtocolContractsTreeRoot.toString().slice(2, 10)) {
+  if (l2ProtocolContractsHash !== expected.l2ProtocolContractsHash.toString().slice(2, 10)) {
     throw new ComponentsVersionsError(
       `L2 protocol contracts vk tree root`,
-      expected.l2ProtocolContractsTreeRoot.toString(),
-      l2ProtocolContractsTreeRoot,
+      expected.l2ProtocolContractsHash.toString(),
+      l2ProtocolContractsHash,
     );
   }
   if (l2CircuitsVkTreeRoot !== expected.l2CircuitsVkTreeRoot.toString().slice(2, 10)) {
@@ -108,10 +99,10 @@ export function validatePartialComponentVersionsMatch(
 ) {
   for (const key of [
     'l1RollupAddress',
-    'l2ProtocolContractsTreeRoot',
+    'l2ProtocolContractsHash',
     'l2CircuitsVkTreeRoot',
     'l1ChainId',
-    'l2ChainVersion',
+    'rollupVersion',
   ] as const) {
     const actualValue = actual[key];
     const expectedValue = expected[key];
@@ -126,11 +117,16 @@ export function validatePartialComponentVersionsMatch(
 /** Returns a Koa middleware that injects the versioning info as headers. */
 export function getVersioningMiddleware(versions: Partial<ComponentsVersions>) {
   return async (ctx: Koa.Context, next: () => Promise<void>) => {
-    await next();
-    for (const key in versions) {
-      const value = versions[key as keyof ComponentsVersions];
-      if (value !== undefined) {
-        ctx.set(`x-aztec-${key}`, value.toString());
+    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());
+        }
       }
     }
   };

package/src/vks/index.ts

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

package/src/vks/verification_key.ts

@@ -1,14 +1,12 @@
-import {
-  HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS,
-} from '@aztec/constants';
+import { ULTRA_VK_LENGTH_IN_FIELDS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { times } from '@aztec/foundation/collection';
-import { Fq, Fr } from '@aztec/foundation/fields';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
+import { hashVK } from '../hash/index.js';
 import { CircuitType } from '../types/shared.js';
 
 /**
@@ -82,13 +80,20 @@ export class CommitmentMap {
 // TODO: find better home for these constants
 export const CIRCUIT_SIZE_INDEX = 0;
 export const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
-export const CIRCUIT_RECURSIVE_INDEX = 3;
 
 /**
  * Provides a 'fields' representation of a circuit's verification key
  */
 export class VerificationKeyAsFields {
-  constructor(public key: Fr[], public hash: Fr) {}
+  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]);
@@ -98,10 +103,6 @@ export class VerificationKeyAsFields {
     return Number(this.key[CIRCUIT_SIZE_INDEX]);
   }
 
-  public get isRecursive() {
-    return this.key[CIRCUIT_RECURSIVE_INDEX].equals(Fr.ONE);
-  }
-
   static get schema() {
     // TODO(palla/schemas): Should we verify the hash matches the key when deserializing?
     return bufferSchemaFor(VerificationKeyAsFields);
@@ -133,6 +134,13 @@ export class VerificationKeyAsFields {
     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.
@@ -142,12 +150,12 @@ export class VerificationKeyAsFields {
   }
 
   static makeFakeHonk(seed = 1): VerificationKeyAsFields {
-    return new VerificationKeyAsFields(makeTuple(HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, Fr.random, seed), Fr.random());
+    return new VerificationKeyAsFields(makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, Fr.random, seed), Fr.random());
   }
 
   static makeFakeRollupHonk(seed = 1): VerificationKeyAsFields {
     return new VerificationKeyAsFields(
-      makeTuple(ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS, i => new Fr(i), seed),
+      makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, i => new Fr(i), seed),
       new Fr(seed + 1),
     );
   }
@@ -249,10 +257,27 @@ export class VerificationKey {
       times(16, i => i),
     );
   }
+
+  /**
+   * Builds a fake MegaHonk verification key buffer for testing.
+   * Uses a real VK from a compiled contract to ensure proper format.
+   *
+   * @returns A valid MegaHonk VK buffer (4064 bytes)
+   */
+  static makeFakeMegaHonk(): Buffer {
+    // This is a real MegaFlavor VK from token_contract, base64-encoded
+    // Size: 4064 bytes (127 fields × 32 bytes)
+    const vk =
+      'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANuAAAAAAAAAAAAAAAAAAAAP/2mLzBM1pS5uiSckb1BVHkAAAAAAAAAAAAAAAAAAAAAAAj416UaEYnPzn49IUFSXgAAAAAAAAAAAAAAAAAAAIXdwCJK3KYAoGKX4p6GfmryAAAAAAAAAAAAAAAAAAAAAAAokraNwSgFcpF48hQxNGkAAAAAAAAAAAAAAAAAAAC7oxlMkGNLFkB2hf+YZ3ZxbgAAAAAAAAAAAAAAAAAAAAAAJxTarsiWssfiDyt71jURAAAAAAAAAAAAAAAAAAAAXrNqIIwSwfoH9ohkDg7vOVkAAAAAAAAAAAAAAAAAAAAAAAmoSGxP3U/r3hzEvHateQAAAAAAAAAAAAAAAAAAABsMbbs6st4J8g1rt+BsNQ/tAAAAAAAAAAAAAAAAAAAAAAAG1jgBz1oWwF9cgJAcbokAAAAAAAAAAAAAAAAAAAAiSGg7Y4g8BZRm7Y263TfzBQAAAAAAAAAAAAAAAAAAAAAABAifGWuruwdNirdcMLaZAAAAAAAAAAAAAAAAAAAAvnjsQ6y/R+pkGIZG+8VaSmoAAAAAAAAAAAAAAAAAAAAAACZ132MJqewzJSlpMIlLrwAAAAAAAAAAAAAAAAAAAGLurX4BKthJm1qWxgHy6poVAAAAAAAAAAAAAAAAAAAAAAATyCVmUda23MUKev5O7H8AAAAAAAAAAAAAAAAAAAAHgBXlGsmyGwFKCc8ECZMtygAAAAAAAAAAAAAAAAAAAAAAA5NUCZBujE33vAepEGQDAAAAAAAAAAAAAAAAAAAAezL+gT6bMTInwgAVVNNDXRkAAAAAAAAAAAAAAAAAAAAAABCAWIHhkvWaCS2ZnKPvSwAAAAAAAAAAAAAAAAAAANPQvFAiWRA8ERg5yGvr88ALAAAAAAAAAAAAAAAAAAAAAAApoSMoGsXzQJaFneSv1KgAAAAAAAAAAAAAAAAAAAB340oDJmM304cJnC9ueo+O5AAAAAAAAAAAAAAAAAAAAAAAHZK4hjDrXvy49q13vwGAAAAAAAAAAAAAAAAAAAAAtQi6GtLBaVOlbS6XGA9eqnwAAAAAAAAAAAAAAAAAAAAAABfiIWL6/lPx838UMvXv4wAAAAAAAAAAAAAAAAAAADr/3SHoETrf6uZZ1rp+WIZQAAAAAAAAAAAAAAAAAAAAAAAqvpwOG8VS0GsAo7Jkj0UAAAAAAAAAAAAAAAAAAABUJxHlFbLDzcMOKg2f7hCicAAAAAAAAAAAAAAAAAAAAAAAEWBEq9cQJCgbdAYavBP5AAAAAAAAAAAAAAAAAAAAdrkZueUT2Ets4CFAG+vXcr4AAAAAAAAAAAAAAAAAAAAAAB6B5XXXSu46eOAFWZAkrwAAAAAAAAAAAAAAAAAAANmWqVvVT2mZ7QrYWIirAquXAAAAAAAAAAAAAAAAAAAAAAACF9hD8+IrMaRi+lqRkAMAAAAAAAAAAAAAAAAAAAAD5Z0isCORGRBnbAxmzTrctgAAAAAAAAAAAAAAAAAAAAAAMAWa6kNzndYcZpD/z9psAAAAAAAAAAAAAAAAAAAA+bz6NGciDYP69hwbHlOFemYAAAAAAAAAAAAAAAAAAAAAACxtqvyR362MHKUfRa1atAAAAAAAAAAAAAAAAAAAABHmXRvQcsHNHFVezkzmPcbGAAAAAAAAAAAAAAAAAAAAAAAgnfqubAIcahOIvmgu5kEAAAAAAAAAAAAAAAAAAACzkNYUnJ/7869CHmpqFcvY7gAAAAAAAAAAAAAAAAAAAAAAByZU2ZsU3OZBBKhDaro4AAAAAAAAAAAAAAAAAAAA5WKKgNFBqO30Fqe8nWMZOfkAAAAAAAAAAAAAAAAAAAAAABeI+NTdPf/53PNok25fhwAAAAAAAAAAAAAAAAAAANTx1sizxFU9c4qiWkoCg1G9AAAAAAAAAAAAAAAAAAAAAAAKK321DuTcjXFo351Z7fAAAAAAAAAAAAAAAAAAAADOP1b+njU8sem9GjVjXe1qTAAAAAAAAAAAAAAAAAAAAAAADLPaoo1d53oBsUXMc0GIAAAAAAAAAAAAAAAAAAAAcW4ObhQI/r76cmLEMHA6iHsAAAAAAAAAAAAAAAAAAAAAAAxzcj9JsZ+WcmGtvE3NSAAAAAAAAAAAAAAAAAAAAPqjE1vBe0DhRJfyQPZj8eamAAAAAAAAAAAAAAAAAAAAAAAOXS9sKDjHSU17NYl3NWcAAAAAAAAAAAAAAAAAAACMJCYI98PRZEMXCwrwNffRggAAAAAAAAAAAAAAAAAAAAAAF7iR11vxzfrikwSlMSOwAAAAAAAAAAAAAAAAAAAAjYxSswL26VlnQdfkOYS9MuYAAAAAAAAAAAAAAAAAAAAAAC6jqRgX46I790Y9ebEJ9gAAAAAAAAAAAAAAAAAAAJq7Vw3WpNxo+vzjpCxfVu0rAAAAAAAAAAAAAAAAAAAAAAAPd0DnQkVFd7Rhjlk7k0wAAAAAAAAAAAAAAAAAAAA/SdmtkYZfq+d1bkNp2l0IdQAAAAAAAAAAAAAAAAAAAAAAEGEmscJv8D/jR09GElDyAAAAAAAAAAAAAAAAAAAAgY2ip4PPEb5BgXBJV0bUHpsAAAAAAAAAAAAAAAAAAAAAABiRsTgHAURQXmqPKFtBggAAAAAAAAAAAAAAAAAAAKWWQ0j6nz6pIx27umcNoUk1AAAAAAAAAAAAAAAAAAAAAAABk5iNZXp0vuxhWmZ0F0YAAAAAAAAAAAAAAAAAAADkU74RRH4d3TDyCXGUcQdG6wAAAAAAAAAAAAAAAAAAAAAALi6nWpWc4hq35DuQOxCdAAAAAAAAAAAAAAAAAAAAjBnq8cvZwI0dqFiGgI3kP/sAAAAAAAAAAAAAAAAAAAAAAAZDjNqd6UXeD/Xbw2vT3wAAAAAAAAAAAAAAAAAAAAey7c2Kz+U0azWgd9i/FoI7AAAAAAAAAAAAAAAAAAAAAAAO4lm5hFdU3KY1MMVooKoAAAAAAAAAAAAAAAAAAAA11ut5lZwgPDn0A1cwtLCjDAAAAAAAAAAAAAAAAAAAAAAADhG7sXUMPuGPPEEkGD/MAAAAAAAAAAAAAAAAAAAAkFC/P2UgsVTxrLhFyeRcTqUAAAAAAAAAAAAAAAAAAAAAAAXZUHR9pRmVh2U5hXP8UgAAAAAAAAAAAAAAAAAAAM9CK5rTZMf33eqMsQVDsdUbAAAAAAAAAAAAAAAAAAAAAAAKfdl2Itg9xMw19PoJjw4AAAAAAAAAAAAAAAAAAACh6Wbif3ZcchD1B7vZ8b5DHwAAAAAAAAAAAAAAAAAAAAAAHGRY+P8dj2Szvs/BINaZAAAAAAAAAAAAAAAAAAAA57z5vC986jfHkCdbvBGY9UEAAAAAAAAAAAAAAAAAAAAAABuC5Ph+YUMEdCTygzTQLgAAAAAAAAAAAAAAAAAAAMdxf6hfQQBnhI5uc4PPJkiwAAAAAAAAAAAAAAAAAAAAAAApr+0qBIeZZf5wFnDZGNcAAAAAAAAAAAAAAAAAAADqhA6wE2ALsS/9BFYP32waPAAAAAAAAAAAAAAAAAAAAAAAKN90iROZj56eOgBuC4DlAAAAAAAAAAAAAAAAAAAAUItiITw6coKXGWZYVGs6EvMAAAAAAAAAAAAAAAAAAAAAAB/gFpTMjB81T6kjfu9v5AAAAAAAAAAAAAAAAAAAAGQG2CBHDqOoGrVyJFkVxqotAAAAAAAAAAAAAAAAAAAAAAAf6yUuTb9Uwg1tZ4id9jcAAAAAAAAAAAAAAAAAAADlkZ2DA7pZH9wO11w4cy+s/gAAAAAAAAAAAAAAAAAAAAAAAt5B32eTTs4csyhddidyAAAAAAAAAAAAAAAAAAAA2aKmCGyHs9jOnHNSufEdfO4AAAAAAAAAAAAAAAAAAAAAAC/vRXfEwTCgPImIiqOUswAAAAAAAAAAAAAAAAAAAFGkxws8pjGFPFrAxEiNiKZvAAAAAAAAAAAAAAAAAAAAAAAaPDkex9QFa+M1+cKv3uYAAAAAAAAAAAAAAAAAAACBxRbxgX6dH/bX8+18EZFW0AAAAAAAAAAAAAAAAAAAAAAAFvOBcJpsuXdvthvuKTZLAAAAAAAAAAAAAAAAAAAAT1jrSA1EinKmegreBOM17oQAAAAAAAAAAAAAAAAAAAAAACpP5938XueYK9lRsqQx8AAAAAAAAAAAAAAAAAAAAD7gDhTe1BwxuEHsc2agJEc/AAAAAAAAAAAAAAAAAAAAAAAhj3icxTsLkBO1+Nwz5bkAAAAAAAAAAAAAAAAAAADUotDXrDmLTxZKvbT011rGRgAAAAAAAAAAAAAAAAAAAAAAAm2Vy0XXc5bPTwYiCnozAAAAAAAAAAAAAAAAAAAA4m//D/oaIEkcbfvcsY8m3yEAAAAAAAAAAAAAAAAAAAAAAAUtiBCqfomCGC6GywfTDQAAAAAAAAAAAAAAAAAAANedPq+IpIRxcYWtqKNbMcFBAAAAAAAAAAAAAAAAAAAAAAAYqcAnwnFfdxcE/rO/iEMAAAAAAAAAAAAAAAAAAADOpZm7rhU1EjBVJa6+CsG3SwAAAAAAAAAAAAAAAAAAAAAADE3UV3HYY4to5MdMoyhzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADR5j3OosE3DcjqfYFSVRVvhQAAAAAAAAAAAAAAAAAAAAAAIkOVicHIGw8ySdK6LLsSAAAAAAAAAAAAAAAAAAAAiUo00o971hiazvZDn4Ir9CsAAAAAAAAAAAAAAAAAAAAAADA8czfrc4+po12HYzzeswAAAAAAAAAAAAAAAAAAAGvMegX/lalrKJQkxfczZw2WAAAAAAAAAAAAAAAAAAAAAAAAxDcm91tv2g3iLODg36sAAAAAAAAAAAAAAAAAAAAdCgnXF47JO614WPluZPC0jQAAAAAAAAAAAAAAAAAAAAAAL5tuC04sAZaN5cMkgqp9AAAAAAAAAAAAAAAAAAAAjKmgRRlkp7urvZ42nbdVYlMAAAAAAAAAAAAAAAAAAAAAABRWfiw+hPwePmnYH2zlgAAAAAAAAAAAAAAAAAAAANYJxZ/uz4mfK5Wv9Rm78/s8AAAAAAAAAAAAAAAAAAAAAAADeJJvFQwwx2CWXfRprm4=';
+    return Buffer.from(vk, 'base64');
+  }
 }
 
 export class VerificationKeyData {
-  constructor(public readonly keyAsFields: VerificationKeyAsFields, public readonly keyAsBytes: Buffer) {}
+  constructor(
+    public readonly keyAsFields: VerificationKeyAsFields,
+    public readonly keyAsBytes: Buffer,
+  ) {}
 
   public get numPublicInputs() {
     return this.keyAsFields.numPublicInputs;
@@ -262,10 +287,6 @@ export class VerificationKeyData {
     return this.keyAsFields.circuitSize;
   }
 
-  public get isRecursive() {
-    return this.keyAsFields.isRecursive;
-  }
-
   static empty() {
     return new VerificationKeyData(VerificationKeyAsFields.makeEmpty(0), Buffer.alloc(0));
   }
@@ -281,7 +302,7 @@ export class VerificationKeyData {
     );
   }
 
-  static makeFake(len = ROLLUP_HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS): VerificationKeyData {
+  static makeFake(len = ULTRA_VK_LENGTH_IN_FIELDS): VerificationKeyData {
     return new VerificationKeyData(VerificationKeyAsFields.makeFake(len), VerificationKey.makeFake().toBuffer());
   }
 
@@ -305,6 +326,10 @@ export class VerificationKeyData {
     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));
   }

package/src/vks/{vk_witness_data.ts → vk_data.ts}

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

package/src/world-state/index.ts

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

package/src/world-state/world_state_revision.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+export class WorldStateRevision {
+  constructor(
+    public readonly forkId: number,
+    public readonly blockNumber: number,
+    public readonly includeUncommitted: boolean,
+  ) {}
+
+  public toString() {
+    return `WorldStateRevision(forkId: ${this.forkId}, blockNumber: ${this.blockNumber}, includeUncommitted: ${this.includeUncommitted})`;
+  }
+
+  static empty() {
+    return new WorldStateRevision(0, 0, false);
+  }
+
+  static get schema() {
+    return z
+      .object({
+        forkId: z.number(),
+        blockNumber: z.number(),
+        includeUncommitted: z.boolean(),
+      })
+      .transform(
+        ({ forkId, blockNumber, includeUncommitted }) =>
+          new WorldStateRevision(forkId, blockNumber, includeUncommitted),
+      );
+  }
+}
+
+export class WorldStateRevisionWithHandle extends WorldStateRevision {
+  constructor(
+    forkId: number,
+    blockNumber: number,
+    includeUncommitted: boolean,
+    public readonly handle: any,
+  ) {
+    super(forkId, blockNumber, includeUncommitted);
+  }
+
+  public toWorldStateRevision() {
+    return new WorldStateRevision(this.forkId, this.blockNumber, this.includeUncommitted);
+  }
+
+  static fromWorldStateRevision(revision: WorldStateRevision, handle: any) {
+    return new WorldStateRevisionWithHandle(revision.forkId, revision.blockNumber, revision.includeUncommitted, handle);
+  }
+
+  static override get schema() {
+    return z
+      .object({
+        forkId: z.number(),
+        blockNumber: z.number(),
+        includeUncommitted: z.boolean(),
+        handle: z.any(),
+      })
+      .transform(
+        ({ forkId, blockNumber, includeUncommitted, handle }) =>
+          new WorldStateRevisionWithHandle(forkId, blockNumber, includeUncommitted, handle),
+      );
+  }
+}

package/src/zkpassport/index.ts

@@ -0,0 +1,118 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { withoutHexPrefix } from '@aztec/foundation/string';
+
+export type ViemZkPassportProofParams = {
+  version: `0x${string}`;
+  proofVerificationData: {
+    vkeyHash: `0x${string}`;
+    proof: `0x${string}`;
+    publicInputs: `0x${string}`[];
+  };
+  committedInputs: `0x${string}`;
+  serviceConfig: {
+    validityPeriodInSeconds: bigint;
+    domain: string;
+    scope: string;
+    devMode: boolean;
+  };
+};
+
+// NOTE: Must match the ZkPassportProofParams struct in the zkpassport verifier contract
+// find here: ROOT/l1-contracts/lib/circuits/src/solidity/src/ZKPassportVerifier.sol
+export class ZkPassportProofParams {
+  constructor(
+    public devMode: boolean,
+    public vkeyHash: Buffer32,
+    public proof: Buffer,
+    public publicInputs: Fr[],
+    public committedInputs: Buffer,
+    public validityPeriodInSeconds: bigint,
+    public domain: string,
+    public scope: string,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer([
+      this.devMode,
+      this.vkeyHash,
+      this.proof.length,
+      this.proof,
+      this.publicInputs.length,
+      this.publicInputs,
+      this.committedInputs.length,
+      this.committedInputs,
+      this.validityPeriodInSeconds,
+      this.domain,
+      this.scope,
+    ]);
+  }
+
+  static random() {
+    const committedInputCounts = [BigInt(1), BigInt(2), BigInt(3), BigInt(4)];
+    const numberOfCommittedInputs = committedInputCounts.reduce((acc, count) => acc + count, BigInt(0));
+    const committedInputs = randomBytes(Number(numberOfCommittedInputs) * 32);
+
+    const publicInputsCount = numberOfCommittedInputs + 16n;
+    const publicInputs = Array.from({ length: Number(publicInputsCount) }, () => Fr.random());
+
+    return new ZkPassportProofParams(
+      false,
+      Buffer32.random(),
+      randomBytes(1024),
+      publicInputs,
+      committedInputs,
+      BigInt(7 * 24 * 60 * 60), // 7 days
+      'sequencer.alpha-testnet.aztec.network',
+      'personhood',
+    );
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new ZkPassportProofParams(
+      reader.readBoolean(),
+      reader.readObject(Buffer32),
+      reader.readBuffer(),
+      reader.readVector(Fr),
+      reader.readBuffer(),
+      reader.readUInt256(),
+      reader.readString(),
+      reader.readString(),
+    );
+  }
+
+  static fromViem(params: ViemZkPassportProofParams) {
+    return new ZkPassportProofParams(
+      params.serviceConfig.devMode,
+      Buffer32.fromString(params.proofVerificationData.vkeyHash),
+      Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'),
+      params.proofVerificationData.publicInputs.map(input => Fr.fromString(input)),
+      Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'),
+      params.serviceConfig.validityPeriodInSeconds,
+      params.serviceConfig.domain,
+      params.serviceConfig.scope,
+    );
+  }
+
+  toViem(): ViemZkPassportProofParams {
+    // Version is set to bytes32(0) as per zkpassport library convention
+    return {
+      version: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      proofVerificationData: {
+        vkeyHash: this.vkeyHash.toString(),
+        proof: `0x${this.proof.toString('hex')}`,
+        publicInputs: this.publicInputs.map(input => input.toString()),
+      },
+      committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      serviceConfig: {
+        devMode: this.devMode,
+        validityPeriodInSeconds: this.validityPeriodInSeconds,
+        domain: this.domain,
+        scope: this.scope,
+      },
+    };
+  }
+}

package/dest/avm/public_data_hint.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import { PublicDataTreeLeafPreimage } from '../trees/index.js';
-export declare class PublicDataHint {
-    leafSlot: Fr;
-    value: Fr;
-    membershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>;
-    leafPreimage: PublicDataTreeLeafPreimage;
-    constructor(leafSlot: Fr, value: Fr, membershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>, leafPreimage: PublicDataTreeLeafPreimage);
-    static empty(): PublicDataHint;
-    static fromBuffer(buffer: Buffer | BufferReader): PublicDataHint;
-    toBuffer(): Buffer;
-}
-//# sourceMappingURL=public_data_hint.d.ts.map

package/dest/avm/public_data_hint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"public_data_hint.d.ts","sourceRoot":"","sources":["../../src/avm/public_data_hint.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAE/D,qBAAa,cAAc;IAEhB,QAAQ,EAAE,EAAE;IACZ,KAAK,EAAE,EAAE;IACT,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,uBAAuB,CAAC;IACpE,YAAY,EAAE,0BAA0B;gBAHxC,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,EAAE,EACT,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,uBAAuB,CAAC,EACpE,YAAY,EAAE,0BAA0B;IAGjD,MAAM,CAAC,KAAK;IASZ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAU/C,QAAQ;CAGT"}