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

package/src/block/l2_block_new.ts

@@ -1,10 +1,11 @@
 import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
@@ -22,7 +23,10 @@ export class L2BlockNew {
     public header: BlockHeader,
     /** L2 block body. */
     public body: Body,
-    private blockHash: Fr | undefined = undefined,
+    /** Number of the checkpoint that the block belongs to. */
+    public checkpointNumber: CheckpointNumber,
+    /** Index of the block within the checkpoint. */
+    public indexWithinCheckpoint: number,
   ) {}
 
   get number(): BlockNumber {
@@ -39,8 +43,13 @@ export class L2BlockNew {
         archive: AppendOnlyTreeSnapshot.schema,
         header: BlockHeader.schema,
         body: Body.schema,
+        checkpointNumber: CheckpointNumberSchema,
+        indexWithinCheckpoint: z.number(),
       })
-      .transform(({ archive, header, body }) => new L2BlockNew(archive, header, body));
+      .transform(
+        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
+          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+      );
   }
 
   /**
@@ -52,8 +61,10 @@ export class L2BlockNew {
     const header = reader.readObject(BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
+    const indexWithinCheckpoint = reader.readNumber();
 
-    return new L2BlockNew(archive, header, body);
+    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -61,26 +72,39 @@ export class L2BlockNew {
    * @returns A serialized L2 block as a Buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body);
+    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
   }
 
   /**
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public async hash(): Promise<Fr> {
-    if (this.blockHash === undefined) {
-      this.blockHash = await this.header.hash();
-    }
-    return this.blockHash;
+  public hash(): Promise<Fr> {
+    return this.header.hash();
   }
 
-  public toBlobFields(isFirstBlock: boolean): Fr[] {
-    const blockBlobData = this.toBlockBlobData(isFirstBlock);
+  /**
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
+   */
+  public equals(other: this): boolean {
+    return (
+      this.archive.equals(other.archive) &&
+      this.header.equals(other.header) &&
+      this.body.equals(other.body) &&
+      this.checkpointNumber === other.checkpointNumber &&
+      this.indexWithinCheckpoint === other.indexWithinCheckpoint
+    );
+  }
+
+  public toBlobFields(): Fr[] {
+    const blockBlobData = this.toBlockBlobData();
     return encodeBlockBlobData(blockBlobData);
   }
 
-  public toBlockBlobData(isFirstBlock: boolean): BlockBlobData {
+  public toBlockBlobData(): BlockBlobData {
+    const isFirstBlock = this.indexWithinCheckpoint === 0;
     return {
       blockEndMarker: {
         numTxs: this.body.txEffects.length,
@@ -104,7 +128,7 @@ export class L2BlockNew {
   }
 
   static empty() {
-    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
+    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty(), CheckpointNumber(0), 0);
   }
 
   /**
@@ -119,11 +143,15 @@ export class L2BlockNew {
   static async random(
     blockNumber: BlockNumber,
     {
+      checkpointNumber = CheckpointNumber(Number(blockNumber)),
+      indexWithinCheckpoint = 0,
       txsPerBlock = 1,
       txOptions = {},
       makeTxOptions,
       ...blockHeaderOverrides
     }: {
+      checkpointNumber?: CheckpointNumber;
+      indexWithinCheckpoint?: number;
       txsPerBlock?: number;
       txOptions?: Partial<Parameters<typeof Body.random>[0]>;
       makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
@@ -132,7 +160,7 @@ export class L2BlockNew {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
     const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body);
+    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -162,9 +190,12 @@ export class L2BlockNew {
     };
   }
 
+  getPrivateLogs(): PrivateLog[] {
+    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
+  }
+
   toBlockInfo(): L2BlockInfo {
     return {
-      blockHash: this.blockHash,
       archive: this.archive.root,
       lastArchive: this.header.lastArchive.root,
       blockNumber: this.number,

package/src/block/l2_block_source.ts

@@ -1,12 +1,12 @@
 import {
   BlockNumber,
   BlockNumberSchema,
-  type CheckpointNumber,
+  CheckpointNumber,
   type EpochNumber,
   type SlotNumber,
 } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -18,8 +18,9 @@ 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 CheckpointedL2Block, PublishedL2Block } from './checkpointed_l2_block.js';
 import type { L2Block } from './l2_block.js';
-import { PublishedL2Block } from './published_l2_block.js';
+import type { L2BlockNew } from './l2_block_new.js';
 import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
 
 /**
@@ -50,13 +51,6 @@ export interface L2BlockSource {
    */
   getProvenBlockNumber(): Promise<BlockNumber>;
 
-  /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
-
   /**
    * Gets an l2 block header.
    * @param number - The block number to return or 'latest' for the most recent one.
@@ -65,40 +59,26 @@ export interface L2BlockSource {
   getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined>;
 
   /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The maximum number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
-   * @returns The requested L2 blocks.
-   */
-  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
-
-  getPublishedCheckpoints(from: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
-
-  /**
-   * Gets a checkpoint by the archive root, which should be the root of the archive tree after the requested checkpoint
-   * is applied.
-   * @param archive - The new archive root of the checkpoint.
-   * @returns The requested checkpoint (or undefined if not found).
+   * Gets a checkpointed L2 block by block number.
+   * Returns undefined if the block doesn't exist or hasn't been checkpointed yet.
+   * @param number - The block number to retrieve.
+   * @returns The requested checkpointed L2 block (or undefined if not found or not checkpointed).
    */
-  getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined>;
-
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
   /**
-   * Gets a published block by its hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested published block (or undefined if not found).
+   * Retrieves a collection of published checkpoints
+   * @param checkpointNumber The first checkpoint to be retrieved
+   * @param limit The number of checkpoints to be retrieved
+   * @returns The collection of complete checkpoints
    */
-  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
-   * 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).
+   * Gets the checkpoints for a given epoch
+   * @param epochNumber - Epoch for which we want checkpoint data
    */
-  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
 
   /**
    * Gets a block header by its hash.
@@ -114,6 +94,13 @@ export interface L2BlockSource {
    */
   getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
 
+  /**
+   * Gets an L2 block by block number.
+   * @param number - The block number to return.
+   * @returns The requested L2 block (or undefined if not found).
+   */
+  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -138,20 +125,6 @@ export interface L2BlockSource {
    */
   getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
-  /**
-   * Returns all checkpoints for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the checkpoint list backwards.
-   * @param epochNumber - The epoch number to return checkpoints for.
-   */
-  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
-
-  /**
-   * Returns all blocks for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the block list backwards.
-   * @param epochNumber - The epoch number to return blocks for.
-   */
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
-
   /**
    * Returns all block headers for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
@@ -195,6 +168,61 @@ export interface L2BlockSource {
 
   /** Force a sync. */
   syncImmediate(): Promise<void>;
+
+  /* Legacy APIS */
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   * @deprecated Use getL2BlockNew instead.
+   */
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+
+  /**
+   * Returns all blocks for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the block list backwards.
+   * @param epochNumber - The epoch number to return blocks for.
+   */
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+
+  /**
+   * Gets a published block by its block hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested 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 block (or undefined if not found).
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The maximum number of blocks to return.
+   * @param proven - If true, only return blocks that have been proven.
+   * @returns The requested L2 blocks.
+   */
+  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+}
+
+/**
+ * Interface for classes that can receive and store L2 blocks.
+ */
+export interface L2BlockSink {
+  /**
+   * Adds a block to the store.
+   * @param block - The L2 block to add.
+   * @throws If block number is not incremental (i.e., not exactly one more than the last stored block).
+   */
+  addBlock(block: L2BlockNew): Promise<void>;
 }
 
 /**

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,5 @@
+import type { PublishedL2Block } from '../checkpointed_l2_block.js';
 import type { L2BlockId, L2Tips } from '../l2_block_source.js';
-import type { PublishedL2Block } from '../published_l2_block.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
 export interface L2BlockStreamLocalDataProvider {

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -26,6 +26,10 @@ export class L2BlockStream {
       skipFinalized?: boolean;
     } = {},
   ) {
+    // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+    // which makes it run periodically, or `sync`, which triggers it once.
+    // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+    // The default is _manually triggered_.
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
   }
 
@@ -42,6 +46,11 @@ export class L2BlockStream {
     return this.runningPromise.isRunning();
   }
 
+  /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */
   public async sync() {
     this.isSyncing = true;
     await this.runningPromise.trigger();

package/src/block/proposal/attestations_and_signers.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';

package/src/block/proposal/committee_attestation.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,8 +1,9 @@
 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 { Fr } from '@aztec/foundation/curves/bn254';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+import { L1PublishedData } from '@aztec/stdlib/checkpoint';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -18,7 +19,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
       block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
-      l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
+      l1: new L1PublishedData(BigInt(number), BigInt(number), `0x${number}`),
       attestations: [],
     });
 

package/src/checkpoint/checkpoint.ts

@@ -1,6 +1,7 @@
 import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
 import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+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';
 
@@ -9,6 +10,7 @@ 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(
@@ -56,7 +58,7 @@ export class Checkpoint {
   }
 
   public toBlobFields(): Fr[] {
-    const blocks = this.blocks.map((block, i) => block.toBlockBlobData(i === 0));
+    const blocks = this.blocks.map(block => block.toBlockBlobData());
     return encodeCheckpointBlobDataFromBlocks(blocks);
   }
 
@@ -68,20 +70,65 @@ export class Checkpoint {
     return this.blocks.at(-1)!.header.state;
   }
 
+  public toCheckpointInfo(): CheckpointInfo {
+    return {
+      archive: this.archive.root,
+      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 } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
+    }: {
+      numBlocks?: number;
+      startBlockNumber?: number;
+      previousArchive?: AppendOnlyTreeSnapshot;
+    } & 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)),
-    );
+    // 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,9 @@
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr, SlotNumber } from '@aztec/foundation/schemas';
+
+export type CheckpointInfo = {
+  archive: Fr;
+  slotNumber: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  timestamp: bigint;
+};

package/src/checkpoint/published_checkpoint.ts

@@ -1,6 +1,6 @@
 // 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 { 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';
@@ -18,11 +18,13 @@ export class L1PublishedData {
   ) {}
 
   static get schema() {
-    return z.object({
-      blockNumber: schemas.BigInt,
-      timestamp: schemas.BigInt,
-      blockHash: z.string(),
-    });
+    return z
+      .object({
+        blockNumber: schemas.BigInt,
+        timestamp: schemas.BigInt,
+        blockHash: z.string(),
+      })
+      .transform(obj => L1PublishedData.fromFields(obj));
   }
 
   static random() {
@@ -36,6 +38,18 @@ export class L1PublishedData {
   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 {

package/src/contract/artifact_hash.ts

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

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';

package/src/contract/contract_class.ts

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

package/src/contract/contract_class_id.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } 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 { 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 };
 }

package/src/contract/contract_instance.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/contract_instance_update.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/deployment_info.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { CompleteAddress } from './complete_address.js';