@aztec/sequencer-client 0.71.0 → 0.72.1

package/src/publisher/l1-publisher.ts

@@ -19,6 +19,7 @@ import {
 import { type FeeRecipient, type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
 import {
   type EthereumChain,
+  FormattedViemError,
   type GasPrice,
   type L1ContractsConfig,
   L1TxUtils,
@@ -416,7 +417,7 @@ export class L1Publisher {
       digest: Buffer.alloc(32),
       signatures: [],
     },
-  ): Promise<void> {
+  ): Promise<bigint> {
     const ts = BigInt((await this.publicClient.getBlock()).timestamp + this.ethereumSlotDuration);
 
     const formattedSignatures = attestationData.signatures.map(attest => attest.toViemSignature());
@@ -441,6 +442,7 @@ export class L1Publisher {
       }
       throw error;
     }
+    return ts;
   }
 
   public async getCurrentEpochCommittee(): Promise<EthAddress[]> {
@@ -545,8 +547,8 @@ export class L1Publisher {
         account: this.account,
       });
     } catch (err) {
-      const msg = formatViemError(err);
-      logger.error(`Failed to vote`, msg);
+      const { message, metaMessages } = formatViemError(err);
+      logger.error(`Failed to vote`, message, { metaMessages });
       this.myLastVotes[voteType] = cachedMyLastVote;
       return false;
     }
@@ -609,15 +611,15 @@ export class L1Publisher {
     //        This means that we can avoid the simulation issues in later checks.
     //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
     //        make time consistency checks break.
-    await this.validateBlockForSubmission(block.header, {
+    const ts = await this.validateBlockForSubmission(block.header, {
       digest: digest.toBuffer(),
       signatures: attestations ?? [],
     });
 
     this.log.debug(`Submitting propose transaction`);
     const result = proofQuote
-      ? await this.sendProposeAndClaimTx(proposeTxArgs, proofQuote, opts)
-      : await this.sendProposeTx(proposeTxArgs, opts);
+      ? await this.sendProposeAndClaimTx(proposeTxArgs, proofQuote, opts, ts)
+      : await this.sendProposeTx(proposeTxArgs, opts, ts);
 
     if (!result?.receipt) {
       this.log.info(`Failed to publish block ${block.number} to L1`, ctx);
@@ -689,9 +691,17 @@ export class L1Publisher {
         }),
       });
     } catch (err) {
-      this.log.error(`Failed to claim epoch proof right`, err, {
-        proofQuote: proofQuote.toInspect(),
-      });
+      if (err instanceof FormattedViemError) {
+        const { message, metaMessages } = err;
+        this.log.error(`Failed to claim epoch proof right`, message, {
+          metaMessages,
+          proofQuote: proofQuote.toInspect(),
+        });
+      } else {
+        this.log.error(`Failed to claim epoch proof right`, err, {
+          proofQuote: proofQuote.toInspect(),
+        });
+      }
       return false;
     }
 
@@ -961,6 +971,8 @@ export class L1Publisher {
 
   private async prepareProposeTx(encodedData: L1ProcessArgs) {
     const kzg = Blob.getViemKzgInstance();
+    const blobInput = Blob.getEthBlobEvaluationInputs(encodedData.blobs);
+    this.log.debug('Validating blob input', { blobInput });
     const blobEvaluationGas = await this.l1TxUtils.estimateGas(
       this.account,
       {
@@ -968,7 +980,7 @@ export class L1Publisher {
         data: encodeFunctionData({
           abi: this.rollupContract.abi,
           functionName: 'validateBlobs',
-          args: [Blob.getEthBlobEvaluationInputs(encodedData.blobs)],
+          args: [blobInput],
         }),
       },
       {},
@@ -978,12 +990,6 @@ export class L1Publisher {
       },
     );
 
-    // @note  We perform this guesstimate instead of the usual `gasEstimate` since
-    //        viem will use the current state to simulate against, which means that
-    //        we will fail estimation in the case where we are simulating for the
-    //        first ethereum block within our slot (as current time is not in the
-    //        slot yet).
-    const gasGuesstimate = blobEvaluationGas + L1Publisher.PROPOSE_GAS_GUESS;
     const attestations = encodedData.attestations
       ? encodedData.attestations.map(attest => attest.toViemSignature())
       : [];
@@ -1003,10 +1009,10 @@ export class L1Publisher {
       attestations,
       // TODO(#9101): Extract blobs from beacon chain => calldata will only contain what's needed to verify blob and body input can be removed
       `0x${encodedData.body.toString('hex')}`,
-      Blob.getEthBlobEvaluationInputs(encodedData.blobs),
+      blobInput,
     ] as const;
 
-    return { args, gas: gasGuesstimate };
+    return { args, blobEvaluationGas };
   }
 
   private getSubmitEpochProofArgs(args: {
@@ -1042,26 +1048,58 @@ export class L1Publisher {
   private async sendProposeTx(
     encodedData: L1ProcessArgs,
     opts: { txTimeoutAt?: Date } = {},
+    timestamp: bigint,
   ): Promise<L1ProcessReturnType | undefined> {
     if (this.interrupted) {
       return undefined;
     }
     try {
       const kzg = Blob.getViemKzgInstance();
-      const { args, gas } = await this.prepareProposeTx(encodedData);
+      const { args, blobEvaluationGas } = await this.prepareProposeTx(encodedData);
       const data = encodeFunctionData({
         abi: this.rollupContract.abi,
         functionName: 'propose',
         args,
       });
+
+      const simulationResult = await this.l1TxUtils.simulateGasUsed(
+        {
+          to: this.rollupContract.address,
+          data,
+          gas: L1Publisher.PROPOSE_GAS_GUESS,
+        },
+        {
+          // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
+          time: timestamp + 1n,
+          // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit
+          gasLimit: L1Publisher.PROPOSE_GAS_GUESS * 2n,
+        },
+        [
+          {
+            address: this.rollupContract.address,
+            // @note we override checkBlob to false since blobs are not part simulate()
+            stateDiff: [
+              {
+                slot: toHex(9n, true),
+                value: toHex(0n, true),
+              },
+            ],
+          },
+        ],
+        {
+          // @note fallback gas estimate to use if the node doesn't support simulation API
+          fallbackGasEstimate: L1Publisher.PROPOSE_GAS_GUESS,
+        },
+      );
+
       const result = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
           data,
         },
         {
-          fixedGas: gas,
           ...opts,
+          gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult + blobEvaluationGas),
         },
         {
           blobs: encodedData.blobs.map(b => b.dataWithZeros),
@@ -1076,7 +1114,12 @@ export class L1Publisher {
         data,
       };
     } catch (err) {
-      this.log.error(`Rollup publish failed.`, err);
+      if (err instanceof FormattedViemError) {
+        const { message, metaMessages } = err;
+        this.log.error(`Rollup publish failed.`, message, { metaMessages });
+      } else {
+        this.log.error(`Rollup publish failed.`, err);
+      }
       return undefined;
     }
   }
@@ -1085,26 +1128,58 @@ export class L1Publisher {
     encodedData: L1ProcessArgs,
     quote: EpochProofQuote,
     opts: { txTimeoutAt?: Date } = {},
+    timestamp: bigint,
   ): Promise<L1ProcessReturnType | undefined> {
     if (this.interrupted) {
       return undefined;
     }
+
     try {
       const kzg = Blob.getViemKzgInstance();
-      const { args, gas } = await this.prepareProposeTx(encodedData);
+      const { args, blobEvaluationGas } = await this.prepareProposeTx(encodedData);
       const data = encodeFunctionData({
         abi: this.rollupContract.abi,
         functionName: 'proposeAndClaim',
         args: [...args, quote.toViemArgs()],
       });
+
+      const simulationResult = await this.l1TxUtils.simulateGasUsed(
+        {
+          to: this.rollupContract.address,
+          data,
+          gas: L1Publisher.PROPOSE_AND_CLAIM_GAS_GUESS,
+        },
+        {
+          // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
+          time: timestamp + 1n,
+          // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit
+          gasLimit: L1Publisher.PROPOSE_AND_CLAIM_GAS_GUESS * 2n,
+        },
+        [
+          {
+            address: this.rollupContract.address,
+            // @note we override checkBlob to false since blobs are not part simulate()
+            stateDiff: [
+              {
+                slot: toHex(9n, true),
+                value: toHex(0n, true),
+              },
+            ],
+          },
+        ],
+        {
+          // @note fallback gas estimate to use if the node doesn't support simulation API
+          fallbackGasEstimate: L1Publisher.PROPOSE_AND_CLAIM_GAS_GUESS,
+        },
+      );
       const result = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
           data,
         },
         {
-          fixedGas: gas,
           ...opts,
+          gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult + blobEvaluationGas),
         },
         {
           blobs: encodedData.blobs.map(b => b.dataWithZeros),
@@ -1120,7 +1195,12 @@ export class L1Publisher {
         data,
       };
     } catch (err) {
-      this.log.error(`Rollup publish failed.`, err);
+      if (err instanceof FormattedViemError) {
+        const { message, metaMessages } = err;
+        this.log.error(`Rollup publish failed.`, message, { metaMessages });
+      } else {
+        this.log.error(`Rollup publish failed.`, err);
+      }
       return undefined;
     }
   }

package/src/sequencer/allowed.ts

@@ -17,13 +17,13 @@ export function getDefaultAllowedSetupFunctions(): AllowedElement[] {
       {
         address: ProtocolContractAddress.FeeJuice,
         // We can't restrict the selector because public functions get routed via dispatch.
-        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))'),
       },
       // needed for private transfers via FPC
       {
         classId: getContractClassFromArtifact(TokenContractArtifact).id,
         // We can't restrict the selector because public functions get routed via dispatch.
-        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))'),
       },
       {
         classId: getContractClassFromArtifact(FPCContract.artifact).id,

package/src/sequencer/sequencer.ts

@@ -236,20 +236,15 @@ export class Sequencer {
     this.setState(SequencerState.PROPOSER_CHECK, 0n);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
-    const historicalHeader = chainTip?.header;
 
-    const newBlockNumber =
-      (historicalHeader === undefined
-        ? await this.l2BlockSource.getBlockNumber()
-        : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
+    const newBlockNumber = (chainTip?.header.globalVariables.blockNumber.toNumber() ?? 0) + 1;
 
     // If we cannot find a tip archive, assume genesis.
-    const chainTipArchive =
-      chainTip == undefined ? new Fr(GENESIS_ARCHIVE_ROOT).toBuffer() : chainTip?.archive.root.toBuffer();
+    const chainTipArchive = chainTip?.archive.root ?? new Fr(GENESIS_ARCHIVE_ROOT);
 
     let slot: bigint;
     try {
-      slot = await this.mayProposeBlock(chainTipArchive, BigInt(newBlockNumber));
+      slot = await this.mayProposeBlock(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
     } catch (err) {
       this.log.debug(`Cannot propose for block ${newBlockNumber}`);
       return;
@@ -278,7 +273,7 @@ export class Sequencer {
 
     this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-      chainTipArchive: new Fr(chainTipArchive),
+      chainTipArchive,
       blockNumber: newBlockNumber,
       slot,
     });
@@ -289,7 +284,7 @@ export class Sequencer {
 
     // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = new BlockHeader(
-      new AppendOnlyTreeSnapshot(Fr.fromBuffer(chainTipArchive), 1),
+      new AppendOnlyTreeSnapshot(chainTipArchive, 1),
       ContentCommitment.empty(),
       StateReference.empty(),
       newGlobalVariables,
@@ -302,9 +297,12 @@ export class Sequencer {
       // @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(pendingTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader);
     } catch (err) {
       this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
+
+      // If the block failed to build, we might still want to claim the proving rights
+      await this.claimEpochProofRightIfAvailable(slot);
     }
     this.setState(SequencerState.IDLE, 0n);
   }
@@ -378,14 +376,13 @@ export class Sequencer {
   protected async buildBlock(
     pendingTxs: Iterable<Tx>,
     newGlobalVariables: GlobalVariables,
-    historicalHeader?: BlockHeader,
     opts: { validateOnly?: boolean } = {},
   ) {
-    const blockNumber = newGlobalVariables.blockNumber.toBigInt();
+    const blockNumber = newGlobalVariables.blockNumber.toNumber();
     const slot = newGlobalVariables.slotNumber.toBigInt();
 
     this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
     const msgCount = l1ToL2Messages.length;
 
     this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
@@ -396,23 +393,21 @@ export class Sequencer {
     });
 
     // Sync to the previous block at least
-    await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
-    this.log.debug(`Synced to previous block ${newGlobalVariables.blockNumber.toNumber() - 1}`);
+    await this.worldState.syncImmediate(blockNumber - 1);
+    this.log.debug(`Synced to previous block ${blockNumber - 1}`);
 
     // NB: separating the dbs because both should update the state
     const publicProcessorFork = await this.worldState.fork();
     const orchestratorFork = await this.worldState.fork();
 
+    const previousBlockHeader =
+      (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorFork.getInitialHeader();
+
     try {
-      const processor = this.publicProcessorFactory.create(
-        publicProcessorFork,
-        historicalHeader,
-        newGlobalVariables,
-        true,
-      );
+      const processor = this.publicProcessorFactory.create(publicProcessorFork, newGlobalVariables, true);
       const blockBuildingTimer = new Timer();
       const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
-      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages);
+      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
 
       // Deadline for processing depends on whether we're proposing a block
       const secondsIntoSlot = this.getSecondsIntoSlot(slot);
@@ -517,16 +512,11 @@ export class Sequencer {
    *
    * @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
    */
-  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
+  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader) => ({
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
-  private async buildBlockAndAttemptToPublish(
-    pendingTxs: Iterable<Tx>,
-    proposalHeader: BlockHeader,
-    historicalHeader: BlockHeader | undefined,
-  ): Promise<void> {
+  private async buildBlockAndAttemptToPublish(pendingTxs: Iterable<Tx>, proposalHeader: BlockHeader): Promise<void> {
     await this.publisher.validateBlockForSubmission(proposalHeader);
 
     const newGlobalVariables = proposalHeader.globalVariables;
@@ -541,7 +531,7 @@ export class Sequencer {
     const proofQuotePromise = this.createProofClaimForPreviousEpoch(slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
+      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
       const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
@@ -640,8 +630,8 @@ export class Sequencer {
     this.log.debug('Creating block proposal for validators');
     const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
     if (!proposal) {
-      this.log.warn(`Failed to create block proposal, skipping collecting attestations`);
-      return undefined;
+      const msg = `Failed to create block proposal`;
+      throw new Error(msg);
     }
 
     this.log.debug('Broadcasting block proposal to validators');

package/src/tx_validator/gas_validator.ts

@@ -1,5 +1,6 @@
 import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
+import { type AztecAddress, Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
+import { U128 } from '@aztec/foundation/abi';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator/server';
 
@@ -34,6 +35,12 @@ export class GasTxValidator implements TxValidator<Tx> {
     return this.#validateTxFee(tx);
   }
 
+  /**
+   * Check whether the tx's max fees are valid for the current block, and skip if not.
+   * We skip instead of invalidating since the tx may become elligible later.
+   * Note that circuits check max fees even if fee payer is unset, so we
+   * keep this validation even if the tx does not pay fees.
+   */
   #shouldSkip(tx: Tx): boolean {
     const gasSettings = tx.data.constants.txContext.gasSettings;
 
@@ -78,12 +85,17 @@ export class GasTxValidator implements TxValidator<Tx> {
         fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
         fn.args.length > 2 &&
         // Public functions get routed through the dispatch function, whose first argument is the target function selector.
-        fn.args[0].equals(FunctionSelector.fromSignature('_increase_public_balance((Field),Field)').toField()) &&
+        fn.args[0].equals(
+          FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))').toField(),
+        ) &&
         fn.args[1].equals(feePayer.toField()) &&
         !fn.callContext.isStaticCall,
     );
 
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
+    // `amount` in the claim function call arguments occupies 2 fields as it is represented as U128.
+    const balance = claimFunctionCall
+      ? initialBalance.add(new Fr(U128.fromFields(claimFunctionCall.args.slice(2, 4)).toInteger()))
+      : initialBalance;
     if (balance.lt(feeLimit)) {
       this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,