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

package/src/config/sequencer-config.ts

@@ -0,0 +1,96 @@
+import {
+  type ConfigMappingsType,
+  floatConfigHelper,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
+
+import type { SequencerConfig } from '../interfaces/configs.js';
+import {
+  DEFAULT_BLOCK_DURATION,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+  getDefaultCheckpointProposalSyncGrace,
+} from '../timetable/index.js';
+
+/** Default duration per block in milliseconds, used to derive how many blocks fit in a slot. */
+export const DEFAULT_BLOCK_DURATION_MS = DEFAULT_BLOCK_DURATION * 1000;
+
+/** Default maximum number of transactions per block. */
+export const DEFAULT_MAX_TXS_PER_BLOCK = 32;
+
+/** Default maximum number of blocks the sequencer packs into a single checkpoint. */
+export const DEFAULT_MAX_BLOCKS_PER_CHECKPOINT = 24;
+
+/**
+ * Partial sequencer config mappings for fields that need to be shared across packages.
+ * The full sequencer config mappings remain in sequencer-client, but shared fields
+ * (like blockDurationMs needed by both p2p and sequencer-client) are defined here
+ * to avoid duplication.
+ */
+export const sharedSequencerConfigMappings: ConfigMappingsType<
+  Pick<
+    SequencerConfig,
+    | 'blockDurationMs'
+    | 'checkpointProposalSyncGraceSeconds'
+    | 'expectedBlockProposalsPerSlot'
+    | 'maxTxsPerBlock'
+    | 'attestationPropagationTime'
+    | 'checkpointProposalPrepareTime'
+    | 'minBlockDuration'
+    | 'maxBlocksPerCheckpoint'
+  >
+> = {
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description: 'Duration per block in milliseconds, used to derive how many blocks fit in a slot.',
+    ...numberConfigHelper(DEFAULT_BLOCK_DURATION_MS),
+  },
+  expectedBlockProposalsPerSlot: {
+    env: 'SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT',
+    description:
+      'Expected number of block proposals per slot for P2P peer scoring. ' +
+      '0 (default) disables block proposal scoring. Set to a positive value to enable.',
+    ...numberConfigHelper(0),
+  },
+  checkpointProposalSyncGraceSeconds: {
+    env: 'CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS',
+    description:
+      'Consensus grace in seconds for a received checkpoint proposal to materialize into local proposed state. ' +
+      'Defaults to twice the block duration.',
+    defaultValue: getDefaultCheckpointProposalSyncGrace(DEFAULT_BLOCK_DURATION_MS / 1000),
+    ...optionalNumberConfigHelper(),
+  },
+  maxTxsPerBlock: {
+    env: 'SEQ_MAX_TX_PER_BLOCK',
+    description: 'The maximum number of txs to include in a block.',
+    ...optionalNumberConfigHelper(),
+  },
+  attestationPropagationTime: {
+    env: 'SEQ_ATTESTATION_PROPAGATION_TIME',
+    description: 'How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way).',
+    defaultValue: DEFAULT_P2P_PROPAGATION_TIME,
+    ...floatConfigHelper(DEFAULT_P2P_PROPAGATION_TIME),
+  },
+  checkpointProposalPrepareTime: {
+    env: 'SEQ_CHECKPOINT_PROPOSAL_PREPARE_TIME',
+    description:
+      'Local time in seconds between the last block build finishing and the checkpoint proposal being ready for p2p send.',
+    defaultValue: DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    ...floatConfigHelper(DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME),
+  },
+  minBlockDuration: {
+    env: 'SEQ_MIN_BLOCK_DURATION',
+    description: 'Minimum block-building time in seconds still worth allocating if the proposer starts late.',
+    defaultValue: DEFAULT_MIN_BLOCK_DURATION,
+    ...floatConfigHelper(DEFAULT_MIN_BLOCK_DURATION),
+  },
+  maxBlocksPerCheckpoint: {
+    env: 'MAX_BLOCKS_PER_CHECKPOINT',
+    description:
+      'Maximum number of blocks the sequencer packs into a single checkpoint, and the maximum indexWithinCheckpoint accepted on inbound block proposals.',
+    parseEnv: (val: string) => parseInt(val, 10),
+    defaultValue: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
+  },
+};

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';
@@ -38,7 +38,8 @@ export class CompleteAddress {
   }
 
   /** Size in bytes of an instance */
-  static readonly SIZE_IN_BYTES = 32 * 10;
+  // address (1 Fr) + publicKeys (1 Fr hash + 1 Point + 4 Fr hashes = 7 Fr) + partialAddress (1 Fr) = 9 Fr
+  static readonly SIZE_IN_BYTES = 32 * 9;
 
   static get schema() {
     return hexSchemaFor(CompleteAddress);
@@ -54,8 +55,11 @@ export class CompleteAddress {
 
   static async fromSecretKeyAndPartialAddress(secretKey: Fr, partialAddress: Fr): Promise<CompleteAddress> {
     const { publicKeys } = await deriveKeys(secretKey);
-    const address = await computeAddress(publicKeys, partialAddress);
+    return await this.fromPublicKeysAndPartialAddress(publicKeys, partialAddress);
+  }
 
+  static async fromPublicKeysAndPartialAddress(publicKeys: PublicKeys, partialAddress: Fr): Promise<CompleteAddress> {
+    const address = await computeAddress(publicKeys, partialAddress);
     return new CompleteAddress(address, publicKeys, partialAddress);
   }
 
@@ -87,7 +91,7 @@ export class CompleteAddress {
    * @returns A readable string representation of the complete address.
    */
   public toReadableString(): string {
-    return `Address: ${this.address.toString()}\nMaster Nullifier Public Key: ${this.publicKeys.masterNullifierPublicKey.toString()}\nMaster Incoming Viewing Public Key: ${this.publicKeys.masterIncomingViewingPublicKey.toString()}\nMaster Outgoing Viewing Public Key: ${this.publicKeys.masterOutgoingViewingPublicKey.toString()}\nMaster Tagging Public Key: ${this.publicKeys.masterTaggingPublicKey.toString()}\nPartial Address: ${this.partialAddress.toString()}\n`;
+    return `Address: ${this.address.toString()}\nNpkM hash: ${this.publicKeys.npkMHash.toString()}\nIvpkM: ${this.publicKeys.ivpkM.toString()}\nOvpkM hash: ${this.publicKeys.ovpkMHash.toString()}\nTpkM hash: ${this.publicKeys.tpkMHash.toString()}\nMspkM hash: ${this.publicKeys.mspkMHash.toString()}\nFbpkM hash: ${this.publicKeys.fbpkMHash.toString()}\nPartial Address: ${this.partialAddress.toString()}\n`;
   }
 
   /**

package/src/contract/contract_address.ts

@@ -1,27 +1,28 @@
-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';
 import { computeVarArgsHash } from '../hash/hash.js';
 import { computeAddress } from '../keys/index.js';
-import type { ContractInstance } from './interfaces/contract_instance.js';
+import type { ContractInstance, ContractInstancePreimage } from './interfaces/contract_instance.js';
+import type { PartialAddress } from './partial_address.js';
 
 // TODO(@spalladino): Review all generator indices in this file
 
 /**
  * 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.
  */
 export async function computeContractAddressFromInstance(
   instance:
-    | ContractInstance
+    | ContractInstancePreimage
     | ({ originalContractClassId: Fr; saltedInitializationHash: Fr } & Pick<ContractInstance, 'publicKeys'>),
 ): Promise<AztecAddress> {
   const partialAddress = await computePartialAddress(instance);
@@ -34,9 +35,9 @@ 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> {
+): Promise<PartialAddress> {
   const saltedInitializationHash =
     'saltedInitializationHash' in instance
       ? instance.saltedInitializationHash
@@ -44,7 +45,7 @@ export async function computePartialAddress(
 
   return poseidon2HashWithSeparator(
     [instance.originalContractClassId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
 }
 
@@ -53,11 +54,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 +88,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,6 @@
-import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { CircuitKind } from '@aztec/bb.js';
+import { vkAsFields } 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 +9,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 +36,8 @@ export async function getContractClassFromArtifact(
 
   privateArtifactFunctions.sort(cmpFunctionArtifacts);
 
-  const contractClass: ContractClass = {
-    version: 1,
+  const contractClass = {
+    version: 1 as const,
     artifactHash,
     packedBytecode,
     privateFunctions: privateArtifactFunctions,
@@ -60,5 +61,5 @@ export async function computeVerificationKeyHash(f: FunctionArtifact) {
   if (!f.verificationKey) {
     throw new Error(`Private function ${f.name} must have a verification key`);
   }
-  return hashVK(await vkAsFieldsMegaHonk(Buffer.from(f.verificationKey, 'base64')));
+  return hashVK(await vkAsFields(Buffer.from(f.verificationKey, 'base64'), CircuitKind.App));
 }

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';
 
@@ -18,9 +18,14 @@ import {
   computeInitializationHash,
   computeInitializationHashFromEncodedArgs,
 } from './contract_address.js';
-import type { ContractInstance, ContractInstanceWithAddress } from './interfaces/contract_instance.js';
+import type {
+  ContractInstance,
+  ContractInstancePreimage,
+  ContractInstancePreimageWithAddress,
+  ContractInstanceWithAddress,
+} from './interfaces/contract_instance.js';
 
-const VERSION = 1 as const;
+const VERSION = 2 as const;
 
 export type ContractInstantiationData = {
   constructorArtifact?: FunctionAbi | string;
@@ -29,6 +34,7 @@ export type ContractInstantiationData = {
   salt: Fr;
   publicKeys?: PublicKeys;
   deployer?: AztecAddress;
+  immutablesHash?: Fr;
 };
 
 export class SerializableContractInstance {
@@ -38,6 +44,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 +56,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 +68,7 @@ export class SerializableContractInstance {
       this.currentContractClassId,
       this.originalContractClassId,
       this.initializationHash,
+      this.immutablesHash,
       this.publicKeys,
     );
   }
@@ -78,6 +87,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 +100,7 @@ export class SerializableContractInstance {
       currentContractClassId: Fr.random(),
       originalContractClassId: Fr.random(),
       initializationHash: Fr.random(),
+      immutablesHash: Fr.random(),
       publicKeys: await PublicKeys.random(),
       ...opts,
     });
@@ -103,11 +114,68 @@ export class SerializableContractInstance {
       currentContractClassId: Fr.zero(),
       originalContractClassId: Fr.zero(),
       initializationHash: Fr.zero(),
+      immutablesHash: Fr.zero(),
       publicKeys: PublicKeys.default(),
     });
   }
 }
 
+export class SerializableContractInstancePreimage {
+  public readonly version = VERSION;
+  public readonly salt: Fr;
+  public readonly deployer: AztecAddress;
+  public readonly originalContractClassId: Fr;
+  public readonly initializationHash: Fr;
+  public readonly immutablesHash: Fr;
+  public readonly publicKeys: PublicKeys;
+
+  constructor(instance: ContractInstancePreimage) {
+    if (instance.version !== VERSION) {
+      throw new Error(`Unexpected contract class version ${instance.version}`);
+    }
+    this.salt = instance.salt;
+    this.deployer = instance.deployer;
+    this.originalContractClassId = instance.originalContractClassId;
+    this.initializationHash = instance.initializationHash;
+    this.immutablesHash = instance.immutablesHash;
+    this.publicKeys = instance.publicKeys;
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(
+      numToUInt8(this.version),
+      this.salt,
+      this.deployer,
+      this.originalContractClassId,
+      this.initializationHash,
+      this.immutablesHash,
+      this.publicKeys,
+    );
+  }
+
+  /** Returns a copy of this object with its address included. */
+  withAddress(address: AztecAddress): ContractInstancePreimageWithAddress {
+    return { ...this, address };
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): SerializableContractInstancePreimage {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const version = reader.readUInt8();
+    if (version !== VERSION) {
+      throw new Error(`Unexpected contract instance preimage version ${version}`);
+    }
+    return new SerializableContractInstancePreimage({
+      version: VERSION,
+      salt: reader.readObject(Fr),
+      deployer: reader.readObject(AztecAddress),
+      originalContractClassId: reader.readObject(Fr),
+      initializationHash: reader.readObject(Fr),
+      immutablesHash: reader.readObject(Fr),
+      publicKeys: reader.readObject(PublicKeys),
+    });
+  }
+}
+
 /**
  * Generates a Contract Instance from some instantiation params.
  * @param artifact - The account contract build artifact.
@@ -130,15 +198,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/index.ts

@@ -1,16 +1,12 @@
 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';
-export * from './deployment_info.js';
 export * from './complete_address.js';