@aztec/sequencer-client 0.63.1 → 0.64.0

package/src/publisher/l1-publisher.ts

@@ -17,7 +17,7 @@ import {
   type Proof,
   type RootRollupPublicInputs,
 } from '@aztec/circuits.js';
-import { type L1ContractsConfig, createEthereumChain } from '@aztec/ethereum';
+import { type EthereumChain, type L1ContractsConfig, createEthereumChain } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
 import { areArraysEqual, compactArray, times } from '@aztec/foundation/collection';
 import { type Signature } from '@aztec/foundation/eth-signature';
@@ -58,7 +58,6 @@ import {
   publicActions,
 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import type * as chains from 'viem/chains';
 
 import { type PublisherConfig, type TxSenderConfig } from './config.js';
 import { L1PublisherMetrics } from './l1-publisher-metrics.js';
@@ -145,19 +144,19 @@ export class L1Publisher {
 
   protected log = createDebugLogger('aztec:sequencer:publisher');
 
-  private rollupContract: GetContractReturnType<
+  protected rollupContract: GetContractReturnType<
     typeof RollupAbi,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+    WalletClient<HttpTransport, Chain, PrivateKeyAccount>
   >;
-  private governanceProposerContract?: GetContractReturnType<
+  protected governanceProposerContract?: GetContractReturnType<
     typeof GovernanceProposerAbi,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+    WalletClient<HttpTransport, Chain, PrivateKeyAccount>
   > = undefined;
 
-  private publicClient: PublicClient<HttpTransport, chains.Chain>;
-  private walletClient: WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>;
-  private account: PrivateKeyAccount;
-  private ethereumSlotDuration: bigint;
+  protected publicClient: PublicClient<HttpTransport, Chain>;
+  protected walletClient: WalletClient<HttpTransport, Chain, PrivateKeyAccount>;
+  protected account: PrivateKeyAccount;
+  protected ethereumSlotDuration: bigint;
 
   public static PROPOSE_GAS_GUESS: bigint = 12_000_000n;
   public static PROPOSE_AND_CLAIM_GAS_GUESS: bigint = this.PROPOSE_GAS_GUESS + 100_000n;
@@ -175,11 +174,7 @@ export class L1Publisher {
     this.account = privateKeyToAccount(publisherPrivateKey);
     this.log.debug(`Publishing from address ${this.account.address}`);
 
-    this.walletClient = createWalletClient({
-      account: this.account,
-      chain: chain.chainInfo,
-      transport: http(chain.rpcUrl),
-    });
+    this.walletClient = this.createWalletClient(this.account, chain);
 
     this.publicClient = createPublicClient({
       chain: chain.chainInfo,
@@ -202,6 +197,17 @@ export class L1Publisher {
     }
   }
 
+  protected createWalletClient(
+    account: PrivateKeyAccount,
+    chain: EthereumChain,
+  ): WalletClient<HttpTransport, Chain, PrivateKeyAccount> {
+    return createWalletClient({
+      account,
+      chain: chain.chainInfo,
+      transport: http(chain.rpcUrl),
+    });
+  }
+
   public getPayLoad() {
     return this.payload;
   }
@@ -226,7 +232,7 @@ export class L1Publisher {
 
   public getRollupContract(): GetContractReturnType<
     typeof RollupAbi,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+    WalletClient<HttpTransport, Chain, PrivateKeyAccount>
   > {
     return this.rollupContract;
   }
@@ -732,10 +738,12 @@ export class L1Publisher {
       : [];
     const txHashes = encodedData.txHashes ? encodedData.txHashes.map(txHash => txHash.to0xString()) : [];
     const args = [
-      `0x${encodedData.header.toString('hex')}`,
-      `0x${encodedData.archive.toString('hex')}`,
-      `0x${encodedData.blockHash.toString('hex')}`,
-      txHashes,
+      {
+        header: `0x${encodedData.header.toString('hex')}`,
+        archive: `0x${encodedData.archive.toString('hex')}`,
+        blockHash: `0x${encodedData.blockHash.toString('hex')}`,
+        txHashes,
+      },
       attestations,
       `0x${encodedData.body.toString('hex')}`,
     ] as const;

package/src/publisher/test-l1-publisher.ts

@@ -0,0 +1,20 @@
+import { type EthereumChain } from '@aztec/ethereum';
+import { type Delayer, withDelayer } from '@aztec/ethereum/test';
+
+import { type Chain, type HttpTransport, type PrivateKeyAccount, type WalletClient } from 'viem';
+
+import { L1Publisher } from './l1-publisher.js';
+
+export class TestL1Publisher extends L1Publisher {
+  public delayer: Delayer | undefined;
+
+  protected override createWalletClient(
+    account: PrivateKeyAccount,
+    chain: EthereumChain,
+  ): WalletClient<HttpTransport, Chain, PrivateKeyAccount> {
+    const baseClient = super.createWalletClient(account, chain);
+    const { client, delayer } = withDelayer(baseClient, { ethereumSlotDuration: this.ethereumSlotDuration });
+    this.delayer = delayer;
+    return client;
+  }
+}

package/src/sequencer/metrics.ts

@@ -21,6 +21,8 @@ export class SequencerMetrics {
   private currentBlockNumber: Gauge;
   private currentBlockSize: Gauge;
 
+  private timeToCollectAttestations: Gauge;
+
   constructor(client: TelemetryClient, getState: SequencerStateCallback, name = 'Sequencer') {
     const meter = client.getMeter(name);
     this.tracer = client.getTracer(name);
@@ -60,9 +62,26 @@ export class SequencerMetrics {
       description: 'Current block number',
     });
 
+    this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
+      description: 'The time spent collecting attestations from committee members',
+    });
+
     this.setCurrentBlock(0, 0);
   }
 
+  startCollectingAttestationsTimer(): () => void {
+    const startTime = Date.now();
+    const stop = () => {
+      const duration = Date.now() - startTime;
+      this.recordTimeToCollectAttestations(duration);
+    };
+    return stop.bind(this);
+  }
+
+  recordTimeToCollectAttestations(time: number) {
+    this.timeToCollectAttestations.record(time);
+  }
+
   recordCancelledBlock() {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'cancelled',

package/src/sequencer/sequencer.ts

@@ -15,6 +15,7 @@ import {
   AppendOnlyTreeSnapshot,
   ContentCommitment,
   GENESIS_ARCHIVE_ROOT,
+  type GlobalVariables,
   Header,
   StateReference,
 } from '@aztec/circuits.js';
@@ -112,6 +113,9 @@ export class Sequencer {
     this.updateConfig(config);
     this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
     this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
+
+    // Register the block builder with the validator client for re-execution
+    this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
   }
 
   get tracer(): Tracer {
@@ -167,11 +171,11 @@ export class Sequencer {
       [SequencerState.IDLE]: this.aztecSlotDuration,
       [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
       [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration, // We always want to allow the full slot to check if we are the proposer
-      [SequencerState.WAITING_FOR_TXS]: 3,
-      [SequencerState.CREATING_BLOCK]: 5,
-      [SequencerState.PUBLISHING_BLOCK_TO_PEERS]: 5 + this.maxTxsPerBlock * 2, // if we take 5 seconds to create block, then 4 transactions at 2 seconds each
-      [SequencerState.WAITING_FOR_ATTESTATIONS]: 5 + this.maxTxsPerBlock * 2 + 3, // it shouldn't take 3 seconds to publish to peers
-      [SequencerState.PUBLISHING_BLOCK]: 5 + this.maxTxsPerBlock * 2 + 3 + 5, // wait 5 seconds for attestations
+      [SequencerState.WAITING_FOR_TXS]: 5,
+      [SequencerState.CREATING_BLOCK]: 7,
+      [SequencerState.PUBLISHING_BLOCK_TO_PEERS]: 7 + this.maxTxsPerBlock * 2, // if we take 5 seconds to create block, then 4 transactions at 2 seconds each
+      [SequencerState.WAITING_FOR_ATTESTATIONS]: 7 + this.maxTxsPerBlock * 2 + 3, // it shouldn't take 3 seconds to publish to peers
+      [SequencerState.PUBLISHING_BLOCK]: 7 + this.maxTxsPerBlock * 2 + 3 + 5, // wait 5 seconds for attestations
     };
     if (this.enforceTimeTable && newTimeTable[SequencerState.PUBLISHING_BLOCK] > this.aztecSlotDuration) {
       throw new Error('Sequencer cannot publish block in less than a slot');
@@ -185,7 +189,7 @@ export class Sequencer {
   public start() {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
     this.runningPromise.start();
-    this.setState(SequencerState.IDLE, true /** force */);
+    this.setState(SequencerState.IDLE, 0, true /** force */);
     this.log.info('Sequencer started');
     return Promise.resolve();
   }
@@ -197,7 +201,7 @@ export class Sequencer {
     this.log.debug(`Stopping sequencer`);
     await this.runningPromise?.stop();
     this.publisher.interrupt();
-    this.setState(SequencerState.STOPPED, true /** force */);
+    this.setState(SequencerState.STOPPED, 0, true /** force */);
     this.log.info('Stopped sequencer');
   }
 
@@ -208,7 +212,7 @@ export class Sequencer {
     this.log.info('Restarting sequencer');
     this.publisher.restart();
     this.runningPromise!.start();
-    this.setState(SequencerState.IDLE, true /** force */);
+    this.setState(SequencerState.IDLE, 0, true /** force */);
   }
 
   /**
@@ -228,7 +232,7 @@ export class Sequencer {
    *          - If our block for some reason is not included, revert the state
    */
   protected async doRealWork() {
-    this.setState(SequencerState.SYNCHRONIZING);
+    this.setState(SequencerState.SYNCHRONIZING, 0);
     // Update state when the previous block has been synced
     const prevBlockSynced = await this.isBlockSynced();
     // Do not go forward with new block if the previous one has not been mined and processed
@@ -239,7 +243,7 @@ export class Sequencer {
 
     this.log.debug('Previous block has been mined and processed');
 
-    this.setState(SequencerState.PROPOSER_CHECK);
+    this.setState(SequencerState.PROPOSER_CHECK, 0);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
     const historicalHeader = chainTip?.header;
@@ -273,8 +277,9 @@ export class Sequencer {
     if (!this.shouldProposeBlock(historicalHeader, {})) {
       return;
     }
+    const secondsIntoSlot = getSecondsIntoSlot(this.l1GenesisTime, this.aztecSlotDuration, Number(slot));
 
-    this.setState(SequencerState.WAITING_FOR_TXS);
+    this.setState(SequencerState.WAITING_FOR_TXS, secondsIntoSlot);
 
     // Get txs to build the new block.
     const pendingTxs = this.p2pClient.getTxs('pending');
@@ -319,7 +324,7 @@ export class Sequencer {
     } catch (err) {
       this.log.error(`Error assembling block`, (err as any).stack);
     }
-    this.setState(SequencerState.IDLE);
+    this.setState(SequencerState.IDLE, 0);
   }
 
   protected async work() {
@@ -333,7 +338,7 @@ export class Sequencer {
         throw err;
       }
     } finally {
-      this.setState(SequencerState.IDLE);
+      this.setState(SequencerState.IDLE, 0);
     }
   }
 
@@ -392,14 +397,13 @@ export class Sequencer {
     return true;
   }
 
-  setState(proposedState: SequencerState, force: boolean = false) {
+  setState(proposedState: SequencerState, secondsIntoSlot: number, force: boolean = false) {
     if (this.state === SequencerState.STOPPED && force !== true) {
       this.log.warn(
         `Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped. Set force=true to override.`,
       );
       return;
     }
-    const secondsIntoSlot = getSecondsIntoSlot(this.l1GenesisTime, this.aztecSlotDuration);
     if (!this.doIHaveEnoughTimeLeft(proposedState, secondsIntoSlot)) {
       throw new SequencerTooSlowError(this.state, proposedState, this.timeTable[proposedState], secondsIntoSlot);
     }
@@ -473,37 +477,21 @@ export class Sequencer {
   }
 
   /**
-   * @notice  Build and propose a block to the chain
+   * Build a block
    *
-   * @dev     MUST throw instead of exiting early to ensure that world-state
-   *          is being rolled back if the block is dropped.
+   * Shared between the sequencer and the validator for re-execution
    *
    * @param validTxs - The valid transactions to construct the block from
-   * @param proposalHeader - The partial header constructed for the proposal
+   * @param newGlobalVariables - The global variables for the new block
    * @param historicalHeader - The historical header of the parent
+   * @param interrupt - The interrupt callback, used to validate the block for submission and check if we should propose the block
    */
-  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
-    [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
-  }))
-  private async buildBlockAndAttemptToPublish(
+  private async buildBlock(
     validTxs: Tx[],
-    proposalHeader: Header,
-    historicalHeader: Header | undefined,
-  ): Promise<void> {
-    await this.publisher.validateBlockForSubmission(proposalHeader);
-
-    const newGlobalVariables = proposalHeader.globalVariables;
-
-    this.metrics.recordNewBlock(newGlobalVariables.blockNumber.toNumber(), validTxs.length);
-    const workTimer = new Timer();
-    this.setState(SequencerState.CREATING_BLOCK);
-    this.log.info(
-      `Building blockNumber=${newGlobalVariables.blockNumber.toNumber()} txCount=${
-        validTxs.length
-      } slotNumber=${newGlobalVariables.slotNumber.toNumber()}`,
-    );
-
-    // Get l1 to l2 messages from the contract
+    newGlobalVariables: GlobalVariables,
+    historicalHeader?: Header,
+    interrupt?: (processedTxs: ProcessedTx[]) => Promise<void>,
+  ) {
     this.log.debug('Requesting L1 to L2 messages from contract');
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(newGlobalVariables.blockNumber.toBigInt());
     this.log.verbose(
@@ -513,11 +501,15 @@ export class Sequencer {
     const numRealTxs = validTxs.length;
     const blockSize = Math.max(2, numRealTxs);
 
+    // Sync to the previous block at least
+    await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
+    this.log.verbose(`Synced to previous block ${newGlobalVariables.blockNumber.toNumber() - 1}`);
+
     // NB: separating the dbs because both should update the state
     const publicProcessorFork = await this.worldState.fork();
     const orchestratorFork = await this.worldState.fork();
+
     try {
-      // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = this.publicProcessorFactory.create(publicProcessorFork, historicalHeader, newGlobalVariables);
       const blockBuildingTimer = new Timer();
       const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
@@ -537,6 +529,62 @@ export class Sequencer {
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
+      await interrupt?.(processedTxs);
+
+      // All real transactions have been added, set the block as full and complete the proving.
+      const block = await blockBuilder.setBlockCompleted();
+
+      return { block, publicProcessorDuration, numProcessedTxs: processedTxs.length, blockBuildingTimer };
+    } finally {
+      // We create a fresh processor each time to reset any cached state (eg storage writes)
+      await publicProcessorFork.close();
+      await orchestratorFork.close();
+    }
+  }
+
+  /**
+   * @notice  Build and propose a block to the chain
+   *
+   * @dev     MUST throw instead of exiting early to ensure that world-state
+   *          is being rolled back if the block is dropped.
+   *
+   * @param validTxs - The valid transactions to construct the block from
+   * @param proposalHeader - The partial header constructed for the proposal
+   * @param historicalHeader - The historical header of the parent
+   */
+  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
+    [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
+  }))
+  private async buildBlockAndAttemptToPublish(
+    validTxs: Tx[],
+    proposalHeader: Header,
+    historicalHeader: Header | undefined,
+  ): Promise<void> {
+    await this.publisher.validateBlockForSubmission(proposalHeader);
+
+    const newGlobalVariables = proposalHeader.globalVariables;
+
+    this.metrics.recordNewBlock(newGlobalVariables.blockNumber.toNumber(), validTxs.length);
+    const workTimer = new Timer();
+    const secondsIntoSlot = getSecondsIntoSlot(
+      this.l1GenesisTime,
+      this.aztecSlotDuration,
+      newGlobalVariables.slotNumber.toNumber(),
+    );
+    this.setState(SequencerState.CREATING_BLOCK, secondsIntoSlot);
+    this.log.info(
+      `Building blockNumber=${newGlobalVariables.blockNumber.toNumber()} txCount=${
+        validTxs.length
+      } slotNumber=${newGlobalVariables.slotNumber.toNumber()}`,
+    );
+
+    /**
+     * BuildBlock is shared between the sequencer and the validator for re-execution
+     * We use the interrupt callback to validate the block for submission and check if we should propose the block
+     *
+     * If we fail, we throw an error in order to roll back
+     */
+    const interrupt = async (processedTxs: ProcessedTx[]) => {
       await this.publisher.validateBlockForSubmission(proposalHeader);
 
       if (
@@ -548,9 +596,15 @@ export class Sequencer {
         // TODO: Roll back changes to world state
         throw new Error('Should not propose the block');
       }
+    };
 
-      // All real transactions have been added, set the block as full and complete the proving.
-      const block = await blockBuilder.setBlockCompleted();
+    try {
+      const { block, publicProcessorDuration, numProcessedTxs, blockBuildingTimer } = await this.buildBlock(
+        validTxs,
+        newGlobalVariables,
+        historicalHeader,
+        interrupt,
+      );
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
@@ -558,7 +612,7 @@ export class Sequencer {
       await this.publisher.validateBlockForSubmission(block.header);
 
       const workDuration = workTimer.ms();
-      this.log.verbose(
+      this.log.info(
         `Assembled block ${block.number} (txEffectsHash: ${block.header.contentCommitment.txsEffectsHash.toString(
           'hex',
         )})`,
@@ -573,35 +627,32 @@ export class Sequencer {
       );
 
       if (this.isFlushing) {
-        this.log.verbose(`Flushing completed`);
+        this.log.info(`Flushing completed`);
       }
 
       const txHashes = validTxs.map(tx => tx.getTxHash());
 
       this.isFlushing = false;
       this.log.verbose('Collecting attestations');
+      const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
       const attestations = await this.collectAttestations(block, txHashes);
       this.log.verbose('Attestations collected');
-
+      stopCollectingAttestationsTimer();
       this.log.verbose('Collecting proof quotes');
+
       const proofQuote = await this.createProofClaimForPreviousEpoch(newGlobalVariables.slotNumber.toBigInt());
-      this.log.verbose(proofQuote ? `Using proof quote ${inspect(proofQuote.payload)}` : 'No proof quote available');
-
-      try {
-        await this.publishL2Block(block, attestations, txHashes, proofQuote);
-        this.metrics.recordPublishedBlock(workDuration);
-        this.log.info(
-          `Submitted rollup block ${block.number} with ${processedTxs.length} transactions duration=${Math.ceil(
-            workDuration,
-          )}ms (Submitter: ${this.publisher.getSenderAddress()})`,
-        );
-      } catch (err) {
-        this.metrics.recordFailedBlock();
-        throw err;
-      }
-    } finally {
-      await publicProcessorFork.close();
-      await orchestratorFork.close();
+      this.log.info(proofQuote ? `Using proof quote ${inspect(proofQuote.payload)}` : 'No proof quote available');
+
+      await this.publishL2Block(block, attestations, txHashes, proofQuote);
+      this.metrics.recordPublishedBlock(workDuration);
+      this.log.info(
+        `Submitted rollup block ${block.number} with ${numProcessedTxs} transactions duration=${Math.ceil(
+          workDuration,
+        )}ms (Submitter: ${this.publisher.getSenderAddress()})`,
+      );
+    } catch (err) {
+      this.metrics.recordFailedBlock();
+      throw err;
     }
   }
 
@@ -621,7 +672,7 @@ export class Sequencer {
     this.log.debug(`Attesting committee length ${committee.length}`);
 
     if (committee.length === 0) {
-      this.log.debug(`Attesting committee length is 0, skipping`);
+      this.log.verbose(`Attesting committee length is 0, skipping`);
       return undefined;
     }
 
@@ -633,16 +684,28 @@ export class Sequencer {
 
     const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
 
-    this.log.verbose('Creating block proposal');
+    this.log.info('Creating block proposal');
     const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
 
-    this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS);
-    this.log.verbose('Broadcasting block proposal to validators');
+    let secondsIntoSlot = getSecondsIntoSlot(
+      this.l1GenesisTime,
+      this.aztecSlotDuration,
+      block.header.globalVariables.slotNumber.toNumber(),
+    );
+
+    this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS, secondsIntoSlot);
+    this.log.info('Broadcasting block proposal to validators');
     this.validatorClient.broadcastBlockProposal(proposal);
 
-    this.setState(SequencerState.WAITING_FOR_ATTESTATIONS);
+    secondsIntoSlot = getSecondsIntoSlot(
+      this.l1GenesisTime,
+      this.aztecSlotDuration,
+      block.header.globalVariables.slotNumber.toNumber(),
+    );
+
+    this.setState(SequencerState.WAITING_FOR_ATTESTATIONS, secondsIntoSlot);
     const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations);
-    this.log.verbose(`Collected attestations from validators, number of attestations: ${attestations.length}`);
+    this.log.info(`Collected attestations from validators, number of attestations: ${attestations.length}`);
 
     // note: the smart contract requires that the signatures are provided in the order of the committee
     return orderAttestations(attestations, committee);
@@ -659,7 +722,7 @@ export class Sequencer {
 
       // Get quotes for the epoch to be proven
       const quotes = await this.p2pClient.getEpochProofQuotes(epochToProve);
-      this.log.verbose(`Retrieved ${quotes.length} quotes, slot: ${slotNumber}, epoch to prove: ${epochToProve}`);
+      this.log.info(`Retrieved ${quotes.length} quotes, slot: ${slotNumber}, epoch to prove: ${epochToProve}`);
       for (const quote of quotes) {
         this.log.verbose(inspect(quote.payload));
       }
@@ -670,7 +733,7 @@ export class Sequencer {
 
       const validQuotes = (await validQuotesPromise).filter((q): q is EpochProofQuote => !!q);
       if (!validQuotes.length) {
-        this.log.verbose(`Failed to find any valid proof quotes`);
+        this.log.warn(`Failed to find any valid proof quotes`);
         return undefined;
       }
       // pick the quote with the lowest fee
@@ -697,8 +760,13 @@ export class Sequencer {
     txHashes?: TxHash[],
     proofQuote?: EpochProofQuote,
   ) {
+    const secondsIntoSlot = getSecondsIntoSlot(
+      this.l1GenesisTime,
+      this.aztecSlotDuration,
+      block.header.globalVariables.slotNumber.toNumber(),
+    );
     // Publishes new block to the network and awaits the tx to be mined
-    this.setState(SequencerState.PUBLISHING_BLOCK);
+    this.setState(SequencerState.PUBLISHING_BLOCK, secondsIntoSlot);
 
     const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
     if (!publishedL2Block) {

package/src/sequencer/utils.ts

@@ -73,6 +73,7 @@ export function orderAttestations(attestations: BlockAttestation[], orderAddress
   return orderedAttestations;
 }
 
-export function getSecondsIntoSlot(l1GenesisTime: number, aztecSlotDuration: number): number {
-  return (Date.now() / 1000 - l1GenesisTime) % aztecSlotDuration;
+export function getSecondsIntoSlot(l1GenesisTime: number, aztecSlotDuration: number, slotNumber: number): number {
+  const slotStartTimestamp = l1GenesisTime + slotNumber * aztecSlotDuration;
+  return Date.now() / 1000 - slotStartTimestamp;
 }