@aztec/sequencer-client 0.69.0-devnet → 0.69.1

package/src/publisher/l1-publisher.ts

@@ -3,7 +3,7 @@ import {
   type EpochProofClaim,
   type EpochProofQuote,
   type L2Block,
-  SignatureDomainSeperator,
+  SignatureDomainSeparator,
   type TxHash,
   getHashedSignaturePayload,
 } from '@aztec/circuit-types';
@@ -27,7 +27,7 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
-import { EmpireBaseAbi, ExtRollupLibAbi, LeonidasLibAbi, RollupAbi, SlasherAbi } from '@aztec/l1-artifacts';
+import { EmpireBaseAbi, RollupAbi, SlasherAbi } from '@aztec/l1-artifacts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
@@ -35,7 +35,7 @@ import {
   type BaseError,
   type Chain,
   type Client,
-  ContractFunctionExecutionError,
+  type ContractFunctionExecutionError,
   ContractFunctionRevertedError,
   type GetContractReturnType,
   type Hex,
@@ -95,6 +95,8 @@ export type MinimalTransactionReceipt = {
   logs: any[];
   /** Block number in which this tx was mined. */
   blockNumber: bigint;
+  /** The block hash in which this tx was mined */
+  blockHash: `0x${string}`;
 };
 
 /** Arguments to the process method of the rollup contract */
@@ -175,6 +177,8 @@ export class L1Publisher {
   protected account: PrivateKeyAccount;
   protected ethereumSlotDuration: bigint;
 
+  private blobSinkUrl: string | undefined;
+
   // @note - with blobs, the below estimate seems too large.
   // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
   // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
@@ -189,6 +193,7 @@ export class L1Publisher {
   ) {
     this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
     this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+    this.blobSinkUrl = config.blobSinkUrl;
     this.metrics = new L1PublisherMetrics(client, 'L1Publisher');
 
     const { l1RpcUrl: rpcUrl, l1ChainId: chainId, publisherPrivateKey, l1Contracts } = config;
@@ -416,38 +421,6 @@ export class L1Publisher {
       if (error instanceof ContractFunctionRevertedError) {
         const err = error as ContractFunctionRevertedError;
         this.log.debug(`Validation failed: ${err.message}`, err.data);
-      } else if (error instanceof ContractFunctionExecutionError) {
-        let err = error as ContractFunctionRevertedError;
-        if (!tryGetCustomErrorName(err)) {
-          // If we get here, it's because the custom error no longer exists in Rollup.sol,
-          // but in another lib. The below reconstructs the error message.
-          try {
-            await this.publicClient.estimateGas({
-              data: encodeFunctionData({
-                abi: this.rollupContract.abi,
-                functionName: 'validateHeader',
-                args,
-              }),
-              account: this.account,
-              to: this.rollupContract.address,
-            });
-          } catch (estGasErr: unknown) {
-            const possibleAbis = [ExtRollupLibAbi, LeonidasLibAbi];
-            possibleAbis.forEach(abi => {
-              const possibleErr = getContractError(estGasErr as BaseError, {
-                args: [],
-                abi: abi,
-                functionName: 'validateHeader',
-                address: this.rollupContract.address,
-                sender: this.account.address,
-              });
-              err = tryGetCustomErrorName(possibleErr) ? possibleErr : err;
-            });
-          }
-          throw err;
-        }
-      } else {
-        this.log.debug(`Unexpected error during validation: ${error}`);
       }
       throw error;
     }
@@ -593,16 +566,19 @@ export class L1Publisher {
 
     const consensusPayload = new ConsensusPayload(block.header, block.archive.root, txHashes ?? []);
 
-    const digest = getHashedSignaturePayload(consensusPayload, SignatureDomainSeperator.blockAttestation);
+    const digest = getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
+
+    const blobs = Blob.getBlobs(block.body.toBlobFields());
     const proposeTxArgs = {
       header: block.header.toBuffer(),
       archive: block.archive.root.toBuffer(),
       blockHash: block.header.hash().toBuffer(),
       body: block.body.toBuffer(),
-      blobs: Blob.getBlobs(block.body.toBlobFields()),
+      blobs,
       attestations,
       txHashes: txHashes ?? [],
     };
+
     // Publish body and propose block (if not already published)
     if (this.interrupted) {
       this.log.verbose('L2 block data syncing interrupted while processing blocks.', ctx);
@@ -647,6 +623,12 @@ export class L1Publisher {
       };
       this.log.verbose(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
       this.metrics.recordProcessBlockTx(timer.ms(), stats);
+
+      // Send the blobs to the blob sink
+      this.sendBlobsToBlobSink(receipt.blockHash, blobs).catch(_err => {
+        this.log.error('Failed to send blobs to blob sink');
+      });
+
       return true;
     }
 
@@ -661,7 +643,7 @@ export class L1Publisher {
         address: this.rollupContract.address,
       },
       {
-        blobs: proposeTxArgs.blobs.map(b => b.data),
+        blobs: proposeTxArgs.blobs.map(b => b.dataWithZeros),
         kzg,
         maxFeePerBlobGas: 10000000000n,
       },
@@ -757,8 +739,7 @@ export class L1Publisher {
           },
         ],
       });
-      // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors,
-      // and viem provides no way to get the revert reason from a given tx.
+      // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors.
       // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
       // See: https://github.com/wevm/viem/issues/2075
       // This throws a EstimateGasExecutionError with the custom error information:
@@ -770,13 +751,13 @@ export class L1Publisher {
       });
       return undefined;
     } catch (simulationErr: any) {
-      // If we don't have a ContractFunctionExecutionError, we have a blob related error => use ExtRollupLibAbi to get the error msg.
+      // If we don't have a ContractFunctionExecutionError, we have a blob related error => use getContractError to get the error msg.
       const contractErr =
         simulationErr.name === 'ContractFunctionExecutionError'
           ? simulationErr
           : getContractError(simulationErr as BaseError, {
               args: [],
-              abi: ExtRollupLibAbi,
+              abi: RollupAbi,
               functionName: args.functionName,
               address: args.address,
               sender: this.account.address,
@@ -966,7 +947,7 @@ export class L1Publisher {
       },
       {},
       {
-        blobs: encodedData.blobs.map(b => b.data),
+        blobs: encodedData.blobs.map(b => b.dataWithZeros),
         kzg,
         maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
       },
@@ -1056,7 +1037,7 @@ export class L1Publisher {
           fixedGas: gas,
         },
         {
-          blobs: encodedData.blobs.map(b => b.data),
+          blobs: encodedData.blobs.map(b => b.dataWithZeros),
           kzg,
           maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
         },
@@ -1095,7 +1076,7 @@ export class L1Publisher {
         },
         { fixedGas: gas },
         {
-          blobs: encodedData.blobs.map(b => b.data),
+          blobs: encodedData.blobs.map(b => b.dataWithZeros),
           kzg,
           maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
         },
@@ -1137,6 +1118,7 @@ export class L1Publisher {
             gasPrice: receipt.effectiveGasPrice,
             logs: receipt.logs,
             blockNumber: receipt.blockNumber,
+            blockHash: receipt.blockHash,
           };
         }
 
@@ -1152,9 +1134,51 @@ export class L1Publisher {
   protected async sleepOrInterrupted() {
     await this.interruptibleSleep.sleep(this.sleepTimeMs);
   }
+
+  /**
+   * Send blobs to the blob sink
+   *
+   * If a blob sink url is configured, then we send blobs to the blob sink
+   * - for now we use the blockHash as the identifier for the blobs;
+   *   In the future this will move to be the beacon block id - which takes a bit more work
+   *   to calculate and will need to be mocked in e2e tests
+   */
+  protected async sendBlobsToBlobSink(blockHash: string, blobs: Blob[]): Promise<boolean> {
+    // TODO(md): for now we are assuming the indexes of the blobs will be 0, 1, 2
+    // When in reality they will not, but for testing purposes this is fine
+    if (!this.blobSinkUrl) {
+      this.log.verbose('No blob sink url configured');
+      return false;
+    }
+
+    this.log.verbose(`Sending ${blobs.length} blobs to blob sink`);
+    try {
+      const res = await fetch(`${this.blobSinkUrl}/blob_sidecar`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          // eslint-disable-next-line camelcase
+          block_id: blockHash,
+          blobs: blobs.map((b, i) => ({ blob: b.toBuffer(), index: i })),
+        }),
+      });
+
+      if (res.ok) {
+        return true;
+      }
+
+      this.log.error('Failed to send blobs to blob sink', res.status);
+      return false;
+    } catch (err) {
+      this.log.error(`Error sending blobs to blob sink`, err);
+      return false;
+    }
+  }
 }
 
-/**
+/*
  * Returns cost of calldata usage in Ethereum.
  * @param data - Calldata.
  * @returns 4 for each zero byte, 16 for each nonzero.

package/src/sequencer/index.ts

@@ -1,2 +1,3 @@
 export * from './config.js';
 export * from './sequencer.js';
+export * from './allowed.js';

package/src/sequencer/sequencer.ts

@@ -4,11 +4,9 @@ import {
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
-  type ProcessedTx,
   SequencerConfigSchema,
   Tx,
   type TxHash,
-  type TxValidator,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
 import type { AllowedElement, Signature, WorldStateSynchronizerStatus } from '@aztec/circuit-types/interfaces';
@@ -17,7 +15,9 @@ import {
   AppendOnlyTreeSnapshot,
   BlockHeader,
   ContentCommitment,
+  type ContractDataSource,
   GENESIS_ARCHIVE_ROOT,
+  Gas,
   type GlobalVariables,
   StateReference,
 } from '@aztec/circuits.js';
@@ -39,7 +39,7 @@ import { type GlobalVariableBuilder } from '../global_variable_builder/global_bu
 import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
 import { prettyLogViemErrorMsg } from '../publisher/utils.js';
 import { type SlasherClient } from '../slasher/slasher_client.js';
-import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
+import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
 import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
@@ -47,12 +47,6 @@ import { SequencerState, orderAttestations } from './utils.js';
 
 export { SequencerState };
 
-export type ShouldProposeArgs = {
-  pendingTxsCount?: number;
-  validTxsCount?: number;
-  processedTxsCount?: number;
-};
-
 export class SequencerTooSlowError extends Error {
   constructor(
     public readonly currentState: SequencerState,
@@ -90,6 +84,7 @@ export class Sequencer {
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
+  private maxBlockGas: Gas = new Gas(10e9, 10e9);
   private processTxTime: number = 12;
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
@@ -112,7 +107,7 @@ export class Sequencer {
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
-    private txValidatorFactory: TxValidatorFactory,
+    private contractDataSource: ContractDataSource,
     protected l1Constants: SequencerRollupConstants,
     private dateProvider: DateProvider,
     telemetry: TelemetryClient,
@@ -149,6 +144,12 @@ export class Sequencer {
     if (config.minTxsPerBlock !== undefined) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
+    if (config.maxDABlockGas !== undefined) {
+      this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
+    }
+    if (config.maxL2BlockGas !== undefined) {
+      this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
+    }
     if (config.coinbase) {
       this._coinbase = config.coinbase;
     }
@@ -179,7 +180,7 @@ export class Sequencer {
     // How late into the slot can we be to start working
     const initialTime = 2;
 
-    // How long it takes to validate the txs collected and get ready to start building
+    // How long it takes to get ready to start building
     const blockPrepareTime = 1;
 
     // How long it takes to for attestations to travel across the p2p layer.
@@ -218,9 +219,9 @@ export class Sequencer {
       [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
       // We always want to allow the full slot to check if we are the proposer
       [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration,
-      // First transition towards building a block
-      [SequencerState.WAITING_FOR_TXS]: initialTime,
-      // We then validate the txs and prepare to start building the block
+      // How late we can start initializing a new block proposal
+      [SequencerState.INITIALIZING_PROPOSAL]: initialTime,
+      // When we start building a block
       [SequencerState.CREATING_BLOCK]: initialTime + blockPrepareTime,
       // We start collecting attestations after building the block
       [SequencerState.COLLECTING_ATTESTATIONS]: initialTime + blockPrepareTime + processTxsTime + blockValidationTime,
@@ -323,25 +324,27 @@ export class Sequencer {
     void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
     void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
 
-    if (!this.shouldProposeBlock(historicalHeader, {})) {
+    // Check the pool has enough txs to build a block
+    const pendingTxCount = this.p2pClient.getPendingTxCount();
+    if (pendingTxCount < this.minTxsPerBLock && !this.isFlushing) {
+      this.log.verbose(`Not enough txs to propose block. Got ${pendingTxCount} min ${this.minTxsPerBLock}.`, {
+        slot,
+        blockNumber: newBlockNumber,
+      });
+      await this.claimEpochProofRightIfAvailable(slot);
       return;
     }
 
+    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
       chainTipArchive: new Fr(chainTipArchive),
       blockNumber: newBlockNumber,
       slot,
     });
 
-    this.setState(SequencerState.WAITING_FOR_TXS, slot);
-
-    // Get txs to build the new block.
-    const pendingTxs = await this.p2pClient.getPendingTxs();
-
-    if (!this.shouldProposeBlock(historicalHeader, { pendingTxsCount: pendingTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
+    // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
+    // and also we may need to fetch more if we don't have enough valid txs.
+    const pendingTxs = this.p2pClient.iteratePendingTxs();
 
     // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = new BlockHeader(
@@ -353,35 +356,12 @@ export class Sequencer {
       Fr.ZERO,
     );
 
-    // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here.
-    // TODO: We should validate only the number of txs we need to speed up this process.
-    const allValidTxs = await this.takeValidTxs(
-      pendingTxs,
-      this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedInSetup),
-    );
-
-    // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
-    // public functions. Only reason why we do it here now is because the public processor and orchestrator
-    // are set up such that they require knowing the total number of txs in advance. Still, main reason for
-    // exceeding max block size in bytes is contract class registration, which happens in private-land. This
-    // may break if we start emitting lots of log data from public-land.
-    const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
-
-    this.log.verbose(
-      `Collected ${validTxs.length} txs out of ${allValidTxs.length} valid txs out of ${pendingTxs.length} total pending txs for block ${newBlockNumber}`,
-    );
-
-    // Bail if we don't have enough valid txs
-    if (!this.shouldProposeBlock(historicalHeader, { validTxsCount: validTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
-
     try {
+      // TODO(palla/txs) Is the note below still valid? We don't seem to be doing any rollback in there.
       // @note  It is very important that the following function will FAIL and not just return early
       //        if it have made any state changes. If not, we won't rollback the state, and you will
       //        be in for a world of pain.
-      await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader, historicalHeader);
     } catch (err) {
       this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
     }
@@ -469,64 +449,20 @@ export class Sequencer {
     this.state = proposedState;
   }
 
-  shouldProposeBlock(historicalHeader: BlockHeader | undefined, args: ShouldProposeArgs): boolean {
-    if (this.isFlushing) {
-      this.log.verbose(`Flushing all pending txs in new block`);
-      return true;
-    }
-
-    // Compute time elapsed since the previous block
-    const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
-    const currentTime = Math.floor(Date.now() / 1000);
-    const elapsedSinceLastBlock = currentTime - lastBlockTime;
-    this.log.debug(
-      `Last block mined at ${lastBlockTime} current time is ${currentTime} (elapsed ${elapsedSinceLastBlock})`,
-    );
-
-    // We need to have at least minTxsPerBLock txs.
-    if (args.pendingTxsCount !== undefined && args.pendingTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // Bail if we don't have enough valid txs
-    if (args.validTxsCount !== undefined && args.validTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // TODO: This check should be processedTxs.length < this.minTxsPerBLock, so we don't publish a block with
-    // 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 (args.processedTxsCount === 0 && this.minTxsPerBLock > 0) {
-      this.log.verbose('No txs processed correctly to build block.');
-      return false;
-    }
-
-    return true;
-  }
-
   /**
    * Build a block
    *
    * Shared between the sequencer and the validator for re-execution
    *
-   * @param validTxs - The valid transactions to construct the block from
+   * @param pendingTxs - The pending transactions to construct the block from
    * @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
    * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
    */
   private async buildBlock(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     newGlobalVariables: GlobalVariables,
     historicalHeader?: BlockHeader,
-    interrupt?: (processedTxs: ProcessedTx[]) => Promise<void>,
     opts: { validateOnly?: boolean } = {},
   ) {
     const blockNumber = newGlobalVariables.blockNumber.toBigInt();
@@ -534,19 +470,9 @@ export class Sequencer {
 
     this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+    const msgCount = l1ToL2Messages.length;
 
-    this.log.verbose(
-      `Building block ${blockNumber} with ${validTxs.length} txs and ${l1ToL2Messages.length} messages`,
-      {
-        msgCount: l1ToL2Messages.length,
-        txCount: validTxs.length,
-        slot,
-        blockNumber,
-      },
-    );
-
-    const numRealTxs = validTxs.length;
-    const blockSize = Math.max(2, numRealTxs);
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, { slot, blockNumber, msgCount });
 
     // Sync to the previous block at least
     await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
@@ -570,18 +496,30 @@ export class Sequencer {
       // We set the deadline for tx processing to the start of the CREATING_BLOCK phase, plus the expected time for tx processing.
       // Deadline is only set if enforceTimeTable is enabled.
       const processingEndTimeWithinSlot = this.timeTable[SequencerState.CREATING_BLOCK] + this.processTxTime;
-      const processingDeadline = this.enforceTimeTable
+      const deadline = this.enforceTimeTable
         ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
         : undefined;
-      this.log.verbose(`Processing ${validTxs.length} txs`, {
+      this.log.verbose(`Processing pending txs`, {
         slot,
         slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
         now: new Date(this.dateProvider.now()),
-        deadline: processingDeadline,
+        deadline,
       });
-      const processingTxValidator = this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork);
+
+      const validators = createValidatorsForBlockBuilding(
+        publicProcessorFork,
+        this.contractDataSource,
+        newGlobalVariables,
+        !!this.config.enforceFees,
+        this.allowedInSetup,
+      );
+
+      // REFACTOR: Public processor should just handle processing, one tx at a time. It should be responsibility
+      // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
+      // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
+      const limits = { deadline, maxTransactions: this.maxTxsPerBlock, maxBlockSize: this.maxBlockSizeInBytes };
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, processingTxValidator, processingDeadline),
+        processor.process(pendingTxs, limits, validators),
       );
 
       if (failedTxs.length > 0) {
@@ -609,8 +547,6 @@ export class Sequencer {
       const duration = Number(end - start) / 1_000;
       this.metrics.recordBlockBuilderTreeInsertions(duration);
 
-      await interrupt?.(processedTxs);
-
       // All real transactions have been added, set the block as full and pad if needed
       const block = await blockBuilder.setBlockCompleted();
 
@@ -618,7 +554,7 @@ export class Sequencer {
         block,
         publicProcessorDuration,
         numMsgs: l1ToL2Messages.length,
-        numProcessedTxs: processedTxs.length,
+        numTxs: processedTxs.length,
         blockBuildingTimer,
       };
     } finally {
@@ -642,7 +578,7 @@ export class Sequencer {
    * @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 pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
    * @param historicalHeader - The historical header of the parent
    */
@@ -650,7 +586,7 @@ export class Sequencer {
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
   private async buildBlockAndAttemptToPublish(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     proposalHeader: BlockHeader,
     historicalHeader: BlockHeader | undefined,
   ): Promise<void> {
@@ -660,40 +596,19 @@ export class Sequencer {
     const blockNumber = newGlobalVariables.blockNumber.toNumber();
     const slot = newGlobalVariables.slotNumber.toBigInt();
 
-    this.metrics.recordNewBlock(blockNumber, validTxs.length);
+    // this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
-    /**
-     * 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 (
-        !this.shouldProposeBlock(historicalHeader, {
-          validTxsCount: validTxs.length,
-          processedTxsCount: processedTxs.length,
-        })
-      ) {
-        // TODO: Roll back changes to world state
-        throw new Error('Should not propose the block');
-      }
-    };
-
     // Start collecting proof quotes for the previous epoch if needed in the background
     const proofQuotePromise = this.createProofClaimForPreviousEpoch(slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(validTxs, newGlobalVariables, historicalHeader, interrupt);
-      const { block, publicProcessorDuration, numProcessedTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
+      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
+      const { block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
-
       await this.publisher.validateBlockForSubmission(block.header);
 
       const workDuration = workTimer.ms();
@@ -707,8 +622,8 @@ export class Sequencer {
       };
 
       const blockHash = block.hash();
-      const txHashes = validTxs.map(tx => tx.getTxHash());
-      this.log.info(`Built block ${block.number} with hash ${blockHash}`, {
+      const txHashes = block.body.txEffects.map(tx => tx.txHash);
+      this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs`, {
         blockHash,
         globalVariables: block.header.globalVariables.toInspect(),
         txHashes,
@@ -734,14 +649,12 @@ export class Sequencer {
       await this.publishL2Block(block, attestations, txHashes, proofQuote);
       this.metrics.recordPublishedBlock(workDuration);
       this.log.info(
-        `Published rollup block ${
-          block.number
-        } with ${numProcessedTxs} transactions and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
+        `Published block ${block.number} with ${numTxs} txs and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
         {
           blockNumber: block.number,
           blockHash: blockHash,
           slot,
-          txCount: numProcessedTxs,
+          txCount: txHashes.length,
           msgCount: numMsgs,
           duration: Math.ceil(workDuration),
           submitter: this.publisher.getSenderAddress().toString(),
@@ -865,36 +778,6 @@ export class Sequencer {
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator<T>): Promise<T[]> {
-    const [valid, invalid] = await validator.validateTxs(txs);
-    if (invalid.length > 0) {
-      this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
-      await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
-    }
-
-    return valid.slice(0, this.maxTxsPerBlock);
-  }
-
-  protected takeTxsWithinMaxSize(txs: Tx[]): Tx[] {
-    const maxSize = this.maxBlockSizeInBytes;
-    let totalSize = 0;
-
-    const toReturn: Tx[] = [];
-    for (const tx of txs) {
-      const txSize = tx.getSize() - tx.clientIvcProof.clientIvcProofBuffer.length;
-      if (totalSize + txSize > maxSize) {
-        this.log.debug(
-          `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
-        );
-        continue;
-      }
-      toReturn.push(tx);
-      totalSize += txSize;
-    }
-
-    return toReturn;
-  }
-
   @trackSpan(
     'Sequencer.claimEpochProofRightIfAvailable',
     slotNumber => ({ [Attributes.SLOT_NUMBER]: Number(slotNumber) }),