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

package/src/block/test/l2_tips_store_test_suite.ts

@@ -0,0 +1,87 @@
+import { times } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+
+import { jestExpect as expect } from '@jest/expect';
+
+import type { L2TipsStore } from '../l2_block_stream/index.js';
+
+export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
+  let tipsStore: L2TipsStore;
+
+  beforeEach(async () => {
+    tipsStore = await makeTipsStore();
+  });
+
+  const makeBlock = (number: number): PublishedL2Block =>
+    PublishedL2Block.fromFields({
+      block: { number, hash: () => Promise.resolve(new Fr(number)) } as L2Block,
+      l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
+      attestations: [],
+    });
+
+  const makeBlockId = (number: number): L2BlockId => ({
+    number,
+    hash: new Fr(number).toString(),
+  });
+
+  const makeTip = (number: number) => ({ number, hash: number === 0 ? undefined : new Fr(number).toString() });
+
+  const makeTips = (latest: number, proven: number, finalized: number) => ({
+    latest: makeTip(latest),
+    proven: makeTip(proven),
+    finalized: makeTip(finalized),
+  });
+
+  it('returns zero if no tips are stored', async () => {
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(0, 0, 0));
+  });
+
+  it('stores chain tips', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(20, i => makeBlock(i + 1)) });
+
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-finalized', block: makeBlockId(5) });
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(8) });
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-pruned', block: makeBlockId(10) });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(10, 8, 5));
+  });
+
+  it('sets latest tip from blocks added', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(3, i => makeBlock(i + 1)) });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(3, 0, 0));
+
+    expect(await tipsStore.getL2BlockHash(1)).toEqual(new Fr(1).toString());
+    expect(await tipsStore.getL2BlockHash(2)).toEqual(new Fr(2).toString());
+    expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
+  });
+
+  it('clears block hashes when setting finalized chain', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(5, i => makeBlock(i + 1)) });
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(3) });
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-finalized', block: makeBlockId(3) });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(5, 3, 3));
+
+    expect(await tipsStore.getL2BlockHash(1)).toBeUndefined();
+    expect(await tipsStore.getL2BlockHash(2)).toBeUndefined();
+
+    expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
+    expect(await tipsStore.getL2BlockHash(4)).toEqual(new Fr(4).toString());
+    expect(await tipsStore.getL2BlockHash(5)).toEqual(new Fr(5).toString());
+  });
+
+  // Regression test for #13142
+  it('does not blow up when setting proven chain on an unseen block number', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [makeBlock(5)] });
+    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(3) });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(5, 3, 0));
+  });
+}

package/src/block/validate_block_result.ts

@@ -0,0 +1,122 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { BlockInfoSchema, type L2BlockInfo, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/** Subtype for invalid block validation results */
+export type ValidateBlockNegativeResult =
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: bigint;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: not enough attestations were posted */
+      reason: 'insufficient-attestations';
+    }
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: bigint;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: an invalid attestation was posted */
+      reason: 'invalid-attestation';
+      /** Index in the attestations array of the invalid attestation posted */
+      invalidIndex: number;
+    };
+
+/** Result type for validating a block attestations */
+export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+
+export const ValidateBlockResultSchema = z.union([
+  z.object({ valid: z.literal(true) }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('insufficient-attestations'),
+  }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('invalid-attestation'),
+    invalidIndex: z.number(),
+  }),
+]) satisfies ZodFor<ValidateBlockResult>;
+
+export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
+  if (result.valid) {
+    return serializeToBuffer(true);
+  }
+
+  const l2Block = serializeBlockInfo(result.block);
+  return serializeToBuffer(
+    result.valid,
+    result.reason,
+    l2Block.length,
+    l2Block,
+    result.committee.length,
+    result.committee,
+    result.epoch,
+    result.seed ?? 0n,
+    result.attestors.length,
+    result.attestors,
+    result.attestations.length,
+    result.attestations,
+    result.reason === 'invalid-attestation' ? result.invalidIndex : 0,
+  );
+}
+
+export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult {
+  const reader = BufferReader.asReader(bufferOrReader);
+  const valid = reader.readBoolean();
+  if (valid) {
+    return { valid };
+  }
+  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
+  const block = deserializeBlockInfo(reader.readBuffer());
+  const committee = reader.readVector(EthAddress);
+  const epoch = reader.readBigInt();
+  const seed = reader.readBigInt();
+  const attestors = reader.readVector(EthAddress);
+  const attestations = reader.readVector(CommitteeAttestation);
+  const invalidIndex = reader.readNumber();
+  if (reason === 'insufficient-attestations') {
+    return { valid, reason, block, committee, epoch, seed, attestors, attestations: attestations };
+  } else if (reason === 'invalid-attestation') {
+    return { valid, reason, block, committee, epoch, seed, attestors, invalidIndex, attestations: attestations };
+  } else {
+    const _: never = reason;
+    throw new Error(`Unknown reason: ${reason}`);
+  }
+}

package/src/checkpoint/checkpoint_body.ts

@@ -0,0 +1,10 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import { getBlockBlobFields } from '../block/body.js';
+import type { TxEffect } from '../tx/tx_effect.js';
+
+export function getCheckpointBlobFields(txEffectsInBlocks: TxEffect[][]) {
+  const blockBlobFields = txEffectsInBlocks.map(blockTxEffects => getBlockBlobFields(blockTxEffects)).flat();
+  const totalNumBlobFields = blockBlobFields.length + 1; // +1 for the prefix indicating the number of total blob fields in a checkpoint.
+  return [new Fr(totalNumBlobFields)].concat(blockBlobFields);
+}

package/src/checkpoint/index.ts

@@ -0,0 +1 @@
+export * from './checkpoint_body.js';

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

@@ -4,6 +4,8 @@ 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/contract_address.ts

@@ -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,4 +1,3 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -6,7 +5,7 @@ import { type ContractArtifact, type FunctionArtifact, FunctionSelector, Functio
 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,5 +1,5 @@
 import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2HashAccumulate, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
@@ -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;
+}

package/src/contract/contract_instance.ts

@@ -2,7 +2,14 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { type ContractArtifact, type FunctionArtifact, FunctionSelector, getDefaultInitializer } from '../abi/index.js';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  type FunctionArtifact,
+  FunctionSelector,
+  getAllFunctionAbis,
+  getDefaultInitializer,
+} from '../abi/index.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { PublicKeys } from '../keys/public_keys.js';
@@ -15,6 +22,15 @@ import type { ContractInstance, ContractInstanceWithAddress } from './interfaces
 
 const VERSION = 1 as const;
 
+export type ContractInstantiationData = {
+  constructorArtifact?: FunctionAbi | string;
+  constructorArgs?: any[];
+  skipArgsDecoding?: boolean;
+  salt: Fr;
+  publicKeys?: PublicKeys;
+  deployer?: AztecAddress;
+};
+
 export class SerializableContractInstance {
   public readonly version = VERSION;
   public readonly salt: Fr;
@@ -93,24 +109,16 @@ export class SerializableContractInstance {
 }
 
 /**
- * Generates a Contract Instance from the deployment params.
+ * Generates a Contract Instance from some instantiation params.
  * @param artifact - The account contract build artifact.
- * @param opts - Options for the deployment.
+ * @param opts - Options for the contract's instantiation.
  * @returns - The contract instance
  */
-export async function getContractInstanceFromDeployParams(
+export async function getContractInstanceFromInstantiationParams(
   artifact: ContractArtifact,
-  opts: {
-    constructorArtifact?: FunctionArtifact | string;
-    constructorArgs?: any[];
-    skipArgsDecoding?: boolean;
-    salt?: Fr;
-    publicKeys?: PublicKeys;
-    deployer?: AztecAddress;
-  },
+  opts: ContractInstantiationData,
 ): Promise<ContractInstanceWithAddress> {
   const args = opts.constructorArgs ?? [];
-  const salt = opts.salt ?? Fr.random();
   const constructorArtifact = getConstructorArtifact(artifact, opts.constructorArtifact);
   const deployer = opts.deployer ?? AztecAddress.ZERO;
   const contractClass = await getContractClassFromArtifact(artifact);
@@ -128,7 +136,7 @@ export async function getContractInstanceFromDeployParams(
     originalContractClassId: contractClass.id,
     initializationHash,
     publicKeys,
-    salt,
+    salt: opts.salt,
     deployer,
     version: 1,
   };
@@ -138,14 +146,15 @@ export async function getContractInstanceFromDeployParams(
 
 function getConstructorArtifact(
   artifact: ContractArtifact,
-  requestedConstructorArtifact: FunctionArtifact | string | undefined,
-): FunctionArtifact | undefined {
+  requestedConstructorArtifact: FunctionArtifact | FunctionAbi | string | undefined,
+): FunctionAbi | undefined {
   if (typeof requestedConstructorArtifact === 'string') {
-    const found = artifact.functions.find(fn => fn.name === requestedConstructorArtifact);
+    const found = getAllFunctionAbis(artifact).find(fn => fn.name === requestedConstructorArtifact);
     if (!found) {
       throw new Error(`No constructor found with name ${requestedConstructorArtifact}`);
     }
     return found;
   }
+  // TODO: shouldn't we check that requestedConstructorArtifact exists on artifact before returning?
   return requestedConstructorArtifact ?? getDefaultInitializer(artifact);
 }

package/src/contract/contract_instance_update.ts

@@ -2,21 +2,22 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import type { UInt64 } from '../types/shared.js';
 import type { ContractInstanceUpdate } from './interfaces/contract_instance_update.js';
 
 export class SerializableContractInstanceUpdate {
   prevContractClassId: Fr;
   newContractClassId: Fr;
-  blockOfChange: number;
+  timestampOfChange: UInt64;
 
   constructor(instance: ContractInstanceUpdate) {
     this.prevContractClassId = instance.prevContractClassId;
     this.newContractClassId = instance.newContractClassId;
-    this.blockOfChange = instance.blockOfChange;
+    this.timestampOfChange = instance.timestampOfChange;
   }
 
   public toBuffer() {
-    return serializeToBuffer(this.prevContractClassId, this.newContractClassId, this.blockOfChange);
+    return serializeToBuffer(this.prevContractClassId, this.newContractClassId, this.timestampOfChange);
   }
 
   static fromBuffer(bufferOrReader: Buffer | BufferReader) {
@@ -24,7 +25,7 @@ export class SerializableContractInstanceUpdate {
     return new SerializableContractInstanceUpdate({
       prevContractClassId: reader.readObject(Fr),
       newContractClassId: reader.readObject(Fr),
-      blockOfChange: reader.readNumber(),
+      timestampOfChange: reader.readObject(Fr).toBigInt(),
     });
   }
 
@@ -32,7 +33,7 @@ export class SerializableContractInstanceUpdate {
     return new SerializableContractInstanceUpdate({
       prevContractClassId: Fr.random(),
       newContractClassId: Fr.random(),
-      blockOfChange: Math.floor(Math.random() * 1000),
+      timestampOfChange: BigInt(Math.floor(Math.random() * 1000)),
       ...opts,
     });
   }
@@ -41,7 +42,7 @@ export class SerializableContractInstanceUpdate {
     return new SerializableContractInstanceUpdate({
       prevContractClassId: Fr.zero(),
       newContractClassId: Fr.zero(),
-      blockOfChange: 0,
+      timestampOfChange: 0n,
     });
   }
 }

package/src/contract/contract_metadata.ts

@@ -0,0 +1,7 @@
+import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
+
+export interface ContractMetadata {
+  contractInstance?: ContractInstanceWithAddress | undefined;
+  isContractInitialized: boolean;
+  isContractPublished: boolean;
+}

package/src/contract/index.ts

@@ -1,12 +1,14 @@
 export * from './artifact_hash.js';
 export * from './contract_address.js';
 export * from './contract_class.js';
+export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
 export * from './contract_instance.js';
+export * from './contract_metadata.js';
 export * from './contract_instance_update.js';
 export * from './private_function.js';
 export * from './private_function_membership_proof.js';
-export * from './unconstrained_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';