@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/test/mock_l1_to_l2_message_source.ts

@@ -1,4 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
+import type { L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 /**
@@ -17,8 +18,8 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
     this.blockNumber = blockNumber;
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    return Promise.resolve(this.messagesPerBlock.get(Number(blockNumber)) ?? []);
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
+    return Promise.resolve(this.messagesPerBlock.get(blockNumber) ?? []);
   }
 
   getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
@@ -28,4 +29,14 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
   getBlockNumber(): Promise<number> {
     return Promise.resolve(this.blockNumber);
   }
+
+  getL2Tips(): Promise<L2Tips> {
+    const number = this.blockNumber;
+    const tip = { number, hash: new Fr(number).toString() };
+    return Promise.resolve({
+      latest: tip,
+      proven: tip,
+      finalized: tip,
+    });
+  }
 }

package/src/test/mock_l2_block_source.ts

@@ -1,17 +1,33 @@
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
-import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  L2Block,
+  L2BlockHash,
+  type L2BlockSource,
+  type L2Tips,
+  PublishedL2Block,
+  type ValidateBlockResult,
+} from '@aztec/stdlib/block';
+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 { UInt64 } from '@aztec/stdlib/types';
 
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */
-export class MockL2BlockSource implements L2BlockSource {
+export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   protected l2Blocks: L2Block[] = [];
 
   private provenBlockNumber: number = 0;
+  private finalizedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
@@ -39,6 +55,13 @@ export class MockL2BlockSource implements L2BlockSource {
     this.provenBlockNumber = provenBlockNumber;
   }
 
+  public setFinalizedBlockNumber(finalizedBlockNumber: number) {
+    if (finalizedBlockNumber > this.provenBlockNumber) {
+      this.provenBlockNumber = finalizedBlockNumber;
+    }
+    this.finalizedBlockNumber = finalizedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -90,24 +113,95 @@ export class MockL2BlockSource implements L2BlockSource {
     );
   }
 
+  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 getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return PublishedL2Block.fromFields({
+          block,
+          l1: {
+            blockNumber: BigInt(block.number),
+            blockHash: Buffer32.random().toString(),
+            timestamp: BigInt(block.number),
+          },
+          attestations: [],
+        });
+      }
+    }
+    return undefined;
+  }
+
+  public getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(
+      PublishedL2Block.fromFields({
+        block,
+        l1: {
+          blockNumber: BigInt(block.number),
+          blockHash: Buffer32.random().toString(),
+          timestamp: BigInt(block.number),
+        },
+        attestations: [],
+      }),
+    );
+  }
+
+  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 undefined;
+  }
+
+  public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    return Promise.resolve(block?.getBlockHeader());
+  }
+
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
-      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
     return Promise.resolve(blocks);
   }
 
+  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    const blocks = await this.getBlocksForEpoch(epochNumber);
+    return blocks.map(b => b.getBlockHeader());
+  }
+
   /**
    * Gets a tx effect.
-   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-   * @returns The requested tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
   public async getTxEffect(txHash: TxHash) {
     const match = this.l2Blocks
@@ -117,7 +211,12 @@ export class MockL2BlockSource implements L2BlockSource {
       return Promise.resolve(undefined);
     }
     const [txEffect, block] = match;
-    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
+    return {
+      data: txEffect,
+      l2BlockNumber: block.number,
+      l2BlockHash: L2BlockHash.fromField(await block.hash()),
+      txIndexInBlock: block.body.txEffects.indexOf(txEffect),
+    };
   }
 
   /**
@@ -147,7 +246,7 @@ export class MockL2BlockSource implements L2BlockSource {
     const [latest, proven, finalized] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
-      await this.getProvenBlockNumber(),
+      this.finalizedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
@@ -170,19 +269,27 @@ export class MockL2BlockSource implements L2BlockSource {
     };
   }
 
-  getL2EpochNumber(): Promise<bigint> {
+  getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('Method not implemented.');
   }
 
-  getL2SlotNumber(): Promise<bigint> {
+  getL2SlotNumber(): Promise<SlotNumber> {
     throw new Error('Method not implemented.');
   }
 
-  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 
   getL1Constants(): Promise<L1RollupConstants> {
+    return Promise.resolve(EmptyL1RollupConstants);
+  }
+
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
+  }
+
+  getL1Timestamp(): Promise<bigint> {
     throw new Error('Method not implemented.');
   }
 
@@ -191,6 +298,7 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the initialization of the l2 block source on completion.
    */
   public start(): Promise<void> {
+    this.log.verbose('Starting mock L2 block source');
     return Promise.resolve();
   }
 
@@ -199,6 +307,43 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the l2 block source is now stopped.
    */
   public stop(): Promise<void> {
+    this.log.verbose('Stopping mock L2 block source');
     return Promise.resolve();
   }
+
+  getContractClass(_id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getBytecodeCommitment(_id: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContract(_address: AztecAddress, _timestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    return Promise.resolve([]);
+  }
+
+  getDebugFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  registerContractFunctionSignatures(_signatures: string[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  syncImmediate(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  isPendingChainInvalid(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+    return Promise.resolve({ valid: true });
+  }
 }

package/src/test/mock_structs.ts

@@ -0,0 +1,49 @@
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt, randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+
+import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
+
+export function makeInboxMessage(
+  previousRollingHash = Buffer16.ZERO,
+  overrides: Partial<InboxMessage> = {},
+): InboxMessage {
+  const { l2BlockNumber = randomInt(100) + 1 } = overrides;
+  const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
+  const { l1BlockHash = Buffer32.random() } = overrides;
+  const { leaf = Fr.random() } = overrides;
+  const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
+  const { index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) } = overrides;
+
+  return {
+    index,
+    leaf,
+    l2BlockNumber,
+    l1BlockNumber,
+    l1BlockHash,
+    rollingHash,
+  };
+}
+
+export function makeInboxMessages(
+  count: number,
+  opts: {
+    initialHash?: Buffer16;
+    initialL2BlockNumber?: number;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+  } = {},
+): InboxMessage[] {
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialL2BlockNumber = 1 } = opts;
+  const messages: InboxMessage[] = [];
+  let rollingHash = initialHash;
+  for (let i = 0; i < count; i++) {
+    const leaf = Fr.random();
+    const l2BlockNumber = i + initialL2BlockNumber;
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), i);
+    rollingHash = message.rollingHash;
+    messages.push(message);
+  }
+
+  return messages;
+}

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts

@@ -1,12 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
-export declare class NullifierStore {
-    #private;
-    private db;
-    constructor(db: AztecAsyncKVStore);
-    addNullifiers(blocks: L2Block[]): Promise<boolean>;
-    deleteNullifiers(blocks: L2Block[]): Promise<boolean>;
-    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
-}
-//# sourceMappingURL=nullifier_store.d.ts.map

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nullifier_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/nullifier_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,qBAAa,cAAc;;IAMb,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAMnC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BlD,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAerD,8BAA8B,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,GACf,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;CAkC5C"}

package/dest/archiver/kv_archiver_store/nullifier_store.js

@@ -1,73 +0,0 @@
-import { MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-export class NullifierStore {
-    db;
-    #nullifiersToBlockNumber;
-    #nullifiersToBlockHash;
-    #nullifiersToIndex;
-    #log;
-    constructor(db){
-        this.db = db;
-        this.#log = createLogger('archiver:log_store');
-        this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
-        this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
-        this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
-    }
-    async addNullifiers(blocks) {
-        const blockHashes = await Promise.all(blocks.map((block)=>block.hash()));
-        await this.db.transactionAsync(async ()=>{
-            await Promise.all(blocks.map((block, i)=>{
-                const dataStartIndexForBlock = block.header.state.partial.nullifierTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-                return Promise.all(block.body.txEffects.map((txEffects, txIndex)=>{
-                    const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-                    return Promise.all(txEffects.nullifiers.map(async (nullifier, nullifierIndex)=>{
-                        await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
-                        await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
-                        await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
-                    }));
-                }));
-            }));
-        });
-        return true;
-    }
-    async deleteNullifiers(blocks) {
-        await this.db.transactionAsync(async ()=>{
-            for (const block of blocks){
-                for (const nullifier of block.body.txEffects.flatMap((tx)=>tx.nullifiers)){
-                    await Promise.all([
-                        this.#nullifiersToBlockNumber.delete(nullifier.toString()),
-                        this.#nullifiersToBlockHash.delete(nullifier.toString()),
-                        this.#nullifiersToIndex.delete(nullifier.toString())
-                    ]);
-                }
-            }
-        });
-        return true;
-    }
-    async findNullifiersIndexesWithBlock(blockNumber, nullifiers) {
-        const asStrings = nullifiers.map((x)=>x.toString());
-        const maybeNullifiers = await Promise.all(asStrings.map(async (nullifier)=>{
-            const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
-                this.#nullifiersToIndex.getAsync(nullifier),
-                this.#nullifiersToBlockNumber.getAsync(nullifier),
-                this.#nullifiersToBlockHash.getAsync(nullifier)
-            ]);
-            return {
-                data,
-                l2BlockNumber,
-                l2BlockHash
-            };
-        }));
-        return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash })=>{
-            if (data === undefined || l2BlockNumber === undefined || l2BlockHash === undefined || l2BlockNumber > blockNumber) {
-                return undefined;
-            } else {
-                return {
-                    data: BigInt(data),
-                    l2BlockNumber,
-                    l2BlockHash
-                };
-            }
-        });
-    }
-}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts

@@ -1,23 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */
-export declare class L1ToL2MessageStore {
-    #private;
-    /**
-     * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-     */
-    protected store: Map<string, Fr>;
-    constructor();
-    getTotalL1ToL2MessageCount(): bigint;
-    addMessage(message: InboxLeaf): void;
-    getMessages(blockNumber: bigint): Fr[];
-    /**
-     * Gets the L1 to L2 message index in the L1 to L2 message tree.
-     * @param l1ToL2Message - The L1 to L2 message.
-     * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-     */
-    getMessageIndex(l1ToL2Message: Fr): bigint | undefined;
-}
-//# sourceMappingURL=l1_to_l2_message_store.d.ts.map

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1_to_l2_message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/memory_archiver_store/l1_to_l2_message_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;AACH,qBAAa,kBAAkB;;IAC7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAa;;IAM7C,0BAA0B,IAAI,MAAM;IAIpC,UAAU,CAAC,OAAO,EAAE,SAAS;IAI7B,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,EAAE;IAsBtC;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,EAAE,GAAG,MAAM,GAAG,SAAS;CAQvD"}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.js

@@ -1,49 +0,0 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */ export class L1ToL2MessageStore {
-    /**
-   * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-   */ store = new Map();
-    #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-    constructor(){}
-    getTotalL1ToL2MessageCount() {
-        return BigInt(this.store.size);
-    }
-    addMessage(message) {
-        this.store.set(`${message.index}`, message.leaf);
-    }
-    getMessages(blockNumber) {
-        const messages = [];
-        let undefinedMessageFound = false;
-        const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
-        for(let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++){
-            // This is inefficient but probably fine for now.
-            const message = this.store.get(`${i}`);
-            if (message) {
-                if (undefinedMessageFound) {
-                    throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
-                }
-                messages.push(message);
-            } else {
-                undefinedMessageFound = true;
-            // We continue iterating over messages here to verify that there are no more messages after the undefined one.
-            // --> If this was the case this would imply there is some issue with log fetching.
-            }
-        }
-        return messages;
-    }
-    /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
-   * @param l1ToL2Message - The L1 to L2 message.
-   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-   */ getMessageIndex(l1ToL2Message) {
-        for (const [key, message] of this.store.entries()){
-            if (message.equals(l1ToL2Message)) {
-                return BigInt(key);
-            }
-        }
-        return undefined;
-    }
-}