@aztec/stdlib 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/config/network-consensus-config.ts

@@ -0,0 +1,302 @@
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type EnvVar, pickConfigMappings } from '@aztec/foundation/config';
+
+import type { SequencerConfig } from '../interfaces/configs.js';
+import {
+  DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+} from '../timetable/budgets.js';
+import { ProposerTimetable } from '../timetable/proposer_timetable.js';
+import { sharedSequencerConfigMappings } from './sequencer-config.js';
+
+/**
+ * Environment variables whose values must be identical across every node of a network. They fall into three
+ * categories, all consensus-critical:
+ *
+ * - Timing/protocol consensus: slot and epoch durations, block sub-slot duration, max blocks per checkpoint, and
+ *   the checkpoint-proposal materialization grace. Proposers and validators must agree on these to land on the
+ *   same proposed chain and the same checkpoint-proposal receive/handoff deadlines.
+ * - Network identity and L1-posted deployment params: the L1 chain id and the staking/governance/slashing
+ *   parameters baked into the deployed rollup contract (committee size, lags, thresholds, mana target, fee
+ *   pricing, governance/slashing round sizes, quorums, slash amounts, etc.). A node disagreeing with the rollup
+ *   it points at would compute the wrong epoch geometry, fees, or slashing rounds.
+ * - Node-side slashing offense consensus: the offense detection/penalty parameters validators apply locally to
+ *   decide which payloads to sign. Validators must agree on these to reach the on-chain slashing quorum.
+ *
+ * Deliberately excluded: bootnodes, P2P/store/OTEL/sentinel settings, SEQ_MIN_TX_PER_BLOCK, SEQ_MAX_TX_PER_*,
+ * AZTEC_SLASHER_ENABLED, PROVER_REAL_PROOFS, TRANSACTIONS_DISABLED, and AZTEC_ENTRY_QUEUE_* (mainnet-only genesis
+ * params enforced by L1).
+ */
+export const NETWORK_CONSENSUS_ENV_VARS = [
+  // Timing/protocol consensus.
+  'ETHEREUM_SLOT_DURATION',
+  'AZTEC_SLOT_DURATION',
+  'AZTEC_EPOCH_DURATION',
+  'SEQ_BLOCK_DURATION_MS',
+  'MAX_BLOCKS_PER_CHECKPOINT',
+  'CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS',
+
+  // Network identity / L1-posted deployment params.
+  'L1_CHAIN_ID',
+  'AZTEC_TARGET_COMMITTEE_SIZE',
+  'AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET',
+  'AZTEC_LAG_IN_EPOCHS_FOR_RANDAO',
+  'AZTEC_ACTIVATION_THRESHOLD',
+  'AZTEC_EJECTION_THRESHOLD',
+  'AZTEC_LOCAL_EJECTION_THRESHOLD',
+  'AZTEC_EXIT_DELAY_SECONDS',
+  'AZTEC_INBOX_LAG',
+  'AZTEC_PROOF_SUBMISSION_EPOCHS',
+  'AZTEC_MANA_TARGET',
+  'AZTEC_PROVING_COST_PER_MANA',
+  'AZTEC_INITIAL_ETH_PER_FEE_ASSET',
+  'AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE',
+  'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
+  'AZTEC_SLASHING_QUORUM',
+  'AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS',
+  'AZTEC_SLASHING_LIFETIME_IN_ROUNDS',
+  'AZTEC_SLASHING_OFFSET_IN_ROUNDS',
+  'AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS',
+  'AZTEC_SLASHING_VETOER',
+  'AZTEC_SLASHING_DISABLE_DURATION',
+  'AZTEC_SLASH_AMOUNT_SMALL',
+  'AZTEC_SLASH_AMOUNT_MEDIUM',
+  'AZTEC_SLASH_AMOUNT_LARGE',
+
+  // Node-side slashing offense consensus.
+  'SLASH_OFFENSE_EXPIRATION_ROUNDS',
+  'SLASH_MAX_PAYLOAD_SIZE',
+  'SLASH_EXECUTE_ROUNDS_LOOK_BACK',
+  'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+  'SLASH_DATA_WITHHOLDING_PENALTY',
+  'SLASH_INACTIVITY_TARGET_PERCENTAGE',
+  'SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD',
+  'SLASH_INACTIVITY_PENALTY',
+  'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+  'SLASH_DUPLICATE_PROPOSAL_PENALTY',
+  'SLASH_DUPLICATE_ATTESTATION_PENALTY',
+  'SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY',
+  'SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+  'SLASH_UNKNOWN_PENALTY',
+  'SLASH_INVALID_BLOCK_PENALTY',
+  'SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+  'SLASH_GRACE_PERIOD_L2_SLOTS',
+] as const satisfies readonly EnvVar[];
+
+/** A consensus-critical environment variable name; see {@link NETWORK_CONSENSUS_ENV_VARS}. */
+export type ConsensusEnvVar = (typeof NETWORK_CONSENSUS_ENV_VARS)[number];
+
+/**
+ * The subset of consensus-critical timing config whose geometry can be validated in isolation. Composed by
+ * picking the canonical fields from their owning config types so the field set never drifts from the config
+ * layer: slot durations from {@link L1ContractsConfig}, block sub-slot/checkpoint timings from
+ * {@link SequencerConfig} (whose fields are optional there, hence `Required`).
+ */
+export type NetworkConsensusConfig = Pick<L1ContractsConfig, 'aztecSlotDuration' | 'ethereumSlotDuration'> &
+  Required<Pick<SequencerConfig, 'blockDurationMs' | 'maxBlocksPerCheckpoint' | 'checkpointProposalSyncGraceSeconds'>>;
+
+/** Config mappings for the slot-timing fields of {@link NetworkConsensusConfig}, picked from their owners. */
+const networkConsensusConfigMappings = {
+  ...pickConfigMappings(l1ContractsConfigMappings, ['aztecSlotDuration', 'ethereumSlotDuration']),
+  ...pickConfigMappings(sharedSequencerConfigMappings, [
+    'blockDurationMs',
+    'maxBlocksPerCheckpoint',
+    'checkpointProposalSyncGraceSeconds',
+  ]),
+};
+
+/**
+ * Extracts the timing {@link NetworkConsensusConfig} from a generated network config object. The env-var names
+ * and the per-field parsing both come from the canonical config mappings (`l1ContractsConfigMappings` and
+ * `sharedSequencerConfigMappings`), so each field is parsed exactly as the node's config layer would parse it.
+ * A field whose env var is absent becomes `NaN`, which {@link validateNetworkConsensusConfig} reports as an
+ * error. Never throws: parse helpers that would throw or yield `undefined` are coerced to `NaN`.
+ */
+export function getConsensusConfigFromNetworkEnv(
+  values: Record<string, string | number | boolean>,
+): NetworkConsensusConfig {
+  const result = {} as Record<keyof NetworkConsensusConfig, number>;
+  for (const [field, mapping] of Object.entries(networkConsensusConfigMappings)) {
+    const raw = mapping.env !== undefined ? values[mapping.env] : undefined;
+    if (raw === undefined) {
+      result[field as keyof NetworkConsensusConfig] = NaN;
+      continue;
+    }
+    let parsed: number | undefined;
+    try {
+      parsed = mapping.parseEnv ? mapping.parseEnv(String(raw)) : Number(raw);
+    } catch {
+      parsed = NaN;
+    }
+    result[field as keyof NetworkConsensusConfig] = parsed ?? NaN;
+  }
+  return result;
+}
+
+/**
+ * Validates a {@link NetworkConsensusConfig} for self-consistency, returning a list of error messages (empty
+ * when valid). Used by the cli unit test that gates the generated network configs.
+ *
+ * The check requires `maxBlocksPerCheckpoint` to be *exactly* what a {@link ProposerTimetable} built from the
+ * same slot timings and the production default budgets derives. This exact-equality requirement ensures the
+ * published network value is precisely what the production default budgets produce, so every node running those
+ * defaults agrees on the per-checkpoint block count without clamping.
+ */
+export function validateNetworkConsensusConfig(config: NetworkConsensusConfig): string[] {
+  const errors: string[] = [];
+
+  for (const [field, value] of Object.entries(config)) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      errors.push(`${field} must be a finite number (got ${value})`);
+    }
+  }
+  if (errors.length > 0) {
+    return errors;
+  }
+
+  if (config.ethereumSlotDuration <= 0) {
+    errors.push(`ethereumSlotDuration must be positive (got ${config.ethereumSlotDuration})`);
+  }
+  if (config.blockDurationMs <= 0) {
+    errors.push(`blockDurationMs must be positive (got ${config.blockDurationMs})`);
+  }
+  if (config.aztecSlotDuration <= 0) {
+    errors.push(`aztecSlotDuration must be positive (got ${config.aztecSlotDuration})`);
+  }
+  if (config.ethereumSlotDuration > 0 && config.aztecSlotDuration % config.ethereumSlotDuration !== 0) {
+    errors.push(
+      `aztecSlotDuration (${config.aztecSlotDuration}s) must be a multiple of ethereumSlotDuration ` +
+        `(${config.ethereumSlotDuration}s)`,
+    );
+  }
+  if (config.blockDurationMs / 1000 > config.aztecSlotDuration) {
+    errors.push(
+      `blockDurationMs (${config.blockDurationMs}ms) exceeds aztecSlotDuration (${config.aztecSlotDuration}s)`,
+    );
+  }
+  if (config.maxBlocksPerCheckpoint < 1) {
+    errors.push(`maxBlocksPerCheckpoint must be at least 1 (got ${config.maxBlocksPerCheckpoint})`);
+  }
+  if (config.checkpointProposalSyncGraceSeconds < 0) {
+    errors.push(
+      `checkpointProposalSyncGraceSeconds must be non-negative (got ${config.checkpointProposalSyncGraceSeconds})`,
+    );
+  }
+  if (errors.length > 0) {
+    return errors;
+  }
+
+  let computed: number;
+  try {
+    computed = new ProposerTimetable({
+      l1Constants: {
+        l1GenesisTime: 0n,
+        slotDuration: config.aztecSlotDuration,
+        ethereumSlotDuration: config.ethereumSlotDuration,
+      },
+      blockDuration: config.blockDurationMs / 1000,
+      minBlockDuration: DEFAULT_MIN_BLOCK_DURATION,
+      p2pPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
+      checkpointProposalPrepareTime: DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+      checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+      checkpointProposalSyncGrace: config.checkpointProposalSyncGraceSeconds,
+    }).getMaxBlocksPerCheckpoint();
+  } catch (err) {
+    // The timetable constructor throws when not even one block fits the default budgets; report instead.
+    errors.push(
+      `maxBlocksPerCheckpoint (${config.maxBlocksPerCheckpoint}) cannot be achieved: the default operational ` +
+        `budgets fit fewer than one block for slot duration ${config.aztecSlotDuration}s and block duration ` +
+        `${config.blockDurationMs / 1000}s (${err instanceof Error ? err.message : String(err)})`,
+    );
+    return errors;
+  }
+
+  if (computed !== config.maxBlocksPerCheckpoint) {
+    errors.push(
+      `maxBlocksPerCheckpoint (${config.maxBlocksPerCheckpoint}) does not match the ${computed} blocks the ` +
+        `production default budgets derive for slot duration ${config.aztecSlotDuration}s and block duration ` +
+        `${config.blockDurationMs / 1000}s`,
+    );
+  }
+
+  return errors;
+}
+
+/**
+ * Enforces that operators do not silently override consensus-critical values diverging from the network config.
+ *
+ * For each var in {@link NETWORK_CONSENSUS_ENV_VARS} present in `networkConfig`: if the operator set it in `env`
+ * to a conflicting value, this throws unless `ALLOW_OVERRIDING_NETWORK_CONFIG` is truthy (in which case it logs
+ * and keeps the operator value).
+ *
+ * This function is pure: it never writes to `env`. Instead it returns the canonical env writes the caller
+ * should apply — a map of env-var name to canonical string value for every numeric var whose env value matched
+ * the network value numerically. Applying these closes a bypass where the config layer parses some vars with
+ * `parseInt` (which reads '6e3' as 6); rewriting them to the network value's string form keeps the operator's
+ * numerically-equal value but in canonical form. Vars kept under `ALLOW_OVERRIDING_NETWORK_CONFIG` (genuine
+ * conflicts) are not included, so the operator value is preserved untouched.
+ *
+ * @returns Canonical env writes (env-var name -> canonical string value) for the caller to apply.
+ */
+export function checkConsensusEnvOverrides(
+  networkConfig: Record<string, string | number | boolean>,
+  env: { [key: string]: string | undefined } = process.env,
+  log?: (msg: string) => void,
+): Record<string, string> {
+  const allowOverride = allowsNetworkConfigOverride(env);
+  const canonical: Record<string, string> = {};
+  const conflicts: string[] = [];
+
+  for (const envVar of NETWORK_CONSENSUS_ENV_VARS) {
+    const networkValue = networkConfig[envVar];
+    if (networkValue === undefined) {
+      continue;
+    }
+
+    const current = env[envVar];
+    if (current === undefined || current === '') {
+      continue;
+    }
+
+    const networkIsNumeric = typeof networkValue === 'number';
+    const matches = networkIsNumeric ? Number(current) === networkValue : current === String(networkValue);
+    if (matches) {
+      if (networkIsNumeric) {
+        canonical[envVar] = String(networkValue);
+      }
+      continue;
+    }
+
+    const conflict = `${envVar}=${current} conflicts with the network value ${networkValue}`;
+    if (allowOverride) {
+      log?.(
+        `Environment variable ${conflict}. Consensus-critical values must match across the network, but ` +
+          `ALLOW_OVERRIDING_NETWORK_CONFIG is set so the operator value is kept (only do this if you know what ` +
+          `you are doing).`,
+      );
+      continue;
+    }
+    conflicts.push(conflict);
+  }
+
+  // Accumulate every conflict so the operator sees all the env vars they need to reconcile at once, rather than
+  // fixing them one failed startup at a time.
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Environment variables conflict with consensus-critical network values:\n` +
+        conflicts.map(c => `  - ${c}`).join('\n') +
+        `\nConsensus-critical values must match across the network. Set ALLOW_OVERRIDING_NETWORK_CONFIG=1 to ` +
+        `override (only do this if you know what you are doing).`,
+    );
+  }
+
+  return canonical;
+}
+
+/** Whether the env opts into overriding network-wide consensus values (`ALLOW_OVERRIDING_NETWORK_CONFIG`). */
+export function allowsNetworkConfigOverride(env: { [key: string]: string | undefined } = process.env): boolean {
+  const value = env.ALLOW_OVERRIDING_NETWORK_CONFIG;
+  return value === '1' || value?.toLowerCase() === 'true';
+}

package/src/config/sequencer-config.ts

@@ -1,10 +1,28 @@
-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_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
@@ -12,26 +30,67 @@ export const DEFAULT_MAX_TXS_PER_BLOCK = 32;
  * to avoid duplication.
  */
 export const sharedSequencerConfigMappings: ConfigMappingsType<
-  Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock'>
+  Pick<
+    SequencerConfig,
+    | 'blockDurationMs'
+    | 'checkpointProposalSyncGraceSeconds'
+    | 'expectedBlockProposalsPerSlot'
+    | 'maxTxsPerBlock'
+    | 'attestationPropagationTime'
+    | 'checkpointProposalPrepareTime'
+    | 'minBlockDuration'
+    | '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),
+    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.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : 0),
-    defaultValue: 0,
+    ...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.',
-    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),
+  },
+  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/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 = poseidon2(DOM_SEP__PARTIAL_ADDRESS, [salt, initialization_hash, deployer])
+ * 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_V1, [public_keys_hash, partial_address]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * 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_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';

package/src/contract/interfaces/contract_class.ts

@@ -42,79 +42,6 @@ const PrivateFunctionSchema = zodFor<PrivateFunction>()(
   }),
 );
 
-/** Private function definition with executable bytecode. */
-export interface ExecutablePrivateFunction extends PrivateFunction {
-  /** ACIR and Brillig bytecode */
-  bytecode: Buffer;
-}
-
-const ExecutablePrivateFunctionSchema = zodFor<ExecutablePrivateFunction>()(
-  PrivateFunctionSchema.and(z.object({ bytecode: schemas.Buffer })),
-);
-
-/** 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 = 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 = {
-  artifactMetadataHash: Fr;
-  functionMetadataHash: Fr;
-  utilityFunctionsTreeRoot: Fr;
-  privateFunctionTreeSiblingPath: Fr[];
-  privateFunctionTreeLeafIndex: number;
-  artifactTreeSiblingPath: Fr[];
-  artifactTreeLeafIndex: number;
-};
-
-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;
-
-/** 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 = 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 = zodFor<ContractClass>()(
   z.object({
     version: z.literal(VERSION),
@@ -143,11 +70,8 @@ export const ContractClassWithIdSchema = zodFor<ContractClassWithId>()(
   }),
 );
 
-/** 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 &
@@ -158,8 +82,6 @@ export const ContractClassPublicSchema = zodFor<ContractClassPublic>()(
     .object({
       id: schemas.Fr,
       privateFunctionsRoot: schemas.Fr,
-      privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
-      utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
     })
     .and(ContractClassSchema.omit({ privateFunctions: true })),
 );
@@ -179,8 +101,6 @@ export function contractClassPublicFromPlainObject(obj: any): ContractClassPubli
     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),
   };
 }