@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/src/checkpoint/index.ts

@@ -1 +1,2 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';
+export * from './published_checkpoint.js';

package/src/{block/published_l2_block.ts → checkpoint/published_checkpoint.ts}

@@ -1,14 +1,14 @@
 // 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';
 
 import { z } from 'zod';
 
-import { L2Block } from './l2_block.js';
-import { CommitteeAttestation } from './proposal/committee_attestation.js';
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { Checkpoint } from './checkpoint.js';
 
 export class L1PublishedData {
   constructor(
@@ -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,42 +38,63 @@ 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 PublishedL2Block {
+export class PublishedCheckpoint {
   constructor(
-    public block: L2Block,
+    public checkpoint: Checkpoint,
     public l1: L1PublishedData,
+    // The attestations for the last block in the checkpoint.
     public attestations: CommitteeAttestation[],
   ) {}
 
   static get schema() {
     return z
       .object({
-        block: L2Block.schema,
+        checkpoint: Checkpoint.schema,
         l1: L1PublishedData.schema,
         attestations: z.array(CommitteeAttestation.schema),
       })
-      .transform(obj => PublishedL2Block.fromFields(obj));
+      .transform(obj => PublishedCheckpoint.from(obj));
   }
 
-  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
     const reader = BufferReader.asReader(bufferOrReader);
-    const block = reader.readObject(L2Block);
+    const checkpoint = reader.readObject(Checkpoint);
     const l1BlockNumber = reader.readBigInt();
     const l1BlockHash = reader.readString();
     const l1Timestamp = reader.readBigInt();
     const attestations = reader.readVector(CommitteeAttestation);
-    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
-  }
-
-  static fromFields(fields: FieldsOf<PublishedL2Block>) {
-    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
   }
 
   public toBuffer(): Buffer {
     return serializeToBuffer(
-      this.block,
+      this.checkpoint,
       this.l1.blockNumber,
       this.l1.blockHash,
       this.l1.timestamp,

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_deployment_data.ts

@@ -0,0 +1,125 @@
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/**
+ * Class containing contract class logs and private logs which are both
+ * relevant for contract registrations and deployments.
+ */
+export class ContractDeploymentData {
+  constructor(
+    public readonly contractClassLogs: ContractClassLog[],
+    public readonly privateLogs: PrivateLog[],
+  ) {}
+
+  public getContractClassLogs(): ContractClassLog[] {
+    return this.contractClassLogs;
+  }
+
+  public getPrivateLogs(): PrivateLog[] {
+    return this.privateLogs;
+  }
+
+  public static from(args: { contractClassLogs: ContractClassLog[]; privateLogs: PrivateLog[] }) {
+    return new ContractDeploymentData(args.contractClassLogs, args.privateLogs);
+  }
+
+  public static empty(): ContractDeploymentData {
+    return new ContractDeploymentData([], []);
+  }
+
+  public static get schema() {
+    return z
+      .object({
+        contractClassLogs: z.array(ContractClassLog.schema),
+        privateLogs: z.array(PrivateLog.schema),
+      })
+      .transform(ContractDeploymentData.from);
+  }
+
+  /**
+   * Creates a ContractDeploymentData from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractDeploymentData fields
+   * @returns A ContractDeploymentData instance
+   */
+  public static fromPlainObject(obj: any): ContractDeploymentData {
+    if (obj instanceof ContractDeploymentData) {
+      return obj;
+    }
+    return new ContractDeploymentData(
+      obj.contractClassLogs.map((log: any) => ContractClassLog.fromPlainObject(log)),
+      obj.privateLogs.map((log: any) => PrivateLog.fromPlainObject(log)),
+    );
+  }
+}
+
+/**
+ * Class containing both revertible and non-revertible registration/deployment data.
+ */
+export class AllContractDeploymentData {
+  constructor(
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
+  ) {}
+
+  public getNonRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.nonRevertibleContractDeploymentData;
+  }
+
+  public getRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.revertibleContractDeploymentData;
+  }
+
+  /**
+   * Extracts all contract registration/deployment data from a tx separated by revertibility.
+   * This includes contract class logs and private logs.
+   *
+   * This method handles both private-only transactions and transactions with public calls,
+   * properly splitting logs between revertible and non-revertible categories.
+   * @param tx - The transaction to extract data from
+   * @returns The extracted deployment data separated by revertibility
+   */
+  static fromTx(tx: Tx): AllContractDeploymentData {
+    const hasPublicCalls = !!tx.data.forPublic;
+
+    // Extract contract class logs from the tx
+    const allClassLogs = tx.getContractClassLogs();
+    let nonRevertibleClassLogs: ContractClassLog[];
+    let revertibleClassLogs: ContractClassLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract class logs
+      // Split the logs up here based on revertibility
+      nonRevertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ false);
+      revertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ true);
+    } else {
+      // Private-only tx: all logs are non-revertible
+      nonRevertibleClassLogs = allClassLogs;
+      revertibleClassLogs = [];
+    }
+
+    // Extract contract instance logs from the transaction's private logs
+    let nonRevertibleInstanceLogs: PrivateLog[];
+    let revertibleInstanceLogs: PrivateLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract instance logs
+      // Split the logs up here based on revertibility
+      nonRevertibleInstanceLogs = tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+    } else {
+      // Private-only tx: use logs from the `forRollup` member of the tx
+      // For private-only txs, all logs are non-revertible
+      nonRevertibleInstanceLogs = tx.data.forRollup!.end.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = [];
+    }
+
+    return new AllContractDeploymentData(
+      new ContractDeploymentData(nonRevertibleClassLogs, nonRevertibleInstanceLogs),
+      new ContractDeploymentData(revertibleClassLogs, revertibleInstanceLogs),
+    );
+  }
+}

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/index.ts

@@ -3,6 +3,7 @@ export * from './contract_address.js';
 export * from './contract_class.js';
 export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
+export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
 export * from './contract_metadata.js';
 export * from './contract_instance_update.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.

package/src/contract/interfaces/contract_instance.ts

@@ -1,10 +1,10 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
-import type { AztecAddress } from '../../aztec-address/index.js';
+import { AztecAddress } from '../../aztec-address/index.js';
 import { PublicKeys } from '../../keys/public_keys.js';
-import { type ZodFor, schemas } from '../../schemas/index.js';
+import { schemas, zodFor } from '../../schemas/index.js';
 
 const VERSION = 1 as const;
 
@@ -32,16 +32,48 @@ export interface ContractInstance {
 
 export type ContractInstanceWithAddress = ContractInstance & { address: AztecAddress };
 
-export const ContractInstanceSchema = z.object({
-  version: z.literal(VERSION),
-  salt: schemas.Fr,
-  deployer: schemas.AztecAddress,
-  currentContractClassId: schemas.Fr,
-  originalContractClassId: schemas.Fr,
-  initializationHash: schemas.Fr,
-  publicKeys: PublicKeys.schema,
-}) satisfies ZodFor<ContractInstance>;
-
-export const ContractInstanceWithAddressSchema = ContractInstanceSchema.and(
-  z.object({ address: schemas.AztecAddress }),
-) satisfies ZodFor<ContractInstanceWithAddress>;
+export const ContractInstanceSchema = zodFor<ContractInstance>()(
+  z.object({
+    version: z.literal(VERSION),
+    salt: schemas.Fr,
+    deployer: schemas.AztecAddress,
+    currentContractClassId: schemas.Fr,
+    originalContractClassId: schemas.Fr,
+    initializationHash: schemas.Fr,
+    publicKeys: PublicKeys.schema,
+  }),
+);
+
+export const ContractInstanceWithAddressSchema = zodFor<ContractInstanceWithAddress>()(
+  ContractInstanceSchema.and(z.object({ address: schemas.AztecAddress })),
+);
+
+/**
+ * Creates a ContractInstance from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ */
+export function contractInstanceFromPlainObject(obj: any): ContractInstance {
+  return {
+    version: 1,
+    salt: Fr.fromPlainObject(obj.salt),
+    deployer: AztecAddress.fromPlainObject(obj.deployer),
+    currentContractClassId: Fr.fromPlainObject(obj.currentContractClassId),
+    originalContractClassId: Fr.fromPlainObject(obj.originalContractClassId),
+    initializationHash: Fr.fromPlainObject(obj.initializationHash),
+    publicKeys: PublicKeys.fromPlainObject(obj.publicKeys),
+  };
+}
+
+/**
+ * Creates a ContractInstanceWithAddress from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ */
+export function contractInstanceWithAddressFromPlainObject(
+  address: AztecAddress,
+  obj: any,
+): ContractInstanceWithAddress {
+  return {
+    ...contractInstanceFromPlainObject(obj),
+    address,
+  };
+}

package/src/contract/interfaces/contract_instance_update.ts

@@ -1,9 +1,9 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
 import type { AztecAddress } from '../../aztec-address/index.js';
-import { type ZodFor, schemas } from '../../schemas/index.js';
+import { schemas, zodFor } from '../../schemas/index.js';
 import type { UInt64 } from '../../types/shared.js';
 
 /**
@@ -20,12 +20,14 @@ export interface ContractInstanceUpdate {
 
 export type ContractInstanceUpdateWithAddress = ContractInstanceUpdate & { address: AztecAddress };
 
-export const ContractInstanceUpdateSchema = z.object({
-  prevContractClassId: schemas.Fr,
-  newContractClassId: schemas.Fr,
-  timestampOfChange: schemas.BigInt,
-}) satisfies ZodFor<ContractInstanceUpdate>;
+export const ContractInstanceUpdateSchema = zodFor<ContractInstanceUpdate>()(
+  z.object({
+    prevContractClassId: schemas.Fr,
+    newContractClassId: schemas.Fr,
+    timestampOfChange: schemas.BigInt,
+  }),
+);
 
-export const ContractInstanceUpdateWithAddressSchema = ContractInstanceUpdateSchema.and(
-  z.object({ address: schemas.AztecAddress }),
-) satisfies ZodFor<ContractInstanceUpdateWithAddress>;
+export const ContractInstanceUpdateWithAddressSchema = zodFor<ContractInstanceUpdateWithAddress>()(
+  ContractInstanceUpdateSchema.and(z.object({ address: schemas.AztecAddress })),
+);

package/src/contract/partial_address.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * A type which along with public key forms a preimage of a contract address. See the link below for more details

package/src/contract/private_function.ts

@@ -1,6 +1,7 @@
 import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
-import { pedersenHash, poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
 
 import type { PrivateFunction } from './interfaces/contract_class.js';