@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/checkpoint/checkpoint.ts

@@ -0,0 +1,136 @@
+import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { sum } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { L2BlockNew } from '../block/l2_block_new.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import type { CheckpointInfo } from './checkpoint_info.js';
+
+export class Checkpoint {
+  constructor(
+    /** Snapshot of archive tree after the checkpoint is added. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the checkpoint. */
+    public header: CheckpointHeader,
+    /** L2 blocks in the checkpoint. */
+    public blocks: L2BlockNew[],
+    /** Number of the checkpoint. */
+    public number: CheckpointNumber,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: CheckpointHeader.schema,
+        blocks: z.array(L2BlockNew.schema),
+        number: CheckpointNumberSchema,
+      })
+      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+  }
+
+  static from(fields: FieldsOf<Checkpoint>) {
+    return new Checkpoint(...Checkpoint.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<Checkpoint>) {
+    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    return new Checkpoint(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(CheckpointHeader),
+      reader.readVector(L2BlockNew),
+      CheckpointNumber(reader.readNumber()),
+    );
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
+  }
+
+  public toBlobFields(): Fr[] {
+    const blocks = this.blocks.map(block => block.toBlockBlobData());
+    return encodeCheckpointBlobDataFromBlocks(blocks);
+  }
+
+  public hash(): Fr {
+    return this.header.hash();
+  }
+
+  public getState() {
+    return this.blocks.at(-1)!.header.state;
+  }
+
+  public toCheckpointInfo(): CheckpointInfo {
+    return {
+      archive: this.archive.root,
+      lastArchive: this.header.lastArchiveRoot,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+    };
+  }
+
+  /** Returns stats used for logging */
+  public getStats() {
+    const txEffects = this.blocks.flatMap(block => block.body.txEffects);
+
+    const logsStats = {
+      privateLogCount: sum(txEffects.map(tx => tx.privateLogs.length)),
+      publicLogCount: sum(txEffects.map(tx => tx.publicLogs.length)),
+      contractClassLogCount: sum(txEffects.map(tx => tx.contractClassLogs.length)),
+      contractClassLogSize: sum(txEffects.map(tx => sum(tx.contractClassLogs.map(log => log.emittedLength)))),
+    };
+
+    return {
+      txCount: txEffects.length,
+      blockCount: this.blocks.length,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+      ...logsStats,
+    };
+  }
+
+  static async random(
+    checkpointNumber = CheckpointNumber(1),
+    {
+      numBlocks = 1,
+      startBlockNumber = 1,
+      previousArchive,
+      ...options
+    }: {
+      numBlocks?: number;
+      startBlockNumber?: number;
+      previousArchive?: AppendOnlyTreeSnapshot;
+    } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
+      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+  ) {
+    const header = CheckpointHeader.random(options);
+
+    // Create blocks sequentially to chain archive roots properly.
+    // Each block's header.lastArchive must equal the previous block's archive.
+    const blocks: L2BlockNew[] = [];
+    let lastArchive = previousArchive;
+    for (let i = 0; i < numBlocks; i++) {
+      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
+        indexWithinCheckpoint: i,
+        ...options,
+        ...(lastArchive ? { lastArchive } : {}),
+      });
+      lastArchive = block.archive;
+      blocks.push(block);
+    }
+
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+  }
+}

package/src/checkpoint/checkpoint_info.ts

@@ -0,0 +1,52 @@
+import {
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  SlotNumber,
+  SlotNumberSchema,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+export type CheckpointInfo = {
+  archive: Fr;
+  lastArchive: Fr;
+  slotNumber: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  timestamp: bigint;
+};
+
+export function randomCheckpointInfo(checkpointNumber?: CheckpointNumber | number): CheckpointInfo {
+  return {
+    archive: Fr.random(),
+    lastArchive: Fr.random(),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
+    checkpointNumber: CheckpointNumber(checkpointNumber ?? Math.floor(Math.random() * 100000) + 1),
+    timestamp: BigInt(Math.floor(Date.now() / 1000)),
+  };
+}
+
+export const CheckpointInfoSchema = z.object({
+  archive: schemas.Fr,
+  lastArchive: schemas.Fr,
+  slotNumber: SlotNumberSchema,
+  checkpointNumber: CheckpointNumberSchema,
+  timestamp: schemas.BigInt,
+});
+
+export function serializeCheckpointInfo(info: CheckpointInfo): Buffer {
+  return serializeToBuffer(info.archive, info.lastArchive, info.slotNumber, info.checkpointNumber, info.timestamp);
+}
+
+export function deserializeCheckpointInfo(buffer: Buffer | BufferReader): CheckpointInfo {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    archive: reader.readObject(Fr),
+    lastArchive: reader.readObject(Fr),
+    slotNumber: SlotNumber(reader.readNumber()),
+    checkpointNumber: CheckpointNumber(reader.readNumber()),
+    timestamp: reader.readBigInt(),
+  };
+}

package/src/checkpoint/index.ts

@@ -0,0 +1,3 @@
+export * from './checkpoint.js';
+export * from './checkpoint_info.js';
+export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,105 @@
+// 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 { 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();
+    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(
+    public checkpoint: Checkpoint,
+    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();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    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/config/{config.ts → chain-config.ts}

@@ -1,13 +1,14 @@
 import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
-import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type AllowedElement } from '../interfaces/allowed_element.js';
 
 export const emptyChainConfig: ChainConfig = {
   l1ChainId: 0,
   l1Contracts: { rollupAddress: EthAddress.ZERO },
-  version: 0,
+  rollupVersion: 0,
 };
 
 export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
@@ -17,10 +18,10 @@ export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
     defaultValue: 31337,
     description: 'The chain ID of the ethereum host.',
   },
-  version: {
-    env: 'VERSION',
+  rollupVersion: {
+    env: 'ROLLUP_VERSION',
     description: 'The version of the rollup.',
-    ...numberConfigHelper(1),
+    parseEnv: (val: string) => (Number.isSafeInteger(parseInt(val, 10)) ? parseInt(val, 10) : undefined),
   },
   l1Contracts: {
     description: 'The deployed L1 contract addresses',
@@ -33,7 +34,7 @@ export type ChainConfig = {
   /** The chain id of the ethereum host. */
   l1ChainId: number;
   /** The version of the rollup. */
-  version: number;
+  rollupVersion: number;
   /** The address to the L1 contracts. */
   l1Contracts: {
     /** The address to rollup */

package/src/config/index.ts

@@ -1 +1,2 @@
-export * from './config.js';
+export * from './chain-config.js';
+export * from './node-rpc-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: '50mb',
+  },
+};
+
+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/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';

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 { 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,7 +11,7 @@ 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)

package/src/contract/contract_class.ts

@@ -1,12 +1,11 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
-import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 import { hashVK } from '../hash/hash.js';
 import { computeArtifactHash } from './artifact_hash.js';
 import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from './contract_class_id.js';
-import type { ContractClass, ContractClassWithId, PublicFunction } from './interfaces/index.js';
+import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
 
 /** Contract artifact including its artifact hash */
 type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
@@ -19,30 +18,16 @@ export async function getContractClassFromArtifact(
   artifact: ContractArtifact | ContractArtifactWithHash,
 ): Promise<ContractClassWithId & ContractClassIdPreimage> {
   const artifactHash = 'artifactHash' in artifact ? artifact.artifactHash : await computeArtifactHash(artifact);
-  const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
-  const artifactPublicFunctions: ContractClass['publicFunctions'] = await Promise.all(
-    publicFunctions.map(async f => ({
-      selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
-      bytecode: f.bytecode,
-    })),
-  );
-
-  artifactPublicFunctions.sort(cmpFunctionArtifacts);
 
-  let packedBytecode = Buffer.alloc(0);
-  let dispatchFunction: PublicFunction | undefined = undefined;
-  if (artifactPublicFunctions.length > 0) {
-    dispatchFunction = artifactPublicFunctions.find(f =>
-      f.selector.equals(FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR))),
+  const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
+  if (publicFunctions.length > 1) {
+    throw new Error(
+      `Contract should contain at most one public function artifact. Received ${publicFunctions.length}.`,
     );
-    if (!dispatchFunction) {
-      throw new Error(
-        `A contract with public functions should define a public_dispatch(Field) function as its public entrypoint. Contract: ${artifact.name}`,
-      );
-    }
-    packedBytecode = dispatchFunction.bytecode;
   }
 
+  const packedBytecode = publicFunctions[0]?.bytecode ?? Buffer.alloc(0);
+
   const privateFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PRIVATE);
   const privateArtifactFunctions: ContractClass['privateFunctions'] = await Promise.all(
     privateFunctions.map(getContractClassPrivateFunctionFromArtifact),
@@ -53,8 +38,6 @@ export async function getContractClassFromArtifact(
   const contractClass: ContractClass = {
     version: 1,
     artifactHash,
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
-    publicFunctions: dispatchFunction ? [dispatchFunction] : [],
     packedBytecode,
     privateFunctions: privateArtifactFunctions,
   };

package/src/contract/contract_class_id.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2HashAccumulate, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';
 
@@ -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
+    GeneratorIndex.CONTRACT_CLASS_ID,
   );
   return { id, artifactHash, privateFunctionsRoot, publicBytecodeCommitment };
 }
@@ -61,10 +61,16 @@ export type ContractClassIdPreimage = {
 
 export async function computePublicBytecodeCommitment(packedBytecode: Buffer) {
   // Encode the buffer into field elements (chunked into 32 bytes each)
-  const encodedBytecode: Fr[] = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
   // The first element is the length of the bytecode (in bytes)
-  const bytecodeLength = Math.ceil(encodedBytecode[0].toNumber() / (Fr.SIZE_IN_BYTES - 1));
+  const [bytecodeLengthAsField, ...bytecodeAsFields] = bufferAsFields(
+    packedBytecode,
+    MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,
+  );
+
+  const bytecodeLength = Math.ceil(bytecodeLengthAsField.toNumber() / (Fr.SIZE_IN_BYTES - 1));
   assert(bytecodeLength < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, 'Bytecode exceeds maximum deployable size');
 
-  return bytecodeLength == 0 ? new Fr(0) : await poseidon2HashAccumulate(encodedBytecode.slice(0, bytecodeLength + 1));
+  // 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);
 }

package/src/contract/contract_class_metadata.ts

@@ -0,0 +1,8 @@
+import type { ContractArtifact } from '../abi/abi.js';
+import type { ContractClassWithId } from './interfaces/contract_class.js';
+
+export interface ContractClassMetadata {
+  contractClass?: ContractClassWithId | undefined;
+  isContractClassPubliclyRegistered: boolean;
+  artifact?: ContractArtifact | undefined;
+}