@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/update-checker/update-checker.ts

@@ -0,0 +1,165 @@
+import { RegistryContract, type ViemClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { EventEmitter } from 'events';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { isDeepStrictEqual } from 'util';
+import { z } from 'zod';
+
+const updateConfigSchema = z.object({
+  version: z.string().optional(),
+  publicTelemetry: z.any().optional(),
+  config: z.any().optional(),
+});
+
+export type EventMap = {
+  newRollupVersion: [{ currentVersion: bigint; latestVersion: bigint }];
+  newNodeVersion: [{ currentVersion: string; latestVersion: string }];
+  updateNodeConfig: [object];
+  updatePublicTelemetryConfig: [object];
+};
+
+type Config = {
+  baseURL: URL;
+  nodeVersion?: string;
+  checkIntervalMs?: number;
+  registryContractAddress: EthAddress;
+  publicClient: ViemClient;
+  fetch?: typeof fetch;
+};
+
+export class UpdateChecker extends EventEmitter<EventMap> {
+  private runningPromise: RunningPromise;
+  private lastPatchedConfig: object = {};
+  private lastPatchedPublicTelemetryConfig: object = {};
+
+  constructor(
+    private updatesUrl: URL,
+    private nodeVersion: string | undefined,
+    private rollupVersion: bigint,
+    private fetch: typeof globalThis.fetch,
+    private getLatestRollupVersion: () => Promise<bigint>,
+    private checkIntervalMs = 10 * 60_000, // every 10 mins
+    private log = createLogger('foundation:update-check'),
+  ) {
+    super();
+    this.runningPromise = new RunningPromise(this.runChecks, this.log, this.checkIntervalMs);
+  }
+
+  public static async new(config: Config): Promise<UpdateChecker> {
+    const registryContract = new RegistryContract(config.publicClient, config.registryContractAddress);
+    const getLatestRollupVersion = () => registryContract.getRollupVersions().then(versions => versions.at(-1)!);
+
+    return new UpdateChecker(
+      config.baseURL,
+      config.nodeVersion ?? getPackageVersion(),
+      await getLatestRollupVersion(),
+      config.fetch ?? fetch,
+      getLatestRollupVersion,
+      config.checkIntervalMs,
+    );
+  }
+
+  public start(): void {
+    if (this.runningPromise.isRunning()) {
+      this.log.debug(`Can't start update checker again`);
+      return;
+    }
+
+    this.log.info('Starting update checker', {
+      nodeVersion: this.nodeVersion,
+      rollupVersion: this.rollupVersion,
+    });
+    this.runningPromise.start();
+  }
+
+  public stop(): Promise<void> {
+    if (!this.runningPromise.isRunning()) {
+      this.log.debug(`Can't stop update checker because it is not running`);
+      return Promise.resolve();
+    }
+    return this.runningPromise.stop();
+  }
+
+  public trigger(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  private runChecks = async (): Promise<void> => {
+    await Promise.all([this.checkRollupVersion(), this.checkConfig()]);
+  };
+
+  private async checkRollupVersion(): Promise<void> {
+    try {
+      const canonicalRollupVersion = await this.getLatestRollupVersion();
+      if (canonicalRollupVersion !== this.rollupVersion) {
+        this.log.debug('New canonical rollup version', {
+          currentVersion: this.rollupVersion,
+          latestVersion: canonicalRollupVersion,
+        });
+        this.emit('newRollupVersion', { currentVersion: this.rollupVersion, latestVersion: canonicalRollupVersion });
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is a new rollup`, err);
+    }
+  }
+
+  private async checkConfig(): Promise<void> {
+    try {
+      const response = await this.fetch(this.updatesUrl);
+      const body = await response.json();
+      if (!response.ok) {
+        this.log.warn(`Unexpected HTTP response checking for updates`, {
+          status: response.status,
+          body: await response.text(),
+          url: this.updatesUrl,
+        });
+      }
+
+      const { version, config, publicTelemetry } = updateConfigSchema.parse(body);
+
+      if (this.nodeVersion && version && version !== this.nodeVersion) {
+        this.log.debug('New node version', { currentVersion: this.nodeVersion, latestVersion: version });
+        this.emit('newNodeVersion', { currentVersion: this.nodeVersion, latestVersion: version });
+      }
+
+      if (config && Object.keys(config).length > 0 && !isDeepStrictEqual(config, this.lastPatchedConfig)) {
+        this.log.debug('New node config', { config });
+        this.lastPatchedConfig = config;
+        this.emit('updateNodeConfig', config);
+      }
+
+      if (
+        publicTelemetry &&
+        Object.keys(publicTelemetry).length > 0 &&
+        !isDeepStrictEqual(publicTelemetry, this.lastPatchedPublicTelemetryConfig)
+      ) {
+        this.log.debug('New metrics config', { config });
+        this.lastPatchedPublicTelemetryConfig = publicTelemetry;
+        this.emit('updatePublicTelemetryConfig', publicTelemetry);
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is an update`, err);
+    }
+  }
+}
+
+/**
+ * Returns package version.
+ */
+export function getPackageVersion(): string | undefined {
+  try {
+    const releasePleaseManifestPath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      '../../../../.release-please-manifest.json',
+    );
+    const version = JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
+    return version;
+  } catch {
+    return undefined;
+  }
+}

package/src/validators/errors.ts

@@ -0,0 +1,59 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { StateReference, TxHash } from '@aztec/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: bigint,
+  ) {
+    super(`Timeout collecting attestations for slot ${slot}: ${collectedCount}/${requiredCount}`);
+  }
+}
+
+export class TransactionsNotAvailableError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Transactions not available: ${txHashes.join(', ')}`);
+  }
+}
+
+export class FailedToReExecuteTransactionsError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);
+  }
+}
+
+export class ReExStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+    public readonly expectedStateReference?: StateReference,
+    public readonly actualStateReference?: StateReference,
+  ) {
+    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,75 @@
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import type {
+  SingleValidatorStats,
+  ValidatorMissedStats,
+  ValidatorStats,
+  ValidatorStatusHistory,
+  ValidatorStatusInSlot,
+  ValidatorsStats,
+} from './types.js';
+
+export const ValidatorStatusInSlotSchema = z.enum([
+  'block-mined',
+  'block-proposed',
+  'block-missed',
+  'attestation-sent',
+  'attestation-missed',
+]) satisfies ZodFor<ValidatorStatusInSlot>;
+
+export const ValidatorStatusHistorySchema = z.array(
+  z.object({
+    slot: schemas.BigInt,
+    status: ValidatorStatusInSlotSchema,
+  }),
+) satisfies ZodFor<ValidatorStatusHistory>;
+
+export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
+
+export const ValidatorStatusHistorySchemaMap = z.record(ValidatorStatusHistorySchemaArray);
+
+const ValidatorTimeStatSchema = z.object({
+  timestamp: schemas.BigInt,
+  slot: schemas.BigInt,
+  date: z.string(),
+});
+
+const ValidatorMissedStatsSchema = z.object({
+  currentStreak: schemas.Integer,
+  rate: z.number().optional(),
+  count: schemas.Integer,
+  total: schemas.Integer,
+}) satisfies ZodFor<ValidatorMissedStats>;
+
+export const ValidatorStatsSchema = z.object({
+  address: schemas.EthAddress,
+  lastProposal: ValidatorTimeStatSchema.optional(),
+  lastAttestation: ValidatorTimeStatSchema.optional(),
+  totalSlots: schemas.Integer,
+  missedProposals: ValidatorMissedStatsSchema,
+  missedAttestations: ValidatorMissedStatsSchema,
+  history: ValidatorStatusHistorySchema,
+}) satisfies ZodFor<ValidatorStats>;
+
+export const ValidatorsStatsSchema = z.object({
+  stats: z.record(ValidatorStatsSchema),
+  lastProcessedSlot: schemas.BigInt.optional(),
+  initialSlot: schemas.BigInt.optional(),
+  slotWindow: schemas.Integer,
+}) satisfies ZodFor<ValidatorsStats>;
+
+export const SingleValidatorStatsSchema = z.object({
+  validator: ValidatorStatsSchema,
+  allTimeProvenPerformance: z.array(
+    z.object({
+      missed: schemas.Integer,
+      total: schemas.Integer,
+      epoch: schemas.BigInt,
+    }),
+  ),
+  lastProcessedSlot: schemas.BigInt.optional(),
+  initialSlot: schemas.BigInt.optional(),
+  slotWindow: schemas.Integer,
+}) satisfies ZodFor<SingleValidatorStats>;

package/src/validators/types.ts

@@ -0,0 +1,46 @@
+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: bigint; status: ValidatorStatusInSlot }[];
+
+export type ValidatorMissedStats = {
+  currentStreak: number;
+  rate?: number;
+  count: number;
+  total: number;
+};
+
+export type ValidatorStats = {
+  address: EthAddress;
+  lastProposal?: { timestamp: bigint; slot: bigint; date: string };
+  lastAttestation?: { timestamp: bigint; slot: bigint; date: string };
+  totalSlots: number;
+  missedProposals: ValidatorMissedStats;
+  missedAttestations: ValidatorMissedStats;
+  history: ValidatorStatusHistory;
+};
+
+export type ValidatorsStats = {
+  stats: Record<string, ValidatorStats>;
+  lastProcessedSlot?: bigint;
+  initialSlot?: bigint;
+  slotWindow: number;
+};
+
+export type ValidatorsEpochPerformance = Record<`0x${string}`, { missed: number; total: number }>;
+
+export type SingleValidatorStats = {
+  validator: ValidatorStats;
+  allTimeProvenPerformance: { missed: number; total: number; epoch: bigint }[];
+  lastProcessedSlot?: bigint;
+  initialSlot?: bigint;
+  slotWindow: number;
+};

package/src/versioning/versioning.ts

@@ -4,10 +4,7 @@ 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,7 +13,7 @@ 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;
+  rollupVersion: number;
   l2ProtocolContractsTreeRoot: string;
   l2CircuitsVkTreeRoot: string;
 };
@@ -30,7 +27,7 @@ export function getComponentsVersionsFromConfig(
   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,
+    rollupVersion: config.rollupVersion,
     l2ProtocolContractsTreeRoot: l2ProtocolContractsTreeRoot.toString(),
     l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString(),
   };
@@ -50,7 +47,7 @@ export function compressComponentVersions(versions: ComponentsVersions): string
     '00',
     versions.l1ChainId,
     versions.l1RollupAddress.toString().slice(2, 10),
-    versions.l2ChainVersion,
+    versions.rollupVersion,
     versions.l2ProtocolContractsTreeRoot.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, l2ProtocolContractsTreeRoot, l2CircuitsVkTreeRoot] =
+    compressed.split('-');
   if (versionVersion !== '00') {
     throw new ComponentsVersionsError('version', '00', versionVersion);
   }
@@ -82,8 +73,8 @@ 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)) {
     throw new ComponentsVersionsError(
@@ -111,7 +102,7 @@ export function validatePartialComponentVersionsMatch(
     'l2ProtocolContractsTreeRoot',
     'l2CircuitsVkTreeRoot',
     'l1ChainId',
-    'l2ChainVersion',
+    'rollupVersion',
   ] as const) {
     const actualValue = actual[key];
     const expectedValue = expected[key];

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,7 +1,4 @@
-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';
@@ -9,6 +6,7 @@ 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);
@@ -142,12 +143,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),
     );
   }
@@ -252,7 +253,10 @@ export class VerificationKey {
 }
 
 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 +266,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 +281,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());
   }
 

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

@@ -7,26 +7,26 @@ 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/zkpassport/index.ts

@@ -0,0 +1,127 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { withoutHexPrefix } from '@aztec/foundation/string';
+
+export type ViemZkPassportProofParams = {
+  proofVerificationData: {
+    vkeyHash: `0x${string}`;
+    proof: `0x${string}`;
+    publicInputs: `0x${string}`[];
+  };
+  commitments: {
+    committedInputs: `0x${string}`;
+    committedInputCounts: bigint[];
+  };
+  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 committedInputCounts: bigint[],
+    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.committedInputCounts.length,
+      this.committedInputCounts,
+      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,
+      committedInputCounts,
+      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.readUint256Vector(),
+      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.commitments.committedInputs), 'hex'),
+      params.commitments.committedInputCounts,
+      params.serviceConfig.validityPeriodInSeconds,
+      params.serviceConfig.domain,
+      params.serviceConfig.scope,
+    );
+  }
+
+  toViem(): ViemZkPassportProofParams {
+    return {
+      serviceConfig: {
+        devMode: this.devMode,
+        validityPeriodInSeconds: this.validityPeriodInSeconds,
+        domain: this.domain,
+        scope: this.scope,
+      },
+      proofVerificationData: {
+        vkeyHash: this.vkeyHash.toString(),
+        proof: `0x${this.proof.toString('hex')}`,
+        publicInputs: this.publicInputs.map(input => input.toString()),
+      },
+      commitments: {
+        committedInputs: `0x${this.committedInputs.toString('hex')}`,
+        committedInputCounts: this.committedInputCounts,
+      },
+    };
+  }
+}