@aztec/prover-node 0.0.1-commit.b655e406 → 0.0.1-commit.c31f2472

package/src/prover-node-publisher.ts

@@ -1,11 +1,13 @@
-import type { BatchedBlob } from '@aztec/blob-lib';
+import { BatchedBlob, getEthBlobEvaluationInputs } from '@aztec/blob-lib';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
-import type { L1TxUtils, RollupContract, ViemCommitteeAttestation } from '@aztec/ethereum';
+import type { RollupContract, ViemCommitteeAttestation } from '@aztec/ethereum/contracts';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { makeTuple } from '@aztec/foundation/array';
+import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { areArraysEqual } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts';
@@ -37,7 +39,7 @@ export class ProverNodePublisher {
   private interrupted = false;
   private metrics: ProverNodePublisherMetrics;
 
-  protected log = createLogger('prover-node:l1-tx-publisher');
+  protected log: Logger;
 
   protected rollupContract: RollupContract;
 
@@ -50,10 +52,12 @@ export class ProverNodePublisher {
       l1TxUtils: L1TxUtils;
       telemetry?: TelemetryClient;
     },
+    bindings?: LoggerBindings,
   ) {
     const telemetry = deps.telemetry ?? getTelemetryClient();
 
     this.metrics = new ProverNodePublisherMetrics(telemetry, 'ProverNode');
+    this.log = createLogger('prover-node:l1-tx-publisher', bindings);
 
     this.rollupContract = deps.rollupContract;
     this.l1TxUtils = deps.l1TxUtils;
@@ -85,16 +89,16 @@ export class ProverNodePublisher {
   }
 
   public async submitEpochProof(args: {
-    epochNumber: number;
-    fromBlock: number;
-    toBlock: number;
+    epochNumber: EpochNumber;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }): Promise<boolean> {
-    const { epochNumber, fromBlock, toBlock } = args;
-    const ctx = { epochNumber, fromBlock, toBlock };
+    const { epochNumber, fromCheckpoint, toCheckpoint } = args;
+    const ctx = { epochNumber, fromCheckpoint, toCheckpoint };
 
     if (!this.interrupted) {
       const timer = new Timer();
@@ -103,6 +107,7 @@ export class ProverNodePublisher {
 
       const txReceipt = await this.sendSubmitEpochProofTx(args);
       if (!txReceipt) {
+        this.log.error(`Failed to mine submitEpochProof tx`, undefined, ctx);
         return false;
       }
 
@@ -135,47 +140,51 @@ export class ProverNodePublisher {
       }
 
       this.metrics.recordFailedTx();
-      this.log.error(`Rollup.submitEpochProof tx status failed ${txReceipt.transactionHash}`, undefined, ctx);
+      this.log.error(`Rollup submitEpochProof tx reverted ${txReceipt.transactionHash}`, undefined, ctx);
     }
 
-    this.log.verbose('L2 block data syncing interrupted', ctx);
+    this.log.verbose('Checkpoint data syncing interrupted', ctx);
     return false;
   }
 
   private async validateEpochProofSubmission(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }) {
-    const { fromBlock, toBlock, publicInputs, batchedBlobInputs } = args;
+    const { fromCheckpoint, toCheckpoint, publicInputs, batchedBlobInputs } = args;
 
-    // Check that the block numbers match the expected epoch to be proven
-    const { pendingBlockNumber: pending, provenBlockNumber: proven } = await this.rollupContract.getTips();
-    // Don't publish if proven is beyond our toBlock, pointless to do so
-    if (proven > BigInt(toBlock)) {
-      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as proven block is ${proven}`);
+    // Check that the checkpoint numbers match the expected epoch to be proven
+    const { pending, proven } = await this.rollupContract.getTips();
+    // Don't publish if proven is beyond our toCheckpoint, pointless to do so
+    if (proven > toCheckpoint) {
+      throw new Error(
+        `Cannot submit epoch proof for ${fromCheckpoint}-${toCheckpoint} as proven checkpoint is ${proven}`,
+      );
     }
-    // toBlock can't be greater than pending
-    if (toBlock > pending) {
-      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as pending block is ${pending}`);
+    // toCheckpoint can't be greater than pending
+    if (toCheckpoint > pending) {
+      throw new Error(
+        `Cannot submit epoch proof for ${fromCheckpoint}-${toCheckpoint} as pending checkpoint is ${pending}`,
+      );
     }
 
-    // Check the archive for the immediate block before the epoch
-    const blockLog = await this.rollupContract.getBlock(BigInt(fromBlock - 1));
-    if (publicInputs.previousArchiveRoot.toString() !== blockLog.archive) {
+    // Check the archive for the immediate checkpoint before the epoch
+    const checkpointLog = await this.rollupContract.getCheckpoint(CheckpointNumber(fromCheckpoint - 1));
+    if (!publicInputs.previousArchiveRoot.equals(checkpointLog.archive)) {
       throw new Error(
-        `Previous archive root mismatch: ${publicInputs.previousArchiveRoot.toString()} !== ${blockLog.archive}`,
+        `Previous archive root mismatch: ${publicInputs.previousArchiveRoot.toString()} !== ${checkpointLog.archive.toString()}`,
       );
     }
 
-    // Check the archive for the last block in the epoch
-    const endBlockLog = await this.rollupContract.getBlock(BigInt(toBlock));
-    if (publicInputs.endArchiveRoot.toString() !== endBlockLog.archive) {
+    // Check the archive for the last checkpoint in the epoch
+    const endCheckpointLog = await this.rollupContract.getCheckpoint(toCheckpoint);
+    if (!publicInputs.endArchiveRoot.equals(endCheckpointLog.archive)) {
       throw new Error(
-        `End archive root mismatch: ${publicInputs.endArchiveRoot.toString()} !== ${endBlockLog.archive}`,
+        `End archive root mismatch: ${publicInputs.endArchiveRoot.toString()} !== ${endCheckpointLog.archive.toString()}`,
       );
     }
 
@@ -193,7 +202,7 @@ export class ProverNodePublisher {
     );
     const argsPublicInputs = [...publicInputs.toFields()];
 
-    if (!areArraysEqual(rollupPublicInputs.map(Fr.fromHexString), argsPublicInputs, (a, b) => a.equals(b))) {
+    if (!areArraysEqual(rollupPublicInputs, argsPublicInputs, (a, b) => a.equals(b))) {
       const fmt = (inputs: Fr[] | readonly string[]) => inputs.map(x => x.toString()).join(', ');
       throw new Error(
         `Root rollup public inputs mismatch:\nRollup:  ${fmt(rollupPublicInputs)}\nComputed:${fmt(argsPublicInputs)}`,
@@ -202,8 +211,8 @@ export class ProverNodePublisher {
   }
 
   private async sendSubmitEpochProofTx(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
@@ -213,8 +222,8 @@ export class ProverNodePublisher {
 
     this.log.info(`Submitting epoch proof to L1 rollup contract`, {
       proofSize: args.proof.withoutPublicInputs().length,
-      fromBlock: args.fromBlock,
-      toBlock: args.toBlock,
+      fromCheckpoint: args.fromCheckpoint,
+      toCheckpoint: args.toCheckpoint,
     });
     const data = encodeFunctionData({
       abi: RollupAbi,
@@ -223,39 +232,43 @@ export class ProverNodePublisher {
     });
     try {
       const { receipt } = await this.l1TxUtils.sendAndMonitorTransaction({ to: this.rollupContract.address, data });
+      if (receipt.status !== 'success') {
+        const errorMsg = await this.l1TxUtils.tryGetErrorFromRevertedTx(
+          data,
+          {
+            args: [...txArgs],
+            functionName: 'submitEpochRootProof',
+            abi: RollupAbi,
+            address: this.rollupContract.address,
+          },
+          /*blobInputs*/ undefined,
+          /*stateOverride*/ [],
+        );
+        this.log.error(`Rollup submit epoch proof tx reverted with ${errorMsg ?? 'unknown error'}`);
+        return undefined;
+      }
       return receipt;
     } catch (err) {
       this.log.error(`Rollup submit epoch proof failed`, err);
-      const errorMsg = await this.l1TxUtils.tryGetErrorFromRevertedTx(
-        data,
-        {
-          args: [...txArgs],
-          functionName: 'submitEpochRootProof',
-          abi: RollupAbi,
-          address: this.rollupContract.address,
-        },
-        /*blobInputs*/ undefined,
-        /*stateOverride*/ [],
-      );
-      this.log.error(`Rollup submit epoch proof tx reverted. ${errorMsg}`);
       return undefined;
     }
   }
 
   private getEpochProofPublicInputsArgs(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }) {
     // Returns arguments for EpochProofLib.sol -> getEpochProofPublicInputs()
     return [
-      BigInt(args.fromBlock) /*_start*/,
-      BigInt(args.toBlock) /*_end*/,
+      BigInt(args.fromCheckpoint) /*_start*/,
+      BigInt(args.toCheckpoint) /*_end*/,
       {
         previousArchive: args.publicInputs.previousArchiveRoot.toString(),
         endArchive: args.publicInputs.endArchiveRoot.toString(),
+        outHash: args.publicInputs.outHash.toString(),
         proverId: EthAddress.fromField(args.publicInputs.constants.proverId).toString(),
       } /*_args*/,
       makeTuple(AZTEC_MAX_EPOCH_DURATION * 2, i =>
@@ -263,13 +276,13 @@ export class ProverNodePublisher {
           ? args.publicInputs.fees[i / 2].recipient.toField().toString()
           : args.publicInputs.fees[(i - 1) / 2].value.toString(),
       ) /*_fees*/,
-      args.batchedBlobInputs.getEthBlobEvaluationInputs() /*_blobPublicInputs*/,
+      getEthBlobEvaluationInputs(args.batchedBlobInputs) /*_blobPublicInputs*/,
     ] as const;
   }
 
   private getSubmitEpochProofArgs(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;

package/src/prover-node.ts

@@ -1,14 +1,16 @@
 import type { Archiver } from '@aztec/archiver';
-import type { RollupContract } from '@aztec/ethereum';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { assertRequired, compact, pick, sum } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { memoize } from '@aztec/foundation/decorators';
-import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import type { P2PClient } from '@aztec/p2p';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
@@ -114,7 +116,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
    * @param epochNumber - The epoch number that was just completed.
    * @returns false if there is an error, true otherwise
    */
-  async handleEpochReadyToProve(epochNumber: bigint): Promise<boolean> {
+  async handleEpochReadyToProve(epochNumber: EpochNumber): Promise<boolean> {
     try {
       this.log.debug(`Running jobs as ${epochNumber} is ready to prove`, {
         jobs: Array.from(this.jobs.values()).map(job => `${job.getEpochNumber()}:${job.getId()}`),
@@ -184,8 +186,8 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   /**
    * Starts a proving process and returns immediately.
    */
-  public async startProof(epochNumber: number | bigint) {
-    const job = await this.createProvingJob(BigInt(epochNumber), { skipEpochCheck: true });
+  public async startProof(epochNumber: EpochNumber) {
+    const job = await this.createProvingJob(epochNumber, { skipEpochCheck: true });
     void this.runJob(job);
   }
 
@@ -238,21 +240,20 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   /**
    * Returns an array of jobs being processed.
    */
-  public getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]> {
+  public getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: EpochNumber }[]> {
     return Promise.resolve(
       Array.from(this.jobs.entries()).map(([uuid, job]) => ({
         uuid,
         status: job.getState(),
-        epochNumber: Number(job.getEpochNumber()),
+        epochNumber: job.getEpochNumber(),
       })),
     );
   }
 
   protected async getActiveJobsForEpoch(
-    epochBigInt: bigint,
+    epochNumber: EpochNumber,
   ): Promise<{ uuid: string; status: EpochProvingJobState }[]> {
     const jobs = await this.getJobs();
-    const epochNumber = Number(epochBigInt);
     return jobs.filter(job => job.epochNumber === epochNumber && !EpochProvingJobTerminalState.includes(job.status));
   }
 
@@ -263,18 +264,21 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     }
   }
 
-  @trackSpan('ProverNode.createProvingJob', epochNumber => ({ [Attributes.EPOCH_NUMBER]: Number(epochNumber) }))
-  private async createProvingJob(epochNumber: bigint, opts: { skipEpochCheck?: boolean } = {}) {
+  @trackSpan('ProverNode.createProvingJob', epochNumber => ({ [Attributes.EPOCH_NUMBER]: epochNumber }))
+  private async createProvingJob(epochNumber: EpochNumber, opts: { skipEpochCheck?: boolean } = {}) {
     this.checkMaximumPendingJobs();
 
     this.publisher = await this.publisherFactory.create();
 
     // Gather all data for this epoch
     const epochData = await this.gatherEpochData(epochNumber);
-
-    const fromBlock = epochData.blocks[0].number;
-    const toBlock = epochData.blocks.at(-1)!.number;
-    this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
+    const fromCheckpoint = epochData.checkpoints[0].number;
+    const toCheckpoint = epochData.checkpoints.at(-1)!.number;
+    const fromBlock = epochData.checkpoints[0].blocks[0].number;
+    const toBlock = epochData.checkpoints.at(-1)!.blocks.at(-1)!.number;
+    this.log.verbose(
+      `Creating proving job for epoch ${epochNumber} for checkpoint range ${fromCheckpoint} to ${toCheckpoint} and block range ${fromBlock} to ${toBlock}`,
+    );
 
     // Fast forward world state to right before the target block and get a fork
     await this.worldState.syncImmediate(toBlock);
@@ -284,12 +288,12 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      this.log.getBindings(),
     );
 
     // Set deadline for this job to run. It will abort if it takes too long.
     const deadlineTs = getProofSubmissionDeadlineTimestamp(epochNumber, await this.getL1Constants());
     const deadline = new Date(Number(deadlineTs) * 1000);
-
     const job = this.doCreateEpochProvingJob(epochData, deadline, publicProcessorFactory, this.publisher, opts);
     this.jobs.set(job.getId(), job);
     return job;
@@ -300,30 +304,32 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     return this.l2BlockSource.getL1Constants();
   }
 
-  @trackSpan('ProverNode.gatherEpochData', epochNumber => ({ [Attributes.EPOCH_NUMBER]: Number(epochNumber) }))
-  private async gatherEpochData(epochNumber: bigint): Promise<EpochProvingJobData> {
-    const blocks = await this.gatherBlocks(epochNumber);
-    const txArray = await this.gatherTxs(epochNumber, blocks);
+  @trackSpan('ProverNode.gatherEpochData', epochNumber => ({ [Attributes.EPOCH_NUMBER]: epochNumber }))
+  private async gatherEpochData(epochNumber: EpochNumber): Promise<EpochProvingJobData> {
+    const checkpoints = await this.gatherCheckpoints(epochNumber);
+    const txArray = await this.gatherTxs(epochNumber, checkpoints);
     const txs = new Map<string, Tx>(txArray.map(tx => [tx.getTxHash().toString(), tx]));
-    const l1ToL2Messages = await this.gatherMessages(epochNumber, blocks);
-    const previousBlockHeader = await this.gatherPreviousBlockHeader(epochNumber, blocks[0]);
-    const [lastBlock] = await this.l2BlockSource.getPublishedBlocks(blocks.at(-1)!.number, 1);
-    const attestations = lastBlock?.attestations ?? [];
+    const l1ToL2Messages = await this.gatherMessages(epochNumber, checkpoints);
+    const [firstBlock] = checkpoints[0].blocks;
+    const previousBlockHeader = await this.gatherPreviousBlockHeader(epochNumber, firstBlock.number - 1);
+    const [lastPublishedCheckpoint] = await this.l2BlockSource.getCheckpoints(checkpoints.at(-1)!.number, 1);
+    const attestations = lastPublishedCheckpoint?.attestations ?? [];
 
-    return { blocks, txs, l1ToL2Messages, epochNumber, previousBlockHeader, attestations };
+    return { checkpoints, txs, l1ToL2Messages, epochNumber, previousBlockHeader, attestations };
   }
 
-  private async gatherBlocks(epochNumber: bigint) {
-    const blocks = await this.l2BlockSource.getBlocksForEpoch(epochNumber);
-    if (blocks.length === 0) {
+  private async gatherCheckpoints(epochNumber: EpochNumber) {
+    const checkpoints = await this.l2BlockSource.getCheckpointsForEpoch(epochNumber);
+    if (checkpoints.length === 0) {
       throw new EmptyEpochError(epochNumber);
     }
-    return blocks;
+    return checkpoints;
   }
 
-  private async gatherTxs(epochNumber: bigint, blocks: L2Block[]) {
+  private async gatherTxs(epochNumber: EpochNumber, checkpoints: Checkpoint[]) {
     const deadline = new Date(this.dateProvider.now() + this.config.txGatheringTimeoutMs);
     const txProvider = this.p2pClient.getTxProvider();
+    const blocks = checkpoints.flatMap(checkpoint => checkpoint.blocks);
     const txsByBlock = await Promise.all(blocks.map(block => txProvider.getTxsForBlock(block, { deadline })));
     const txs = txsByBlock.map(({ txs }) => txs).flat();
     const missingTxs = txsByBlock.map(({ missingTxs }) => missingTxs).flat();
@@ -336,25 +342,24 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     throw new Error(`Txs not found for epoch ${epochNumber}: ${missingTxs.map(hash => hash.toString()).join(', ')}`);
   }
 
-  private async gatherMessages(epochNumber: bigint, blocks: L2Block[]) {
-    const messages = await Promise.all(blocks.map(b => this.l1ToL2MessageSource.getL1ToL2Messages(b.number)));
+  private async gatherMessages(epochNumber: EpochNumber, checkpoints: Checkpoint[]) {
+    const messages = await Promise.all(checkpoints.map(c => this.l1ToL2MessageSource.getL1ToL2Messages(c.number)));
     const messageCount = sum(messages.map(m => m.length));
     this.log.verbose(`Gathered all ${messageCount} messages for epoch ${epochNumber}`, { epochNumber });
-    const messagesByBlock: Record<number, Fr[]> = {};
-    for (let i = 0; i < blocks.length; i++) {
-      messagesByBlock[blocks[i].number] = messages[i];
+    const messagesByCheckpoint: Record<CheckpointNumber, Fr[]> = {};
+    for (let i = 0; i < checkpoints.length; i++) {
+      messagesByCheckpoint[checkpoints[i].number] = messages[i];
     }
-    return messagesByBlock;
+    return messagesByCheckpoint;
   }
 
-  private async gatherPreviousBlockHeader(epochNumber: bigint, initialBlock: L2Block) {
-    const previousBlockNumber = initialBlock.number - 1;
+  private async gatherPreviousBlockHeader(epochNumber: EpochNumber, previousBlockNumber: number) {
     const header = await (previousBlockNumber === 0
       ? this.worldState.getCommitted().getInitialHeader()
-      : this.l2BlockSource.getBlockHeader(previousBlockNumber));
+      : this.l2BlockSource.getBlockHeader(BlockNumber(previousBlockNumber)));
 
     if (!header) {
-      throw new Error(`Previous block header ${initialBlock.number} not found for proving epoch ${epochNumber}`);
+      throw new Error(`Previous block header ${previousBlockNumber} not found for proving epoch ${epochNumber}`);
     }
 
     this.log.verbose(`Gathered previous block header ${header.getBlockNumber()} for epoch ${epochNumber}`);
@@ -380,6 +385,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
       this.jobMetrics,
       deadline,
       { parallelBlockLimit, skipSubmitProof: proverNodeDisableProofPublish, ...opts },
+      this.log.getBindings(),
     );
   }
 
@@ -391,7 +397,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   private validateConfig() {
     if (
       this.config.proverNodeFailedEpochStore &&
-      (!this.config.dataDirectory || !this.config.l1ChainId || !this.config.rollupVersion)
+      (!this.config.dataDirectory || !this.config.l1ChainId || this.config.rollupVersion === undefined)
     ) {
       this.log.warn(
         `Invalid prover-node config (missing dataDirectory, l1ChainId, or rollupVersion)`,
@@ -405,7 +411,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
 }
 
 class EmptyEpochError extends Error {
-  constructor(epochNumber: bigint) {
+  constructor(epochNumber: EpochNumber) {
     super(`No blocks found for epoch ${epochNumber}`);
     this.name = 'EmptyEpochError';
   }

package/src/prover-publisher-factory.ts

@@ -1,4 +1,7 @@
-import type { L1TxUtils, PublisherManager, RollupContract } from '@aztec/ethereum';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import type { PublisherManager } from '@aztec/ethereum/publisher-manager';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
@@ -12,6 +15,7 @@ export class ProverPublisherFactory {
       publisherManager: PublisherManager<L1TxUtils>;
       telemetry?: TelemetryClient;
     },
+    private bindings?: LoggerBindings,
   ) {}
 
   public async start() {
@@ -28,10 +32,14 @@ export class ProverPublisherFactory {
    */
   public async create(): Promise<ProverNodePublisher> {
     const l1Publisher = await this.deps.publisherManager.getAvailablePublisher();
-    return new ProverNodePublisher(this.config, {
-      rollupContract: this.deps.rollupContract,
-      l1TxUtils: l1Publisher,
-      telemetry: this.deps.telemetry,
-    });
+    return new ProverNodePublisher(
+      this.config,
+      {
+        rollupContract: this.deps.rollupContract,
+        l1TxUtils: l1Publisher,
+        telemetry: this.deps.telemetry,
+      },
+      this.bindings,
+    );
   }
 }