@aztec/archiver 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/src/test/mock_l2_block_source.ts

@@ -1,23 +1,24 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  CheckpointedL2Block,
   L2Block,
   L2BlockHash,
   type L2BlockSource,
   type L2Tips,
-  PublishedL2Block,
-  type ValidateBlockResult,
+  type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { type BlockHeader, TxExecutionResult, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
@@ -28,22 +29,23 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
   private provenBlockNumber: number = 0;
   private finalizedBlockNumber: number = 0;
+  private checkpointedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
   public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = await L2Block.random(blockNum);
+      const block = await L2Block.random(BlockNumber(blockNum), { slotNumber: SlotNumber(blockNum) });
       this.l2Blocks.push(block);
     }
 
     this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
   }
 
-  public addBlocks(blocks: L2Block[]) {
+  public addProposedBlocks(blocks: L2Block[]) {
     this.l2Blocks.push(...blocks);
-    this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+    this.log.verbose(`Added ${blocks.length} proposed blocks to the mock L2 block source`);
   }
 
   public removeBlocks(numBlocks: number) {
@@ -62,6 +64,10 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     this.finalizedBlockNumber = finalizedBlockNumber;
   }
 
+  public setCheckpointedBlockNumber(checkpointedBlockNumber: number) {
+    this.checkpointedBlockNumber = checkpointedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -83,11 +89,51 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
    */
   public getBlockNumber() {
-    return Promise.resolve(this.l2Blocks.length);
+    return Promise.resolve(BlockNumber(this.l2Blocks.length));
   }
 
-  public getProvenBlockNumber(): Promise<number> {
-    return Promise.resolve(this.provenBlockNumber);
+  public getProvenBlockNumber() {
+    return Promise.resolve(BlockNumber(this.provenBlockNumber));
+  }
+
+  public getCheckpointedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.checkpointedBlockNumber));
+  }
+
+  public getFinalizedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.finalizedBlockNumber));
+  }
+
+  public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    if (number > this.checkpointedBlockNumber) {
+      return Promise.resolve(undefined);
+    }
+    const block = this.l2Blocks[number - 1];
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    const checkpointedBlock = new CheckpointedL2Block(
+      CheckpointNumber.fromBlockNumber(number),
+      block,
+      new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`),
+      [],
+    );
+    return Promise.resolve(checkpointedBlock);
+  }
+
+  public async getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
+    const result: CheckpointedL2Block[] = [];
+    for (let i = 0; i < limit; i++) {
+      const blockNum = from + i;
+      if (blockNum > this.checkpointedBlockNumber) {
+        break;
+      }
+      const block = await this.getCheckpointedBlock(BlockNumber(blockNum));
+      if (block) {
+        result.push(block);
+      }
+    }
+    return result;
   }
 
   /**
@@ -95,8 +141,19 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public getBlock(number: number) {
-    return Promise.resolve(this.l2Blocks[number - 1]);
+  public getBlock(number: number): Promise<L2Block | undefined> {
+    const block = this.l2Blocks[number - 1];
+    return Promise.resolve(block);
+  }
+
+  /**
+   * Gets an L2 block (new format).
+   * @param number - The block number to return.
+   * @returns The requested L2 block.
+   */
+  public getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
+    const block = this.l2Blocks[number - 1];
+    return Promise.resolve(block);
   }
 
   /**
@@ -105,40 +162,47 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param limit - The maximum number of blocks to return.
    * @returns The requested mocked L2 blocks.
    */
-  public getBlocks(from: number, limit: number, proven?: boolean) {
-    return Promise.resolve(
-      this.l2Blocks
-        .slice(from - 1, from - 1 + limit)
-        .filter(b => !proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber),
+  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
+    return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
+  }
+
+  public getCheckpoints(from: CheckpointNumber, limit: number) {
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
+    const blocks = this.l2Blocks.slice(from - 1, from - 1 + limit);
+    return Promise.all(
+      blocks.map(async block => {
+        // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
+        const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+        checkpoint.blocks = [block];
+        return new PublishedCheckpoint(
+          checkpoint,
+          new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+          [],
+        );
+      }),
     );
   }
 
-  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
-    const blocks = await this.getBlocks(from, limit, proven);
-    return blocks.map(block =>
-      PublishedL2Block.fromFields({
-        block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
-        attestations: [],
-      }),
-    );
+  public async getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined> {
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    if (!block) {
+      return undefined;
+    }
+    // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
+    const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+    checkpoint.blocks = [block];
+    return checkpoint;
   }
 
-  public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+  public async getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
-        return PublishedL2Block.fromFields({
+        return CheckpointedL2Block.fromFields({
+          checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
           block,
-          l1: {
-            blockNumber: BigInt(block.number),
-            blockHash: Buffer32.random().toString(),
-            timestamp: BigInt(block.number),
-          },
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
           attestations: [],
         });
       }
@@ -146,29 +210,41 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return undefined;
   }
 
-  public getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
     if (!block) {
       return Promise.resolve(undefined);
     }
     return Promise.resolve(
-      PublishedL2Block.fromFields({
+      CheckpointedL2Block.fromFields({
+        checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
         block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
       }),
     );
   }
 
+  public async getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return block;
+      }
+    }
+    return undefined;
+  }
+
+  public getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    return Promise.resolve(block);
+  }
+
   public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
-        return block.getBlockHeader();
+        return block.header;
       }
     }
     return undefined;
@@ -176,26 +252,58 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
   public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
-    return Promise.resolve(block?.getBlockHeader());
+    return Promise.resolve(block?.header);
   }
 
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
   }
 
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
       const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
+    // Create checkpoints from blocks - manually construct since L2Block doesn't have toCheckpoint()
+    return Promise.all(
+      blocks.map(async block => {
+        const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+        checkpoint.blocks = [block];
+        return checkpoint;
+      }),
+    );
+  }
+
+  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
+    const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+    const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
+    const blocks = this.l2Blocks.filter(b => {
+      const slot = b.header.globalVariables.slotNumber;
+      return slot >= start && slot <= end;
+    });
+    return Promise.resolve(
+      blocks.map(block =>
+        CheckpointedL2Block.fromFields({
+          checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
+          block,
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+          attestations: [],
+        }),
+      ),
+    );
+  }
+
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+    const blocks = this.l2Blocks.filter(b => b.header.globalVariables.slotNumber === slotNumber);
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
-    const blocks = await this.getBlocksForEpoch(epochNumber);
-    return blocks.map(b => b.getBlockHeader());
+  async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
+    return checkpointedBlocks.map(b => b.block.header);
   }
 
   /**
@@ -228,10 +336,12 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
+          // In mock, assume all txs are checkpointed with successful execution
           return new TxReceipt(
             txHash,
-            TxStatus.SUCCESS,
-            '',
+            TxStatus.CHECKPOINTED,
+            TxExecutionResult.SUCCESS,
+            undefined,
             txEffect.transactionFee.toBigInt(),
             L2BlockHash.fromField(await block.hash()),
             block.number,
@@ -243,29 +353,45 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   }
 
   async getL2Tips(): Promise<L2Tips> {
-    const [latest, proven, finalized] = [
+    const [latest, proven, finalized, checkpointed] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
       this.finalizedBlockNumber,
+      this.checkpointedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
     const provenBlock = this.l2Blocks[proven - 1];
     const finalizedBlock = this.l2Blocks[finalized - 1];
+    const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+
+    const latestBlockId = {
+      number: BlockNumber(latest),
+      hash: (await latestBlock?.hash())?.toString(),
+    };
+    const provenBlockId = {
+      number: BlockNumber(proven),
+      hash: (await provenBlock?.hash())?.toString(),
+    };
+    const finalizedBlockId = {
+      number: BlockNumber(finalized),
+      hash: (await finalizedBlock?.hash())?.toString(),
+    };
+    const checkpointedBlockId = {
+      number: BlockNumber(checkpointed),
+      hash: (await checkpointedBlock?.hash())?.toString(),
+    };
+
+    const makeTipId = (blockId: typeof latestBlockId) => ({
+      block: blockId,
+      checkpoint: { number: CheckpointNumber.fromBlockNumber(blockId.number), hash: blockId.hash },
+    });
 
     return {
-      latest: {
-        number: latest,
-        hash: (await latestBlock?.hash())?.toString(),
-      },
-      proven: {
-        number: proven,
-        hash: (await provenBlock?.hash())?.toString(),
-      },
-      finalized: {
-        number: finalized,
-        hash: (await finalizedBlock?.hash())?.toString(),
-      },
+      proposed: latestBlockId,
+      checkpointed: makeTipId(checkpointedBlockId),
+      proven: makeTipId(provenBlockId),
+      finalized: makeTipId(finalizedBlockId),
     };
   }
 
@@ -343,7 +469,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(false);
   }
 
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
     return Promise.resolve({ valid: true });
   }
 }