@aztec/stdlib 0.0.1-commit.9b94fc1 → 0.0.1-commit.c7c42ec

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -25,6 +26,10 @@ export class L2BlockStream {
       skipFinalized?: boolean;
     } = {},
   ) {
+    // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+    // which makes it run periodically, or `sync`, which triggers it once.
+    // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+    // The default is _manually triggered_.
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
   }
 
@@ -41,6 +46,11 @@ export class L2BlockStream {
     return this.runningPromise.isRunning();
   }
 
+  /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */
   public async sync() {
     this.isSyncing = true;
     await this.runningPromise.trigger();
@@ -74,7 +84,7 @@ export class L2BlockStream {
       }
 
       if (latestBlockNumber < localTips.latest.number) {
-        latestBlockNumber = Math.min(latestBlockNumber, sourceTips.latest.number); // see #13471
+        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.latest.number)); // see #13471
         const hash = sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber));
         if (latestBlockNumber !== 0 && !hash) {
           throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
@@ -85,7 +95,7 @@ export class L2BlockStream {
 
       // 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);
+        latestBlockNumber = BlockNumber(Math.max(this.opts.startingBlock - 1, 0));
       }
 
       // Only log this entry once (for sanity)
@@ -108,7 +118,11 @@ export class L2BlockStream {
       while (nextBlockNumber <= sourceTips.latest.number) {
         const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.latest.number - nextBlockNumber + 1);
         this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getPublishedBlocks(nextBlockNumber, limit, this.opts.proven);
+        const blocks = await this.l2BlockSource.getPublishedBlocks(
+          BlockNumber(nextBlockNumber),
+          limit,
+          this.opts.proven,
+        );
         if (blocks.length === 0) {
           break;
         }
@@ -139,7 +153,7 @@ 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: BlockHashCache }) {
+  private async areBlockHashesEqualAt(blockNumber: BlockNumber, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
@@ -163,7 +177,7 @@ export class L2BlockStream {
     return localBlockHash === sourceBlockHash;
   }
 
-  private getBlockHashFromSource(blockNumber: number) {
+  private getBlockHashFromSource(blockNumber: BlockNumber) {
     return this.l2BlockSource
       .getBlockHeader(blockNumber)
       .then(h => h?.hash())

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -1,3 +1,6 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+
 import type { L2Block } from '../l2_block.js';
 import type { L2BlockId, L2BlockTag, L2Tips } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
@@ -7,7 +10,7 @@ import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalD
  * @dev tests in kv-store/src/stores/l2_tips_memory_store.test.ts
  */
 export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
-  protected readonly l2TipsStore: Map<L2BlockTag, number> = new Map();
+  protected readonly l2TipsStore: Map<L2BlockTag, BlockNumber> = new Map();
   protected readonly l2BlockHashesStore: Map<number, string> = new Map();
 
   public getL2BlockHash(number: number): Promise<string | undefined> {
@@ -25,7 +28,7 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   private getL2Tip(tag: L2BlockTag): L2BlockId {
     const blockNumber = this.l2TipsStore.get(tag);
     if (blockNumber === undefined || blockNumber === 0) {
-      return { number: 0, hash: undefined };
+      return { number: BlockNumber.ZERO, hash: GENESIS_BLOCK_HEADER_HASH.toString() };
     }
     const blockHash = this.l2BlockHashesStore.get(blockNumber);
     if (!blockHash) {

package/src/block/proposal/attestations_and_signers.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';

package/src/block/proposal/committee_attestation.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,6 +1,9 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+import { L1PublishedData } from '@aztec/stdlib/checkpoint';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -15,17 +18,20 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
 
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
-      block: { number, hash: () => Promise.resolve(new Fr(number)) } as L2Block,
-      l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
+      block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
+      l1: new L1PublishedData(BigInt(number), BigInt(number), `0x${number}`),
       attestations: [],
     });
 
   const makeBlockId = (number: number): L2BlockId => ({
-    number,
+    number: BlockNumber(number),
     hash: new Fr(number).toString(),
   });
 
-  const makeTip = (number: number) => ({ number, hash: number === 0 ? undefined : new Fr(number).toString() });
+  const makeTip = (number: number): L2BlockId => ({
+    number: BlockNumber(number),
+    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : new Fr(number).toString(),
+  });
 
   const makeTips = (latest: number, proven: number, finalized: number) => ({
     latest: makeTip(latest),

package/src/checkpoint/checkpoint.ts

@@ -1,6 +1,7 @@
 import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { Fr } from '@aztec/foundation/fields';
-import { schemas } from '@aztec/foundation/schemas';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { sum } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -9,6 +10,7 @@ import { z } from 'zod';
 import { L2BlockNew } from '../block/l2_block_new.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import type { CheckpointInfo } from './checkpoint_info.js';
 
 export class Checkpoint {
   constructor(
@@ -19,7 +21,7 @@ export class Checkpoint {
     /** L2 blocks in the checkpoint. */
     public blocks: L2BlockNew[],
     /** Number of the checkpoint. */
-    public number: number,
+    public number: CheckpointNumber,
   ) {}
 
   static get schema() {
@@ -28,7 +30,7 @@ export class Checkpoint {
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
         blocks: z.array(L2BlockNew.schema),
-        number: schemas.UInt32,
+        number: CheckpointNumberSchema,
       })
       .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
   }
@@ -47,7 +49,7 @@ export class Checkpoint {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(CheckpointHeader),
       reader.readVector(L2BlockNew),
-      reader.readNumber(),
+      CheckpointNumber(reader.readNumber()),
     );
   }
 
@@ -56,7 +58,7 @@ export class Checkpoint {
   }
 
   public toBlobFields(): Fr[] {
-    const blocks = this.blocks.map((block, i) => block.toBlockBlobData(i === 0));
+    const blocks = this.blocks.map(block => block.toBlockBlobData());
     return encodeCheckpointBlobDataFromBlocks(blocks);
   }
 
@@ -68,20 +70,65 @@ export class Checkpoint {
     return this.blocks.at(-1)!.header.state;
   }
 
+  public toCheckpointInfo(): CheckpointInfo {
+    return {
+      archive: this.archive.root,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+    };
+  }
+
+  /** Returns stats used for logging */
+  public getStats() {
+    const txEffects = this.blocks.flatMap(block => block.body.txEffects);
+
+    const logsStats = {
+      privateLogCount: sum(txEffects.map(tx => tx.privateLogs.length)),
+      publicLogCount: sum(txEffects.map(tx => tx.publicLogs.length)),
+      contractClassLogCount: sum(txEffects.map(tx => tx.contractClassLogs.length)),
+      contractClassLogSize: sum(txEffects.map(tx => sum(tx.contractClassLogs.map(log => log.emittedLength)))),
+    };
+
+    return {
+      txCount: txEffects.length,
+      blockCount: this.blocks.length,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+      ...logsStats,
+    };
+  }
+
   static async random(
-    checkpointNumber = 1,
+    checkpointNumber = CheckpointNumber(1),
     {
       numBlocks = 1,
       startBlockNumber = 1,
+      previousArchive,
       ...options
-    }: { numBlocks?: number; startBlockNumber?: number } & Partial<FieldsOf<CheckpointHeader>> &
+    }: {
+      numBlocks?: number;
+      startBlockNumber?: number;
+      previousArchive?: AppendOnlyTreeSnapshot;
+    } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
       Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
   ) {
     const header = CheckpointHeader.random(options);
 
-    const blocks = await Promise.all(
-      Array.from({ length: numBlocks }, (_, i) => L2BlockNew.random(startBlockNumber + i, options)),
-    );
+    // Create blocks sequentially to chain archive roots properly.
+    // Each block's header.lastArchive must equal the previous block's archive.
+    const blocks: L2BlockNew[] = [];
+    let lastArchive = previousArchive;
+    for (let i = 0; i < numBlocks; i++) {
+      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
+        indexWithinCheckpoint: i,
+        ...options,
+        ...(lastArchive ? { lastArchive } : {}),
+      });
+      lastArchive = block.archive;
+      blocks.push(block);
+    }
 
     return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
   }

package/src/checkpoint/checkpoint_info.ts

@@ -0,0 +1,9 @@
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr, SlotNumber } from '@aztec/foundation/schemas';
+
+export type CheckpointInfo = {
+  archive: Fr;
+  slotNumber: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  timestamp: bigint;
+};

package/src/checkpoint/published_checkpoint.ts

@@ -1,6 +1,6 @@
 // Ignoring import issue to fix portable inferred type issue in zod schema
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { randomBigInt } from '@aztec/foundation/crypto';
+import { randomBigInt } from '@aztec/foundation/crypto/random';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -18,11 +18,13 @@ export class L1PublishedData {
   ) {}
 
   static get schema() {
-    return z.object({
-      blockNumber: schemas.BigInt,
-      timestamp: schemas.BigInt,
-      blockHash: z.string(),
-    });
+    return z
+      .object({
+        blockNumber: schemas.BigInt,
+        timestamp: schemas.BigInt,
+        blockHash: z.string(),
+      })
+      .transform(obj => L1PublishedData.fromFields(obj));
   }
 
   static random() {
@@ -36,6 +38,18 @@ export class L1PublishedData {
   static fromFields(fields: FieldsOf<L1PublishedData>) {
     return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
   }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.blockNumber, this.blockHash, this.timestamp);
+  }
 }
 
 export class PublishedCheckpoint {

package/src/contract/artifact_hash.ts

@@ -1,5 +1,5 @@
-import { sha256 } from '@aztec/foundation/crypto';
-import { Fr, reduceFn } from '@aztec/foundation/fields';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
+import { Fr, reduceFn } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { numToUInt8 } from '@aztec/foundation/serialize';
 import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';

package/src/contract/complete_address.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';

package/src/contract/contract_address.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { type FunctionAbi, FunctionSelector, encodeArguments } from '../abi/index.js';
 import type { AztecAddress } from '../aztec-address/index.js';

package/src/contract/contract_class.ts

@@ -1,5 +1,5 @@
-import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 import { hashVK } from '../hash/hash.js';

package/src/contract/contract_class_id.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';
 
@@ -40,7 +40,7 @@ export async function computeContractClassIdWithPreimage(
       : await computePublicBytecodeCommitment(contractClass.packedBytecode);
   const id = await poseidon2HashWithSeparator(
     [artifactHash, privateFunctionsRoot, publicBytecodeCommitment],
-    GeneratorIndex.CONTRACT_LEAF, // TODO(@spalladino): Review all generator indices in this file
+    GeneratorIndex.CONTRACT_CLASS_ID,
   );
   return { id, artifactHash, privateFunctionsRoot, publicBytecodeCommitment };
 }

package/src/contract/contract_instance.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/contract_instance_update.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/deployment_info.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { CompleteAddress } from './complete_address.js';
 

package/src/contract/interfaces/contract_class.ts

@@ -1,5 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -35,10 +35,12 @@ export interface PrivateFunction {
   vkHash: Fr;
 }
 
-const PrivateFunctionSchema = z.object({
-  selector: FunctionSelector.schema,
-  vkHash: schemas.Fr,
-}) satisfies ZodFor<PrivateFunction>;
+const PrivateFunctionSchema = zodFor<PrivateFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    vkHash: schemas.Fr,
+  }),
+);
 
 /** Private function definition with executable bytecode. */
 export interface ExecutablePrivateFunction extends PrivateFunction {
@@ -46,9 +48,9 @@ export interface ExecutablePrivateFunction extends PrivateFunction {
   bytecode: Buffer;
 }
 
-const ExecutablePrivateFunctionSchema = PrivateFunctionSchema.and(
-  z.object({ bytecode: schemas.Buffer }),
-) satisfies ZodFor<ExecutablePrivateFunction>;
+const ExecutablePrivateFunctionSchema = zodFor<ExecutablePrivateFunction>()(
+  PrivateFunctionSchema.and(z.object({ bytecode: schemas.Buffer })),
+);
 
 /** Utility function definition. */
 export interface UtilityFunction {
@@ -58,11 +60,12 @@ export interface UtilityFunction {
   bytecode: Buffer;
 }
 
-const UtilityFunctionSchema = z.object({
-  /** lala */
-  selector: FunctionSelector.schema,
-  bytecode: schemas.Buffer,
-}) satisfies ZodFor<UtilityFunction>;
+const UtilityFunctionSchema = zodFor<UtilityFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    bytecode: schemas.Buffer,
+  }),
+);
 
 /** Sibling paths and sibling commitments for proving membership of a private function within a contract class. */
 export type PrivateFunctionMembershipProof = {
@@ -75,15 +78,17 @@ export type PrivateFunctionMembershipProof = {
   artifactTreeLeafIndex: number;
 };
 
-const PrivateFunctionMembershipProofSchema = z.object({
-  artifactMetadataHash: schemas.Fr,
-  functionMetadataHash: schemas.Fr,
-  utilityFunctionsTreeRoot: schemas.Fr,
-  privateFunctionTreeSiblingPath: z.array(schemas.Fr),
-  privateFunctionTreeLeafIndex: schemas.Integer,
-  artifactTreeSiblingPath: z.array(schemas.Fr),
-  artifactTreeLeafIndex: schemas.Integer,
-}) satisfies ZodFor<PrivateFunctionMembershipProof>;
+const PrivateFunctionMembershipProofSchema = zodFor<PrivateFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    utilityFunctionsTreeRoot: schemas.Fr,
+    privateFunctionTreeSiblingPath: z.array(schemas.Fr),
+    privateFunctionTreeLeafIndex: schemas.Integer,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
 
 /** A private function with a membership proof. */
 export type ExecutablePrivateFunctionWithMembershipProof = ExecutablePrivateFunction & PrivateFunctionMembershipProof;
@@ -97,23 +102,27 @@ export type UtilityFunctionMembershipProof = {
   artifactTreeLeafIndex: number;
 };
 
-const UtilityFunctionMembershipProofSchema = z.object({
-  artifactMetadataHash: schemas.Fr,
-  functionMetadataHash: schemas.Fr,
-  privateFunctionsArtifactTreeRoot: schemas.Fr,
-  artifactTreeSiblingPath: z.array(schemas.Fr),
-  artifactTreeLeafIndex: schemas.Integer,
-}) satisfies ZodFor<UtilityFunctionMembershipProof>;
+const UtilityFunctionMembershipProofSchema = zodFor<UtilityFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    privateFunctionsArtifactTreeRoot: schemas.Fr,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
 
 /** A utility function with a membership proof. */
 export type UtilityFunctionWithMembershipProof = UtilityFunction & UtilityFunctionMembershipProof;
 
-export const ContractClassSchema = z.object({
-  version: z.literal(VERSION),
-  artifactHash: schemas.Fr,
-  privateFunctions: z.array(PrivateFunctionSchema),
-  packedBytecode: schemas.Buffer,
-}) satisfies ZodFor<ContractClass>;
+export const ContractClassSchema = zodFor<ContractClass>()(
+  z.object({
+    version: z.literal(VERSION),
+    artifactHash: schemas.Fr,
+    privateFunctions: z.array(PrivateFunctionSchema),
+    packedBytecode: schemas.Buffer,
+  }),
+);
 
 /** Commitments to fields of a contract class. */
 interface ContractClassCommitments {
@@ -128,9 +137,11 @@ interface ContractClassCommitments {
 /** A contract class with its precomputed id. */
 export type ContractClassWithId = ContractClass & Pick<ContractClassCommitments, 'id'>;
 
-export const ContractClassWithIdSchema = ContractClassSchema.extend({
-  id: schemas.Fr,
-}) satisfies ZodFor<ContractClassWithId>;
+export const ContractClassWithIdSchema = zodFor<ContractClassWithId>()(
+  ContractClassSchema.extend({
+    id: schemas.Fr,
+  }),
+);
 
 /** A contract class with public bytecode information, and optional private and utility functions. */
 export type ContractClassPublic = {
@@ -142,14 +153,34 @@ export type ContractClassPublic = {
 export type ContractClassPublicWithCommitment = ContractClassPublic &
   Pick<ContractClassCommitments, 'publicBytecodeCommitment'>;
 
-export const ContractClassPublicSchema = z
-  .object({
-    id: schemas.Fr,
-    privateFunctionsRoot: schemas.Fr,
-    privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
-    utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
-  })
-  .and(ContractClassSchema.omit({ privateFunctions: true })) satisfies ZodFor<ContractClassPublic>;
+export const ContractClassPublicSchema = zodFor<ContractClassPublic>()(
+  z
+    .object({
+      id: schemas.Fr,
+      privateFunctionsRoot: schemas.Fr,
+      privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
+      utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
+    })
+    .and(ContractClassSchema.omit({ privateFunctions: true })),
+);
 
 /** The contract class with the block it was initially deployed at */
 export type ContractClassPublicWithBlockNumber = { l2BlockNumber: number } & ContractClassPublic;
+
+/**
+ * Creates a ContractClassPublic from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ * Note: privateFunctions and utilityFunctions are set to empty arrays since
+ * C++ does not provide them.
+ */
+export function contractClassPublicFromPlainObject(obj: any): ContractClassPublic {
+  return {
+    id: Fr.fromPlainObject(obj.id),
+    version: 1,
+    artifactHash: Fr.fromPlainObject(obj.artifactHash),
+    privateFunctionsRoot: Fr.fromPlainObject(obj.privateFunctionsRoot),
+    privateFunctions: [],
+    utilityFunctions: [],
+    packedBytecode: obj.packedBytecode instanceof Buffer ? obj.packedBytecode : Buffer.from(obj.packedBytecode),
+  };
+}

package/src/contract/interfaces/contract_data_source.ts

@@ -1,4 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
@@ -11,7 +12,7 @@ export interface ContractDataSource {
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Returns the contract class for a given contract class id, or undefined if not found.