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

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 { DomainSeparator } from '@aztec/constants';
+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';
@@ -13,9 +13,9 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
 /**
  * Returns the deployment address for a given contract instance.
  * ```
- * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
- * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)
- * address = ((poseidon2Hash([public_keys_hash, partial_address, GENERATOR__CONTRACT_ADDRESS_V1]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * salted_initialization_hash = poseidon2(DOM_SEP__SALTED_INITIALIZATION_HASH, [salt, initialization_hash, deployer, immutables_hash])
+ * partial_address = poseidon2(DOM_SEP__PARTIAL_ADDRESS, [contract_class_id, salted_initialization_hash])
+ * address = ((poseidon2(DOM_SEP__CONTRACT_ADDRESS_V2, [public_keys_hash, partial_address]) * G) + ivpk_m).x <- the x-coordinate of the address point
  * ```
  * @param instance - A contract instance for which to calculate the deployment address.
  */
@@ -34,7 +34,7 @@ export async function computeContractAddressFromInstance(
  */
 export async function computePartialAddress(
   instance:
-    | Pick<ContractInstance, 'originalContractClassId' | 'initializationHash' | 'salt' | 'deployer'>
+    | Pick<ContractInstance, 'originalContractClassId' | 'initializationHash' | 'salt' | 'deployer' | 'immutablesHash'>
     | { originalContractClassId: Fr; saltedInitializationHash: Fr },
 ): Promise<Fr> {
   const saltedInitializationHash =
@@ -44,7 +44,7 @@ export async function computePartialAddress(
 
   return poseidon2HashWithSeparator(
     [instance.originalContractClassId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
 }
 
@@ -53,11 +53,11 @@ export async function computePartialAddress(
  * @param instance - Contract instance for which to compute the salted initialization hash.
  */
 export function computeSaltedInitializationHash(
-  instance: Pick<ContractInstance, 'initializationHash' | 'salt' | 'deployer'>,
+  instance: Pick<ContractInstance, 'initializationHash' | 'salt' | 'deployer' | 'immutablesHash'>,
 ): Promise<Fr> {
   return poseidon2HashWithSeparator(
-    [instance.salt, instance.initializationHash, instance.deployer],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    [instance.salt, instance.initializationHash, instance.deployer, instance.immutablesHash],
+    DomainSeparator.SALTED_INITIALIZATION_HASH,
   );
 }
 
@@ -87,5 +87,5 @@ export async function computeInitializationHashFromEncodedArgs(
   encodedArgs: Fr[],
 ): Promise<Fr> {
   const argsHash = await computeVarArgsHash(encodedArgs);
-  return poseidon2HashWithSeparator([initFn, argsHash], GeneratorIndex.CONSTRUCTOR);
+  return poseidon2HashWithSeparator([initFn, argsHash], DomainSeparator.INITIALIZER);
 }

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';
@@ -8,7 +8,7 @@ import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from
 import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
 
 /** Contract artifact including its artifact hash */
-type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
 
 const cmpFunctionArtifacts = <T extends { selector: FunctionSelector }>(a: T, b: T) =>
   a.selector.toField().cmp(b.selector.toField());
@@ -35,8 +35,8 @@ export async function getContractClassFromArtifact(
 
   privateArtifactFunctions.sort(cmpFunctionArtifacts);
 
-  const contractClass: ContractClass = {
-    version: 1,
+  const contractClass = {
+    version: 1 as const,
     artifactHash,
     packedBytecode,
     privateFunctions: privateArtifactFunctions,

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 { DomainSeparator, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';
 
@@ -13,10 +13,10 @@ import { computePrivateFunctionsRoot } from './private_function.js';
  *
  * ```
  * version = 1
- * private_function_leaves = private_functions.map(fn => pedersen([fn.function_selector as Field, fn.vk_hash], GENERATOR__FUNCTION_LEAF))
+ * private_function_leaves = private_functions.map(fn => poseidon2(DOM_SEP__PRIVATE_FUNCTION_LEAF, [fn.function_selector as Field, fn.vk_hash]))
  * private_functions_root = merkleize(private_function_leaves)
  * bytecode_commitment = calculate_commitment(packed_bytecode)
- * contract_class_id = pedersen([version, artifact_hash, private_functions_root, bytecode_commitment], GENERATOR__CLASS_IDENTIFIER)
+ * contract_class_id = poseidon2(DOM_SEP__CONTRACT_CLASS_ID, [version, artifact_hash, private_functions_root, bytecode_commitment])
  * ```
  * @param contractClass - Contract class.
  * @returns The identifier.
@@ -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
+    DomainSeparator.CONTRACT_CLASS_ID,
   );
   return { id, artifactHash, privateFunctionsRoot, publicBytecodeCommitment };
 }
@@ -60,7 +60,7 @@ export type ContractClassIdPreimage = {
 };
 
 export async function computePublicBytecodeCommitment(packedBytecode: Buffer) {
-  // Encode the buffer into field elements (chunked into 32 bytes each)
+  // Encode the buffer into field elements (chunked into 31 bytes each)
   // The first element is the length of the bytecode (in bytes)
   const [bytecodeLengthAsField, ...bytecodeAsFields] = bufferAsFields(
     packedBytecode,
@@ -72,5 +72,6 @@ export async function computePublicBytecodeCommitment(packedBytecode: Buffer) {
 
   // NOTE: hash the bytecode here only up to the actual length of the bytecode.
   // We do not hash the entire max bytecode length!
-  return await poseidon2HashWithSeparator(bytecodeAsFields.slice(0, bytecodeLength), GeneratorIndex.PUBLIC_BYTECODE);
+  const sep = BigInt(DomainSeparator.PUBLIC_BYTECODE) + (bytecodeLengthAsField.toBigInt() << 32n);
+  return await poseidon2HashWithSeparator(bytecodeAsFields.slice(0, bytecodeLength), new Fr(sep).toNumber());
 }

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';
 
@@ -20,7 +20,7 @@ import {
 } from './contract_address.js';
 import type { ContractInstance, ContractInstanceWithAddress } from './interfaces/contract_instance.js';
 
-const VERSION = 1 as const;
+const VERSION = 2 as const;
 
 export type ContractInstantiationData = {
   constructorArtifact?: FunctionAbi | string;
@@ -29,6 +29,7 @@ export type ContractInstantiationData = {
   salt: Fr;
   publicKeys?: PublicKeys;
   deployer?: AztecAddress;
+  immutablesHash?: Fr;
 };
 
 export class SerializableContractInstance {
@@ -38,6 +39,7 @@ export class SerializableContractInstance {
   public readonly currentContractClassId: Fr;
   public readonly originalContractClassId: Fr;
   public readonly initializationHash: Fr;
+  public readonly immutablesHash: Fr;
   public readonly publicKeys: PublicKeys;
 
   constructor(instance: ContractInstance) {
@@ -49,6 +51,7 @@ export class SerializableContractInstance {
     this.currentContractClassId = instance.currentContractClassId;
     this.originalContractClassId = instance.originalContractClassId;
     this.initializationHash = instance.initializationHash;
+    this.immutablesHash = instance.immutablesHash;
     this.publicKeys = instance.publicKeys;
   }
 
@@ -60,6 +63,7 @@ export class SerializableContractInstance {
       this.currentContractClassId,
       this.originalContractClassId,
       this.initializationHash,
+      this.immutablesHash,
       this.publicKeys,
     );
   }
@@ -78,6 +82,7 @@ export class SerializableContractInstance {
       currentContractClassId: reader.readObject(Fr),
       originalContractClassId: reader.readObject(Fr),
       initializationHash: reader.readObject(Fr),
+      immutablesHash: reader.readObject(Fr),
       publicKeys: reader.readObject(PublicKeys),
     });
   }
@@ -90,6 +95,7 @@ export class SerializableContractInstance {
       currentContractClassId: Fr.random(),
       originalContractClassId: Fr.random(),
       initializationHash: Fr.random(),
+      immutablesHash: Fr.random(),
       publicKeys: await PublicKeys.random(),
       ...opts,
     });
@@ -103,6 +109,7 @@ export class SerializableContractInstance {
       currentContractClassId: Fr.zero(),
       originalContractClassId: Fr.zero(),
       initializationHash: Fr.zero(),
+      immutablesHash: Fr.zero(),
       publicKeys: PublicKeys.default(),
     });
   }
@@ -130,15 +137,17 @@ export async function getContractInstanceFromInstantiationParams(
         )
       : await computeInitializationHash(constructorArtifact, args);
   const publicKeys = opts.publicKeys ?? PublicKeys.default();
+  const immutablesHash = opts.immutablesHash ?? Fr.ZERO;
 
   const instance: ContractInstance = {
     currentContractClassId: contractClass.id,
     originalContractClassId: contractClass.id,
     initializationHash,
+    immutablesHash,
     publicKeys,
     salt: opts.salt,
     deployer,
-    version: 1,
+    version: 2,
   };
 
   return { ...instance, address: await computeContractAddressFromInstance(instance) };

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

@@ -1,14 +1,11 @@
 export * from './artifact_hash.js';
 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';
 export * from './private_function.js';
-export * from './private_function_membership_proof.js';
-export * from './utility_function_membership_proof.js';
 export * from './interfaces/index.js';
 export * from './contract_function_dao.js';
 export * from './partial_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,85 +35,21 @@ export interface PrivateFunction {
   vkHash: Fr;
 }
 
-const PrivateFunctionSchema = z.object({
-  selector: FunctionSelector.schema,
-  vkHash: schemas.Fr,
-}) satisfies ZodFor<PrivateFunction>;
-
-/** Private function definition with executable bytecode. */
-export interface ExecutablePrivateFunction extends PrivateFunction {
-  /** ACIR and Brillig bytecode */
-  bytecode: Buffer;
-}
-
-const ExecutablePrivateFunctionSchema = PrivateFunctionSchema.and(
-  z.object({ bytecode: schemas.Buffer }),
-) satisfies ZodFor<ExecutablePrivateFunction>;
-
-/** Utility function definition. */
-export interface UtilityFunction {
-  /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
-  selector: FunctionSelector;
-  /** Brillig. */
-  bytecode: Buffer;
-}
-
-const UtilityFunctionSchema = z.object({
-  /** lala */
-  selector: FunctionSelector.schema,
-  bytecode: schemas.Buffer,
-}) satisfies ZodFor<UtilityFunction>;
-
-/** Sibling paths and sibling commitments for proving membership of a private function within a contract class. */
-export type PrivateFunctionMembershipProof = {
-  artifactMetadataHash: Fr;
-  functionMetadataHash: Fr;
-  utilityFunctionsTreeRoot: Fr;
-  privateFunctionTreeSiblingPath: Fr[];
-  privateFunctionTreeLeafIndex: number;
-  artifactTreeSiblingPath: Fr[];
-  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>;
-
-/** A private function with a membership proof. */
-export type ExecutablePrivateFunctionWithMembershipProof = ExecutablePrivateFunction & PrivateFunctionMembershipProof;
-
-/** Sibling paths and commitments for proving membership of a utility  function within a contract class. */
-export type UtilityFunctionMembershipProof = {
-  artifactMetadataHash: Fr;
-  functionMetadataHash: Fr;
-  privateFunctionsArtifactTreeRoot: Fr;
-  artifactTreeSiblingPath: Fr[];
-  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>;
-
-/** 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>;
+const PrivateFunctionSchema = zodFor<PrivateFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    vkHash: schemas.Fr,
+  }),
+);
+
+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,28 +64,43 @@ 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 = {
-  privateFunctions: ExecutablePrivateFunctionWithMembershipProof[];
-  utilityFunctions: UtilityFunctionWithMembershipProof[];
-} & Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
+/** A contract class with public bytecode information. */
+export type ContractClassPublic = Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
   Omit<ContractClass, 'privateFunctions'>;
 
 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,
+    })
+    .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),
+    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,12 +1,12 @@
-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;
+const VERSION = 2 as const;
 
 /**
  * A contract instance is a concrete deployment of a contract class. It always references a contract class,
@@ -26,22 +26,58 @@ export interface ContractInstance {
   originalContractClassId: Fr;
   /** Hash of the selector and arguments to the constructor. */
   initializationHash: Fr;
+  /** Hash of Immutables Values the contract is deployed with. */
+  immutablesHash: Fr;
   /** Public keys associated with this instance. */
   publicKeys: PublicKeys;
 }
 
 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,
+    immutablesHash: 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: 2,
+    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),
+    immutablesHash: Fr.fromPlainObject(obj.immutablesHash),
+    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,
+  };
+}