@aztec/sequencer-client 0.67.0 → 0.67.1-devnet

package/src/config.ts

@@ -1,5 +1,5 @@
-import { type AllowedElement } from '@aztec/circuit-types';
-import { AztecAddress, Fr, FunctionSelector, getContractClassFromArtifact } from '@aztec/circuits.js';
+import { type AllowedElement, type SequencerConfig } from '@aztec/circuit-types/config';
+import { AztecAddress, Fr, FunctionSelector } from '@aztec/circuits.js';
 import {
   type L1ContractsConfig,
   type L1ReaderConfig,
@@ -14,9 +14,6 @@ import {
 } from '@aztec/foundation/config';
 import { pickConfigMappings } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { FPCContract } from '@aztec/noir-contracts.js/FPC';
-import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 
 import {
   type PublisherConfig,
@@ -24,7 +21,9 @@ import {
   getPublisherConfigMappings,
   getTxSenderConfigMappings,
 } from './publisher/config.js';
-import { type SequencerConfig } from './sequencer/config.js';
+
+export * from './publisher/config.js';
+export { SequencerConfig };
 
 /** Chain configuration. */
 type ChainConfig = {
@@ -60,17 +59,6 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     description: 'The minimum number of txs to include in a block.',
     ...numberConfigHelper(1),
   },
-  minSecondsBetweenBlocks: {
-    env: 'SEQ_MIN_SECONDS_BETWEEN_BLOCKS',
-    description: 'The minimum number of seconds in-between consecutive blocks.',
-    ...numberConfigHelper(0),
-  },
-  maxSecondsBetweenBlocks: {
-    env: 'SEQ_MAX_SECONDS_BETWEEN_BLOCKS',
-    description:
-      'The maximum number of seconds in-between consecutive blocks. Sequencer will produce a block with less than minTxsPerBlock once this threshold is reached.',
-    ...numberConfigHelper(0),
-  },
   coinbase: {
     env: 'COINBASE',
     parseEnv: (val: string) => EthAddress.fromString(val),
@@ -92,18 +80,10 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
   allowedInSetup: {
     env: 'SEQ_ALLOWED_SETUP_FN',
     parseEnv: (val: string) => parseSequencerAllowList(val),
-    defaultValue: getDefaultAllowedSetupFunctions(),
     description: 'The list of functions calls allowed to run in setup',
     printDefault: () =>
       'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
   },
-  allowedInTeardown: {
-    env: 'SEQ_ALLOWED_TEARDOWN_FN',
-    parseEnv: (val: string) => parseSequencerAllowList(val),
-    defaultValue: getDefaultAllowedTeardownFunctions(),
-    description: 'The list of functions calls allowed to run teardown',
-    printDefault: () => 'FPC.pay_refund',
-  },
   maxBlockSizeInBytes: {
     env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
     description: 'Max block size',
@@ -202,38 +182,3 @@ export function parseSequencerAllowList(value: string): AllowedElement[] {
 
   return entries;
 }
-
-function getDefaultAllowedSetupFunctions(): AllowedElement[] {
-  return [
-    // 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)'),
-    },
-  ];
-}
-
-function getDefaultAllowedTeardownFunctions(): AllowedElement[] {
-  return [
-    {
-      classId: getContractClassFromArtifact(FPCContract.artifact).id,
-      selector: FunctionSelector.fromSignature('pay_refund((Field),Field,(Field))'),
-    },
-  ];
-}

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
-export * from './sequencer/index.js';
 
 // Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
 // ISSUE(#9832)

package/src/publisher/index.ts

@@ -1,3 +1,2 @@
 export { L1Publisher, L1SubmitEpochProofArgs } from './l1-publisher.js';
 export * from './test-l1-publisher.js';
-export * from './config.js';

package/src/publisher/l1-publisher.ts

@@ -25,6 +25,8 @@ 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';
@@ -32,7 +34,7 @@ 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 */
@@ -166,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;
 
@@ -342,7 +350,10 @@ export class L1Publisher {
     try {
       await this.rollupContract.read.validateEpochProofRightClaimAtTime(args, { account: this.account });
     } catch (err) {
-      const errorName = tryGetCustomErrorName(err);
+      let errorName = tryGetCustomErrorName(err);
+      if (!errorName) {
+        errorName = tryGetCustomErrorNameContractFunction(err as ContractFunctionExecutionError);
+      }
       this.log.warn(`Proof quote validation failed: ${errorName}`, quote);
       return undefined;
     }
@@ -375,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;
 
@@ -386,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}`);
       }
@@ -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);
@@ -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') {
@@ -551,14 +592,21 @@ export class L1Publisher {
     }
 
     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);
     }
   }
 
@@ -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,35 +915,47 @@ 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);
@@ -851,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;
     }
@@ -859,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);
@@ -935,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/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';