@aztec/stdlib 0.0.1-commit.b33fc05d0 → 0.0.1-commit.b3d3157a

package/src/checkpoint/checkpoint_reexecution_tracker.ts

@@ -0,0 +1,167 @@
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+/**
+ * Outcome of attempting to re-execute a checkpoint proposal locally.
+ *
+ * - `valid`        — re-execution succeeded and the computed checkpoint matched the proposal.
+ * - `invalid`      — the proposal disagreed with the computed checkpoint, or violated a deterministic
+ *                    constraint (limits, signatures, etc).
+ * - `unvalidated`  — the local node could not complete validation for non-deterministic reasons
+ *                    (missing blocks/txs, timeouts, infra errors). Treated as proposer-fault for
+ *                    slashing but surfaced separately for telemetry.
+ */
+export type ReexecutionOutcome = 'valid' | 'invalid' | 'unvalidated';
+
+/**
+ * Tracks two pieces of per-slot state collected during proposal handling:
+ *
+ *  1. Whether each block proposal's transactions were successfully collected locally
+ *     (keyed by `slot` + `indexWithinCheckpoint`). Consumed by the data-withholding watcher.
+ *  2. The outcome of locally re-executing each checkpoint proposal (keyed by
+ *     `(checkpointNumber, archiveRoot)` and by `slot`). Consumed by the data-withholding
+ *     watcher (via `hasReexecuted`) and the sentinel (via `getOutcomeForSlot`).
+ *
+ * Both pieces of state live on the same per-slot `Entry`, so cleanup via `removeBefore`
+ * naturally drops everything for a pruned slot in one step.
+ */
+interface Entry {
+  // Set by recordOutcome — these may be undefined until the checkpoint proposal has been
+  // evaluated. recordTxsCollected may create an Entry before any of them are known.
+  checkpointNumber: CheckpointNumber | undefined;
+  archiveRoot: string | undefined;
+  outcome: ReexecutionOutcome | undefined;
+
+  slot: SlotNumber;
+
+  // Per block-proposal at this slot: indexWithinCheckpoint → true (collected) | false (failed to collect).
+  txsCollected: Map<number, boolean>;
+}
+
+export class CheckpointReexecutionTracker {
+  private readonly byCheckpoint = new Map<CheckpointNumber, Map<string, Entry>>();
+  private readonly bySlot = new Map<SlotNumber, Entry>();
+
+  /**
+   * Record the outcome of evaluating a checkpoint proposal.
+   * @param slot - Slot the proposal was for. Always required.
+   * @param archiveRoot - Archive root in the proposal.
+   * @param outcome - Outcome of evaluation.
+   * @param checkpointNumber - Checkpoint number, if known. Required for `valid` outcomes; optional
+   *   for `invalid`/`unvalidated` because some early rejections fire before blocks are loaded.
+   */
+  public recordOutcome(
+    slot: SlotNumber,
+    archiveRoot: Fr,
+    outcome: ReexecutionOutcome,
+    checkpointNumber?: CheckpointNumber,
+  ): void {
+    const archiveRootStr = archiveRoot.toString();
+
+    // Preserve any per-block txsCollected already accumulated for this slot.
+    const existing = this.bySlot.get(slot);
+    const entry: Entry = {
+      checkpointNumber,
+      archiveRoot: archiveRootStr,
+      slot,
+      outcome,
+      txsCollected: existing?.txsCollected ?? new Map(),
+    };
+
+    if (checkpointNumber !== undefined) {
+      let archives = this.byCheckpoint.get(checkpointNumber);
+      if (!archives) {
+        archives = new Map();
+        this.byCheckpoint.set(checkpointNumber, archives);
+      }
+      archives.set(archiveRootStr, entry);
+    }
+
+    this.bySlot.set(slot, entry);
+  }
+
+  /**
+   * Record whether the local node successfully collected the transactions for a block proposal.
+   * Called from the validator's proposal handler immediately after tx collection completes
+   * (regardless of whether re-execution will subsequently succeed). The data-withholding
+   * watcher consults these records as an authoritative signal: tx availability now is too
+   * weak (txs may have been evicted from the mempool by the time the watcher runs), but a
+   * record that the txs *were* available at proposal time still vouches for the proposer.
+   *
+   * @param slot - Slot the block proposal was for.
+   * @param indexWithinCheckpoint - Index of the block within its enclosing checkpoint.
+   * @param collected - True if every tx in the proposal was collected locally before deadline.
+   */
+  public recordTxsCollected(slot: SlotNumber, indexWithinCheckpoint: number, collected: boolean): void {
+    let entry = this.bySlot.get(slot);
+    if (!entry) {
+      entry = {
+        checkpointNumber: undefined,
+        archiveRoot: undefined,
+        slot,
+        outcome: undefined,
+        txsCollected: new Map(),
+      };
+      this.bySlot.set(slot, entry);
+    }
+    entry.txsCollected.set(indexWithinCheckpoint, collected);
+  }
+
+  /**
+   * Returns true if the given (checkpoint number, archive root) has been successfully
+   * re-executed locally (outcome `valid`).
+   */
+  public hasReexecuted(checkpointNumber: CheckpointNumber, archiveRoot: Fr): boolean {
+    return this.byCheckpoint.get(checkpointNumber)?.get(archiveRoot.toString())?.outcome === 'valid';
+  }
+
+  /** Returns the recorded outcome for a given slot, or undefined if no proposal was evaluated. */
+  public getOutcomeForSlot(slot: SlotNumber): ReexecutionOutcome | undefined {
+    return this.bySlot.get(slot)?.outcome;
+  }
+
+  /**
+   * Returns the recorded tx-collection result for a block proposal at the given slot and
+   * `indexWithinCheckpoint`, or `undefined` if no record exists.
+   *
+   * Three-valued by design:
+   *   - `true`      — we collected every tx for this block proposal before the deadline.
+   *   - `false`     — we tried and failed (missing txs at the deadline).
+   *   - `undefined` — no record (e.g. we never saw the block proposal). Callers should fall
+   *                   back to a current-state check (e.g. mempool probe) for this case.
+   */
+  public getTxsCollectedRecord(slot: SlotNumber, indexWithinCheckpoint: number): boolean | undefined {
+    return this.bySlot.get(slot)?.txsCollected.get(indexWithinCheckpoint);
+  }
+
+  /** Drops entries for checkpoints with `number < checkpointNumber`. */
+  public removeBefore(checkpointNumber: CheckpointNumber): void {
+    // Track the highest slot among checkpoints we're pruning. Once we know it, any slot
+    // strictly below that watermark is older than the most recently pruned checkpoint and
+    // can be dropped from `bySlot` too — including slot-only entries (no checkpoint number)
+    // which would otherwise leak, because removing by checkpoint number can't reach them.
+    let maxRemovedSlot: SlotNumber | undefined;
+    for (const [n, archives] of this.byCheckpoint) {
+      if (n < checkpointNumber) {
+        for (const entry of archives.values()) {
+          // Only drop the slot index if it still points at the entry we're removing.
+          if (this.bySlot.get(entry.slot) === entry) {
+            this.bySlot.delete(entry.slot);
+          }
+          if (maxRemovedSlot === undefined || entry.slot > maxRemovedSlot) {
+            maxRemovedSlot = entry.slot;
+          }
+        }
+        this.byCheckpoint.delete(n);
+      }
+    }
+
+    if (maxRemovedSlot !== undefined) {
+      for (const slot of [...this.bySlot.keys()]) {
+        if (slot < maxRemovedSlot) {
+          this.bySlot.delete(slot);
+        }
+      }
+    }
+  }
+}

package/src/checkpoint/digest.ts

@@ -0,0 +1,28 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { type CoordinationSignatureContext, getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+
+/**
+ * Computes the EIP-712 payload digest for a checkpoint proposal — the digest validators sign
+ * and the L1 contract verifies during `propose()`. Mirrors `ProposeLib.digest(ProposePayload)` on L1.
+ *
+ * The result is the same `bytes32` that gets stored in `tempCheckpointLogs[checkpointNumber].payloadDigest`,
+ * so this helper is also reused when constructing simulation state overrides for pipelined proposals.
+ */
+export function computeCheckpointPayloadDigest(args: {
+  header: CheckpointHeader;
+  archiveRoot: Fr;
+  feeAssetPriceModifier: bigint;
+  signatureContext: CoordinationSignatureContext;
+}): Buffer32 {
+  const consensusPayload = new ConsensusPayload(
+    args.header,
+    args.archiveRoot,
+    args.feeAssetPriceModifier,
+    args.signatureContext,
+  );
+  return getHashedSignaturePayloadTypedData(consensusPayload);
+}

package/src/checkpoint/index.ts

@@ -1,5 +1,8 @@
 export * from './checkpoint.js';
 export * from './checkpoint_data.js';
 export * from './checkpoint_info.js';
+export * from './checkpoint_reexecution_tracker.js';
+export * from './digest.js';
+export * from './previous_checkpoint_out_hashes.js';
 export * from './published_checkpoint.js';
 export * from './validate.js';

package/src/checkpoint/previous_checkpoint_out_hashes.ts

@@ -0,0 +1,61 @@
+import { CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { Logger } from '@aztec/foundation/log';
+
+import type { L2BlockSource } from '../block/l2_block_source.js';
+import { type L1RollupConstants, getEpochAtSlot } from '../epoch-helpers/index.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+
+/**
+ * Returns the out hashes (in epoch order) of all checkpoints in `epoch` that precede
+ * `checkpointNumber`, used to compute the `epochOutHash` baked into that checkpoint's header.
+ *
+ * Under proposer pipelining the parent checkpoint may not be confirmed on L1 by the time the
+ * builder runs, so the on-chain archiver query (`getCheckpointsData`) is missing it and the
+ * resulting `epochOutHash` would diverge from what other validators (and L1) compute after the
+ * parent lands. To avoid that, the parent's `checkpointOutHash` is spliced in from the locally
+ * known proposed checkpoint when:
+ *   - pipelining is enabled,
+ *   - the archiver lookup is genuinely short (its last entry is not already cp `N-1`),
+ *   - and the proposed cp `N-1` is in the same target epoch (otherwise we're at an epoch boundary
+ *     and the previous-epoch cps must be excluded).
+ *
+ * Callers may either pass the already-loaded `proposedCheckpointData` (the proposer has it on
+ * hand) or leave it undefined, in which case it's fetched via `getProposedCheckpointData`.
+ */
+export async function getPreviousCheckpointOutHashes(input: {
+  blockSource: Pick<L2BlockSource, 'getCheckpointsData' | 'getProposedCheckpointData'>;
+  epoch: EpochNumber;
+  checkpointNumber: CheckpointNumber;
+  l1Constants: Pick<L1RollupConstants, 'epochDuration'>;
+  pipeliningEnabled: boolean;
+  proposedCheckpointData?: ProposedCheckpointData;
+  log?: Logger;
+}): Promise<Fr[]> {
+  const { blockSource, epoch, checkpointNumber, l1Constants, pipeliningEnabled, log } = input;
+
+  const checkpointed = (await blockSource.getCheckpointsData({ epoch }))
+    .filter(c => c.checkpointNumber < checkpointNumber)
+    .sort((a, b) => a.checkpointNumber - b.checkpointNumber);
+
+  if (!pipeliningEnabled || checkpointNumber === 0) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  const parentCheckpoint = CheckpointNumber(checkpointNumber - 1);
+  if (checkpointed.at(-1)?.checkpointNumber === parentCheckpoint) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  const proposedParent =
+    input.proposedCheckpointData ?? (await blockSource.getProposedCheckpointData({ number: parentCheckpoint }));
+  if (!proposedParent || proposedParent.checkpointNumber !== parentCheckpoint) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+  if (getEpochAtSlot(proposedParent.header.slotNumber, l1Constants) !== epoch) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  log?.debug(`Splicing pipelined parent cp ${parentCheckpoint} outHash for cp ${checkpointNumber}`);
+  return [...checkpointed.map(c => c.checkpointOutHash), proposedParent.checkpointOutHash];
+}

package/src/checkpoint/validate.ts

@@ -36,7 +36,7 @@ export function validateCheckpoint(
 ): void {
   validateCheckpointStructure(checkpoint);
   validateCheckpointLimits(checkpoint, opts);
-  validateCheckpointBlocksGasLimits(checkpoint, opts);
+  validateCheckpointBlocksLimits(checkpoint, opts);
 }
 
 /**
@@ -125,7 +125,7 @@ export function validateCheckpointStructure(checkpoint: Checkpoint): void {
 }
 
 /** Validates checkpoint blocks gas limits */
-function validateCheckpointBlocksGasLimits(
+function validateCheckpointBlocksLimits(
   checkpoint: Checkpoint,
   opts: {
     maxL2BlockGas?: number;

package/src/config/chain-config.ts

@@ -1,5 +1,5 @@
-import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
-import type { ConfigMappingsType } from '@aztec/foundation/config';
+import { type L1ContractAddresses, pickL1ContractAddressMappings } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
@@ -7,26 +7,28 @@ export { type AllowedElement } from '../interfaces/allowed_element.js';
 
 export const emptyChainConfig: ChainConfig = {
   l1ChainId: 0,
-  l1Contracts: { rollupAddress: EthAddress.ZERO },
   rollupVersion: 0,
+  rollupAddress: EthAddress.ZERO,
 };
 
 export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
   l1ChainId: {
     env: 'L1_CHAIN_ID',
-    parseEnv: (val: string) => +val,
-    defaultValue: 31337,
+    ...numberConfigHelper(31337),
     description: 'The chain ID of the ethereum host.',
   },
   rollupVersion: {
     env: 'ROLLUP_VERSION',
     description: 'The version of the rollup.',
-    parseEnv: (val: string) => (Number.isSafeInteger(parseInt(val, 10)) ? parseInt(val, 10) : undefined),
-  },
-  l1Contracts: {
-    description: 'The deployed L1 contract addresses',
-    nested: l1ContractAddressesMapping,
+    parseEnv: (val: string) => {
+      const parsed = parseInt(val, 10);
+      if (!Number.isSafeInteger(parsed)) {
+        throw new Error(`Invalid rollup version: ${val}`);
+      }
+      return parsed;
+    },
   },
+  ...pickL1ContractAddressMappings('rollupAddress'),
 };
 
 /** Chain configuration. */
@@ -35,9 +37,4 @@ export type ChainConfig = {
   l1ChainId: number;
   /** The version of the rollup. */
   rollupVersion: number;
-  /** The address to the L1 contracts. */
-  l1Contracts: {
-    /** The address to rollup */
-    rollupAddress: EthAddress;
-  };
-};
+} & Pick<L1ContractAddresses, 'rollupAddress'>;

package/src/config/sequencer-config.ts

@@ -1,10 +1,19 @@
-import type { ConfigMappingsType } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  floatConfigHelper,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
 
 import type { SequencerConfig } from '../interfaces/configs.js';
+import { DEFAULT_P2P_PROPAGATION_TIME } from '../timetable/index.js';
 
 /** 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
@@ -12,26 +21,45 @@ export const DEFAULT_MAX_TXS_PER_BLOCK = 32;
  * to avoid duplication.
  */
 export const sharedSequencerConfigMappings: ConfigMappingsType<
-  Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock'>
+  Pick<
+    SequencerConfig,
+    | 'blockDurationMs'
+    | 'expectedBlockProposalsPerSlot'
+    | 'maxTxsPerBlock'
+    | 'attestationPropagationTime'
+    | 'maxBlocksPerCheckpoint'
+  >
 > = {
   blockDurationMs: {
     env: 'SEQ_BLOCK_DURATION_MS',
     description:
       'Duration per block in milliseconds when building multiple blocks per slot. ' +
       'If undefined (default), builds a single block per slot using the full slot duration.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    ...optionalNumberConfigHelper(),
   },
   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.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : 0),
-    defaultValue: 0,
+    ...numberConfigHelper(0),
   },
   maxTxsPerBlock: {
     env: 'SEQ_MAX_TX_PER_BLOCK',
     description: 'The maximum number of txs to include in a block.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    ...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),
+  },
+  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/complete_address.ts

@@ -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

@@ -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 =
@@ -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],
-    DomainSeparator.PARTIAL_ADDRESS,
+    [instance.salt, instance.initializationHash, instance.deployer, instance.immutablesHash],
+    DomainSeparator.SALTED_INITIALIZATION_HASH,
   );
 }
 

package/src/contract/contract_class_id.ts

@@ -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__PRIVATE_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.

package/src/contract/contract_instance.ts

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

@@ -6,8 +6,6 @@ export * from './contract_deployment_data.js';
 export * from './contract_instance.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';