@aztec/ethereum 3.0.0-nightly.20250911 → 3.0.0-nightly.20250913

package/dest/utils.js

@@ -118,34 +118,16 @@ function getNestedErrorData(error) {
     if (error instanceof Error) {
         return new FormattedViemError(error.message, error?.metaMessages);
     }
-    // Extract the actual error message and highlight it for clarity
-    let formattedRes = extractAndFormatRequestBody(error?.message || String(error));
-    let errorDetail = '';
-    // Look for specific details in known locations
-    if (error) {
-        // Check for details property which often has the most specific error message
-        if (typeof error.details === 'string' && error.details) {
-            errorDetail = error.details;
-        } else if (typeof error.shortMessage === 'string' && error.shortMessage) {
-            errorDetail = error.shortMessage;
-        }
-    }
-    // If we found a specific error detail, format it clearly
-    if (errorDetail) {
-        // Look for key sections of the formatted result to replace with highlighted error
-        let replaced = false;
-        // Try to find the Details: section
-        const detailsMatch = formattedRes.match(/Details: ([^\n]+)/);
-        if (detailsMatch) {
-            formattedRes = formattedRes.replace(detailsMatch[0], `Details: *${errorDetail}*`);
-            replaced = true;
-        }
-        // If we didn't find a Details section, add the error at the beginning
-        if (!replaced) {
-            formattedRes = `Error: *${errorDetail}*\n\n${formattedRes}`;
-        }
-    }
-    return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+    const body = String(error);
+    const length = body.length;
+    // LogExplorer can only render up to 2500 characters in it's summary view. Try to keep the whole message below this number
+    // Limit the error to 2000 chacaters in order to allow code higher up to decorate this error with extra details (up to 500 characters)
+    if (length > 2000) {
+        const chunk = 950;
+        const truncated = length - 2 * chunk;
+        return new FormattedViemError(body.slice(0, chunk) + `...${truncated} characters truncated...` + body.slice(-1 * chunk));
+    }
+    return new FormattedViemError(body);
 }
 function stripAbis(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -166,139 +148,6 @@ function stripAbis(obj) {
         }
     });
 }
-function extractAndFormatRequestBody(message) {
-    // First check if message is extremely large and contains very large hex strings
-    if (message.length > 50000) {
-        message = replaceHexStrings(message, {
-            minLength: 10000,
-            truncateLength: 200
-        });
-    }
-    // Add a specific check for RPC calls with large params
-    if (message.includes('"method":"eth_sendRawTransaction"')) {
-        message = replaceHexStrings(message, {
-            pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-            transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-        });
-    }
-    // First handle Request body JSON
-    const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
-    let result = message.replace(requestBodyRegex, (match, body)=>{
-        return `Request body: ${formatRequestBody(body)}\n`;
-    });
-    // Then handle Arguments section
-    const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
-    result = result.replace(argsRegex, (section)=>{
-        const lines = section.split('\n');
-        const processedLines = lines.map((line)=>{
-            // Check if line contains a colon followed by content
-            const colonIndex = line.indexOf(':');
-            if (colonIndex !== -1) {
-                const [prefix, content] = [
-                    line.slice(0, colonIndex + 1),
-                    line.slice(colonIndex + 1).trim()
-                ];
-                // If content contains a hex string, truncate it
-                if (content.includes('0x')) {
-                    const processedContent = replaceHexStrings(content);
-                    return `${prefix} ${processedContent}`;
-                }
-            }
-            return line;
-        });
-        return processedLines.join('\n');
-    });
-    // Finally, catch any remaining hex strings in the message
-    result = replaceHexStrings(result);
-    return result;
-}
-function truncateHex(hex, length = 100) {
-    if (!hex || typeof hex !== 'string') {
-        return hex;
-    }
-    if (!hex.startsWith('0x')) {
-        return hex;
-    }
-    if (hex.length <= length * 2) {
-        return hex;
-    }
-    // For extremely large hex strings, use more aggressive truncation
-    if (hex.length > 10000) {
-        return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
-    }
-    return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-}
-function replaceHexStrings(text, options = {}) {
-    const { minLength = 10, maxLength = Infinity, truncateLength = 100, pattern, transform = (hex)=>truncateHex(hex, truncateLength) } = options;
-    const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
-    return text.replace(hexRegex, (match)=>transform(match));
-}
-function formatRequestBody(body) {
-    try {
-        // Special handling for eth_sendRawTransaction
-        if (body.includes('"method":"eth_sendRawTransaction"')) {
-            try {
-                const parsed = JSON.parse(body);
-                if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
-                    // These are likely large transaction hex strings
-                    parsed.params = parsed.params.map((param)=>{
-                        if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
-                            return truncateHex(param, 200);
-                        }
-                        return param;
-                    });
-                }
-                return JSON.stringify(parsed, null, 2);
-            } catch  {
-                // If specific parsing fails, fall back to regex-based truncation
-                return replaceHexStrings(body, {
-                    pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-                    transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-                });
-            }
-        }
-        // For extremely large request bodies, use simple truncation instead of parsing
-        if (body.length > 50000) {
-            const jsonStart = body.indexOf('{');
-            const jsonEnd = body.lastIndexOf('}');
-            if (jsonStart >= 0 && jsonEnd > jsonStart) {
-                return replaceHexStrings(body, {
-                    minLength: 10000,
-                    truncateLength: 200
-                });
-            }
-        }
-        const parsed = JSON.parse(body);
-        // Process the entire request body
-        const processed = processParams(parsed);
-        return JSON.stringify(processed, null, 2);
-    } catch  {
-        // If JSON parsing fails, do a simple truncation of any large hex strings
-        return replaceHexStrings(body, {
-            minLength: 1000,
-            truncateLength: 150
-        });
-    }
-}
-// Recursively process all parameters that might contain hex strings
-function processParams(obj) {
-    if (Array.isArray(obj)) {
-        return obj.map((item)=>processParams(item));
-    }
-    if (typeof obj === 'object' && obj !== null) {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)){
-            result[key] = processParams(value);
-        }
-        return result;
-    }
-    if (typeof obj === 'string') {
-        if (obj.startsWith('0x')) {
-            return truncateHex(obj);
-        }
-    }
-    return obj;
-}
 export function tryGetCustomErrorName(err) {
     try {
         // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "3.0.0-nightly.20250911",
+  "version": "3.0.0-nightly.20250913",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -31,10 +31,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20250911",
-    "@aztec/constants": "3.0.0-nightly.20250911",
-    "@aztec/foundation": "3.0.0-nightly.20250911",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250911",
+    "@aztec/blob-lib": "3.0.0-nightly.20250913",
+    "@aztec/constants": "3.0.0-nightly.20250913",
+    "@aztec/foundation": "3.0.0-nightly.20250913",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20250913",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "lodash.chunk": "^4.2.0",

package/src/config.ts

@@ -28,6 +28,8 @@ export type L1ContractsConfig = {
   aztecEpochDuration: number;
   /** The target validator committee size. */
   aztecTargetCommitteeSize: number;
+  /** The number of epochs to lag behind the current epoch for validator selection. */
+  lagInEpochs: number;
   /** The number of epochs after an epoch ends that proofs are still accepted. */
   aztecProofSubmissionEpochs: number;
   /** The deposit amount for a validator */
@@ -48,6 +50,8 @@ export type L1ContractsConfig = {
   slashingVetoer: EthAddress;
   /** How many slashing rounds back we slash (ie when slashing in round N, we slash for offenses committed during epochs of round N-offset) */
   slashingOffsetInRounds: number;
+  /** How long slashing can be disabled for in seconds when vetoer disables it */
+  slashingDisableDuration: number;
   /** Type of slasher proposer */
   slasherFlavor: 'empire' | 'tally' | 'none';
   /** Minimum amount that can be slashed in tally slashing */
@@ -73,6 +77,7 @@ export const DefaultL1ContractsConfig = {
   aztecSlotDuration: 36,
   aztecEpochDuration: 32,
   aztecTargetCommitteeSize: 48,
+  lagInEpochs: 2,
   aztecProofSubmissionEpochs: 1, // you have a full epoch to submit a proof after the epoch to prove ends
   activationThreshold: BigInt(100e18),
   ejectionThreshold: BigInt(50e18),
@@ -90,6 +95,7 @@ export const DefaultL1ContractsConfig = {
   exitDelaySeconds: 2 * 24 * 60 * 60,
   slasherFlavor: 'tally' as const,
   slashingOffsetInRounds: 2,
+  slashingDisableDuration: 5 * 24 * 60 * 60, // 5 days in seconds
 } satisfies L1ContractsConfig;
 
 const LocalGovernanceConfiguration = {
@@ -303,6 +309,11 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
     description: 'The target validator committee size.',
     ...numberConfigHelper(DefaultL1ContractsConfig.aztecTargetCommitteeSize),
   },
+  lagInEpochs: {
+    env: 'AZTEC_LAG_IN_EPOCHS',
+    description: 'The number of epochs to lag behind the current epoch for validator selection.',
+    ...numberConfigHelper(DefaultL1ContractsConfig.lagInEpochs),
+  },
   aztecProofSubmissionEpochs: {
     env: 'AZTEC_PROOF_SUBMISSION_EPOCHS',
     description: 'The number of epochs after an epoch ends that proofs are still accepted.',
@@ -376,6 +387,11 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
     parseEnv: (val: string) => EthAddress.fromString(val),
     defaultValue: DefaultL1ContractsConfig.slashingVetoer,
   },
+  slashingDisableDuration: {
+    env: 'AZTEC_SLASHING_DISABLE_DURATION',
+    description: 'How long slashing can be disabled for in seconds when vetoer disables it',
+    ...numberConfigHelper(DefaultL1ContractsConfig.slashingDisableDuration),
+  },
   governanceProposerQuorum: {
     env: 'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
     description: 'The governance proposing quorum',
@@ -449,7 +465,7 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
   }
 
   // EmpireBase constructor validations for governance/slashing proposers
-  // From: require(QUORUM_SIZE > ROUND_SIZE / 2, Errors.GovernanceProposer__InvalidQuorumAndRoundSize(QUORUM_SIZE, ROUND_SIZE));
+  // From: require(QUORUM_SIZE > ROUND_SIZE / 2, Errors.EmpireBase__InvalidQuorumAndRoundSize(QUORUM_SIZE, ROUND_SIZE));
   const { governanceProposerQuorum, governanceProposerRoundSize } = config;
   if (
     governanceProposerQuorum !== undefined &&
@@ -460,7 +476,7 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
     );
   }
 
-  // From: require(QUORUM_SIZE <= ROUND_SIZE, Errors.GovernanceProposer__QuorumCannotBeLargerThanRoundSize(QUORUM_SIZE, ROUND_SIZE));
+  // From: require(QUORUM_SIZE <= ROUND_SIZE, Errors.EmpireBase__QuorumCannotBeLargerThanRoundSize(QUORUM_SIZE, ROUND_SIZE));
   if (governanceProposerQuorum !== undefined && governanceProposerQuorum > governanceProposerRoundSize) {
     errors.push(
       `governanceProposerQuorum (${governanceProposerQuorum}) cannot be larger than governanceProposerRoundSize (${governanceProposerRoundSize})`,

package/src/contracts/rollup.ts

@@ -10,6 +10,7 @@ import {
   type GetContractReturnType,
   type Hex,
   type StateOverride,
+  type WatchContractEventReturnType,
   encodeFunctionData,
   getContract,
   hexToBigInt,
@@ -225,6 +226,11 @@ export class RollupContract {
     return this.rollup.read.getLocalEjectionThreshold();
   }
 
+  @memoize
+  getLagInEpochs() {
+    return this.rollup.read.getLagInEpochs();
+  }
+
   @memoize
   getActivationThreshold() {
     return this.rollup.read.getActivationThreshold();
@@ -436,8 +442,15 @@ export class RollupContract {
     return this.rollup.read.getEntryQueueLength();
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
+  getNextFlushableEpoch() {
+    return this.rollup.read.getNextFlushableEpoch();
+  }
+
+  getCurrentEpochNumber(): Promise<bigint> {
+    return this.rollup.read.getCurrentEpoch();
+  }
+
+  getEpochNumberForBlock(blockNumber: bigint) {
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
   }
 
@@ -722,7 +735,9 @@ export class RollupContract {
     });
   }
 
-  public listenToSlasherChanged(callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown) {
+  public listenToSlasherChanged(
+    callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.SlasherUpdated(
       {},
       {
@@ -738,6 +753,22 @@ export class RollupContract {
     );
   }
 
+  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
+    return this.rollup.watchEvent.BlockInvalidated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.blockNumber !== undefined) {
+              callback({ blockNumber: args.blockNumber });
+            }
+          }
+        },
+      },
+    );
+  }
+
   public async getSlashEvents(l1BlockHash: Hex): Promise<{ amount: bigint; attester: EthAddress }[]> {
     const events = await this.rollup.getEvents.Slashed({}, { blockHash: l1BlockHash, strict: true });
     return events.map(event => ({
@@ -746,7 +777,9 @@ export class RollupContract {
     }));
   }
 
-  public listenToSlash(callback: (args: { amount: bigint; attester: EthAddress }) => unknown) {
+  public listenToSlash(
+    callback: (args: { amount: bigint; attester: EthAddress }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.Slashed(
       {},
       {

package/src/contracts/slasher_contract.ts

@@ -38,6 +38,19 @@ export class SlasherContract {
     }
   }
 
+  /**
+   * Checks if slashing is currently enabled. Slashing can be disabled by the vetoer.
+   * @returns True if slashing is enabled, false otherwise
+   */
+  public async isSlashingEnabled(): Promise<boolean> {
+    try {
+      return await this.contract.read.isSlashingEnabled();
+    } catch (error) {
+      this.log.error(`Error checking if slashing is enabled`, error);
+      throw error;
+    }
+  }
+
   /**
    * Gets the current vetoer address.
    * @returns The vetoer address
@@ -47,6 +60,15 @@ export class SlasherContract {
     return EthAddress.fromString(vetoer);
   }
 
+  /**
+   * Gets the disable duration by the vetoer.
+   * @returns The disable duration in seconds
+   */
+  public async getSlashingDisableDuration(): Promise<number> {
+    const duration = await this.contract.read.SLASHING_DISABLE_DURATION();
+    return Number(duration);
+  }
+
   /**
    * Gets the current governance address.
    * @returns The governance address

package/src/deploy_l1_contracts.ts

@@ -5,6 +5,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
@@ -430,6 +431,7 @@ export const deployRollupForUpgrade = async (
   registryAddress: EthAddress,
   logger: Logger,
   txUtilsConfig: L1TxUtilsConfig,
+  flushEntryQueue: boolean = true,
 ) => {
   const deployer = new L1Deployer(
     extendedClient,
@@ -442,7 +444,14 @@ export const deployRollupForUpgrade = async (
 
   const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
 
-  const { rollup, slashFactoryAddress } = await deployRollup(extendedClient, deployer, args, addresses, logger);
+  const { rollup, slashFactoryAddress } = await deployRollup(
+    extendedClient,
+    deployer,
+    args,
+    addresses,
+    flushEntryQueue,
+    logger,
+  );
 
   await deployer.waitForDeployments();
 
@@ -501,6 +510,7 @@ export const deployRollup = async (
     | 'gseAddress'
     | 'governanceAddress'
   >,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   if (!addresses.gseAddress) {
@@ -530,6 +540,7 @@ export const deployRollup = async (
     aztecSlotDuration: BigInt(args.aztecSlotDuration),
     aztecEpochDuration: BigInt(args.aztecEpochDuration),
     targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
+    lagInEpochs: BigInt(args.lagInEpochs),
     aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
     slashingQuorum: BigInt(args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1),
     slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
@@ -547,6 +558,7 @@ export const deployRollup = async (
     slashingOffsetInRounds: BigInt(args.slashingOffsetInRounds),
     slashAmounts: [args.slashAmountSmall, args.slashAmountMedium, args.slashAmountLarge],
     localEjectionThreshold: args.localEjectionThreshold,
+    slashingDisableDuration: BigInt(args.slashingDisableDuration ?? 0n),
   };
 
   const genesisStateArgs = {
@@ -674,6 +686,7 @@ export const deployRollup = async (
       addresses.stakingAssetAddress.toString(),
       args.initialValidators,
       args.acceleratedTestDeployments,
+      flushEntryQueue,
       logger,
     );
   }
@@ -850,6 +863,7 @@ export const addMultipleValidators = async (
   stakingAssetAddress: Hex,
   validators: Operator[],
   acceleratedTestDeployments: boolean | undefined,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   const rollup = new RollupContract(extendedClient, rollupAddress);
@@ -916,7 +930,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, true],
+              args: [validatorsTuples, /* skip flushing */ true],
             }),
           },
           {
@@ -924,19 +938,49 @@ export const addMultipleValidators = async (
           },
         );
 
-        await deployer.l1TxUtils.sendAndMonitorTransaction(
-          {
-            to: rollupAddress,
-            data: encodeFunctionData({
-              abi: RollupArtifact.contractAbi,
-              functionName: 'flushEntryQueue',
-              args: [],
-            }),
-          },
-          {
-            gasLimit: 40_000_000n,
-          },
-        );
+        let queueLength = await rollup.getEntryQueueLength();
+        while (flushEntryQueue && queueLength > 0n) {
+          logger.info(`Flushing entry queue with ${queueLength} entries`);
+
+          try {
+            await deployer.l1TxUtils.sendAndMonitorTransaction(
+              {
+                to: rollupAddress,
+                data: encodeFunctionData({
+                  abi: RollupArtifact.contractAbi,
+                  functionName: 'flushEntryQueue',
+                  args: [],
+                }),
+              },
+              {
+                gasLimit: 20_000_000n,
+              },
+            );
+          } catch (err) {
+            logger.warn('Failed to flush queue', { err });
+          }
+
+          queueLength = await rollup.getEntryQueueLength();
+          // check if we drained the queue enough here so we can avoid sleep
+          if (queueLength === 0n) {
+            break;
+          }
+
+          logger.info(`Waiting for next flushable epoch to flush remaining ${queueLength} entries`);
+          await retryUntil(
+            async () => {
+              const [currentEpoch, flushableEpoch] = await Promise.all([
+                rollup.getCurrentEpochNumber(),
+                rollup.getNextFlushableEpoch(),
+              ]);
+              logger.debug(`Next flushable epoch is ${flushableEpoch} (current epoch is ${currentEpoch})`);
+              return currentEpoch >= flushableEpoch;
+            },
+            'wait for next flushable epoch',
+            3600,
+            12,
+          );
+        }
       } else {
         await deployer.l1TxUtils.sendAndMonitorTransaction(
           {
@@ -944,7 +988,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, false],
+              args: [validatorsTuples, /* skip flushing */ !flushEntryQueue],
             }),
           },
           {
@@ -1027,6 +1071,7 @@ export const deployL1Contracts = async (
   args: DeployL1ContractsArgs,
   txUtilsConfig: L1TxUtilsConfig = getL1TxUtilsConfigEnvVars(),
   createVerificationJson: string | false = false,
+  flushEntryQueue: boolean = true,
 ): Promise<DeployL1ContractsReturnType> => {
   logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
   validateConfig(args);
@@ -1093,6 +1138,7 @@ export const deployL1Contracts = async (
       stakingAssetAddress,
       governanceAddress,
     },
+    flushEntryQueue,
     logger,
   );
 

package/src/l1_tx_utils.ts

@@ -279,7 +279,13 @@ export class ReadOnlyL1TxUtils {
     let blobBaseFee = 0n;
     if (isBlobTx) {
       try {
-        blobBaseFee = await this.client.getBlobBaseFee();
+        blobBaseFee = await retry<bigint>(
+          () => this.client.getBlobBaseFee(),
+          'Getting L1 blob base fee',
+          makeBackoff(times(2, () => 1)),
+          this.logger,
+          true,
+        );
         this.logger?.debug('L1 Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
       } catch {
         this.logger?.warn('Failed to get L1 blob base fee', attempt);
@@ -864,7 +870,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             },
           );
 
-          const txData = {
+          const txData: PrepareTransactionRequestRequest = {
             ...request,
             ...blobInputs,
             nonce,
@@ -872,6 +878,9 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             maxFeePerGas: newGasPrice.maxFeePerGas,
             maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
           };
+          if (isBlobTx && newGasPrice.maxFeePerBlobGas) {
+            (txData as any).maxFeePerBlobGas = newGasPrice.maxFeePerBlobGas;
+          }
           const signedRequest = await this.prepareSignedTransaction(txData);
           const newHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
           if (!isCancelTx) {

package/src/queries.ts

@@ -33,6 +33,7 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
+    lagInEpochs,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -45,6 +46,7 @@ export async function getL1ContractsConfig(
     slashingOffsetInRounds,
     slashingAmounts,
     slashingVetoer,
+    slashingDisableDuration,
     manaTarget,
     provingCostPerMana,
     rollupVersion,
@@ -57,6 +59,7 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
+    rollup.getLagInEpochs(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
     rollup.getLocalEjectionThreshold(),
@@ -69,6 +72,7 @@ export async function getL1ContractsConfig(
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
     slasher?.getVetoer() ?? EthAddress.ZERO,
+    slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
@@ -83,6 +87,7 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochs: Number(lagInEpochs),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,
@@ -93,7 +98,8 @@ export async function getL1ContractsConfig(
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingVetoer,
-    manaTarget: manaTarget,
+    slashingDisableDuration,
+    manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot,