@aztec/archiver 0.0.0-test.0

package/dest/archiver/structs/published.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"published.d.ts","sourceRoot":"","sources":["../../../src/archiver/structs/published.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,IAAI,EAAE,CAAC,CAAC;IACR,EAAE,EAAE,eAAe,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dest/archiver/structs/published.js

@@ -0,0 +1 @@
+/** Extends a type with L1 published info (block number, hash, and timestamp) */ export { };

package/dest/factory.d.ts

@@ -0,0 +1,24 @@
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import type { ArchiverApi, Service } from '@aztec/stdlib/interfaces/server';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { ArchiverConfig } from './archiver/config.js';
+/**
+ * Creates a local archiver.
+ * @param config - The archiver configuration.
+ * @param blobSinkClient - The blob sink client.
+ * @param opts - The options.
+ * @param telemetry - The telemetry client.
+ * @returns The local archiver.
+ */
+export declare function createArchiver(config: ArchiverConfig & DataStoreConfig, blobSinkClient: BlobSinkClientInterface, opts?: {
+    blockUntilSync: boolean;
+}, telemetry?: TelemetryClient): Promise<ArchiverApi & Service & L2BlockSourceEventEmitter>;
+/**
+ * Creates a remote archiver client.
+ * @param config - The archiver configuration.
+ * @returns The remote archiver client.
+ */
+export declare function createRemoteArchiver(config: ArchiverConfig): ArchiverApi;
+//# sourceMappingURL=factory.d.ts.map

package/dest/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAQ9D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAMrE,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAE5E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI3D;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,GAAG,eAAe,EACxC,cAAc,EAAE,uBAAuB,EACvC,IAAI,GAAE;IAAE,cAAc,EAAE,OAAO,CAAA;CAA6B,EAC5D,SAAS,GAAE,eAAsC,GAChD,OAAO,CAAC,WAAW,GAAG,OAAO,GAAG,yBAAyB,CAAC,CAW5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CASxE"}

package/dest/factory.js

@@ -0,0 +1,85 @@
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractNames, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
+import { computePublicBytecodeCommitment, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { Archiver } from './archiver/archiver.js';
+import { KVArchiverDataStore } from './archiver/index.js';
+import { createArchiverClient } from './rpc/index.js';
+/**
+ * Creates a local archiver.
+ * @param config - The archiver configuration.
+ * @param blobSinkClient - The blob sink client.
+ * @param opts - The options.
+ * @param telemetry - The telemetry client.
+ * @returns The local archiver.
+ */ export async function createArchiver(config, blobSinkClient, opts = {
+    blockUntilSync: true
+}, telemetry = getTelemetryClient()) {
+    const store = await createStore('archiver', KVArchiverDataStore.SCHEMA_VERSION, config, createLogger('archiver:lmdb'));
+    const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
+    await registerProtocolContracts(archiverStore);
+    await registerCommonContracts(archiverStore);
+    return Archiver.createAndSync(config, archiverStore, {
+        telemetry,
+        blobSinkClient
+    }, opts.blockUntilSync);
+}
+/**
+ * Creates a remote archiver client.
+ * @param config - The archiver configuration.
+ * @returns The remote archiver client.
+ */ export function createRemoteArchiver(config) {
+    if (!config.archiverUrl) {
+        throw new Error('Archiver URL is required');
+    }
+    return createArchiverClient(config.archiverUrl, getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot()));
+}
+async function registerProtocolContracts(store) {
+    const blockNumber = 0;
+    for (const name of protocolContractNames){
+        const provider = new BundledProtocolContractsProvider();
+        const contract = await provider.getProtocolContractArtifact(name);
+        const contractClassPublic = {
+            ...contract.contractClass,
+            privateFunctions: [],
+            unconstrainedFunctions: []
+        };
+        const publicFunctionSignatures = contract.artifact.functions.filter((fn)=>fn.functionType === FunctionType.PUBLIC).map((fn)=>decodeFunctionSignature(fn.name, fn.parameters));
+        await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
+        const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
+        await store.addContractClasses([
+            contractClassPublic
+        ], [
+            bytecodeCommitment
+        ], blockNumber);
+        await store.addContractInstances([
+            contract.instance
+        ], blockNumber);
+    }
+}
+// TODO(#10007): Remove this method. We are explicitly registering these contracts
+// here to ensure they are available to all nodes and all prover nodes, since the PXE
+// was tweaked to automatically push contract classes to the node it is registered,
+// but other nodes in the network may require the contract classes to be registered as well.
+// TODO(#10007): Remove the dependency on noir-contracts.js from this package once we remove this.
+async function registerCommonContracts(store) {
+    const blockNumber = 0;
+    const artifacts = [
+        TokenBridgeContractArtifact,
+        TokenContractArtifact
+    ];
+    const classes = await Promise.all(artifacts.map(async (artifact)=>({
+            ...await getContractClassFromArtifact(artifact),
+            privateFunctions: [],
+            unconstrainedFunctions: []
+        })));
+    const bytecodeCommitments = await Promise.all(classes.map((x)=>computePublicBytecodeCommitment(x.packedBytecode)));
+    await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
+}

package/dest/index.d.ts

@@ -0,0 +1,5 @@
+export * from './archiver/index.js';
+export * from './factory.js';
+export * from './rpc/index.js';
+export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAE/B,OAAO,EAAE,wBAAwB,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC"}

package/dest/index.js

@@ -0,0 +1,4 @@
+export * from './archiver/index.js';
+export * from './factory.js';
+export * from './rpc/index.js';
+export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';

package/dest/rpc/index.d.ts

@@ -0,0 +1,10 @@
+import { type ArchiverApi } from '@aztec/stdlib/interfaces/server';
+import { type ComponentsVersions } from '@aztec/stdlib/versioning';
+export declare function createArchiverClient(url: string, versions: Partial<ComponentsVersions>, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, extraHeaders?: Record<string, string> | undefined, noRetry?: boolean | undefined) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>): ArchiverApi;
+export declare function createArchiverRpcServer(handler: ArchiverApi): import("@aztec/foundation/json-rpc/server").SafeJsonRpcServer;
+//# sourceMappingURL=index.d.ts.map

package/dest/rpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rpc/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,0BAA0B,CAAC;AAGjG,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAAmC,GACvC,WAAW,CAMb;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,iEAE3D"}

package/dest/rpc/index.js

@@ -0,0 +1,18 @@
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
+import { getVersioningResponseHandler } from '@aztec/stdlib/versioning';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
+export function createArchiverClient(url, versions, fetch = makeTracedFetch([
+    1,
+    2,
+    3
+], true)) {
+    return createSafeJsonRpcClient(url, ArchiverApiSchema, {
+        namespaceMethods: 'archiver',
+        fetch,
+        onResponse: getVersioningResponseHandler(versions)
+    });
+}
+export function createArchiverRpcServer(handler) {
+    return createTracedJsonRpcServer(handler, ArchiverApiSchema);
+}

package/dest/test/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mock_l2_block_source.js';
+export * from './mock_l1_to_l2_message_source.js';
+export * from './mock_archiver.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC"}

package/dest/test/index.js

@@ -0,0 +1,3 @@
+export * from './mock_l2_block_source.js';
+export * from './mock_l1_to_l2_message_source.js';
+export * from './mock_archiver.js';

package/dest/test/mock_archiver.d.ts

@@ -0,0 +1,23 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { MockL2BlockSource } from './mock_l2_block_source.js';
+/**
+ * A mocked implementation of the archiver that implements L2BlockSource and L1ToL2MessageSource.
+ */
+export declare class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1ToL2MessageSource {
+    private messageSource;
+    setL1ToL2Messages(blockNumber: number, msgs: Fr[]): void;
+    getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+    getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined>;
+}
+/**
+ * A mocked implementation of the archiver with a set of precomputed blocks and messages.
+ */
+export declare class MockPrefilledArchiver extends MockArchiver {
+    private precomputed;
+    constructor(precomputed: L2Block[], messages: Fr[][]);
+    setPrefilledBlocks(blocks: L2Block[], messages: Fr[][]): void;
+    createBlocks(numBlocks: number): Promise<void>;
+}
+//# sourceMappingURL=mock_archiver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock_archiver.d.ts","sourceRoot":"","sources":["../../src/test/mock_archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;GAEG;AACH,qBAAa,YAAa,SAAQ,iBAAkB,YAAW,aAAa,EAAE,mBAAmB;IAC/F,OAAO,CAAC,aAAa,CAAkC;IAEhD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;IAIxD,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAIrD,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CAGvE;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;IACrD,OAAO,CAAC,WAAW,CAAY;gBAEnB,WAAW,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE;IAM7C,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE;IAO7C,YAAY,CAAC,SAAS,EAAE,MAAM;CAW/C"}

package/dest/test/mock_archiver.js

@@ -0,0 +1,40 @@
+import { MockL1ToL2MessageSource } from './mock_l1_to_l2_message_source.js';
+import { MockL2BlockSource } from './mock_l2_block_source.js';
+/**
+ * A mocked implementation of the archiver that implements L2BlockSource and L1ToL2MessageSource.
+ */ export class MockArchiver extends MockL2BlockSource {
+    messageSource = new MockL1ToL2MessageSource(0);
+    setL1ToL2Messages(blockNumber, msgs) {
+        this.messageSource.setL1ToL2Messages(blockNumber, msgs);
+    }
+    getL1ToL2Messages(blockNumber) {
+        return this.messageSource.getL1ToL2Messages(blockNumber);
+    }
+    getL1ToL2MessageIndex(_l1ToL2Message) {
+        return this.messageSource.getL1ToL2MessageIndex(_l1ToL2Message);
+    }
+}
+/**
+ * A mocked implementation of the archiver with a set of precomputed blocks and messages.
+ */ export class MockPrefilledArchiver extends MockArchiver {
+    precomputed;
+    constructor(precomputed, messages){
+        super();
+        this.precomputed = precomputed.slice();
+        messages.forEach((msgs, i)=>this.setL1ToL2Messages(i + 1, msgs));
+    }
+    setPrefilledBlocks(blocks, messages) {
+        for (const block of blocks){
+            this.precomputed[block.number - 1] = block;
+        }
+        messages.forEach((msgs, i)=>this.setL1ToL2Messages(blocks[i].number, msgs));
+    }
+    createBlocks(numBlocks) {
+        if (this.l2Blocks.length + numBlocks > this.precomputed.length) {
+            throw new Error(`Not enough precomputed blocks to create ${numBlocks} more blocks (already at ${this.l2Blocks.length})`);
+        }
+        const fromBlock = this.l2Blocks.length;
+        this.addBlocks(this.precomputed.slice(fromBlock, fromBlock + numBlocks));
+        return Promise.resolve();
+    }
+}

package/dest/test/mock_l1_to_l2_message_source.d.ts

@@ -0,0 +1,16 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+/**
+ * A mocked implementation of L1ToL2MessageSource to be used in tests.
+ */
+export declare class MockL1ToL2MessageSource implements L1ToL2MessageSource {
+    private blockNumber;
+    private messagesPerBlock;
+    constructor(blockNumber: number);
+    setL1ToL2Messages(blockNumber: number, msgs: Fr[]): void;
+    setBlockNumber(blockNumber: number): void;
+    getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+    getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined>;
+    getBlockNumber(): Promise<number>;
+}
+//# sourceMappingURL=mock_l1_to_l2_message_source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock_l1_to_l2_message_source.d.ts","sourceRoot":"","sources":["../../src/test/mock_l1_to_l2_message_source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAGrD,OAAO,CAAC,WAAW;IAF/B,OAAO,CAAC,gBAAgB,CAA2B;gBAE/B,WAAW,EAAE,MAAM;IAEhC,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;IAIjD,cAAc,CAAC,WAAW,EAAE,MAAM;IAIzC,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAIrD,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAItE,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;CAGlC"}

package/dest/test/mock_l1_to_l2_message_source.js

@@ -0,0 +1,25 @@
+/**
+ * A mocked implementation of L1ToL2MessageSource to be used in tests.
+ */ export class MockL1ToL2MessageSource {
+    blockNumber;
+    messagesPerBlock;
+    constructor(blockNumber){
+        this.blockNumber = blockNumber;
+        this.messagesPerBlock = new Map();
+    }
+    setL1ToL2Messages(blockNumber, msgs) {
+        this.messagesPerBlock.set(blockNumber, msgs);
+    }
+    setBlockNumber(blockNumber) {
+        this.blockNumber = blockNumber;
+    }
+    getL1ToL2Messages(blockNumber) {
+        return Promise.resolve(this.messagesPerBlock.get(Number(blockNumber)) ?? []);
+    }
+    getL1ToL2MessageIndex(_l1ToL2Message) {
+        throw new Error('Method not implemented.');
+    }
+    getBlockNumber() {
+        return Promise.resolve(this.blockNumber);
+    }
+}

package/dest/test/mock_l2_block_source.d.ts

@@ -0,0 +1,79 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L2Block, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+/**
+ * A mocked implementation of L2BlockSource to be used in tests.
+ */
+export declare class MockL2BlockSource implements L2BlockSource {
+    protected l2Blocks: L2Block[];
+    private provenBlockNumber;
+    private log;
+    createBlocks(numBlocks: number): Promise<void>;
+    addBlocks(blocks: L2Block[]): void;
+    removeBlocks(numBlocks: number): void;
+    setProvenBlockNumber(provenBlockNumber: number): void;
+    /**
+     * Method to fetch the rollup contract address at the base-layer.
+     * @returns The rollup address.
+     */
+    getRollupAddress(): Promise<EthAddress>;
+    /**
+     * Method to fetch the registry contract address at the base-layer.
+     * @returns The registry address.
+     */
+    getRegistryAddress(): Promise<EthAddress>;
+    /**
+     * Gets the number of the latest L2 block processed by the block source implementation.
+     * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
+     */
+    getBlockNumber(): Promise<number>;
+    getProvenBlockNumber(): Promise<number>;
+    /**
+     * Gets an l2 block.
+     * @param number - The block number to return (inclusive).
+     * @returns The requested L2 block.
+     */
+    getBlock(number: number): Promise<L2Block>;
+    /**
+     * 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: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+    getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined>;
+    getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]>;
+    /**
+     * Gets a tx effect.
+     * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+     * @returns The requested tx effect.
+     */
+    getTxEffect(txHash: TxHash): Promise<{
+        data: import("@aztec/stdlib/tx").TxEffect;
+        l2BlockNumber: number;
+        l2BlockHash: `0x${string}`;
+    } | undefined>;
+    /**
+     * Gets a receipt of a settled tx.
+     * @param txHash - The hash of a tx we try to get the receipt for.
+     * @returns The requested tx receipt (or undefined if not found).
+     */
+    getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
+    getL2Tips(): Promise<L2Tips>;
+    getL2EpochNumber(): Promise<bigint>;
+    getL2SlotNumber(): Promise<bigint>;
+    isEpochComplete(_epochNumber: bigint): Promise<boolean>;
+    getL1Constants(): Promise<L1RollupConstants>;
+    /**
+     * Starts the block source. In this mock implementation, this is a noop.
+     * @returns A promise that signals the initialization of the l2 block source on completion.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the block source. In this mock implementation, this is a noop.
+     * @returns A promise that signals the l2 block source is now stopped.
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=mock_l2_block_source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock_l2_block_source.d.ts","sourceRoot":"","sources":["../../src/test/mock_l2_block_source.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAe,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,KAAK,iBAAiB,EAAwB,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,EAAE,SAAS,EAAY,MAAM,kBAAkB,CAAC;AAEjF;;GAEG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IACrD,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAM;IAEnC,OAAO,CAAC,iBAAiB,CAAa;IAEtC,OAAO,CAAC,GAAG,CAAiD;IAE/C,YAAY,CAAC,SAAS,EAAE,MAAM;IAUpC,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE;IAK3B,YAAY,CAAC,SAAS,EAAE,MAAM;IAK9B,oBAAoB,CAAC,iBAAiB,EAAE,MAAM;IAIrD;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;;OAGG;IACH,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC;IAIzC;;;OAGG;IACI,cAAc;IAId,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9C;;;;OAIG;IACI,QAAQ,CAAC,MAAM,EAAE,MAAM;IAI9B;;;;;OAKG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO;IAQ9D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAI3E,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAU1D;;;;OAIG;IACU,WAAW,CAAC,MAAM,EAAE,MAAM;;;;;IAWvC;;;;OAIG;IACU,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAkB1E,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IA2BlC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAInC,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC;IAIlC,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvD,cAAc,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAI5C;;;OAGG;IACI,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B;;;OAGG;IACI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dest/test/mock_l2_block_source.js

@@ -0,0 +1,163 @@
+import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { L2Block, L2BlockHash } from '@aztec/stdlib/block';
+import { getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+/**
+ * A mocked implementation of L2BlockSource to be used in tests.
+ */ export class MockL2BlockSource {
+    l2Blocks = [];
+    provenBlockNumber = 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(blockNum);
+            this.l2Blocks.push(block);
+        }
+        this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
+    }
+    addBlocks(blocks) {
+        this.l2Blocks.push(...blocks);
+        this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+    }
+    removeBlocks(numBlocks) {
+        this.l2Blocks = this.l2Blocks.slice(0, -numBlocks);
+        this.log.verbose(`Removed ${numBlocks} blocks from the mock L2 block source`);
+    }
+    setProvenBlockNumber(provenBlockNumber) {
+        this.provenBlockNumber = provenBlockNumber;
+    }
+    /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */ getRollupAddress() {
+        return Promise.resolve(EthAddress.random());
+    }
+    /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */ getRegistryAddress() {
+        return Promise.resolve(EthAddress.random());
+    }
+    /**
+   * Gets the number of the latest L2 block processed by the block source implementation.
+   * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
+   */ getBlockNumber() {
+        return Promise.resolve(this.l2Blocks.length);
+    }
+    getProvenBlockNumber() {
+        return Promise.resolve(this.provenBlockNumber);
+    }
+    /**
+   * 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]);
+    }
+    /**
+   * 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));
+    }
+    getBlockHeader(number) {
+        return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+    }
+    getBlocksForEpoch(epochNumber) {
+        const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+        const [start, end] = getSlotRangeForEpoch(epochNumber, {
+            epochDuration
+        });
+        const blocks = this.l2Blocks.filter((b)=>{
+            const slot = b.header.globalVariables.slotNumber.toBigInt();
+            return slot >= start && slot <= end;
+        });
+        return Promise.resolve(blocks);
+    }
+    /**
+   * Gets a tx effect.
+   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+   * @returns The requested tx effect.
+   */ async getTxEffect(txHash) {
+        const match = this.l2Blocks.flatMap((b)=>b.body.txEffects.map((tx)=>[
+                    tx,
+                    b
+                ])).find(([tx])=>tx.txHash.equals(txHash));
+        if (!match) {
+            return Promise.resolve(undefined);
+        }
+        const [txEffect, block] = match;
+        return {
+            data: txEffect,
+            l2BlockNumber: block.number,
+            l2BlockHash: (await block.hash()).toString()
+        };
+    }
+    /**
+   * Gets a receipt of a settled tx.
+   * @param txHash - The hash of a tx we try to get the receipt for.
+   * @returns The requested tx receipt (or undefined if not found).
+   */ async getSettledTxReceipt(txHash) {
+        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);
+                }
+            }
+        }
+        return undefined;
+    }
+    async getL2Tips() {
+        const [latest, proven, finalized] = [
+            await this.getBlockNumber(),
+            await this.getProvenBlockNumber(),
+            await this.getProvenBlockNumber()
+        ];
+        const latestBlock = this.l2Blocks[latest - 1];
+        const provenBlock = this.l2Blocks[proven - 1];
+        const finalizedBlock = this.l2Blocks[finalized - 1];
+        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()
+            }
+        };
+    }
+    getL2EpochNumber() {
+        throw new Error('Method not implemented.');
+    }
+    getL2SlotNumber() {
+        throw new Error('Method not implemented.');
+    }
+    isEpochComplete(_epochNumber) {
+        throw new Error('Method not implemented.');
+    }
+    getL1Constants() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+   * Starts the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the initialization of the l2 block source on completion.
+   */ start() {
+        return Promise.resolve();
+    }
+    /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */ stop() {
+        return Promise.resolve();
+    }
+}