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

package/dest/test/mock_l2_block_source.js

@@ -1,32 +1,35 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, 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 { createLogger } from '@aztec/foundation/log';
-import { L2Block, L2BlockHash, PublishedL2Block } from '@aztec/stdlib/block';
-import { L1PublishedData } from '@aztec/stdlib/checkpoint';
+import { BlockHash, CheckpointedL2Block, L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */ export class MockL2BlockSource {
     l2Blocks = [];
     provenBlockNumber = 0;
     finalizedBlockNumber = 0;
+    checkpointedBlockNumber = 0;
     log = createLogger('archiver:mock_l2_block_source');
     async createBlocks(numBlocks) {
         for(let i = 0; i < numBlocks; i++){
             const blockNum = this.l2Blocks.length + 1;
-            const block = await L2Block.random(BlockNumber(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`);
     }
-    addBlocks(blocks) {
+    addProposedBlocks(blocks) {
         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`);
     }
     removeBlocks(numBlocks) {
         this.l2Blocks = this.l2Blocks.slice(0, -numBlocks);
@@ -41,6 +44,9 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         this.finalizedBlockNumber = finalizedBlockNumber;
     }
+    setCheckpointedBlockNumber(checkpointedBlockNumber) {
+        this.checkpointedBlockNumber = checkpointedBlockNumber;
+    }
     /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -62,54 +68,96 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     getProvenBlockNumber() {
         return Promise.resolve(BlockNumber(this.provenBlockNumber));
     }
-    getCheckpointedBlock(_number) {
-        // In this mock, we don't track checkpointed blocks separately
-        return Promise.resolve(undefined);
+    getCheckpointedL2BlockNumber() {
+        return Promise.resolve(BlockNumber(this.checkpointedBlockNumber));
+    }
+    getFinalizedL2BlockNumber() {
+        return Promise.resolve(BlockNumber(this.finalizedBlockNumber));
+    }
+    getCheckpointedBlock(number) {
+        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);
+    }
+    async getCheckpointedBlocks(from, limit) {
+        const result = [];
+        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;
     }
     /**
    * Gets an l2 block.
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */ getBlock(number) {
-        return Promise.resolve(this.l2Blocks[number - 1]);
+        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.
-   */ getL2BlockNew(number) {
+   */ getL2Block(number) {
         const block = this.l2Blocks[number - 1];
-        return Promise.resolve(block?.toL2Block());
+        return Promise.resolve(block);
     }
     /**
    * 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.
    * @returns The requested mocked L2 blocks.
-   */ getBlocks(from, limit, proven) {
-        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit).filter((b)=>!proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber));
-    }
-    async getPublishedCheckpoints(from, limit) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return (await this.getPublishedBlocks(from, limit)).map((block)=>block.toPublishedCheckpoint());
+   */ getBlocks(from, limit) {
+        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
+    }
+    getCheckpoints(from, limit) {
+        // 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()), []);
+        }));
     }
     async getCheckpointByArchive(archive) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return (await this.getPublishedBlockByArchive(archive))?.block.toCheckpoint();
-    }
-    async getPublishedBlocks(from, limit, proven) {
-        const blocks = await this.getBlocks(from, limit, proven);
-        return blocks.map((block)=>PublishedL2Block.fromFields({
-                block,
-                l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                attestations: []
-            }));
+        // 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;
     }
-    async getPublishedBlockByHash(blockHash) {
+    async getCheckpointedBlockByHash(blockHash) {
         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: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
                     attestations: []
@@ -118,38 +166,69 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         return undefined;
     }
-    getPublishedBlockByArchive(archive) {
+    getCheckpointedBlockByArchive(archive) {
         const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
         if (!block) {
             return Promise.resolve(undefined);
         }
-        return Promise.resolve(PublishedL2Block.fromFields({
+        return Promise.resolve(CheckpointedL2Block.fromFields({
+            checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
             block,
             l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
             attestations: []
         }));
     }
+    async getL2BlockByHash(blockHash) {
+        for (const block of this.l2Blocks){
+            const hash = await block.hash();
+            if (hash.equals(blockHash)) {
+                return block;
+            }
+        }
+        return undefined;
+    }
+    getL2BlockByArchive(archive) {
+        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
+        return Promise.resolve(block);
+    }
     async getBlockHeaderByHash(blockHash) {
         for (const block of this.l2Blocks){
             const hash = await block.hash();
             if (hash.equals(blockHash)) {
-                return block.getBlockHeader();
+                return block.header;
             }
         }
         return undefined;
     }
     getBlockHeaderByArchive(archive) {
         const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        return Promise.resolve(block?.getBlockHeader());
+        return Promise.resolve(block?.header);
     }
     getBlockHeader(number) {
-        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);
     }
     getCheckpointsForEpoch(epochNumber) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return this.getBlocksForEpoch(epochNumber).then((blocks)=>blocks.map((b)=>b.toCheckpoint()));
+        // 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;
+        }));
     }
-    getBlocksForEpoch(epochNumber) {
+    getCheckpointedBlocksForEpoch(epochNumber) {
         const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
         const [start, end] = getSlotRangeForEpoch(epochNumber, {
             epochDuration
@@ -158,11 +237,20 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             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) {
+        const blocks = this.l2Blocks.filter((b)=>b.header.globalVariables.slotNumber === slotNumber);
         return Promise.resolve(blocks);
     }
-    async getBlockHeadersForEpoch(epochNumber) {
-        const blocks = await this.getBlocksForEpoch(epochNumber);
-        return blocks.map((b)=>b.getBlockHeader());
+    async getCheckpointedBlockHeadersForEpoch(epochNumber) {
+        const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
+        return checkpointedBlocks.map((b)=>b.block.header);
     }
     /**
    * Gets a tx effect.
@@ -180,7 +268,7 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         return {
             data: txEffect,
             l2BlockNumber: block.number,
-            l2BlockHash: L2BlockHash.fromField(await block.hash()),
+            l2BlockHash: BlockHash.fromField(await block.hash()),
             txIndexInBlock: block.body.txEffects.indexOf(txEffect)
         };
     }
@@ -192,34 +280,52 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         for (const block of this.l2Blocks){
             for (const txEffect of block.body.txEffects){
                 if (txEffect.txHash.equals(txHash)) {
-                    return new TxReceipt(txHash, TxStatus.SUCCESS, '', txEffect.transactionFee.toBigInt(), L2BlockHash.fromField(await block.hash()), block.number);
+                    // In mock, assume all txs are checkpointed with successful execution
+                    return new TxReceipt(txHash, TxStatus.CHECKPOINTED, TxExecutionResult.SUCCESS, undefined, txEffect.transactionFee.toBigInt(), BlockHash.fromField(await block.hash()), block.number);
                 }
             }
         }
         return undefined;
     }
     async getL2Tips() {
-        const [latest, proven, finalized] = [
+        const [latest, proven, finalized, checkpointed] = [
             await this.getBlockNumber(),
             await this.getProvenBlockNumber(),
-            this.finalizedBlockNumber
+            this.finalizedBlockNumber,
+            this.checkpointedBlockNumber
         ];
         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)=>({
+                block: blockId,
+                checkpoint: {
+                    number: CheckpointNumber.fromBlockNumber(blockId.number),
+                    hash: blockId.hash
+                }
+            });
         return {
-            latest: {
-                number: BlockNumber(latest),
-                hash: (await latestBlock?.hash())?.toString()
-            },
-            proven: {
-                number: BlockNumber(proven),
-                hash: (await provenBlock?.hash())?.toString()
-            },
-            finalized: {
-                number: BlockNumber(finalized),
-                hash: (await finalizedBlock?.hash())?.toString()
-            }
+            proposed: latestBlockId,
+            checkpointed: makeTipId(checkpointedBlockId),
+            proven: makeTipId(provenBlockId),
+            finalized: makeTipId(finalizedBlockId)
         };
     }
     getL2EpochNumber() {

package/dest/test/mock_structs.d.ts

@@ -1,10 +1,85 @@
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16 } from '@aztec/foundation/buffer';
-import { type InboxMessage } from '../archiver/structs/inbox_message.js';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { StateReference } from '@aztec/stdlib/tx';
+import { type InboxMessage } from '../structs/inbox_message.js';
 export declare function makeInboxMessage(previousRollingHash?: Buffer16, overrides?: Partial<InboxMessage>): InboxMessage;
-export declare function makeInboxMessages(count: number, opts?: {
+export declare function makeInboxMessages(totalCount: number, opts?: {
     initialHash?: Buffer16;
     initialCheckpointNumber?: CheckpointNumber;
+    messagesPerCheckpoint?: number;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
 }): InboxMessage[];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19zdHJ1Y3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9tb2NrX3N0cnVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxFQUFFLFFBQVEsRUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBSzlELE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBcUIsTUFBTSxzQ0FBc0MsQ0FBQztBQUU1Rix3QkFBZ0IsZ0JBQWdCLENBQzlCLG1CQUFtQixXQUFnQixFQUNuQyxTQUFTLEdBQUUsT0FBTyxDQUFDLFlBQVksQ0FBTSxHQUNwQyxZQUFZLENBZ0JkO0FBRUQsd0JBQWdCLGlCQUFpQixDQUMvQixLQUFLLEVBQUUsTUFBTSxFQUNiLElBQUksR0FBRTtJQUNKLFdBQVcsQ0FBQyxFQUFFLFFBQVEsQ0FBQztJQUN2Qix1QkFBdUIsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO0lBQzNDLFVBQVUsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxLQUFLLFlBQVksQ0FBQztDQUM1RCxHQUNMLFlBQVksRUFBRSxDQWFoQiJ9
+/** Creates inbox messages distributed across multiple blocks with proper checkpoint numbering. */
+export declare function makeInboxMessagesWithFullBlocks(blockCount: number, opts?: {
+    initialCheckpointNumber?: CheckpointNumber;
+}): InboxMessage[];
+/** Creates a deterministic block hash from a block number. */
+export declare function makeBlockHash(blockNumber: number): `0x${string}`;
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */
+export declare function makeStateForBlock(blockNumber: number, txsPerBlock: number): StateReference;
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */
+export declare function makeL1PublishedData(l1BlockNumber: number): L1PublishedData;
+/** Wraps a Checkpoint with L1 published data and random attestations. */
+export declare function makePublishedCheckpoint(checkpoint: Checkpoint, l1BlockNumber: number, attestationCount?: number): PublishedCheckpoint;
+export interface MakeChainedCheckpointsOptions {
+    /** Number of L2 blocks per checkpoint. Default: 1 */
+    blocksPerCheckpoint?: number;
+    /** Number of transactions per block. Default: 4 */
+    txsPerBlock?: number;
+    /** Starting checkpoint number. Default: CheckpointNumber(1) */
+    startCheckpointNumber?: CheckpointNumber;
+    /** Starting block number. Default: 1 */
+    startBlockNumber?: number;
+    /** Starting L1 block number. Default: 10 */
+    startL1BlockNumber?: number;
+    /** Previous archive to chain from. Default: undefined */
+    previousArchive?: AppendOnlyTreeSnapshot;
+    /** Optional function to provide per-checkpoint overrides */
+    makeCheckpointOptions?: (cpNumber: CheckpointNumber) => Partial<Parameters<typeof Checkpoint.random>[1]>;
+}
+/**
+ * Creates multiple checkpoints with properly chained archives.
+ * Each checkpoint's blocks have their lastArchive set to the previous block's archive,
+ * ensuring archive chain continuity for testing.
+ */
+export declare function makeChainedCheckpoints(count: number, options?: MakeChainedCheckpointsOptions): Promise<PublishedCheckpoint[]>;
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */
+export declare function makeSignedPublishedCheckpoint(checkpoint: Checkpoint, signers: Secp256k1Signer[], committee: EthAddress[], l1BlockNumber?: number): PublishedCheckpoint;
+/** Creates a deterministic SiloedTag for private log testing. */
+export declare function makePrivateLogTag(blockNumber: number, txIndex: number, logIndex: number): SiloedTag;
+/** Creates a PrivateLog with fields derived from the tag. */
+export declare function makePrivateLog(tag: SiloedTag): PrivateLog;
+/** Creates multiple private logs for a transaction. */
+export declare function mockPrivateLogs(blockNumber: number, txIndex: number, numLogsPerTx: number): PrivateLog[];
+/** Creates a deterministic Tag for public log testing. */
+export declare function makePublicLogTag(blockNumber: number, txIndex: number, logIndex: number): Tag;
+/** Creates a PublicLog with fields derived from the tag. */
+export declare function makePublicLog(tag: Tag, contractAddress?: AztecAddress): PublicLog;
+/** Creates multiple public logs for a transaction. */
+export declare function makePublicLogs(blockNumber: number, txIndex: number, numLogsPerTx: number, contractAddress?: AztecAddress): PublicLog[];
+export interface MockCheckpointWithLogsOptions {
+    previousArchive?: AppendOnlyTreeSnapshot;
+    numTxsPerBlock?: number;
+    privateLogs?: {
+        numLogsPerTx: number;
+    };
+    publicLogs?: {
+        numLogsPerTx: number;
+        contractAddress?: AztecAddress;
+    };
+}
+/** Creates a checkpoint with specified logs on each tx effect. */
+export declare function makeCheckpointWithLogs(blockNumber: number, options?: MockCheckpointWithLogsOptions): Promise<PublishedCheckpoint>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/test/mock_structs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock_structs.d.ts","sourceRoot":"","sources":["../../src/test/mock_structs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAK9D,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,sCAAsC,CAAC;AAE5F,wBAAgB,gBAAgB,CAC9B,mBAAmB,WAAgB,EACnC,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GACpC,YAAY,CAgBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;IACJ,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,uBAAuB,CAAC,EAAE,gBAAgB,CAAC;IAC3C,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC;CAC5D,GACL,YAAY,EAAE,CAahB"}
+{"version":3,"file":"mock_structs.d.ts","sourceRoot":"","sources":["../../src/test/mock_structs.ts"],"names":[],"mappings":"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"}

package/dest/test/mock_structs.js

@@ -1,9 +1,21 @@
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { MAX_NOTE_HASHES_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { updateRollingHash } from '../archiver/structs/inbox_message.js';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeCheckpointAttestationFromCheckpoint } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { PartialStateReference, StateReference, TxEffect } from '@aztec/stdlib/tx';
+import { updateRollingHash } from '../structs/inbox_message.js';
 export function makeInboxMessage(previousRollingHash = Buffer16.ZERO, overrides = {}) {
     const { checkpointNumber = CheckpointNumber(randomInt(100) + 1) } = overrides;
     const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
@@ -20,19 +32,140 @@ export function makeInboxMessage(previousRollingHash = Buffer16.ZERO, overrides
         rollingHash
     };
 }
-export function makeInboxMessages(count, opts = {}) {
-    const { initialHash = Buffer16.ZERO, overrideFn = (msg)=>msg, initialCheckpointNumber = 1 } = opts;
+export function makeInboxMessages(totalCount, opts = {}) {
+    const { initialHash = Buffer16.ZERO, overrideFn = (msg)=>msg, initialCheckpointNumber = CheckpointNumber(1), messagesPerCheckpoint = 1 } = opts;
     const messages = [];
     let rollingHash = initialHash;
-    for(let i = 0; i < count; i++){
+    for(let i = 0; i < totalCount; i++){
+        const msgIndex = i % messagesPerCheckpoint;
+        const checkpointNumber = CheckpointNumber.fromBigInt(BigInt(initialCheckpointNumber) + BigInt(i) / BigInt(messagesPerCheckpoint));
         const leaf = Fr.random();
-        const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
         const message = overrideFn(makeInboxMessage(rollingHash, {
             leaf,
-            checkpointNumber
+            checkpointNumber,
+            index: InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(msgIndex)
         }), i);
         rollingHash = message.rollingHash;
         messages.push(message);
     }
     return messages;
 }
+/** Creates inbox messages distributed across multiple blocks with proper checkpoint numbering. */ export function makeInboxMessagesWithFullBlocks(blockCount, opts = {}) {
+    const { initialCheckpointNumber = CheckpointNumber(13) } = opts;
+    return makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
+        overrideFn: (msg, i)=>{
+            const checkpointNumber = CheckpointNumber(initialCheckpointNumber + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+            const index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+            return {
+                ...msg,
+                checkpointNumber,
+                index
+            };
+        }
+    });
+}
+/** Creates a deterministic block hash from a block number. */ export function makeBlockHash(blockNumber) {
+    return `0x${blockNumber.toString(16).padStart(64, '0')}`;
+}
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */ export function makeStateForBlock(blockNumber, txsPerBlock) {
+    const noteHashIndex = blockNumber * txsPerBlock * MAX_NOTE_HASHES_PER_TX;
+    return new StateReference(AppendOnlyTreeSnapshot.random(), new PartialStateReference(new AppendOnlyTreeSnapshot(Fr.random(), noteHashIndex), AppendOnlyTreeSnapshot.random(), AppendOnlyTreeSnapshot.random()));
+}
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */ export function makeL1PublishedData(l1BlockNumber) {
+    return new L1PublishedData(BigInt(l1BlockNumber), BigInt(l1BlockNumber * 1000), makeBlockHash(l1BlockNumber));
+}
+/** Wraps a Checkpoint with L1 published data and random attestations. */ export function makePublishedCheckpoint(checkpoint, l1BlockNumber, attestationCount = 3) {
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), times(attestationCount, CommitteeAttestation.random));
+}
+/**
+ * Creates multiple checkpoints with properly chained archives.
+ * Each checkpoint's blocks have their lastArchive set to the previous block's archive,
+ * ensuring archive chain continuity for testing.
+ */ export async function makeChainedCheckpoints(count, options = {}) {
+    const { blocksPerCheckpoint = 1, txsPerBlock = 4, startCheckpointNumber = CheckpointNumber(1), startBlockNumber = 1, startL1BlockNumber = 10, makeCheckpointOptions } = options;
+    let previousArchive = options.previousArchive;
+    const checkpoints = [];
+    for(let i = 0; i < count; i++){
+        const cpNumber = CheckpointNumber(startCheckpointNumber + i);
+        const blockStart = startBlockNumber + i * blocksPerCheckpoint;
+        const customOptions = makeCheckpointOptions?.(cpNumber) ?? {};
+        const checkpoint = await Checkpoint.random(cpNumber, {
+            numBlocks: blocksPerCheckpoint,
+            startBlockNumber: blockStart,
+            previousArchive,
+            txsPerBlock,
+            state: makeStateForBlock(blockStart, txsPerBlock),
+            txOptions: {
+                numPublicCallsPerTx: 2,
+                numPublicLogsPerCall: 2
+            },
+            ...customOptions
+        });
+        previousArchive = checkpoint.blocks.at(-1).archive;
+        checkpoints.push(makePublishedCheckpoint(checkpoint, startL1BlockNumber + i * 10));
+    }
+    return checkpoints;
+}
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */ export function makeSignedPublishedCheckpoint(checkpoint, signers, committee, l1BlockNumber = 1) {
+    const attestations = signers.map((signer)=>makeCheckpointAttestationFromCheckpoint(checkpoint, signer));
+    const committeeAttestations = orderAttestations(attestations, committee);
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), committeeAttestations);
+}
+/** Creates a deterministic SiloedTag for private log testing. */ export function makePrivateLogTag(blockNumber, txIndex, logIndex) {
+    return new SiloedTag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr(blockNumber * 100 + txIndex * 10 + logIndex));
+}
+/** Creates a PrivateLog with fields derived from the tag. */ export function makePrivateLog(tag) {
+    return PrivateLog.from({
+        fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, (i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i))),
+        emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS
+    });
+}
+/** Creates multiple private logs for a transaction. */ export function mockPrivateLogs(blockNumber, txIndex, numLogsPerTx) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePrivateLogTag(blockNumber, txIndex, logIndex);
+        return makePrivateLog(tag);
+    });
+}
+/** Creates a deterministic Tag for public log testing. */ export function makePublicLogTag(blockNumber, txIndex, logIndex) {
+    return new Tag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * 123));
+}
+/** Creates a PublicLog with fields derived from the tag. */ export function makePublicLog(tag, contractAddress = AztecAddress.fromNumber(543254)) {
+    return PublicLog.from({
+        contractAddress,
+        fields: new Array(10).fill(null).map((_, i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))
+    });
+}
+/** Creates multiple public logs for a transaction. */ export function makePublicLogs(blockNumber, txIndex, numLogsPerTx, contractAddress = AztecAddress.fromNumber(543254)) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePublicLogTag(blockNumber, txIndex, logIndex);
+        return makePublicLog(tag, contractAddress);
+    });
+}
+/** Creates a checkpoint with specified logs on each tx effect. */ export async function makeCheckpointWithLogs(blockNumber, options = {}) {
+    const { previousArchive, numTxsPerBlock = 4, privateLogs, publicLogs } = options;
+    const block = await L2Block.random(BlockNumber(blockNumber), {
+        checkpointNumber: CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
+        indexWithinCheckpoint: IndexWithinCheckpoint(0),
+        state: makeStateForBlock(blockNumber, numTxsPerBlock),
+        ...previousArchive ? {
+            lastArchive: previousArchive
+        } : {}
+    });
+    block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
+    block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex)=>{
+        const txEffect = await TxEffect.random();
+        txEffect.privateLogs = privateLogs ? mockPrivateLogs(blockNumber, txIndex, privateLogs.numLogsPerTx) : [];
+        txEffect.publicLogs = publicLogs ? makePublicLogs(blockNumber, txIndex, publicLogs.numLogsPerTx, publicLogs.contractAddress) : [];
+        return txEffect;
+    });
+    const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+        block
+    ], CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)));
+    return makePublishedCheckpoint(checkpoint, blockNumber);
+}