@aztec/archiver 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/dest/archiver/config.d.ts

@@ -1,21 +0,0 @@
-import { type BlobSinkConfig } from '@aztec/blob-sink/client';
-import { type L1ContractsConfig, type L1ReaderConfig } from '@aztec/ethereum';
-import { type ConfigMappingsType } from '@aztec/foundation/config';
-import { type ChainConfig } from '@aztec/stdlib/config';
-import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
-/**
- * The archiver configuration.
- * There are 2 polling intervals used in this configuration. The first is the archiver polling interval, archiverPollingIntervalMS.
- * This is the interval between successive calls to eth_blockNumber via viem.
- * Results of calls to eth_blockNumber are cached by viem with this cache being updated periodically at the interval specified by viemPollingIntervalMS.
- * As a result the maximum observed polling time for new blocks will be viemPollingIntervalMS + archiverPollingIntervalMS.
- */
-export type ArchiverConfig = ArchiverSpecificConfig & L1ReaderConfig & L1ContractsConfig & BlobSinkConfig & ChainConfig;
-export declare const archiverConfigMappings: ConfigMappingsType<ArchiverConfig>;
-/**
- * Returns the archiver configuration from the environment variables.
- * Note: If an environment variable is not set, the default value is used.
- * @returns The archiver configuration.
- */
-export declare function getArchiverConfigFromEnv(): ArchiverConfig;
-//# sourceMappingURL=config.d.ts.map

package/dest/archiver/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/archiver/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAyB,MAAM,yBAAyB,CAAC;AACrF,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAIpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,GAAG,cAAc,GAAG,iBAAiB,GAAG,cAAc,GAAG,WAAW,CAAC;AAExH,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CAsCrE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CAEzD"}

package/dest/archiver/data_retrieval.d.ts

@@ -1,78 +0,0 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { ViemClient, ViemPublicClient } from '@aztec/ethereum';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, PublishedL2Block } from '@aztec/stdlib/block';
-import { Proof } from '@aztec/stdlib/proofs';
-import { ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
-import { type GetContractReturnType, type Hex } from 'viem';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { InboxMessage } from './structs/inbox_message.js';
-import type { L1PublishedData } from './structs/published.js';
-export type RetrievedL2Block = {
-    l2BlockNumber: number;
-    archiveRoot: Fr;
-    stateReference: StateReference;
-    header: ProposedBlockHeader;
-    body: Body;
-    l1: L1PublishedData;
-    chainId: Fr;
-    version: Fr;
-    attestations: CommitteeAttestation[];
-};
-export declare function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): PublishedL2Block;
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
- */
-export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<RetrievedL2Block[]>;
-export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
-/** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
-export declare function retrieveL1ToL2Message(inbox: GetContractReturnType<typeof InboxAbi, ViemClient>, leaf: Fr, fromBlock: bigint, toBlock: bigint): Promise<InboxMessage | undefined>;
-/**
- * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of InboxLeaf and next eth block to search from.
- */
-export declare function retrieveL1ToL2Messages(inbox: GetContractReturnType<typeof InboxAbi, ViemClient>, searchStartBlock: bigint, searchEndBlock: bigint): Promise<InboxMessage[]>;
-/** Retrieves L2ProofVerified events from the rollup contract. */
-export declare function retrieveL2ProofVerifiedEvents(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<{
-    l1BlockNumber: bigint;
-    l2BlockNumber: number;
-    proverId: Fr;
-    txHash: Hex;
-}[]>;
-/** Retrieve submitted proofs from the rollup contract */
-export declare function retrieveL2ProofsFromRollup(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<DataRetrieval<{
-    proof: Proof;
-    proverId: Fr;
-    l2BlockNumber: number;
-    txHash: `0x${string}`;
-}>>;
-export type SubmitBlockProof = {
-    archiveRoot: Fr;
-    proverId: Fr;
-    proof: Proof;
-};
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */
-export declare function getProofFromSubmitProofTx(publicClient: ViemPublicClient, txHash: `0x${string}`, expectedProverId: Fr): Promise<SubmitBlockProof>;
-//# sourceMappingURL=data_retrieval.d.ts.map

package/dest/archiver/data_retrieval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data_retrieval.d.ts","sourceRoot":"","sources":["../../src/archiver/data_retrieval.ts"],"names":[],"mappings":"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"}

package/dest/archiver/data_retrieval.js

@@ -1,369 +0,0 @@
-import { Blob, BlobDeserializationError, EMPTY_BLOB_VERSIONED_HASH } from '@aztec/blob-lib';
-import { asyncPool } from '@aztec/foundation/async-pool';
-import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { bufferToHex } from '@aztec/foundation/string';
-import { RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
-import { Proof } from '@aztec/stdlib/proofs';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader, GlobalVariables, ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
-import { decodeFunctionData, getAbiItem, hexToBytes, multicall3Abi } from 'viem';
-import { NoBlobBodiesFoundError } from './errors.js';
-export function retrievedBlockToPublishedL2Block(retrievedBlock) {
-    const { l2BlockNumber, archiveRoot, stateReference, header: proposedHeader, body, l1, chainId, version, attestations } = retrievedBlock;
-    const archive = new AppendOnlyTreeSnapshot(archiveRoot, l2BlockNumber + 1);
-    const globalVariables = GlobalVariables.from({
-        chainId,
-        version,
-        blockNumber: l2BlockNumber,
-        slotNumber: proposedHeader.slotNumber,
-        timestamp: proposedHeader.timestamp,
-        coinbase: proposedHeader.coinbase,
-        feeRecipient: proposedHeader.feeRecipient,
-        gasFees: proposedHeader.gasFees
-    });
-    const header = BlockHeader.from({
-        lastArchive: new AppendOnlyTreeSnapshot(proposedHeader.lastArchiveRoot, l2BlockNumber),
-        contentCommitment: proposedHeader.contentCommitment,
-        state: stateReference,
-        globalVariables,
-        totalFees: body.txEffects.reduce((accum, txEffect)=>accum.add(txEffect.transactionFee), Fr.ZERO),
-        totalManaUsed: proposedHeader.totalManaUsed
-    });
-    const block = new L2Block(archive, header, body);
-    return PublishedL2Block.fromFields({
-        block,
-        l1,
-        attestations
-    });
-}
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
- */ export async function retrieveBlocksFromRollup(rollup, publicClient, blobSinkClient, searchStartBlock, searchEndBlock, logger = createLogger('archiver')) {
-    const retrievedBlocks = [];
-    let rollupConstants;
-    do {
-        if (searchStartBlock > searchEndBlock) {
-            break;
-        }
-        const l2BlockProposedLogs = (await rollup.getEvents.L2BlockProposed({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
-        if (l2BlockProposedLogs.length === 0) {
-            break;
-        }
-        const lastLog = l2BlockProposedLogs[l2BlockProposedLogs.length - 1];
-        logger.debug(`Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`);
-        if (rollupConstants === undefined) {
-            const [chainId, version, targetCommitteeSize] = await Promise.all([
-                publicClient.getChainId(),
-                rollup.read.getVersion(),
-                rollup.read.getTargetCommitteeSize()
-            ]);
-            rollupConstants = {
-                chainId: new Fr(chainId),
-                version: new Fr(version),
-                targetCommitteeSize: Number(targetCommitteeSize)
-            };
-        }
-        const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, l2BlockProposedLogs, rollupConstants, logger);
-        retrievedBlocks.push(...newBlocks);
-        searchStartBlock = lastLog.blockNumber + 1n;
-    }while (searchStartBlock <= searchEndBlock)
-    // The asyncpool from processL2BlockProposedLogs will not necessarily return the blocks in order, so we sort them before returning.
-    return retrievedBlocks.sort((a, b)=>Number(a.l1.blockNumber - b.l1.blockNumber));
-}
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */ async function processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, logger) {
-    const retrievedBlocks = [];
-    await asyncPool(10, logs, async (log)=>{
-        const l2BlockNumber = Number(log.args.blockNumber);
-        const archive = log.args.archive;
-        const archiveFromChain = await rollup.read.archiveAt([
-            BigInt(l2BlockNumber)
-        ]);
-        const blobHashes = log.args.versionedBlobHashes.map((blobHash)=>Buffer.from(blobHash.slice(2), 'hex'));
-        // The value from the event and contract will match only if the block is in the chain.
-        if (archive === archiveFromChain) {
-            const block = await getBlockFromRollupTx(publicClient, blobSinkClient, log.transactionHash, blobHashes, l2BlockNumber, rollup.address, targetCommitteeSize, logger);
-            const l1 = {
-                blockNumber: log.blockNumber,
-                blockHash: log.blockHash,
-                timestamp: await getL1BlockTime(publicClient, log.blockNumber)
-            };
-            retrievedBlocks.push({
-                ...block,
-                l1,
-                chainId,
-                version
-            });
-            logger.trace(`Retrieved L2 block ${l2BlockNumber} from L1 tx ${log.transactionHash}`, {
-                l1BlockNumber: log.blockNumber,
-                l2BlockNumber,
-                archive: archive.toString(),
-                attestations: block.attestations
-            });
-        } else {
-            logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
-                actual: archive,
-                expected: archiveFromChain
-            });
-        }
-    });
-    return retrievedBlocks;
-}
-export async function getL1BlockTime(publicClient, blockNumber) {
-    const block = await publicClient.getBlock({
-        blockNumber,
-        includeTransactions: false
-    });
-    return block.timestamp;
-}
-/**
- * Extracts the first 'propose' method calldata from a multicall3 transaction's data.
- * @param multicall3Data - The multicall3 transaction input data
- * @param rollupAddress - The address of the rollup contract
- * @returns The calldata for the first 'propose' method call to the rollup contract
- */ function extractRollupProposeCalldata(multicall3Data, rollupAddress) {
-    const { functionName: multicall3FunctionName, args: multicall3Args } = decodeFunctionData({
-        abi: multicall3Abi,
-        data: multicall3Data
-    });
-    if (multicall3FunctionName !== 'aggregate3') {
-        throw new Error(`Unexpected multicall3 method called ${multicall3FunctionName}`);
-    }
-    if (multicall3Args.length !== 1) {
-        throw new Error(`Unexpected number of arguments for multicall3`);
-    }
-    const [calls] = multicall3Args;
-    // Find all rollup calls
-    const rollupAddressLower = rollupAddress.toLowerCase();
-    for(let i = 0; i < calls.length; i++){
-        const addr = calls[i].target;
-        if (addr.toLowerCase() !== rollupAddressLower) {
-            continue;
-        }
-        const callData = calls[i].callData;
-        try {
-            const { functionName: rollupFunctionName } = decodeFunctionData({
-                abi: RollupAbi,
-                data: callData
-            });
-            if (rollupFunctionName === 'propose') {
-                return callData;
-            }
-        } catch  {
-            continue;
-        }
-    }
-    throw new Error(`Rollup address not found in multicall3 args`);
-}
-/**
- * Gets block from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNumber - L2 block number.
- * @returns L2 block from the calldata, deserialized
- */ async function getBlockFromRollupTx(publicClient, blobSinkClient, txHash, blobHashes, l2BlockNumber, rollupAddress, targetCommitteeSize, logger) {
-    const { input: forwarderData, blockHash } = await publicClient.getTransaction({
-        hash: txHash
-    });
-    const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
-    const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
-        abi: RollupAbi,
-        data: rollupData
-    });
-    if (rollupFunctionName !== 'propose') {
-        throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
-    }
-    const [decodedArgs, packedAttestations, _signers, _blobInput] = rollupArgs;
-    const attestations = CommitteeAttestation.fromPacked(packedAttestations, targetCommitteeSize);
-    logger.trace(`Recovered propose calldata from tx ${txHash}`, {
-        l2BlockNumber,
-        archive: decodedArgs.archive,
-        stateReference: decodedArgs.stateReference,
-        header: decodedArgs.header,
-        blobHashes,
-        attestations,
-        packedAttestations,
-        targetCommitteeSize
-    });
-    // TODO(md): why is the proposed block header different to the actual block header?
-    // This is likely going to be a footgun
-    const header = ProposedBlockHeader.fromViem(decodedArgs.header);
-    const body = await getBlockBodyFromBlobs(blobSinkClient, blockHash, blobHashes, l2BlockNumber, logger);
-    const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-    const stateReference = StateReference.fromViem(decodedArgs.stateReference);
-    return {
-        l2BlockNumber,
-        archiveRoot,
-        stateReference,
-        header,
-        body,
-        attestations
-    };
-}
-async function getBlockBodyFromBlobs(blobSinkClient, blockHash, blobHashes, l2BlockNumber, logger) {
-    const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
-    logger.trace(`Fetched ${blobBodies.length} blob bodies for L2 block ${l2BlockNumber}`, {
-        blobHashes: blobHashes.map(bufferToHex),
-        l2BlockNumber
-    });
-    if (blobBodies.length !== blobHashes.length) {
-        // If there is exactly one blob hash and it is the empty blob hash, we are fine with not downloading it
-        // and just defaulting to an empty block body.
-        if (blobHashes.length === 1 && blobBodies.length === 0 && blobHashes[0].equals(EMPTY_BLOB_VERSIONED_HASH)) {
-            logger.verbose(`Ignoring error fetching blob body for block ${l2BlockNumber} as it is empty`);
-            return Body.empty();
-        } else {
-            throw new NoBlobBodiesFoundError(l2BlockNumber, blobBodies.length, blobHashes.length);
-        }
-    }
-    let blockFields;
-    try {
-        blockFields = Blob.toEncodedFields(blobBodies.map((b)=>b.blob));
-    } catch (err) {
-        if (err instanceof BlobDeserializationError) {
-            logger.error(err.message);
-        } else {
-            logger.error('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
-        }
-        throw err;
-    }
-    // The blob source gives us blockFields, and we must construct the body from them:
-    return Body.fromBlobFields(blockFields);
-}
-/** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */ export async function retrieveL1ToL2Message(inbox, leaf, fromBlock, toBlock) {
-    const logs = await inbox.getEvents.MessageSent({
-        hash: leaf.toString()
-    }, {
-        fromBlock,
-        toBlock
-    });
-    const messages = mapLogsInboxMessage(logs);
-    return messages.length > 0 ? messages[0] : undefined;
-}
-/**
- * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of InboxLeaf and next eth block to search from.
- */ export async function retrieveL1ToL2Messages(inbox, searchStartBlock, searchEndBlock) {
-    const retrievedL1ToL2Messages = [];
-    while(searchStartBlock <= searchEndBlock){
-        const messageSentLogs = (await inbox.getEvents.MessageSent({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
-        if (messageSentLogs.length === 0) {
-            break;
-        }
-        retrievedL1ToL2Messages.push(...mapLogsInboxMessage(messageSentLogs));
-        searchStartBlock = messageSentLogs.at(-1).blockNumber + 1n;
-    }
-    return retrievedL1ToL2Messages;
-}
-function mapLogsInboxMessage(logs) {
-    return logs.map((log)=>{
-        const { index, hash, l2BlockNumber, rollingHash } = log.args;
-        return {
-            index: index,
-            leaf: Fr.fromHexString(hash),
-            l1BlockNumber: log.blockNumber,
-            l1BlockHash: Buffer32.fromString(log.blockHash),
-            l2BlockNumber: Number(l2BlockNumber),
-            rollingHash: Buffer16.fromString(rollingHash)
-        };
-    });
-}
-/** Retrieves L2ProofVerified events from the rollup contract. */ export async function retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock) {
-    const logs = await publicClient.getLogs({
-        address: rollupAddress.toString(),
-        fromBlock: searchStartBlock,
-        toBlock: searchEndBlock ? searchEndBlock : undefined,
-        strict: true,
-        event: getAbiItem({
-            abi: RollupAbi,
-            name: 'L2ProofVerified'
-        })
-    });
-    return logs.map((log)=>({
-            l1BlockNumber: log.blockNumber,
-            l2BlockNumber: Number(log.args.blockNumber),
-            proverId: Fr.fromHexString(log.args.proverId),
-            txHash: log.transactionHash
-        }));
-}
-/** Retrieve submitted proofs from the rollup contract */ export async function retrieveL2ProofsFromRollup(publicClient, rollupAddress, searchStartBlock, searchEndBlock) {
-    const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
-    const retrievedData = [];
-    const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1).l1BlockNumber : searchStartBlock - 1n;
-    for (const { txHash, proverId, l2BlockNumber } of logs){
-        const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
-        retrievedData.push({
-            proof: proofData.proof,
-            proverId: proofData.proverId,
-            l2BlockNumber,
-            txHash
-        });
-    }
-    return {
-        retrievedData,
-        lastProcessedL1BlockNumber
-    };
-}
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */ export async function getProofFromSubmitProofTx(publicClient, txHash, expectedProverId) {
-    const { input: data } = await publicClient.getTransaction({
-        hash: txHash
-    });
-    const { functionName, args } = decodeFunctionData({
-        abi: RollupAbi,
-        data
-    });
-    let proverId;
-    let archiveRoot;
-    let proof;
-    if (functionName === 'submitEpochRootProof') {
-        const [decodedArgs] = args;
-        proverId = Fr.fromHexString(decodedArgs.args.proverId);
-        archiveRoot = Fr.fromHexString(decodedArgs.args.endArchive);
-        proof = Proof.fromBuffer(Buffer.from(hexToBytes(decodedArgs.proof)));
-    } else {
-        throw new Error(`Unexpected proof method called ${functionName}`);
-    }
-    if (!proverId.equals(expectedProverId)) {
-        throw new Error(`Prover ID mismatch: expected ${expectedProverId} but got ${proverId}`);
-    }
-    return {
-        proverId,
-        archiveRoot,
-        proof
-    };
-}

package/dest/archiver/errors.d.ts

@@ -1,12 +0,0 @@
-export declare class NoBlobBodiesFoundError extends Error {
-    constructor(l2BlockNum: number, found: number, expected: number);
-}
-export declare class InitialBlockNumberNotSequentialError extends Error {
-    readonly newBlockNumber: number;
-    readonly previousBlockNumber: number | undefined;
-    constructor(newBlockNumber: number, previousBlockNumber: number | undefined);
-}
-export declare class BlockNumberNotSequentialError extends Error {
-    constructor(newBlockNumber: number, previous: number | undefined);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dest/archiver/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/archiver/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAGhE;AAED,qBAAa,oCAAqC,SAAQ,KAAK;aAE3C,cAAc,EAAE,MAAM;aACtB,mBAAmB,EAAE,MAAM,GAAG,SAAS;gBADvC,cAAc,EAAE,MAAM,EACtB,mBAAmB,EAAE,MAAM,GAAG,SAAS;CAQ1D;AAED,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS;CAKjE"}

package/dest/archiver/errors.js

@@ -1,17 +0,0 @@
-export class NoBlobBodiesFoundError extends Error {
-    constructor(l2BlockNum, found, expected){
-        super(`No blob bodies found for block ${l2BlockNum} (expected ${expected} but found ${found})`);
-    }
-}
-export class InitialBlockNumberNotSequentialError extends Error {
-    newBlockNumber;
-    previousBlockNumber;
-    constructor(newBlockNumber, previousBlockNumber){
-        super(`Cannot insert new block ${newBlockNumber} given previous block number in store is ${previousBlockNumber ?? 'undefined'}`), this.newBlockNumber = newBlockNumber, this.previousBlockNumber = previousBlockNumber;
-    }
-}
-export class BlockNumberNotSequentialError extends Error {
-    constructor(newBlockNumber, previous){
-        super(`Cannot insert new block ${newBlockNumber} given previous block number in batch is ${previous ?? 'undefined'}`);
-    }
-}

package/dest/archiver/index.d.ts

@@ -1,7 +0,0 @@
-export * from './archiver.js';
-export * from './config.js';
-export { type PublishedL2Block, type L1PublishedData } from './structs/published.js';
-export type { ArchiverDataStore } from './archiver_store.js';
-export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
-export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/archiver/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACrF,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC"}

package/dest/archiver/index.js

@@ -1,4 +0,0 @@
-export * from './archiver.js';
-export * from './config.js';
-export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
-export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';

package/dest/archiver/instrumentation.d.ts

@@ -1,35 +0,0 @@
-import type { L2Block } from '@aztec/stdlib/block';
-import { type LmdbStatsCallback, type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-export declare class ArchiverInstrumentation {
-    private telemetry;
-    readonly tracer: Tracer;
-    private blockHeight;
-    private txCount;
-    private l1BlockHeight;
-    private proofsSubmittedDelay;
-    private proofsSubmittedCount;
-    private dbMetrics;
-    private pruneDuration;
-    private pruneCount;
-    private syncDurationPerBlock;
-    private syncBlockCount;
-    private manaPerBlock;
-    private txsPerBlock;
-    private syncDurationPerMessage;
-    private syncMessageCount;
-    private log;
-    private constructor();
-    static new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback): Promise<ArchiverInstrumentation>;
-    isEnabled(): boolean;
-    processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]): void;
-    processNewMessages(count: number, syncPerMessageMs: number): void;
-    processPrune(duration: number): void;
-    updateLastProvenBlock(blockNumber: number): void;
-    processProofsVerified(logs: {
-        proverId: string;
-        l2BlockNumber: bigint;
-        delay: bigint;
-    }[]): void;
-    updateL1BlockHeight(blockNumber: bigint): void;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/dest/archiver/instrumentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/archiver/instrumentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAKL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uBAAuB;IAwBhC,OAAO,CAAC,SAAS;IAvBnB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAY;IAE/B,OAAO,CAAC,sBAAsB,CAAY;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IAExC,OAAO,CAAC,GAAG,CAA4C;IAEvD,OAAO;WAuFa,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,iBAAiB;IAY1E,SAAS,IAAI,OAAO;IAIpB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;IAY5D,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAK1D,YAAY,CAAC,QAAQ,EAAE,MAAM;IAK7B,qBAAqB,CAAC,WAAW,EAAE,MAAM;IAIzC,qBAAqB,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE;IAaxF,mBAAmB,CAAC,WAAW,EAAE,MAAM;CAG/C"}