@aztec/sequencer-client 0.49.2 → 0.50.1

package/src/publisher/l1-publisher.ts

@@ -1,17 +1,34 @@
-import { type L2Block } from '@aztec/circuit-types';
+import { type L2Block, type Signature } from '@aztec/circuit-types';
 import { type L1PublishBlockStats, type L1PublishProofStats } from '@aztec/circuit-types/stats';
-import { type EthAddress, type Header, type Proof } from '@aztec/circuits.js';
+import { ETHEREUM_SLOT_DURATION, EthAddress, type Header, type Proof } from '@aztec/circuits.js';
+import { createEthereumChain } from '@aztec/ethereum';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
+import { AvailabilityOracleAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
-
-import { type L2BlockReceiver } from '../receiver.js';
-import { type PublisherConfig } from './config.js';
+import {
+  type GetContractReturnType,
+  type Hex,
+  type HttpTransport,
+  type PrivateKeyAccount,
+  type PublicClient,
+  type WalletClient,
+  createPublicClient,
+  createWalletClient,
+  getAddress,
+  getContract,
+  hexToBytes,
+  http,
+} 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';
 
 /**
@@ -27,7 +44,7 @@ export type TransactionStats = {
 };
 
 /**
- * Minimal information from a tx receipt returned by an L1PublisherTxSender.
+ * Minimal information from a tx receipt.
  */
 export type MinimalTransactionReceipt = {
   /** True if the tx was successful, false if reverted. */
@@ -49,84 +66,18 @@ export type MinimalTransactionReceipt = {
  */
 export type Attestation = { isEmpty: boolean; v: number; r: `0x${string}`; s: `0x${string}` };
 
-/**
- * Pushes txs to the L1 chain and waits for their completion.
- */
-export interface L1PublisherTxSender {
-  /** Attests to the given archive root. */
-  attest(archive: `0x${string}`): Promise<Attestation>;
-
-  /** Returns the EOA used for sending txs to L1.  */
-  getSenderAddress(): Promise<EthAddress>;
-
-  /** Returns the address of the L2 proposer at the NEXT Ethereum block zero if anyone can submit. */
-  getProposerAtNextEthBlock(): Promise<EthAddress>;
-
-  /**
-   * Publishes tx effects to Availability Oracle.
-   * @param encodedBody - Encoded block body.
-   * @returns The hash of the mined tx.
-   */
-  sendPublishTx(encodedBody: Buffer): Promise<string | undefined>;
-
-  /**
-   * Sends a tx to the L1 rollup contract with a new L2 block. Returns once the tx has been mined.
-   * @param encodedData - Serialized data for processing the new L2 block.
-   * @returns The hash of the mined tx.
-   */
-  sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
-
-  /**
-   * Publishes tx effects to availability oracle and send L2 block to rollup contract
-   * @param encodedData - Data for processing the new L2 block.
-   * @returns The hash of the tx.
-   */
-  sendPublishAndProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
-
-  /**
-   * Sends a tx to the L1 rollup contract with a proof. Returns once the tx has been mined.
-   * @param encodedData - Serialized data for processing the new L2 block.
-   * @returns The hash of the mined tx.
-   */
-  sendSubmitProofTx(submitProofArgs: L1SubmitProofArgs): Promise<string | undefined>;
-
-  /**
-   * Returns a tx receipt if the tx has been mined.
-   * @param txHash - Hash of the tx to look for.
-   * @returns Undefined if the tx hasn't been mined yet, the receipt otherwise.
-   */
-  getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined>;
-
-  /**
-   * Returns info on a tx by calling eth_getTransaction.
-   * @param txHash - Hash of the tx to look for.
-   */
-  getTransactionStats(txHash: string): Promise<TransactionStats | undefined>;
-
-  /**
-   * Returns the current archive root.
-   * @returns The current archive root of the rollup contract.
-   */
-  getCurrentArchive(): Promise<Buffer>;
-
-  /**
-   * Checks if the transaction effects of the given block are available.
-   * @param block - The block of which to check whether txs are available.
-   * @returns True if the txs are available, false otherwise.
-   */
-  checkIfTxsAreAvailable(block: L2Block): Promise<boolean>;
-}
-
 /** Arguments to the process method of the rollup contract */
 export type L1ProcessArgs = {
   /** The L2 block header. */
   header: Buffer;
   /** A root of the archive tree after the L2 block is applied. */
   archive: Buffer;
+  /** The L2 block's leaf in the archive tree. */
+  blockHash: Buffer;
   /** L2 block body. */
   body: Buffer;
   /** Attestations */
-  attestations?: Attestation[];
+  attestations?: Signature[];
 };
 
 /** Arguments to the submitProof method of the rollup contract */
@@ -151,38 +102,107 @@ export type L1SubmitProofArgs = {
  *
  * Adapted from https://github.com/AztecProtocol/aztec2-internal/blob/master/falafel/src/rollup_publisher.ts.
  */
-export class L1Publisher implements L2BlockReceiver {
+export class L1Publisher {
   private interruptibleSleep = new InterruptibleSleep();
   private sleepTimeMs: number;
   private interrupted = false;
   private metrics: L1PublisherMetrics;
   private log = createDebugLogger('aztec:sequencer:publisher');
 
-  constructor(private txSender: L1PublisherTxSender, client: TelemetryClient, config?: PublisherConfig) {
+  private availabilityOracleContract: GetContractReturnType<
+    typeof AvailabilityOracleAbi,
+    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+  >;
+  private rollupContract: GetContractReturnType<
+    typeof RollupAbi,
+    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+  >;
+  private publicClient: PublicClient<HttpTransport, chains.Chain>;
+  private account: PrivateKeyAccount;
+
+  constructor(config: TxSenderConfig & PublisherConfig, client: TelemetryClient) {
     this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
     this.metrics = new L1PublisherMetrics(client, 'L1Publisher');
+
+    const { l1RpcUrl: rpcUrl, l1ChainId: chainId, publisherPrivateKey, l1Contracts } = config;
+    const chain = createEthereumChain(rpcUrl, chainId);
+    this.account = privateKeyToAccount(publisherPrivateKey);
+    const walletClient = createWalletClient({
+      account: this.account,
+      chain: chain.chainInfo,
+      transport: http(chain.rpcUrl),
+    });
+
+    this.publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: http(chain.rpcUrl),
+    });
+
+    this.availabilityOracleContract = getContract({
+      address: getAddress(l1Contracts.availabilityOracleAddress.toString()),
+      abi: AvailabilityOracleAbi,
+      client: walletClient,
+    });
+    this.rollupContract = getContract({
+      address: getAddress(l1Contracts.rollupAddress.toString()),
+      abi: RollupAbi,
+      client: walletClient,
+    });
   }
 
-  public async attest(archive: `0x${string}`): Promise<Attestation> {
-    return await this.txSender.attest(archive);
+  public getSenderAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.fromString(this.account.address));
   }
 
-  public async senderAddress(): Promise<EthAddress> {
-    return await this.txSender.getSenderAddress();
+  // Computes who will be the L2 proposer at the next Ethereum block
+  // Using next Ethereum block so we do NOT need to wait for it being mined before seeing the effect
+  // @note Assumes that all ethereum slots have blocks
+  async getProposerAtNextEthBlock(): Promise<EthAddress> {
+    try {
+      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(ETHEREUM_SLOT_DURATION));
+      const submitter = await this.rollupContract.read.getProposerAt([ts]);
+      return EthAddress.fromString(submitter);
+    } catch (err) {
+      this.log.warn(`Failed to get submitter: ${err}`);
+      return EthAddress.ZERO;
+    }
   }
 
   public async isItMyTurnToSubmit(): Promise<boolean> {
-    const submitter = await this.txSender.getProposerAtNextEthBlock();
-    const sender = await this.txSender.getSenderAddress();
+    const submitter = await this.getProposerAtNextEthBlock();
+    const sender = await this.getSenderAddress();
     return submitter.isZero() || submitter.equals(sender);
   }
 
+  public async getCurrentEpochCommittee(): Promise<EthAddress[]> {
+    const committee = await this.rollupContract.read.getCurrentEpochCommittee();
+    return committee.map(EthAddress.fromString);
+  }
+
+  checkIfTxsAreAvailable(block: L2Block): Promise<boolean> {
+    const args = [`0x${block.body.getTxsEffectsHash().toString('hex').padStart(64, '0')}`] as const;
+    return this.availabilityOracleContract.read.isAvailable(args);
+  }
+
+  async getTransactionStats(txHash: string): Promise<TransactionStats | undefined> {
+    const tx = await this.publicClient.getTransaction({ hash: txHash as Hex });
+    if (!tx) {
+      return undefined;
+    }
+    const calldata = hexToBytes(tx.input);
+    return {
+      transactionHash: tx.hash,
+      calldataSize: calldata.length,
+      calldataGas: getCalldataGasUsage(calldata),
+    };
+  }
+
   /**
    * Publishes L2 block on L1.
    * @param block - L2 block to publish.
    * @returns True once the tx has been confirmed and is successful, false on revert or interrupt, blocks otherwise.
    */
-  public async processL2Block(block: L2Block, attestations?: Attestation[]): Promise<boolean> {
+  public async processL2Block(block: L2Block, attestations?: Signature[]): Promise<boolean> {
     const ctx = { blockNumber: block.number, blockHash: block.hash().toString() };
     // TODO(#4148) Remove this block number check, it's here because we don't currently have proper genesis state on the contract
     const lastArchive = block.header.lastArchive.root.toBuffer();
@@ -195,6 +215,7 @@ export class L1Publisher implements L2BlockReceiver {
     const processTxArgs = {
       header: block.header.toBuffer(),
       archive: block.archive.root.toBuffer(),
+      blockHash: block.header.hash().toBuffer(),
       body: encodedBody,
       attestations,
     };
@@ -204,7 +225,7 @@ export class L1Publisher implements L2BlockReceiver {
       let txHash;
       const timer = new Timer();
 
-      if (await this.txSender.checkIfTxsAreAvailable(block)) {
+      if (await this.checkIfTxsAreAvailable(block)) {
         this.log.verbose(`Transaction effects of block ${block.number} already published.`, ctx);
         txHash = await this.sendProcessTx(processTxArgs);
       } else {
@@ -224,7 +245,7 @@ export class L1Publisher implements L2BlockReceiver {
 
       // Tx was mined successfully
       if (receipt.status) {
-        const tx = await this.txSender.getTransactionStats(txHash);
+        const tx = await this.getTransactionStats(txHash);
         const stats: L1PublishBlockStats = {
           ...pick(receipt, 'gasPrice', 'gasUsed', 'transactionHash'),
           ...pick(tx!, 'calldataGas', 'calldataSize'),
@@ -284,13 +305,13 @@ export class L1Publisher implements L2BlockReceiver {
 
       // Tx was mined successfully
       if (receipt.status) {
-        const tx = await this.txSender.getTransactionStats(txHash);
+        const tx = await this.getTransactionStats(txHash);
         const stats: L1PublishProofStats = {
           ...pick(receipt, 'gasPrice', 'gasUsed', 'transactionHash'),
           ...pick(tx!, 'calldataGas', 'calldataSize'),
           eventName: 'proof-published-to-l1',
         };
-        this.log.info(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
+        this.log.info(`Published proof to L1 rollup contract`, { ...stats, ...ctx });
         this.metrics.recordSubmitProof(timer.ms(), stats);
         return true;
       }
@@ -320,13 +341,18 @@ export class L1Publisher implements L2BlockReceiver {
     this.interrupted = false;
   }
 
+  async getCurrentArchive(): Promise<Buffer> {
+    const archive = await this.rollupContract.read.archive();
+    return Buffer.from(archive.replace('0x', ''), 'hex');
+  }
+
   /**
    * Verifies that the given value of last archive in a block header equals current archive of the rollup contract
    * @param lastArchive - The last archive of the block we wish to publish.
    * @returns Boolean indicating if the hashes are equal.
    */
   private async checkLastArchiveHash(lastArchive: Buffer): Promise<boolean> {
-    const fromChain = await this.txSender.getCurrentArchive();
+    const fromChain = await this.getCurrentArchive();
     const areSame = lastArchive.equals(fromChain);
     if (!areSame) {
       this.log.debug(`Contract archive: ${fromChain.toString('hex')}`);
@@ -339,7 +365,19 @@ export class L1Publisher implements L2BlockReceiver {
     try {
       const size = Object.values(submitProofArgs).reduce((acc, arg) => acc + arg.length, 0);
       this.log.info(`SubmitProof size=${size} bytes`);
-      return await this.txSender.sendSubmitProofTx(submitProofArgs);
+
+      const { header, archive, proverId, aggregationObject, proof } = submitProofArgs;
+      const args = [
+        `0x${header.toString('hex')}`,
+        `0x${archive.toString('hex')}`,
+        `0x${proverId.toString('hex')}`,
+        `0x${aggregationObject.toString('hex')}`,
+        `0x${proof.toString('hex')}`,
+      ] as const;
+
+      return await this.rollupContract.write.submitBlockRootProof(args, {
+        account: this.account,
+      });
     } catch (err) {
       this.log.error(`Rollup submit proof failed`, err);
       return undefined;
@@ -350,7 +388,11 @@ export class L1Publisher implements L2BlockReceiver {
     while (!this.interrupted) {
       try {
         this.log.info(`TxEffects size=${encodedBody.length} bytes`);
-        return await this.txSender.sendPublishTx(encodedBody);
+        const args = [`0x${encodedBody.toString('hex')}`] as const;
+
+        return await this.availabilityOracleContract.write.publish(args, {
+          account: this.account,
+        });
       } catch (err) {
         this.log.error(`TxEffects publish failed`, err);
         return undefined;
@@ -361,7 +403,29 @@ export class L1Publisher implements L2BlockReceiver {
   private async sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined> {
     while (!this.interrupted) {
       try {
-        return await this.txSender.sendProcessTx(encodedData);
+        if (encodedData.attestations) {
+          const attestations = encodedData.attestations.map(attest => attest.toViemSignature());
+          const args = [
+            `0x${encodedData.header.toString('hex')}`,
+            `0x${encodedData.archive.toString('hex')}`,
+            `0x${encodedData.blockHash.toString('hex')}`,
+            attestations,
+          ] as const;
+
+          return await this.rollupContract.write.process(args, {
+            account: this.account,
+          });
+        } else {
+          const args = [
+            `0x${encodedData.header.toString('hex')}`,
+            `0x${encodedData.archive.toString('hex')}`,
+            `0x${encodedData.blockHash.toString('hex')}`,
+          ] as const;
+
+          return await this.rollupContract.write.process(args, {
+            account: this.account,
+          });
+        }
       } catch (err) {
         this.log.error(`Rollup publish failed`, err);
         return undefined;
@@ -372,7 +436,32 @@ export class L1Publisher implements L2BlockReceiver {
   private async sendPublishAndProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined> {
     while (!this.interrupted) {
       try {
-        return await this.txSender.sendPublishAndProcessTx(encodedData);
+        // @note  This is quite a sin, but I'm committing war crimes in this code already.
+        if (encodedData.attestations) {
+          const attestations = encodedData.attestations.map(attest => attest.toViemSignature());
+          const args = [
+            `0x${encodedData.header.toString('hex')}`,
+            `0x${encodedData.archive.toString('hex')}`,
+            `0x${encodedData.blockHash.toString('hex')}`,
+            attestations,
+            `0x${encodedData.body.toString('hex')}`,
+          ] as const;
+
+          return await this.rollupContract.write.publishAndProcess(args, {
+            account: this.account,
+          });
+        } else {
+          const args = [
+            `0x${encodedData.header.toString('hex')}`,
+            `0x${encodedData.archive.toString('hex')}`,
+            `0x${encodedData.blockHash.toString('hex')}`,
+            `0x${encodedData.body.toString('hex')}`,
+          ] as const;
+
+          return await this.rollupContract.write.publishAndProcess(args, {
+            account: this.account,
+          });
+        }
       } catch (err) {
         this.log.error(`Rollup publish failed`, err);
         return undefined;
@@ -380,10 +469,34 @@ export class L1Publisher implements L2BlockReceiver {
     }
   }
 
-  private async getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined> {
+  /**
+   * Returns a tx receipt if the tx has been mined.
+   * @param txHash - Hash of the tx to look for.
+   * @returns Undefined if the tx hasn't been mined yet, the receipt otherwise.
+   */
+  async getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined> {
     while (!this.interrupted) {
       try {
-        return await this.txSender.getTransactionReceipt(txHash);
+        const receipt = await this.publicClient.getTransactionReceipt({
+          hash: txHash as Hex,
+        });
+
+        if (receipt) {
+          if (receipt.transactionHash !== txHash) {
+            throw new Error(`Tx hash mismatch: ${receipt.transactionHash} !== ${txHash}`);
+          }
+
+          return {
+            status: receipt.status === 'success',
+            transactionHash: txHash,
+            gasUsed: receipt.gasUsed,
+            gasPrice: receipt.effectiveGasPrice,
+            logs: receipt.logs,
+          };
+        }
+
+        this.log.debug(`Receipt not found for tx hash ${txHash}`);
+        return undefined;
       } catch (err) {
         //this.log.error(`Error getting tx receipt`, err);
         await this.sleepOrInterrupted();
@@ -395,3 +508,12 @@ export class L1Publisher implements L2BlockReceiver {
     await this.interruptibleSleep.sleep(this.sleepTimeMs);
   }
 }
+
+/**
+ * Returns cost of calldata usage in Ethereum.
+ * @param data - Calldata.
+ * @returns 4 for each zero byte, 16 for each nonzero.
+ */
+function getCalldataGasUsage(data: Uint8Array) {
+  return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
+}

package/src/sequencer/sequencer.ts

@@ -1,8 +1,10 @@
 import {
+  type BlockAttestation,
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
   type ProcessedTx,
+  Signature,
   Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
@@ -16,11 +18,12 @@ import { Timer, elapsed } from '@aztec/foundation/timer';
 import { type P2P } from '@aztec/p2p';
 import { type PublicProcessorFactory } from '@aztec/simulator';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { type ValidatorClient } from '@aztec/validator-client';
 import { type WorldStateStatus, type WorldStateSynchronizer } from '@aztec/world-state';
 
 import { type BlockBuilderFactory } from '../block_builder/index.js';
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type Attestation, type L1Publisher } from '../publisher/l1-publisher.js';
+import { type L1Publisher } from '../publisher/l1-publisher.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
@@ -50,9 +53,11 @@ export class Sequencer {
   private allowedInTeardown: AllowedElement[] = [];
   private maxBlockSizeInBytes: number = 1024 * 1024;
   private metrics: SequencerMetrics;
+  private isFlushing: boolean = false;
 
   constructor(
     private publisher: L1Publisher,
+    private validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
     private globalsBuilder: GlobalVariableBuilder,
     private p2pClient: P2P,
     private worldState: WorldStateSynchronizer,
@@ -190,6 +195,10 @@ export class Sequencer {
         return;
       }
 
+      if (this.isFlushing) {
+        this.log.verbose(`Flushing all pending txs in new block`);
+      }
+
       // Compute time elapsed since the previous block
       const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
       const currentTime = Math.floor(Date.now() / 1000);
@@ -199,7 +208,11 @@ export class Sequencer {
       );
 
       // Do not go forward with new block if not enough time has passed since last block
-      if (this.minSecondsBetweenBlocks > 0 && elapsedSinceLastBlock < this.minSecondsBetweenBlocks) {
+      if (
+        !this.isFlushing &&
+        this.minSecondsBetweenBlocks > 0 &&
+        elapsedSinceLastBlock < this.minSecondsBetweenBlocks
+      ) {
         this.log.debug(
           `Not creating block because not enough time ${this.minSecondsBetweenBlocks} has passed since last block`,
         );
@@ -212,7 +225,7 @@ export class Sequencer {
       const pendingTxs = this.p2pClient.getTxs('pending');
 
       // If we haven't hit the maxSecondsBetweenBlocks, we need to have at least minTxsPerBLock txs.
-      if (pendingTxs.length < this.minTxsPerBLock) {
+      if (!this.isFlushing && pendingTxs.length < this.minTxsPerBLock) {
         if (this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock)) {
           this.log.debug(
             `Creating block with only ${pendingTxs.length} txs as more than ${this.maxSecondsBetweenBlocks}s have passed since last block`,
@@ -248,7 +261,11 @@ export class Sequencer {
       const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
 
       // Bail if we don't have enough valid txs
-      if (!this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock) && validTxs.length < this.minTxsPerBLock) {
+      if (
+        !this.isFlushing &&
+        !this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock) &&
+        validTxs.length < this.minTxsPerBLock
+      ) {
         this.log.debug(
           `Not creating block because not enough valid txs loaded from the pool (got ${validTxs.length} min ${this.minTxsPerBLock})`,
         );
@@ -330,7 +347,12 @@ export class Sequencer {
     // less txs than the minimum. But that'd cause the entire block to be aborted and retried. Instead, we should
     // go back to the p2p pool and load more txs until we hit our minTxsPerBLock target. Only if there are no txs
     // we should bail.
-    if (processedTxs.length === 0 && !this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock) && this.minTxsPerBLock > 0) {
+    if (
+      !this.isFlushing &&
+      processedTxs.length === 0 &&
+      !this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock) &&
+      this.minTxsPerBLock > 0
+    ) {
       this.log.verbose('No txs processed correctly to build block. Exiting');
       blockBuilder.cancelBlock();
       return;
@@ -370,6 +392,11 @@ export class Sequencer {
       } satisfies L2BlockBuiltStats,
     );
 
+    if (this.isFlushing) {
+      this.log.verbose(`Flushing completed`);
+    }
+    this.isFlushing = false;
+
     try {
       const attestations = await this.collectAttestations(block);
       await this.publishL2Block(block, attestations);
@@ -377,7 +404,7 @@ export class Sequencer {
       this.log.info(
         `Submitted rollup block ${block.number} with ${
           processedTxs.length
-        } transactions duration=${workDuration}ms (Submitter: ${await this.publisher.senderAddress()})`,
+        } transactions duration=${workDuration}ms (Submitter: ${await this.publisher.getSenderAddress()})`,
       );
     } catch (err) {
       this.metrics.recordFailedBlock();
@@ -385,7 +412,12 @@ export class Sequencer {
     }
   }
 
-  protected async collectAttestations(block: L2Block): Promise<Attestation[] | undefined> {
+  /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
+  public flush() {
+    this.isFlushing = true;
+  }
+
+  protected async collectAttestations(block: L2Block): Promise<Signature[] | undefined> {
     // @todo  This should collect attestations properly and fix the ordering of them to make sense
     //        the current implementation is a PLACEHOLDER and should be nuked from orbit.
     //        It is assuming that there will only be ONE (1) validator, so only one attestation
@@ -399,12 +431,30 @@ export class Sequencer {
     //                ;   ;
     //                /   \
     //  _____________/_ __ \_____________
-    if (IS_DEV_NET) {
+    if (IS_DEV_NET || !this.validatorClient) {
       return undefined;
     }
 
-    const myAttestation = await this.publisher.attest(block.archive.root.toString());
-    return [myAttestation];
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
+    const committee = await this.publisher.getCurrentEpochCommittee();
+    const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
+
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7974): we do not have transaction[] lists in the block for now
+    // Dont do anything with the proposals for now - just collect them
+
+    const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, []);
+
+    this.state = SequencerState.PUBLISHING_BLOCK_TO_PEERS;
+    this.validatorClient.broadcastBlockProposal(proposal);
+
+    this.state = SequencerState.WAITING_FOR_ATTESTATIONS;
+    const attestations = await this.validatorClient.collectAttestations(
+      proposal.header.globalVariables.slotNumber.toBigInt(),
+      numberOfRequiredAttestations,
+    );
+
+    // note: the smart contract requires that the signatures are provided in the order of the committee
+    return await orderAttestations(attestations, committee);
   }
 
   /**
@@ -414,9 +464,10 @@ export class Sequencer {
   @trackSpan('Sequencer.publishL2Block', block => ({
     [Attributes.BLOCK_NUMBER]: block.number,
   }))
-  protected async publishL2Block(block: L2Block, attestations?: Attestation[]) {
+  protected async publishL2Block(block: L2Block, attestations?: Signature[]) {
     // Publishes new block to the network and awaits the tx to be mined
     this.state = SequencerState.PUBLISHING_BLOCK;
+
     const publishedL2Block = await this.publisher.processL2Block(block, attestations);
     if (publishedL2Block) {
       this.lastPublishedBlock = block.number;
@@ -503,6 +554,14 @@ export enum SequencerState {
    * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
    */
   CREATING_BLOCK,
+  /**
+   * Publishing blocks to validator peers. Will move to WAITING_FOR_ATTESTATIONS.
+   */
+  PUBLISHING_BLOCK_TO_PEERS,
+  /**
+   * The block has been published to peers, and we are waiting for attestations. Will move to PUBLISHING_CONTRACT_DATA.
+   */
+  WAITING_FOR_ATTESTATIONS,
   /**
    * Sending the tx to L1 with encrypted logs and awaiting it to be mined. Will move back to PUBLISHING_BLOCK once finished.
    */
@@ -516,3 +575,30 @@ export enum SequencerState {
    */
   STOPPED,
 }
+
+/** Order Attestations
+ *
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ *
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+async function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Promise<Signature[]> {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, BlockAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = await attestation.getSender();
+    if (sender) {
+      attestationMap.set(sender.toString(), attestation);
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty signature
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString)?.signature || Signature.empty();
+  });
+
+  return orderedAttestations;
+}