@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/block/l2_block_source.ts

@@ -1,17 +1,17 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { Fr } from '@aztec/foundation/fields';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
-import { BlockAttestation } from '../p2p/block_attestation.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
 import type { L2Block } from './l2_block.js';
 import { PublishedL2Block } from './published_l2_block.js';
+import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -67,6 +67,34 @@ export interface L2BlockSource {
   /** Equivalent to getBlocks but includes publish data. */
   getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
 
+  /**
+   * Gets a published block by its hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested published block (or undefined if not found).
+   */
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a published block by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested published block (or undefined if not found).
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a block header by its hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Gets a block header by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -121,6 +149,9 @@ export interface L2BlockSource {
    */
   getL1Constants(): Promise<L1RollupConstants>;
 
+  /** Returns values for the genesis block */
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
+
   /** Latest synced L1 timestamp. */
   getL1Timestamp(): Promise<bigint>;
 
@@ -140,59 +171,10 @@ export interface L2BlockSource {
   syncImmediate(): Promise<void>;
 }
 
-/** Subtype for invalid block validation results */
-export type ValidateBlockNegativeResult =
-  | {
-      valid: false;
-      block: PublishedL2Block;
-      committee: EthAddress[];
-      epoch: bigint;
-      seed: bigint;
-      attestations: BlockAttestation[];
-      reason: 'insufficient-attestations';
-    }
-  | {
-      valid: false;
-      block: PublishedL2Block;
-      committee: EthAddress[];
-      epoch: bigint;
-      seed: bigint;
-      reason: 'invalid-attestation';
-      attestations: BlockAttestation[];
-      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), block: PublishedL2Block.schema.optional() }),
-  z.object({
-    valid: z.literal(false),
-    block: PublishedL2Block.schema,
-    committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
-    seed: schemas.BigInt,
-    attestations: z.array(BlockAttestation.schema),
-    reason: z.literal('insufficient-attestations'),
-  }),
-  z.object({
-    valid: z.literal(false),
-    block: PublishedL2Block.schema,
-    committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
-    seed: schemas.BigInt,
-    attestations: z.array(BlockAttestation.schema),
-    reason: z.literal('invalid-attestation'),
-    invalidIndex: z.number(),
-  }),
-]) satisfies ZodFor<ValidateBlockResult>;
-
 /**
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
  */
-
 export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
   [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -70,6 +70,6 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   }
 
   protected computeBlockHash(block: L2Block) {
-    return block.header.hash().then(hash => hash.toString());
+    return block.hash().then(hash => hash.toString());
   }
 }

package/src/block/proposal/attestations_and_signers.ts

@@ -0,0 +1,121 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import { hexToBuffer } from '@aztec/foundation/string';
+
+import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import { z } from 'zod';
+
+import type { Signable, SignatureDomainSeparator } from '../../p2p/signature_utils.js';
+import { CommitteeAttestation } from './committee_attestation.js';
+
+export class CommitteeAttestationsAndSigners implements Signable {
+  constructor(public attestations: CommitteeAttestation[]) {}
+
+  static get schema() {
+    return z
+      .object({
+        attestations: CommitteeAttestation.schema.array(),
+      })
+      .transform(obj => new CommitteeAttestationsAndSigners(obj.attestations));
+  }
+
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters('uint8,(bytes,bytes),address[]');
+    const packed = this.getPackedAttestations();
+
+    const encodedData = encodeAbiParameters(abi, [
+      domainSeparator,
+      [packed.signatureIndices, packed.signaturesOrAddresses],
+      this.getSigners().map(s => s.toString()),
+    ]);
+
+    return hexToBuffer(encodedData);
+  }
+
+  static empty(): CommitteeAttestationsAndSigners {
+    return new CommitteeAttestationsAndSigners([]);
+  }
+
+  toString() {
+    throw new Error('Not implemented');
+  }
+
+  getSigners() {
+    return this.attestations.filter(a => !a.signature.isEmpty()).map(a => a.address);
+  }
+
+  getSignedAttestations() {
+    return this.attestations.filter(a => !a.signature.isEmpty());
+  }
+
+  /**
+   * Packs an array of committee attestations into the format expected by the Solidity contract
+   *
+   * @param attestations - Array of committee attestations with addresses and signatures
+   * @returns Packed attestations with bitmap and tightly packed signature/address data
+   */
+  getPackedAttestations(): ViemCommitteeAttestations {
+    const length = this.attestations.length;
+    const attestations = this.attestations.map(a => a.toViem());
+
+    // Calculate bitmap size (1 bit per attestation, rounded up to nearest byte)
+    const bitmapSize = Math.ceil(length / 8);
+    const signatureIndices = new Uint8Array(bitmapSize);
+
+    // Calculate total data size needed
+    let totalDataSize = 0;
+    for (let i = 0; i < length; i++) {
+      const signature = attestations[i].signature;
+      // Check if signature is empty (v = 0)
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        totalDataSize += 65; // v (1) + r (32) + s (32)
+      } else {
+        totalDataSize += 20; // address only
+      }
+    }
+
+    const signaturesOrAddresses = new Uint8Array(totalDataSize);
+    let dataIndex = 0;
+
+    // Pack the data
+    for (let i = 0; i < length; i++) {
+      const attestation = attestations[i];
+      const signature = attestation.signature;
+
+      // Check if signature is empty
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        // Set bit in bitmap (bit 7-0 in each byte, left to right)
+        const byteIndex = Math.floor(i / 8);
+        const bitIndex = 7 - (i % 8);
+        signatureIndices[byteIndex] |= 1 << bitIndex;
+
+        // Pack signature: v + r + s
+        signaturesOrAddresses[dataIndex] = signature.v;
+        dataIndex++;
+
+        // Pack r (32 bytes)
+        const rBytes = Buffer.from(signature.r.slice(2), 'hex');
+        signaturesOrAddresses.set(rBytes, dataIndex);
+        dataIndex += 32;
+
+        // Pack s (32 bytes)
+        const sBytes = Buffer.from(signature.s.slice(2), 'hex');
+        signaturesOrAddresses.set(sBytes, dataIndex);
+        dataIndex += 32;
+      } else {
+        // Pack address only (20 bytes)
+        const addrBytes = Buffer.from(attestation.addr.slice(2), 'hex');
+        signaturesOrAddresses.set(addrBytes, dataIndex);
+        dataIndex += 20;
+      }
+    }
+
+    return {
+      signatureIndices: `0x${Buffer.from(signatureIndices).toString('hex')}`,
+      signaturesOrAddresses: `0x${Buffer.from(signaturesOrAddresses).toString('hex')}`,
+    };
+  }
+}

package/src/block/proposal/index.ts

@@ -1 +1,2 @@
 export * from './committee_attestation.js';
+export * from './attestations_and_signers.js';

package/src/block/published_l2_block.ts

@@ -2,11 +2,11 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { randomBigInt } from '@aztec/foundation/crypto';
 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 { BlockAttestation } from '../p2p/block_attestation.js';
-import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
@@ -32,6 +32,10 @@ export class L1PublishedData {
       Buffer32.random().toString(),
     );
   }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
 }
 
 export class PublishedL2Block {
@@ -42,19 +46,37 @@ export class PublishedL2Block {
   ) {}
 
   static get schema() {
-    return z.object({
-      block: L2Block.schema,
-      l1: L1PublishedData.schema,
-      attestations: z.array(CommitteeAttestation.schema),
-    });
+    return z
+      .object({
+        block: L2Block.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedL2Block.fromFields(obj));
   }
-}
 
-export function getAttestationsFromPublishedL2Block(
-  block: Pick<PublishedL2Block, 'attestations' | 'block'>,
-): BlockAttestation[] {
-  const payload = ConsensusPayload.fromBlock(block.block);
-  return block.attestations
-    .filter(attestation => !attestation.signature.isEmpty())
-    .map(attestation => new BlockAttestation(block.block.number, payload, attestation.signature));
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const block = reader.readObject(L2Block);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
+  }
+
+  static fromFields(fields: FieldsOf<PublishedL2Block>) {
+    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
 }

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,7 +1,6 @@
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import type { L2Block, L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
-import type { BlockHeader } from '@aztec/stdlib/tx';
+import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -14,11 +13,12 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     tipsStore = await makeTipsStore();
   });
 
-  const makeBlock = (number: number): PublishedL2Block => ({
-    block: { number, header: { hash: () => Promise.resolve(new Fr(number)) } as BlockHeader } as L2Block,
-    l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
-    attestations: [],
-  });
+  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,

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/node-rpc-config.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 
 export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
@@ -6,6 +7,12 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
     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.',
@@ -21,6 +28,8 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
 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 */

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

@@ -22,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;
@@ -107,17 +116,9 @@ export class SerializableContractInstance {
  */
 export async function getContractInstanceFromInstantiationParams(
   artifact: ContractArtifact,
-  opts: {
-    constructorArtifact?: FunctionAbi | 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);
@@ -135,7 +136,7 @@ export async function getContractInstanceFromInstantiationParams(
     originalContractClassId: contractClass.id,
     initializationHash,
     publicKeys,
-    salt,
+    salt: opts.salt,
     deployer,
     version: 1,
   };

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,8 +1,10 @@
 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';

package/src/contract/interfaces/contract_class.ts

@@ -18,7 +18,7 @@ export interface ContractClass {
   /**
    * Hash of the contract artifact. The specification of this hash is not enforced by the protocol. Should include
    * commitments to code of utility functions and compilation metadata. Intended to be used by clients to verify that
-   * an off-chain fetched artifact matches a registered class.
+   * an offchain fetched artifact matches a registered class.
    */
   artifactHash: Fr;
   /** List of individual private functions, constructors included. */

package/src/epoch-helpers/index.ts

@@ -56,7 +56,10 @@ export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants,
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
-export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
+export function getSlotRangeForEpoch(
+  epochNumber: bigint,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): [bigint, bigint] {
   const startSlot = epochNumber * BigInt(constants.epochDuration);
   return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
 }
@@ -68,7 +71,7 @@ export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1Roll
 export function getTimestampRangeForEpoch(
   epochNumber: bigint,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
-) {
+): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
@@ -79,6 +82,17 @@ export function getTimestampRangeForEpoch(
   ];
 }
 
+/**
+ * Returns the start timestamp for a given epoch number.
+ */
+export function getStartTimestampForEpoch(
+  epochNumber: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
+) {
+  const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
+  return getTimestampForSlot(startSlot, constants);
+}
+
 /**
  * Returns the epoch number at which proofs are no longer accepted for a given epoch.
  * See l1-contracts/src/core/libraries/TimeLib.sol
@@ -104,3 +118,11 @@ export function getProofSubmissionDeadlineTimestamp(
   const [deadlineSlot] = getSlotRangeForEpoch(deadlineEpoch, constants);
   return getTimestampForSlot(deadlineSlot, constants);
 }
+
+/** Returns the timestamp to start building a block for a given L2 slot. Computed as the start timestamp of the slot minus one L1 slot duration. */
+export function getSlotStartBuildTimestamp(
+  slotNumber: number | bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
+): number {
+  return Number(constants.l1GenesisTime) + Number(slotNumber) * constants.slotDuration - constants.ethereumSlotDuration;
+}