@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/block/published_l2_block.ts

@@ -1,43 +1,18 @@
 // Ignoring import issue to fix portable inferred type issue in zod schema
-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 { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.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(),
-    });
-  }
-
-  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);
-  }
-}
-
+/**
+ * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
+ * L2 blocks do not need to link to L1PublishedData directly.
+ * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
+ */
 export class PublishedL2Block {
   constructor(
     public block: L2Block,
@@ -79,4 +54,12 @@ export class PublishedL2Block {
       this.attestations,
     );
   }
+
+  public toPublishedCheckpoint() {
+    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
+  }
+
+  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
+    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
+  }
 }

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,3 +1,5 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
@@ -15,17 +17,20 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
 
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
-      block: { number, hash: () => Promise.resolve(new Fr(number)) } as L2Block,
+      block: { number: BlockNumber(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,
+    number: BlockNumber(number),
     hash: new Fr(number).toString(),
   });
 
-  const makeTip = (number: number) => ({ number, hash: number === 0 ? undefined : new Fr(number).toString() });
+  const makeTip = (number: number): L2BlockId => ({
+    number: BlockNumber(number),
+    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : new Fr(number).toString(),
+  });
 
   const makeTips = (latest: number, proven: number, finalized: number) => ({
     latest: makeTip(latest),

package/src/block/validate_block_result.ts

@@ -1,3 +1,4 @@
+import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -16,7 +17,7 @@ export type ValidateBlockNegativeResult =
       /** Committee members at the epoch this block was proposed */
       committee: EthAddress[];
       /** Epoch in which this block was proposed */
-      epoch: bigint;
+      epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
       /** List of committee members who signed this block proposal */
@@ -33,7 +34,7 @@ export type ValidateBlockNegativeResult =
       /** Committee members at the epoch this block was proposed */
       committee: EthAddress[];
       /** Epoch in which this block was proposed */
-      epoch: bigint;
+      epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
       /** List of committee members who signed this block proposal */
@@ -46,16 +47,17 @@ export type ValidateBlockNegativeResult =
       invalidIndex: number;
     };
 
+// TODO: Rename to ValidateAttestationsResult
 /** Result type for validating a block attestations */
 export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
 
-export const ValidateBlockResultSchema = z.union([
+export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
     valid: z.literal(false),
     block: BlockInfoSchema,
     committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
+    epoch: EpochNumberSchema,
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
@@ -65,14 +67,14 @@ export const ValidateBlockResultSchema = z.union([
     valid: z.literal(false),
     block: BlockInfoSchema,
     committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
+    epoch: EpochNumberSchema,
     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) {
@@ -106,7 +108,7 @@ export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferRe
   const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
   const block = deserializeBlockInfo(reader.readBuffer());
   const committee = reader.readVector(EthAddress);
-  const epoch = reader.readBigInt();
+  const epoch = EpochNumber(reader.readNumber());
   const seed = reader.readBigInt();
   const attestors = reader.readVector(EthAddress);
   const attestations = reader.readVector(CommitteeAttestation);

package/src/checkpoint/checkpoint.ts

@@ -0,0 +1,88 @@
+import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/fields';
+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';
+
+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, i) => block.toBlockBlobData(i === 0));
+    return encodeCheckpointBlobDataFromBlocks(blocks);
+  }
+
+  public hash(): Fr {
+    return this.header.hash();
+  }
+
+  public getState() {
+    return this.blocks.at(-1)!.header.state;
+  }
+
+  static async random(
+    checkpointNumber = CheckpointNumber(1),
+    {
+      numBlocks = 1,
+      startBlockNumber = 1,
+      ...options
+    }: { numBlocks?: number; startBlockNumber?: number } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
+      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+  ) {
+    const header = CheckpointHeader.random(options);
+
+    const blocks = await Promise.all(
+      Array.from({ length: numBlocks }, (_, i) => L2BlockNew.random(BlockNumber(startBlockNumber + i), options)),
+    );
+
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+  }
+}

package/src/checkpoint/index.ts

@@ -1 +1,2 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';
+export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,91 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+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 { 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(),
+    });
+  }
+
+  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);
+  }
+}
+
+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/contract/contract_deployment_data.ts

@@ -0,0 +1,125 @@
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/**
+ * Class containing contract class logs and private logs which are both
+ * relevant for contract registrations and deployments.
+ */
+export class ContractDeploymentData {
+  constructor(
+    public readonly contractClassLogs: ContractClassLog[],
+    public readonly privateLogs: PrivateLog[],
+  ) {}
+
+  public getContractClassLogs(): ContractClassLog[] {
+    return this.contractClassLogs;
+  }
+
+  public getPrivateLogs(): PrivateLog[] {
+    return this.privateLogs;
+  }
+
+  public static from(args: { contractClassLogs: ContractClassLog[]; privateLogs: PrivateLog[] }) {
+    return new ContractDeploymentData(args.contractClassLogs, args.privateLogs);
+  }
+
+  public static empty(): ContractDeploymentData {
+    return new ContractDeploymentData([], []);
+  }
+
+  public static get schema() {
+    return z
+      .object({
+        contractClassLogs: z.array(ContractClassLog.schema),
+        privateLogs: z.array(PrivateLog.schema),
+      })
+      .transform(ContractDeploymentData.from);
+  }
+
+  /**
+   * Creates a ContractDeploymentData from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractDeploymentData fields
+   * @returns A ContractDeploymentData instance
+   */
+  public static fromPlainObject(obj: any): ContractDeploymentData {
+    if (obj instanceof ContractDeploymentData) {
+      return obj;
+    }
+    return new ContractDeploymentData(
+      obj.contractClassLogs.map((log: any) => ContractClassLog.fromPlainObject(log)),
+      obj.privateLogs.map((log: any) => PrivateLog.fromPlainObject(log)),
+    );
+  }
+}
+
+/**
+ * Class containing both revertible and non-revertible registration/deployment data.
+ */
+export class AllContractDeploymentData {
+  constructor(
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
+  ) {}
+
+  public getNonRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.nonRevertibleContractDeploymentData;
+  }
+
+  public getRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.revertibleContractDeploymentData;
+  }
+
+  /**
+   * Extracts all contract registration/deployment data from a tx separated by revertibility.
+   * This includes contract class logs and private logs.
+   *
+   * This method handles both private-only transactions and transactions with public calls,
+   * properly splitting logs between revertible and non-revertible categories.
+   * @param tx - The transaction to extract data from
+   * @returns The extracted deployment data separated by revertibility
+   */
+  static fromTx(tx: Tx): AllContractDeploymentData {
+    const hasPublicCalls = !!tx.data.forPublic;
+
+    // Extract contract class logs from the tx
+    const allClassLogs = tx.getContractClassLogs();
+    let nonRevertibleClassLogs: ContractClassLog[];
+    let revertibleClassLogs: ContractClassLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract class logs
+      // Split the logs up here based on revertibility
+      nonRevertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ false);
+      revertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ true);
+    } else {
+      // Private-only tx: all logs are non-revertible
+      nonRevertibleClassLogs = allClassLogs;
+      revertibleClassLogs = [];
+    }
+
+    // Extract contract instance logs from the transaction's private logs
+    let nonRevertibleInstanceLogs: PrivateLog[];
+    let revertibleInstanceLogs: PrivateLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract instance logs
+      // Split the logs up here based on revertibility
+      nonRevertibleInstanceLogs = tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+    } else {
+      // Private-only tx: use logs from the `forRollup` member of the tx
+      // For private-only txs, all logs are non-revertible
+      nonRevertibleInstanceLogs = tx.data.forRollup!.end.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = [];
+    }
+
+    return new AllContractDeploymentData(
+      new ContractDeploymentData(nonRevertibleClassLogs, nonRevertibleInstanceLogs),
+      new ContractDeploymentData(revertibleClassLogs, revertibleInstanceLogs),
+    );
+  }
+}

package/src/contract/index.ts

@@ -3,6 +3,7 @@ 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_deployment_data.js';
 export * from './contract_instance.js';
 export * from './contract_metadata.js';
 export * from './contract_instance_update.js';

package/src/contract/interfaces/contract_data_source.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 
 import type { FunctionSelector } from '../../abi/index.js';
@@ -11,7 +12,7 @@ export interface ContractDataSource {
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Returns the contract class for a given contract class id, or undefined if not found.

package/src/contract/private_function_membership_proof.ts

@@ -101,7 +101,7 @@ export async function createPrivateFunctionMembershipProof(
  * // Compute function leaf and assert it belongs to the private functions tree
  * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
  * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_function_root
+ * assert computed_private_function_tree_root == contract_class.private_functions_root
  *
  * // Compute artifact leaf and assert it belongs to the artifact
  * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))

package/src/epoch-helpers/index.ts

@@ -1,3 +1,5 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { z } from 'zod';
 
 import { type ZodFor, schemas } from '../schemas/index.js';
@@ -31,37 +33,42 @@ export const L1RollupConstantsSchema = z.object({
 
 /** Returns the timestamp for a given L2 slot. */
 export function getTimestampForSlot(
-  slot: bigint,
+  slot: SlotNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
 ) {
-  return constants.l1GenesisTime + slot * BigInt(constants.slotDuration);
+  return constants.l1GenesisTime + BigInt(slot) * BigInt(constants.slotDuration);
 }
 
 /** Returns the slot number for a given timestamp. */
-export function getSlotAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>) {
-  return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(constants.slotDuration);
+export function getSlotAtTimestamp(
+  ts: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+): SlotNumber {
+  return ts < constants.l1GenesisTime
+    ? SlotNumber.ZERO
+    : SlotNumber.fromBigInt((ts - constants.l1GenesisTime) / BigInt(constants.slotDuration));
 }
 
 /** Returns the epoch number for a given timestamp. */
 export function getEpochNumberAtTimestamp(
   ts: bigint,
   constants: Pick<L1RollupConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>,
-) {
+): EpochNumber {
   return getEpochAtSlot(getSlotAtTimestamp(ts, constants), constants);
 }
 
 /** Returns the epoch number for a given slot. */
-export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
-  return slot / BigInt(constants.epochDuration);
+export function getEpochAtSlot(slot: SlotNumber, constants: Pick<L1RollupConstants, 'epochDuration'>): EpochNumber {
+  return EpochNumber.fromBigInt(BigInt(slot) / BigInt(constants.epochDuration));
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
 export function getSlotRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
-): [bigint, bigint] {
-  const startSlot = epochNumber * BigInt(constants.epochDuration);
-  return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
+): [SlotNumber, SlotNumber] {
+  const startSlot = SlotNumber(epochNumber * constants.epochDuration);
+  return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }
 
 /**
@@ -69,15 +76,15 @@ export function getSlotRangeForEpoch(
  * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
  */
 export function getTimestampRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
 ): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
-    constants.l1GenesisTime + startSlot * BigInt(constants.slotDuration),
+    constants.l1GenesisTime + BigInt(startSlot) * BigInt(constants.slotDuration),
     constants.l1GenesisTime +
-      endSlot * BigInt(constants.slotDuration) +
+      BigInt(endSlot) * BigInt(constants.slotDuration) +
       BigInt((ethereumSlotsPerL2Slot - 1) * constants.ethereumSlotDuration),
   ];
 }
@@ -86,7 +93,7 @@ export function getTimestampRangeForEpoch(
  * Returns the start timestamp for a given epoch number.
  */
 export function getStartTimestampForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
 ) {
   const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
@@ -98,10 +105,10 @@ export function getStartTimestampForEpoch(
  * See l1-contracts/src/core/libraries/TimeLib.sol
  */
 export function getProofSubmissionDeadlineEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'proofSubmissionEpochs'>,
-) {
-  return epochNumber + BigInt(constants.proofSubmissionEpochs + 1);
+): EpochNumber {
+  return EpochNumber(epochNumber + constants.proofSubmissionEpochs + 1);
 }
 
 /**
@@ -109,7 +116,7 @@ export function getProofSubmissionDeadlineEpoch(
  * Computed as the start of the given epoch plus the proof submission window.
  */
 export function getProofSubmissionDeadlineTimestamp(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'proofSubmissionEpochs'>,
 ) {
   // See l1-contracts/src/core/libraries/TimeLib.sol:
@@ -121,8 +128,8 @@ export function getProofSubmissionDeadlineTimestamp(
 
 /** 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,
+  slotNumber: SlotNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
 ): number {
-  return Number(constants.l1GenesisTime) + Number(slotNumber) * constants.slotDuration - constants.ethereumSlotDuration;
+  return Number(constants.l1GenesisTime) + slotNumber * constants.slotDuration - constants.ethereumSlotDuration;
 }

package/src/file-store/http.ts

@@ -6,7 +6,7 @@ import { createWriteStream } from 'fs';
 import { mkdir } from 'fs/promises';
 import { dirname } from 'path';
 import { Readable } from 'stream';
-import { finished } from 'stream/promises';
+import { pipeline } from 'stream/promises';
 
 import type { ReadOnlyFileStore } from './interface.js';
 
@@ -43,11 +43,14 @@ export class HttpFileStore implements ReadOnlyFileStore {
   public async download(pathOrUrl: string, destPath: string): Promise<void> {
     const url = this.getUrl(pathOrUrl);
     try {
+      this.log.debug(`Downloading file from ${url} to ${destPath}`);
       const response = await this.fetch<Readable>({ url, method: 'GET', responseType: 'stream' });
+      this.log.debug(`Response ${response.status} (${response.statusText}) from ${url}, writing to ${destPath}`);
       await mkdir(dirname(destPath), { recursive: true });
-      await finished(response.data.pipe(createWriteStream(destPath)));
+      await pipeline(response.data, createWriteStream(destPath));
+      this.log.debug(`Download of ${url} to ${destPath} complete`);
     } catch (error) {
-      throw new Error(`Error fetching file from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Error fetching file from ${url}`, { cause: error });
     }
   }