@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,108 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto/random';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
+import { Checkpoint } from './checkpoint.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        blockNumber: schemas.BigInt,
+        timestamp: schemas.BigInt,
+        blockHash: z.string(),
+      })
+      .transform(obj => L1PublishedData.fromFields(obj));
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.blockNumber, this.blockHash, this.timestamp);
+  }
+}
+
+export class PublishedCheckpoint {
+  constructor(
+    /** The checkpoint itself. */
+    public checkpoint: Checkpoint,
+    /** Info on when this checkpoint was published on L1. */
+    public l1: L1PublishedData,
+    /** The attestations for the last block in the checkpoint. */
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        checkpoint: Checkpoint.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedCheckpoint.from(obj));
+  }
+
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpoint = reader.readObject(Checkpoint);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpoint,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/checkpoint/validate.ts

@@ -0,0 +1,230 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { sum } from '@aztec/foundation/collection';
+
+import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import type { Checkpoint } from './checkpoint.js';
+
+export class CheckpointValidationError extends Error {
+  constructor(
+    message: string,
+    public readonly checkpointNumber: CheckpointNumber,
+    public readonly slot: SlotNumber,
+  ) {
+    super(message);
+    this.name = 'CheckpointValidationError';
+  }
+}
+
+/**
+ * Validates a checkpoint. Throws a CheckpointValidationError if any validation fails.
+ * - Validates structural integrity (non-empty, block count, sequential numbers, archive chaining, slot consistency)
+ * - Validates checkpoint blob field count against maxBlobFields limit
+ * - Validates total L2 gas used by checkpoint blocks against the Rollup contract mana limit
+ * - Validates total DA gas used by checkpoint blocks against MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT
+ * - Validates individual block L2 gas and DA gas against maxL2BlockGas and maxDABlockGas limits
+ */
+export function validateCheckpoint(
+  checkpoint: Checkpoint,
+  opts: {
+    rollupManaLimit?: number;
+    maxL2BlockGas?: number;
+    maxDABlockGas?: number;
+    maxTxsPerCheckpoint?: number;
+    maxTxsPerBlock?: number;
+  },
+): void {
+  validateCheckpointStructure(checkpoint);
+  validateCheckpointLimits(checkpoint, opts);
+  validateCheckpointBlocksLimits(checkpoint, opts);
+}
+
+/**
+ * Validates structural integrity of a checkpoint.
+ * - Non-empty block list
+ * - Block count within MAX_BLOCKS_PER_CHECKPOINT
+ * - Checkpoint slot matches the first block's slot
+ * - Checkpoint lastArchiveRoot matches the first block's lastArchive root
+ * - Sequential block numbers without gaps
+ * - Sequential indexWithinCheckpoint starting at 0
+ * - Archive root chaining between consecutive blocks
+ * - Consistent slot number across all blocks
+ * - Global variables (slot, timestamp, coinbase, feeRecipient, gasFees) match checkpoint header for each block
+ */
+export function validateCheckpointStructure(checkpoint: Checkpoint): void {
+  const { blocks, number, slot } = checkpoint;
+
+  if (blocks.length === 0) {
+    throw new CheckpointValidationError('Checkpoint has no blocks', number, slot);
+  }
+
+  if (blocks.length > MAX_BLOCKS_PER_CHECKPOINT) {
+    throw new CheckpointValidationError(
+      `Checkpoint has ${blocks.length} blocks, exceeding limit of ${MAX_BLOCKS_PER_CHECKPOINT}`,
+      number,
+      slot,
+    );
+  }
+
+  const firstBlock = blocks[0];
+
+  if (!checkpoint.header.lastArchiveRoot.equals(firstBlock.header.lastArchive.root)) {
+    throw new CheckpointValidationError(
+      `Checkpoint lastArchiveRoot does not match first block's lastArchive root`,
+      number,
+      slot,
+    );
+  }
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+
+    if (block.indexWithinCheckpoint !== i) {
+      throw new CheckpointValidationError(
+        `Block at index ${i} has indexWithinCheckpoint ${block.indexWithinCheckpoint}, expected ${i}`,
+        number,
+        slot,
+      );
+    }
+
+    if (block.slot !== slot) {
+      throw new CheckpointValidationError(
+        `Block ${block.number} has slot ${block.slot}, expected ${slot} (all blocks must share the same slot)`,
+        number,
+        slot,
+      );
+    }
+
+    if (!checkpoint.header.matchesGlobalVariables(block.header.globalVariables)) {
+      throw new CheckpointValidationError(
+        `Block ${block.number} global variables (slot, timestamp, coinbase, feeRecipient, gasFees) do not match checkpoint header`,
+        number,
+        slot,
+      );
+    }
+
+    if (i > 0) {
+      const prev = blocks[i - 1];
+      if (block.number !== prev.number + 1) {
+        throw new CheckpointValidationError(
+          `Block numbers are not sequential: block at index ${i - 1} has number ${prev.number}, block at index ${i} has number ${block.number}`,
+          number,
+          slot,
+        );
+      }
+
+      if (!block.header.lastArchive.root.equals(prev.archive.root)) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} lastArchive root does not match archive root of block ${prev.number}`,
+          number,
+          slot,
+        );
+      }
+    }
+  }
+}
+
+/** Validates checkpoint blocks gas limits */
+function validateCheckpointBlocksLimits(
+  checkpoint: Checkpoint,
+  opts: {
+    maxL2BlockGas?: number;
+    maxDABlockGas?: number;
+    maxTxsPerBlock?: number;
+  },
+): void {
+  const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = opts;
+
+  if (maxL2BlockGas !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockL2Gas = block.header.totalManaUsed.toNumber();
+      if (blockL2Gas > maxL2BlockGas) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has L2 gas used ${blockL2Gas} exceeding limit of ${maxL2BlockGas}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+
+  if (maxDABlockGas !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockDAGas = block.computeDAGasUsed();
+      if (blockDAGas > maxDABlockGas) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has DA gas used ${blockDAGas} exceeding limit of ${maxDABlockGas}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+
+  if (maxTxsPerBlock !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockTxCount = block.body.txEffects.length;
+      if (blockTxCount > maxTxsPerBlock) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has ${blockTxCount} txs exceeding limit of ${maxTxsPerBlock}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+}
+
+/** Validates checkpoint max blob fields, gas limits, and tx limits */
+function validateCheckpointLimits(
+  checkpoint: Checkpoint,
+  opts: {
+    rollupManaLimit?: number;
+    maxTxsPerCheckpoint?: number;
+  },
+): void {
+  const { rollupManaLimit, maxTxsPerCheckpoint } = opts;
+
+  const maxBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+  const maxDAGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+
+  if (rollupManaLimit !== undefined) {
+    const checkpointMana = sum(checkpoint.blocks.map(block => block.header.totalManaUsed.toNumber()));
+    if (checkpointMana > rollupManaLimit) {
+      throw new CheckpointValidationError(
+        `Checkpoint mana cost ${checkpointMana} exceeds rollup limit of ${rollupManaLimit}`,
+        checkpoint.number,
+        checkpoint.slot,
+      );
+    }
+  }
+
+  const checkpointDAGas = sum(checkpoint.blocks.map(block => block.computeDAGasUsed()));
+  if (checkpointDAGas > maxDAGas) {
+    throw new CheckpointValidationError(
+      `Checkpoint DA gas cost ${checkpointDAGas} exceeds limit of ${maxDAGas}`,
+      checkpoint.number,
+      checkpoint.slot,
+    );
+  }
+
+  const checkpointBlobFields = checkpoint.toBlobFields().length;
+  if (checkpointBlobFields > maxBlobFields) {
+    throw new CheckpointValidationError(
+      `Checkpoint blob field count ${checkpointBlobFields} exceeds limit of ${maxBlobFields}`,
+      checkpoint.number,
+      checkpoint.slot,
+    );
+  }
+
+  if (maxTxsPerCheckpoint !== undefined) {
+    const checkpointTxCount = sum(checkpoint.blocks.map(block => block.body.txEffects.length));
+    if (checkpointTxCount > maxTxsPerCheckpoint) {
+      throw new CheckpointValidationError(
+        `Checkpoint tx count ${checkpointTxCount} exceeds limit of ${maxTxsPerCheckpoint}`,
+        checkpoint.number,
+        checkpoint.slot,
+      );
+    }
+  }
+}

package/src/config/chain-config.ts

@@ -0,0 +1,40 @@
+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';
+export { type AllowedElement } from '../interfaces/allowed_element.js';
+
+export const emptyChainConfig: ChainConfig = {
+  l1ChainId: 0,
+  rollupVersion: 0,
+  rollupAddress: EthAddress.ZERO,
+};
+
+export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
+  l1ChainId: {
+    env: 'L1_CHAIN_ID',
+    ...numberConfigHelper(31337),
+    description: 'The chain ID of the ethereum host.',
+  },
+  rollupVersion: {
+    env: 'ROLLUP_VERSION',
+    description: 'The version of the rollup.',
+    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. */
+export type ChainConfig = {
+  /** The chain id of the ethereum host. */
+  l1ChainId: number;
+  /** The version of the rollup. */
+  rollupVersion: number;
+} & Pick<L1ContractAddresses, 'rollupAddress'>;

package/src/config/index.ts

@@ -1 +1,3 @@
-export * from './config.js';
+export * from './chain-config.js';
+export * from './node-rpc-config.js';
+export * from './sequencer-config.js';

package/src/config/node-rpc-config.ts

@@ -0,0 +1,37 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+
+export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
+  rpcSimulatePublicMaxGasLimit: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT',
+    description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
+    ...numberConfigHelper(10e9),
+  },
+  rpcSimulatePublicMaxDebugLogMemoryReads: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS',
+    description:
+      'Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. ',
+    ...numberConfigHelper(DEFAULT_MAX_DEBUG_LOG_MEMORY_READS),
+  },
+  rpcMaxBatchSize: {
+    env: 'RPC_MAX_BATCH_SIZE',
+    description: 'Maximum allowed batch size for JSON RPC batch requests.',
+    ...numberConfigHelper(100),
+  },
+  rpcMaxBodySize: {
+    env: 'RPC_MAX_BODY_SIZE',
+    description: 'Maximum allowed batch size for JSON RPC batch requests.',
+    defaultValue: '1mb',
+  },
+};
+
+export type NodeRPCConfig = {
+  /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxGasLimit: number;
+  /** Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxDebugLogMemoryReads: number;
+  /** Maximum allowed batch size for JSON RPC batch requests. */
+  rpcMaxBatchSize: number;
+  /** The maximum body size the RPC server will accept */
+  rpcMaxBodySize: string;
+};

package/src/config/sequencer-config.ts

@@ -0,0 +1,65 @@
+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
+ * (like blockDurationMs needed by both p2p and sequencer-client) are defined here
+ * to avoid duplication.
+ */
+export const sharedSequencerConfigMappings: ConfigMappingsType<
+  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.',
+    ...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.',
+    ...numberConfigHelper(0),
+  },
+  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),
+  },
+  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,9 +1,11 @@
-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';
 
+import deterministicStringify from 'json-stringify-deterministic';
+
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 
 const VERSION = 1;
@@ -21,26 +23,26 @@ const sha256Fr = reduceFn(sha256, Fr);
  *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
  * private_functions_artifact_tree_root = merkleize(private_functions_artifact_leaves)
  *
- * unconstrained_functions_artifact_leaves = artifact.unconstrained_functions.map fn =>
+ * utility_functions_artifact_leaves = artifact.utility_functions.map fn =>
  *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
- * unconstrained_functions_artifact_tree_root = merkleize(unconstrained_functions_artifact_leaves)
+ * utility_functions_artifact_tree_root = merkleize(utility_functions_artifact_leaves)
  *
  * version = 1
  * artifact_hash = sha256(
  *   version,
  *   private_functions_artifact_tree_root,
- *   unconstrained_functions_artifact_tree_root,
+ *   utility_functions_artifact_tree_root,
  *   artifact_metadata,
  * )
  * ```
  * @param artifact - Artifact to calculate the hash for.
  */
 export async function computeArtifactHash(
-  artifact: ContractArtifact | { privateFunctionRoot: Fr; unconstrainedFunctionRoot: Fr; metadataHash: Fr },
+  artifact: ContractArtifact | { privateFunctionRoot: Fr; utilityFunctionRoot: Fr; metadataHash: Fr },
 ): Promise<Fr> {
-  if ('privateFunctionRoot' in artifact && 'unconstrainedFunctionRoot' in artifact && 'metadataHash' in artifact) {
-    const { privateFunctionRoot, unconstrainedFunctionRoot, metadataHash } = artifact;
-    const preimage = [privateFunctionRoot, unconstrainedFunctionRoot, metadataHash].map(x => x.toBuffer());
+  if ('privateFunctionRoot' in artifact && 'utilityFunctionRoot' in artifact && 'metadataHash' in artifact) {
+    const { privateFunctionRoot, utilityFunctionRoot, metadataHash } = artifact;
+    const preimage = [privateFunctionRoot, utilityFunctionRoot, metadataHash].map(x => x.toBuffer());
     return sha256Fr(Buffer.concat([numToUInt8(VERSION), ...preimage]));
   }
 
@@ -52,13 +54,13 @@ export async function computeArtifactHash(
 
 export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
   const privateFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.PRIVATE);
-  const unconstrainedFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UNCONSTRAINED);
+  const utilityFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UTILITY);
   const metadataHash = computeArtifactMetadataHash(artifact);
-  return { privateFunctionRoot, unconstrainedFunctionRoot, metadataHash };
+  return { privateFunctionRoot, utilityFunctionRoot, metadataHash };
 }
 
 export function computeArtifactMetadataHash(artifact: ContractArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
+  return sha256Fr(Buffer.from(deterministicStringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
 }
 
 export async function computeArtifactFunctionTreeRoot(artifact: ContractArtifact, fnType: FunctionType) {
@@ -103,7 +105,7 @@ export async function computeFunctionArtifactHash(
 }
 
 export function computeFunctionMetadataHash(fn: FunctionArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify(fn.returnTypes), 'utf8'));
+  return sha256Fr(Buffer.from(deterministicStringify(fn.returnTypes), 'utf8'));
 }
 
 function getLogger() {
@@ -111,5 +113,5 @@ function getLogger() {
 }
 
 export function getArtifactMerkleTreeHasher() {
-  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer());
+  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer() as Buffer<ArrayBuffer>);
 }

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,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';
@@ -11,11 +11,11 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
 // TODO(@spalladino): Review all generator indices in this file
 
 /**
- * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * 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);
 }