@aztec/sequencer-client 0.66.0 → 0.67.1-devnet

package/src/publisher/l1-publisher.ts

@@ -11,9 +11,9 @@ import { type L1PublishBlockStats, type L1PublishProofStats } from '@aztec/circu
 import {
   AGGREGATION_OBJECT_LENGTH,
   AZTEC_MAX_EPOCH_DURATION,
+  type BlockHeader,
   EthAddress,
   type FeeRecipient,
-  type Header,
   type Proof,
   type RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -25,14 +25,16 @@ import {
   createEthereumChain,
 } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
+import { toHex } from '@aztec/foundation/bigint-buffer';
+import { Blob } from '@aztec/foundation/blob';
 import { areArraysEqual, compactArray, times } from '@aztec/foundation/collection';
 import { type Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { 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 { GovernanceProposerAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { ExtRollupLibAbi, GovernanceProposerAbi, LeonidasLibAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
@@ -41,7 +43,7 @@ import {
   type BaseError,
   type Chain,
   type Client,
-  type ContractFunctionExecutionError,
+  ContractFunctionExecutionError,
   ContractFunctionRevertedError,
   type GetContractReturnType,
   type Hex,
@@ -60,6 +62,7 @@ import {
   getAbiItem,
   getAddress,
   getContract,
+  getContractError,
   hexToBytes,
   http,
   publicActions,
@@ -110,8 +113,10 @@ type L1ProcessArgs = {
   archive: Buffer;
   /** The L2 block's leaf in the archive tree. */
   blockHash: Buffer;
-  /** L2 block body. */
+  /** L2 block body. TODO(#9101): Remove block body once we can extract blobs. */
   body: Buffer;
+  /** L2 block blobs containing all tx effects. */
+  blobs: Blob[];
   /** L2 block tx hashes */
   txHashes: TxHash[];
   /** Attestations */
@@ -149,7 +154,8 @@ export class L1Publisher {
   private payload: EthAddress = EthAddress.ZERO;
   private myLastVote: bigint = 0n;
 
-  protected log = createDebugLogger('aztec:sequencer:publisher');
+  protected log = createLogger('sequencer:publisher');
+  protected governanceLog = createLogger('sequencer:publisher:governance');
 
   protected rollupContract: GetContractReturnType<
     typeof RollupAbi,
@@ -165,6 +171,9 @@ export class L1Publisher {
   protected account: PrivateKeyAccount;
   protected ethereumSlotDuration: bigint;
 
+  // @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)
   public static PROPOSE_GAS_GUESS: bigint = 12_000_000n;
   public static PROPOSE_AND_CLAIM_GAS_GUESS: bigint = this.PROPOSE_GAS_GUESS + 100_000n;
 
@@ -341,8 +350,11 @@ export class L1Publisher {
     try {
       await this.rollupContract.read.validateEpochProofRightClaimAtTime(args, { account: this.account });
     } catch (err) {
-      const errorName = tryGetCustomErrorName(err);
-      this.log.warn(`Proof quote validation failed: ${errorName}`);
+      let errorName = tryGetCustomErrorName(err);
+      if (!errorName) {
+        errorName = tryGetCustomErrorNameContractFunction(err as ContractFunctionExecutionError);
+      }
+      this.log.warn(`Proof quote validation failed: ${errorName}`, quote);
       return undefined;
     }
     return quote;
@@ -358,7 +370,7 @@ export class L1Publisher {
    *
    */
   public async validateBlockForSubmission(
-    header: Header,
+    header: BlockHeader,
     attestationData: { digest: Buffer; signatures: Signature[] } = {
       digest: Buffer.alloc(32),
       signatures: [],
@@ -374,7 +386,7 @@ export class L1Publisher {
       formattedSignatures,
       `0x${attestationData.digest.toString('hex')}`,
       ts,
-      `0x${header.contentCommitment.txsEffectsHash.toString('hex')}`,
+      `0x${header.contentCommitment.blobsHash.toString('hex')}`,
       flags,
     ] as const;
 
@@ -385,6 +397,36 @@ 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}`);
       }
@@ -432,7 +474,7 @@ export class L1Publisher {
       this.governanceProposerContract.read.computeRound([slotNumber]),
     ]);
 
-    if (proposer != this.account.address) {
+    if (proposer.toLowerCase() !== this.account.address.toLowerCase()) {
       return false;
     }
 
@@ -450,14 +492,14 @@ export class L1Publisher {
     const cachedMyLastVote = this.myLastVote;
     this.myLastVote = slotNumber;
 
+    this.governanceLog.verbose(`Casting vote for ${this.payload}`);
+
     let txHash;
     try {
-      txHash = await this.governanceProposerContract.write.vote([this.payload.toString()], {
-        account: this.account,
-      });
+      txHash = await this.governanceProposerContract.write.vote([this.payload.toString()], { account: this.account });
     } catch (err) {
       const msg = prettyLogViemErrorMsg(err);
-      this.log.error(`Governance: Failed to vote`, msg);
+      this.governanceLog.error(`Failed to vote`, msg);
       this.myLastVote = cachedMyLastVote;
       return false;
     }
@@ -465,14 +507,13 @@ export class L1Publisher {
     if (txHash) {
       const receipt = await this.getTransactionReceipt(txHash);
       if (!receipt) {
-        this.log.info(`Failed to get receipt for tx ${txHash}`);
+        this.governanceLog.warn(`Failed to get receipt for tx ${txHash}`);
         this.myLastVote = cachedMyLastVote;
         return false;
       }
     }
 
-    this.log.info(`Governance: Cast vote for ${this.payload}`);
-
+    this.governanceLog.info(`Cast vote for ${this.payload}`);
     return true;
   }
 
@@ -501,10 +542,10 @@ export class L1Publisher {
       archive: block.archive.root.toBuffer(),
       blockHash: block.header.hash().toBuffer(),
       body: block.body.toBuffer(),
+      blobs: Blob.getBlobs(block.body.toBlobFields()),
       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);
@@ -522,7 +563,7 @@ export class L1Publisher {
       signatures: attestations ?? [],
     });
 
-    this.log.verbose(`Submitting propose transaction`);
+    this.log.debug(`Submitting propose transaction`);
     const result = proofQuote
       ? await this.sendProposeAndClaimTx(proposeTxArgs, proofQuote)
       : await this.sendProposeTx(proposeTxArgs);
@@ -532,7 +573,7 @@ export class L1Publisher {
       return false;
     }
 
-    const { receipt, args, functionName } = result;
+    const { receipt, args, functionName, data } = result;
 
     // Tx was mined successfully
     if (receipt.status === 'success') {
@@ -545,20 +586,27 @@ export class L1Publisher {
         ...block.getStats(),
         eventName: 'rollup-published-to-l1',
       };
-      this.log.info(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
+      this.log.verbose(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
       this.metrics.recordProcessBlockTx(timer.ms(), stats);
       return true;
     }
 
     this.metrics.recordFailedTx('process');
-
-    const errorMsg = await this.tryGetErrorFromRevertedTx({
-      args,
-      functionName,
-      abi: RollupAbi,
-      address: this.rollupContract.address,
-      blockNumber: receipt.blockNumber,
-    });
+    const kzg = Blob.getViemKzgInstance();
+    const errorMsg = await this.tryGetErrorFromRevertedTx(
+      data,
+      {
+        args,
+        functionName,
+        abi: RollupAbi,
+        address: this.rollupContract.address,
+      },
+      {
+        blobs: proposeTxArgs.blobs.map(b => b.data),
+        kzg,
+        maxFeePerBlobGas: 10000000000n,
+      },
+    );
     this.log.error(`Rollup process tx reverted. ${errorMsg}`, undefined, {
       ...ctx,
       txHash: receipt.transactionHash,
@@ -567,25 +615,69 @@ export class L1Publisher {
     return false;
   }
 
-  private async tryGetErrorFromRevertedTx(args: {
-    args: any[];
-    functionName: string;
-    abi: any;
-    address: Hex;
-    blockNumber: bigint | undefined;
-  }) {
+  private async tryGetErrorFromRevertedTx(
+    data: Hex,
+    args: {
+      args: any[];
+      functionName: string;
+      abi: any;
+      address: Hex;
+    },
+    _blobInputs?: {
+      blobs: Uint8Array[];
+      kzg: any;
+      maxFeePerBlobGas: bigint;
+    },
+  ) {
+    const blobInputs = _blobInputs || {};
     try {
-      await this.publicClient.simulateContract({ ...args, account: this.walletClient.account });
+      // NB: If this fn starts unexpectedly giving incorrect blob hash errors, it may be because the checkBlob
+      // bool is no longer at the slot below. To find the slot, run: forge inspect src/core/Rollup.sol:Rollup storage
+      const checkBlobSlot = 9n;
+      await this.publicClient.simulateContract({
+        ...args,
+        account: this.walletClient.account,
+        stateOverride: [
+          {
+            address: args.address,
+            stateDiff: [
+              {
+                slot: toHex(checkBlobSlot, true),
+                value: toHex(0n, true),
+              },
+            ],
+          },
+        ],
+      });
+      // 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.
+      // 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:
+      await this.walletClient.prepareTransactionRequest({
+        account: this.walletClient.account,
+        to: this.rollupContract.address,
+        data,
+        ...blobInputs,
+      });
       return undefined;
-    } catch (err: any) {
-      if (err.name === 'ContractFunctionExecutionError') {
-        const execErr = err as ContractFunctionExecutionError;
-        return compactArray([
-          execErr.shortMessage,
-          ...(execErr.metaMessages ?? []).slice(0, 2).map(s => s.trim()),
-        ]).join(' ');
+    } catch (simulationErr: any) {
+      // If we don't have a ContractFunctionExecutionError, we have a blob related error => use ExtRollupLibAbi to get the error msg.
+      const contractErr =
+        simulationErr.name === 'ContractFunctionExecutionError'
+          ? simulationErr
+          : getContractError(simulationErr as BaseError, {
+              args: [],
+              abi: ExtRollupLibAbi,
+              functionName: args.functionName,
+              address: args.address,
+              sender: this.account.address,
+            });
+      if (contractErr.name === 'ContractFunctionExecutionError') {
+        const execErr = contractErr as ContractFunctionExecutionError;
+        return tryGetCustomErrorNameContractFunction(execErr);
       }
-      this.log.error(`Error getting error from simulation`, err);
+      this.log.error(`Error getting error from simulation`, simulationErr);
     }
   }
 
@@ -687,7 +779,7 @@ export class L1Publisher {
       : proof.extractAggregationObject();
     const argsPublicInputs = [...publicInputs.toFields(), ...aggregationObject];
 
-    if (!areArraysEqual(rollupPublicInputs.map(Fr.fromString), argsPublicInputs, (a, b) => a.equals(b))) {
+    if (!areArraysEqual(rollupPublicInputs.map(Fr.fromHexString), argsPublicInputs, (a, b) => a.equals(b))) {
       const fmt = (inputs: Fr[] | readonly string[]) => inputs.map(x => x.toString()).join(', ');
       throw new Error(
         `Root rollup public inputs mismatch:\nRollup:  ${fmt(rollupPublicInputs)}\nComputed:${fmt(argsPublicInputs)}`,
@@ -726,7 +818,8 @@ export class L1Publisher {
           epochSize: argsArray[0],
           args: argsArray[1],
           fees: argsArray[2],
-          aggregationObject: argsArray[3],
+          blobPublicInputs: argsArray[3],
+          aggregationObject: argsArray[4],
           proof: proofHex,
         },
       ] as const;
@@ -750,22 +843,31 @@ export class L1Publisher {
   }
 
   private async prepareProposeTx(encodedData: L1ProcessArgs) {
-    const computeTxsEffectsHashGas = await this.l1TxUtils.estimateGas(this.account, {
-      to: this.rollupContract.address,
-      data: encodeFunctionData({
-        abi: this.rollupContract.abi,
-        functionName: 'computeTxsEffectsHash',
-        args: [`0x${encodedData.body.toString('hex')}`],
-      }),
-    });
+    const kzg = Blob.getViemKzgInstance();
+    const blobEvaluationGas = await this.l1TxUtils.estimateGas(
+      this.account,
+      {
+        to: this.rollupContract.address,
+        data: encodeFunctionData({
+          abi: this.rollupContract.abi,
+          functionName: 'validateBlobs',
+          args: [Blob.getEthBlobEvaluationInputs(encodedData.blobs)],
+        }),
+      },
+      {},
+      {
+        blobs: encodedData.blobs.map(b => b.data),
+        kzg,
+        maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+      },
+    );
 
     // @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 = computeTxsEffectsHashGas + L1Publisher.PROPOSE_GAS_GUESS;
-
+    const gasGuesstimate = blobEvaluationGas + L1Publisher.PROPOSE_GAS_GUESS;
     const attestations = encodedData.attestations
       ? encodedData.attestations.map(attest => attest.toViemSignature())
       : [];
@@ -783,7 +885,9 @@ export class L1Publisher {
         txHashes,
       },
       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),
     ] as const;
 
     return { args, gas: gasGuesstimate };
@@ -811,40 +915,51 @@ export class L1Publisher {
           ? args.publicInputs.fees[i / 2].recipient.toField().toString()
           : args.publicInputs.fees[(i - 1) / 2].value.toString(),
       ),
+      `0x${args.publicInputs.blobPublicInputs
+        .filter((_, i) => i < args.toBlock - args.fromBlock + 1)
+        .map(b => b.toString())
+        .join(``)}`,
       `0x${serializeToBuffer(args.proof.extractAggregationObject()).toString('hex')}`,
     ] as const;
   }
 
   private async sendProposeTx(
     encodedData: L1ProcessArgs,
-  ): Promise<{ receipt: TransactionReceipt; args: any; functionName: string } | undefined> {
+  ): Promise<{ receipt: TransactionReceipt | undefined; args: any; functionName: string; data: Hex } | undefined> {
     if (this.interrupted) {
       return undefined;
     }
     try {
+      const kzg = Blob.getViemKzgInstance();
       const { args, gas } = await this.prepareProposeTx(encodedData);
+      const data = encodeFunctionData({
+        abi: this.rollupContract.abi,
+        functionName: 'propose',
+        args,
+      });
       const receipt = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
-          data: encodeFunctionData({
-            abi: this.rollupContract.abi,
-            functionName: 'propose',
-            args,
-          }),
+          data,
         },
         {
           fixedGas: gas,
         },
+        {
+          blobs: encodedData.blobs.map(b => b.data),
+          kzg,
+          maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+        },
       );
       return {
         receipt,
         args,
         functionName: 'propose',
+        data,
       };
     } catch (err) {
       prettyLogViemError(err, this.log);
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log.error(`Rollup publish failed`, errorMessage);
+      this.log.error(`Rollup publish failed`, err);
       return undefined;
     }
   }
@@ -852,7 +967,7 @@ export class L1Publisher {
   private async sendProposeAndClaimTx(
     encodedData: L1ProcessArgs,
     quote: EpochProofQuote,
-  ): Promise<{ receipt: TransactionReceipt; args: any; functionName: string } | undefined> {
+  ): Promise<{ receipt: TransactionReceipt | undefined; args: any; functionName: string; data: Hex } | undefined> {
     if (this.interrupted) {
       return undefined;
     }
@@ -860,23 +975,31 @@ export class L1Publisher {
       this.log.info(`ProposeAndClaim`);
       this.log.info(inspect(quote.payload));
 
+      const kzg = Blob.getViemKzgInstance();
       const { args, gas } = await this.prepareProposeTx(encodedData);
+      const data = encodeFunctionData({
+        abi: this.rollupContract.abi,
+        functionName: 'proposeAndClaim',
+        args: [...args, quote.toViemArgs()],
+      });
       const receipt = await this.l1TxUtils.sendAndMonitorTransaction(
         {
           to: this.rollupContract.address,
-          data: encodeFunctionData({
-            abi: this.rollupContract.abi,
-            functionName: 'proposeAndClaim',
-            args: [...args, quote.toViemArgs()],
-          }),
+          data,
         },
         { fixedGas: gas },
+        {
+          blobs: encodedData.blobs.map(b => b.data),
+          kzg,
+          maxFeePerBlobGas: 10000000000n, //This is 10 gwei, taken from DEFAULT_MAX_FEE_PER_GAS
+        },
       );
 
       return {
         receipt,
-        args,
+        args: [...args, quote.toViemArgs()],
         functionName: 'proposeAndClaim',
+        data,
       };
     } catch (err) {
       prettyLogViemError(err, this.log);
@@ -936,6 +1059,10 @@ function getCalldataGasUsage(data: Uint8Array) {
   return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
 }
 
+function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError) {
+  return compactArray([err.shortMessage, ...(err.metaMessages ?? []).slice(0, 2).map(s => s.trim())]).join(' ');
+}
+
 function tryGetCustomErrorName(err: any) {
   try {
     // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors

package/src/publisher/utils.ts

@@ -14,6 +14,7 @@ export function prettyLogViemErrorMsg(err: any) {
   }
 }
 
+// TODO(palla/log): Review this method
 export function prettyLogViemError(err: any, logger: Logger) {
   const msg = prettyLogViemErrorMsg(err);
   if (msg) {

package/src/sequencer/allowed.ts

@@ -0,0 +1,36 @@
+import { type AllowedElement } from '@aztec/circuit-types';
+import { getContractClassFromArtifact } from '@aztec/circuits.js';
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+let defaultAllowedSetupFunctions: AllowedElement[] | undefined = undefined;
+
+export function getDefaultAllowedSetupFunctions(): AllowedElement[] {
+  if (defaultAllowedSetupFunctions === undefined) {
+    defaultAllowedSetupFunctions = [
+      // needed for authwit support
+      {
+        address: ProtocolContractAddress.AuthRegistry,
+      },
+      // needed for claiming on the same tx as a spend
+      {
+        address: ProtocolContractAddress.FeeJuice,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((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)'),
+      },
+      {
+        classId: getContractClassFromArtifact(FPCContract.artifact).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
+      },
+    ];
+  }
+  return defaultAllowedSetupFunctions;
+}

package/src/sequencer/config.ts

@@ -1 +1 @@
-export { SequencerConfig } from '@aztec/circuit-types';
+export { type SequencerConfig } from '@aztec/circuit-types/config';

package/src/sequencer/metrics.ts

@@ -7,7 +7,6 @@ import {
   type Tracer,
   type UpDownCounter,
   ValueType,
-  millisecondBuckets,
 } from '@aztec/telemetry-client';
 
 import { type SequencerState, type SequencerStateCallback, sequencerStateToNumber } from './utils.js';
@@ -32,18 +31,12 @@ export class SequencerMetrics {
       unit: 'ms',
       description: 'Duration to build a block',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(2),
-      },
     });
     this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
       unit: 'ms',
       description:
         'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(2),
-      },
     });
 
     const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {