@aztec/archiver 0.0.1-commit.c80b6263 → 0.0.1-commit.cf93bcc56

package/src/store/log_store.ts

@@ -20,6 +20,7 @@ import {
   Tag,
   TxScopedL2Log,
 } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
 
 import type { BlockStore } from './block_store.js';
 
@@ -219,6 +220,7 @@ export class LogStore {
         .map((txEffect, txIndex) =>
           [
             numToUInt32BE(txIndex),
+            txEffect.txHash.toBuffer(),
             numToUInt32BE(txEffect.publicLogs.length),
             txEffect.publicLogs.map(log => log.toBuffer()),
           ].flat(),
@@ -242,6 +244,7 @@ export class LogStore {
         .map((txEffect, txIndex) =>
           [
             numToUInt32BE(txIndex),
+            txEffect.txHash.toBuffer(),
             numToUInt32BE(txEffect.contractClassLogs.length),
             txEffect.contractClassLogs.map(log => log.toBuffer()),
           ].flat(),
@@ -271,7 +274,7 @@ export class LogStore {
     });
   }
 
-  #packWithBlockHash(blockHash: Fr, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
+  #packWithBlockHash(blockHash: BlockHash, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
     return Buffer.concat([blockHash.toBuffer(), ...data]);
   }
 
@@ -282,7 +285,7 @@ export class LogStore {
       throw new Error('Failed to read block hash from log entry buffer');
     }
 
-    return BlockHash.fromField(blockHash);
+    return new BlockHash(blockHash);
   }
 
   deleteLogs(blocks: L2Block[]): Promise<boolean> {
@@ -386,24 +389,33 @@ export class LogStore {
     }
 
     const buffer = (await this.#publicLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
-    const publicLogsInBlock: [PublicLog[]] = [[]];
+    const publicLogsInBlock: { txHash: TxHash; logs: PublicLog[] }[] = [];
     const reader = new BufferReader(buffer);
 
     const blockHash = this.#unpackBlockHash(reader);
 
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
+      const txHash = reader.readObject(TxHash);
       const numLogsInTx = reader.readNumber();
-      publicLogsInBlock[indexOfTx] = [];
+      publicLogsInBlock[indexOfTx] = { txHash, logs: [] };
       for (let i = 0; i < numLogsInTx; i++) {
-        publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+        publicLogsInBlock[indexOfTx].logs.push(reader.readObject(PublicLog));
       }
     }
 
-    const txLogs = publicLogsInBlock[txIndex];
+    const txData = publicLogsInBlock[txIndex];
 
     const logs: ExtendedPublicLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulatePublicLogs(
+      logs,
+      blockNumber,
+      blockHash,
+      txIndex,
+      txData.txHash,
+      txData.logs,
+      filter,
+    );
 
     return { logs, maxLogsHit };
   }
@@ -424,22 +436,31 @@ export class LogStore {
 
     let maxLogsHit = false;
     loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({ start, end })) {
-      const publicLogsInBlock: [PublicLog[]] = [[]];
+      const publicLogsInBlock: { txHash: TxHash; logs: PublicLog[] }[] = [];
       const reader = new BufferReader(logBuffer);
 
       const blockHash = this.#unpackBlockHash(reader);
 
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
+        const txHash = reader.readObject(TxHash);
         const numLogsInTx = reader.readNumber();
-        publicLogsInBlock[indexOfTx] = [];
+        publicLogsInBlock[indexOfTx] = { txHash, logs: [] };
         for (let i = 0; i < numLogsInTx; i++) {
-          publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+          publicLogsInBlock[indexOfTx].logs.push(reader.readObject(PublicLog));
         }
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++) {
-        const txLogs = publicLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
+        const txData = publicLogsInBlock[txIndex];
+        maxLogsHit = this.#accumulatePublicLogs(
+          logs,
+          blockNumber,
+          blockHash,
+          txIndex,
+          txData.txHash,
+          txData.logs,
+          filter,
+        );
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -475,24 +496,33 @@ export class LogStore {
       return { logs: [], maxLogsHit: false };
     }
     const contractClassLogsBuffer = (await this.#contractClassLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
-    const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
+    const contractClassLogsInBlock: { txHash: TxHash; logs: ContractClassLog[] }[] = [];
 
     const reader = new BufferReader(contractClassLogsBuffer);
     const blockHash = this.#unpackBlockHash(reader);
 
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
+      const txHash = reader.readObject(TxHash);
       const numLogsInTx = reader.readNumber();
-      contractClassLogsInBlock[indexOfTx] = [];
+      contractClassLogsInBlock[indexOfTx] = { txHash, logs: [] };
       for (let i = 0; i < numLogsInTx; i++) {
-        contractClassLogsInBlock[indexOfTx].push(reader.readObject(ContractClassLog));
+        contractClassLogsInBlock[indexOfTx].logs.push(reader.readObject(ContractClassLog));
       }
     }
 
-    const txLogs = contractClassLogsInBlock[txIndex];
+    const txData = contractClassLogsInBlock[txIndex];
 
     const logs: ExtendedContractClassLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulateContractClassLogs(
+      logs,
+      blockNumber,
+      blockHash,
+      txIndex,
+      txData.txHash,
+      txData.logs,
+      filter,
+    );
 
     return { logs, maxLogsHit };
   }
@@ -516,20 +546,29 @@ export class LogStore {
       start,
       end,
     })) {
-      const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
+      const contractClassLogsInBlock: { txHash: TxHash; logs: ContractClassLog[] }[] = [];
       const reader = new BufferReader(logBuffer);
       const blockHash = this.#unpackBlockHash(reader);
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
+        const txHash = reader.readObject(TxHash);
         const numLogsInTx = reader.readNumber();
-        contractClassLogsInBlock[indexOfTx] = [];
+        contractClassLogsInBlock[indexOfTx] = { txHash, logs: [] };
         for (let i = 0; i < numLogsInTx; i++) {
-          contractClassLogsInBlock[indexOfTx].push(reader.readObject(ContractClassLog));
+          contractClassLogsInBlock[indexOfTx].logs.push(reader.readObject(ContractClassLog));
         }
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++) {
-        const txLogs = contractClassLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
+        const txData = contractClassLogsInBlock[txIndex];
+        maxLogsHit = this.#accumulateContractClassLogs(
+          logs,
+          blockNumber,
+          blockHash,
+          txIndex,
+          txData.txHash,
+          txData.logs,
+          filter,
+        );
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -540,12 +579,13 @@ export class LogStore {
     return { logs, maxLogsHit };
   }
 
-  #accumulateLogs(
-    results: (ExtendedContractClassLog | ExtendedPublicLog)[],
+  #accumulatePublicLogs(
+    results: ExtendedPublicLog[],
     blockNumber: number,
     blockHash: BlockHash,
     txIndex: number,
-    txLogs: (ContractClassLog | PublicLog)[],
+    txHash: TxHash,
+    txLogs: PublicLog[],
     filter: LogFilter = {},
   ): boolean {
     let maxLogsHit = false;
@@ -553,15 +593,37 @@ export class LogStore {
     for (; logIndex < txLogs.length; logIndex++) {
       const log = txLogs[logIndex];
       if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
-        if (log instanceof ContractClassLog) {
-          results.push(
-            new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log),
-          );
-        } else if (log instanceof PublicLog) {
-          results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
-        } else {
-          throw new Error('Unknown log type');
+        results.push(
+          new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txHash, txIndex, logIndex), log),
+        );
+
+        if (results.length >= this.#logsMaxPageSize) {
+          maxLogsHit = true;
+          break;
         }
+      }
+    }
+
+    return maxLogsHit;
+  }
+
+  #accumulateContractClassLogs(
+    results: ExtendedContractClassLog[],
+    blockNumber: number,
+    blockHash: BlockHash,
+    txIndex: number,
+    txHash: TxHash,
+    txLogs: ContractClassLog[],
+    filter: LogFilter = {},
+  ): boolean {
+    let maxLogsHit = false;
+    let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
+    for (; logIndex < txLogs.length; logIndex++) {
+      const log = txLogs[logIndex];
+      if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
+        results.push(
+          new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txHash, txIndex, logIndex), log),
+        );
 
         if (results.length >= this.#logsMaxPageSize) {
           maxLogsHit = true;

package/src/test/fake_l1_state.ts

@@ -131,6 +131,7 @@ export class FakeL1State {
   private provenCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
   private targetCommitteeSize: number = 0;
   private version: bigint = 1n;
+  private canPruneResult: boolean = false;
 
   // Computed from checkpoints based on L1 block visibility
   private pendingCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
@@ -194,9 +195,9 @@ export class FakeL1State {
     this.addMessages(checkpointNumber, messagesL1BlockNumber, messages);
 
     // Create the transaction and blobs
-    const tx = this.makeRollupTx(checkpoint, signers);
-    const blobHashes = this.makeVersionedBlobHashes(checkpoint);
-    const blobs = this.makeBlobsFromCheckpoint(checkpoint);
+    const tx = await this.makeRollupTx(checkpoint, signers);
+    const blobHashes = await this.makeVersionedBlobHashes(checkpoint);
+    const blobs = await this.makeBlobsFromCheckpoint(checkpoint);
 
     // Store the checkpoint data
     this.checkpoints.push({
@@ -276,6 +277,11 @@ export class FakeL1State {
     this.targetCommitteeSize = size;
   }
 
+  /** Sets whether the rollup contract would allow pruning at the next block. */
+  setCanPrune(value: boolean): void {
+    this.canPruneResult = value;
+  }
+
   /**
    * Removes all entries for a checkpoint number (simulates L1 reorg or prune).
    * Note: Does NOT remove messages for this checkpoint (use numL1ToL2Messages: 0 when re-adding).
@@ -384,6 +390,8 @@ export class FakeL1State {
       });
     });
 
+    mockRollup.canPruneAtTime.mockImplementation(() => Promise.resolve(this.canPruneResult));
+
     // Mock the wrapper method for fetching checkpoint events
     mockRollup.getCheckpointProposedEvents.mockImplementation((fromBlock: bigint, toBlock: bigint) =>
       Promise.resolve(this.getCheckpointProposedLogs(fromBlock, toBlock)),
@@ -531,14 +539,14 @@ export class FakeL1State {
       }));
   }
 
-  private makeRollupTx(checkpoint: Checkpoint, signers: Secp256k1Signer[]): Transaction {
+  private async makeRollupTx(checkpoint: Checkpoint, signers: Secp256k1Signer[]): Promise<Transaction> {
     const attestations = signers
       .map(signer => makeCheckpointAttestationFromCheckpoint(checkpoint, signer))
       .map(attestation => CommitteeAttestation.fromSignature(attestation.signature))
       .map(committeeAttestation => committeeAttestation.toViem());
 
     const header = checkpoint.header.toViem();
-    const blobInput = getPrefixedEthBlobCommitments(getBlobsPerL1Block(checkpoint.toBlobFields()));
+    const blobInput = getPrefixedEthBlobCommitments(await getBlobsPerL1Block(checkpoint.toBlobFields()));
     const archive = toHex(checkpoint.archive.root.toBuffer());
     const attestationsAndSigners = new CommitteeAttestationsAndSigners(
       attestations.map(attestation => CommitteeAttestation.fromViem(attestation)),
@@ -587,13 +595,13 @@ export class FakeL1State {
     } as Transaction<bigint, number>;
   }
 
-  private makeVersionedBlobHashes(checkpoint: Checkpoint): `0x${string}`[] {
-    return getBlobsPerL1Block(checkpoint.toBlobFields()).map(
+  private async makeVersionedBlobHashes(checkpoint: Checkpoint): Promise<`0x${string}`[]> {
+    return (await getBlobsPerL1Block(checkpoint.toBlobFields())).map(
       b => `0x${b.getEthVersionedBlobHash().toString('hex')}` as `0x${string}`,
     );
   }
 
-  private makeBlobsFromCheckpoint(checkpoint: Checkpoint): Blob[] {
-    return getBlobsPerL1Block(checkpoint.toBlobFields());
+  private async makeBlobsFromCheckpoint(checkpoint: Checkpoint): Promise<Blob[]> {
+    return await getBlobsPerL1Block(checkpoint.toBlobFields());
   }
 }

package/src/test/mock_archiver.ts

@@ -56,8 +56,9 @@ export class MockPrefilledArchiver extends MockArchiver {
     }
 
     const fromBlock = this.l2Blocks.length;
-    // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
-    this.addProposedBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap(c => c.blocks));
+    const checkpointsToAdd = this.prefilled.slice(fromBlock, fromBlock + numBlocks);
+    this.addProposedBlocks(checkpointsToAdd.flatMap(c => c.blocks));
+    this.checkpointList.push(...checkpointsToAdd);
     return Promise.resolve();
   }
 }