Merge remote-tracking branch 'origin/v4' into v4-next

Author: AztecBot

yarn-project/prover-node/src/prover-node-publisher.test.ts

@@ -199,6 +199,82 @@ describe('prover-node-publisher', () => {
     },
   );
 
+  it('waits until the proven checkpoint reaches the checkpoint before the proof start', async () => {
+    const checkpoints = Array.from({ length: 100 }, () => RootRollupPublicInputs.random());
+    const fromCheckpoint = CheckpointNumber(33);
+    const toCheckpoint = CheckpointNumber(64);
+
+    rollup.getTips
+      .mockResolvedValueOnce({
+        pending: CheckpointNumber(65),
+        proven: CheckpointNumber(31),
+      })
+      .mockResolvedValueOnce({
+        pending: CheckpointNumber(65),
+        proven: CheckpointNumber(32),
+      })
+      .mockResolvedValue({
+        pending: CheckpointNumber(65),
+        proven: CheckpointNumber(32),
+      });
+    rollup.getRollupConstants.mockResolvedValue({
+      l1StartBlock: 0n,
+      l1GenesisTime: BigInt(Math.floor(Date.now() / 1000)),
+      slotDuration: 1,
+      epochDuration: 1,
+      proofSubmissionEpochs: 100,
+      targetCommitteeSize: 48,
+      rollupManaLimit: Number.MAX_SAFE_INTEGER,
+    });
+
+    rollup.getCheckpoint.mockImplementation((checkpointNumber: CheckpointNumber) =>
+      Promise.resolve({
+        archive: checkpoints[checkpointNumber - 1].endArchiveRoot,
+        attestationsHash: Buffer32.ZERO,
+        payloadDigest: Buffer32.ZERO,
+        headerHash: Buffer32.ZERO,
+        blobCommitmentsHash: Buffer32.ZERO,
+        outHash: '0x',
+        slotNumber: SlotNumber(0),
+        feeHeader: {
+          excessMana: 0n,
+          manaUsed: 0n,
+          ethPerFeeAsset: 0n,
+          congestionCost: 0n,
+          proverCost: 0n,
+        },
+      }),
+    );
+
+    const ourPublicInputs = RootRollupPublicInputs.random();
+    ourPublicInputs.previousArchiveRoot = checkpoints[fromCheckpoint - 2].endArchiveRoot;
+    ourPublicInputs.endArchiveRoot = checkpoints[toCheckpoint - 1].endArchiveRoot;
+
+    const ourBatchedBlob = new BatchedBlob(
+      ourPublicInputs.blobPublicInputs.blobCommitmentsHash,
+      ourPublicInputs.blobPublicInputs.z,
+      ourPublicInputs.blobPublicInputs.y,
+      ourPublicInputs.blobPublicInputs.c,
+      ourPublicInputs.blobPublicInputs.c.negate(),
+    );
+
+    rollup.getEpochProofPublicInputs.mockResolvedValue(ourPublicInputs.toFields());
+
+    await publisher.submitEpochProof({
+      epochNumber: EpochNumber(2),
+      fromCheckpoint,
+      toCheckpoint,
+      publicInputs: ourPublicInputs,
+      proof: Proof.empty(),
+      batchedBlobInputs: ourBatchedBlob,
+      attestations: [],
+    });
+
+    expect(rollup.getRollupConstants).toHaveBeenCalled();
+    expect(rollup.getTips).toHaveBeenCalledTimes(3);
+    expect(l1Utils.sendAndMonitorTransaction).toHaveBeenCalled();
+  });
+
   it('handles reverted txs correctly', async () => {
     const checkpoints = [RootRollupPublicInputs.random(), RootRollupPublicInputs.random()];
 

yarn-project/prover-node/src/prover-node-publisher.ts

@@ -8,11 +8,13 @@ import { areArraysEqual } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
 import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import type { Proof } from '@aztec/stdlib/proofs';
 import type { FeeRecipient, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 import type { L1PublishProofStats } from '@aztec/stdlib/stats';
@@ -101,6 +103,11 @@ export class ProverNodePublisher {
     const ctx = { epochNumber, fromCheckpoint, toCheckpoint };
 
     if (!this.interrupted) {
+      if (!(await this.waitUntilStartBuildsOnProven(args))) {
+        this.log.verbose('Checkpoint data syncing interrupted', ctx);
+        return false;
+      }
+
       const timer = new Timer();
       // Validate epoch proof range and hashes are correct before submitting
       await this.validateEpochProofSubmission(args);
@@ -147,6 +154,53 @@ export class ProverNodePublisher {
     return false;
   }
 
+  private async waitUntilStartBuildsOnProven(args: { epochNumber: EpochNumber; fromCheckpoint: CheckpointNumber }) {
+    const { epochNumber, fromCheckpoint } = args;
+    const provenCheckpoint = await this.getProvenCheckpoint();
+    if (this.isStartBuildingOnProven(fromCheckpoint, provenCheckpoint)) {
+      return true;
+    }
+
+    const timeout = await this.getSecondsUntilProofSubmissionWindowEnd(epochNumber);
+    this.log.info(`Waiting for proven checkpoint to reach proof start`, {
+      epochNumber,
+      fromCheckpoint,
+      provenCheckpoint,
+      timeout,
+    });
+
+    await retryUntil(
+      async () => {
+        if (this.interrupted) {
+          return true;
+        }
+
+        const proven = await this.getProvenCheckpoint();
+        this.log.verbose(`Proven checkpoint is at ${proven} (waiting for ${fromCheckpoint - 1})`, { epochNumber });
+        return this.isStartBuildingOnProven(fromCheckpoint, proven) ? true : undefined;
+      },
+      `proven checkpoint to reach ${fromCheckpoint - 1}`,
+      timeout,
+      4,
+    );
+
+    return !this.interrupted;
+  }
+
+  private async getProvenCheckpoint() {
+    return (await this.rollupContract.getTips()).proven;
+  }
+
+  private isStartBuildingOnProven(fromCheckpoint: CheckpointNumber, provenCheckpoint: CheckpointNumber) {
+    return fromCheckpoint - 1 <= provenCheckpoint;
+  }
+
+  private async getSecondsUntilProofSubmissionWindowEnd(epochNumber: EpochNumber) {
+    const deadline = getProofSubmissionDeadlineTimestamp(epochNumber, await this.rollupContract.getRollupConstants());
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    return Math.max(Number(deadline - now), 0.001);
+  }
+
   private async validateEpochProofSubmission(args: {
     fromCheckpoint: CheckpointNumber;
     toCheckpoint: CheckpointNumber;