@aztec/ethereum 0.69.0-devnet → 0.69.1-devnet

package/dest/utils.js

@@ -1,4 +1,4 @@
-import { decodeEventLog, } from 'viem';
+import { BaseError, ContractFunctionRevertedError, decodeEventLog, } from 'viem';
 export function extractEvent(logs, address, abi, eventName, filter, logger) {
     const event = tryExtractEvent(logs, address, abi, eventName, filter, logger);
     if (!event) {
@@ -24,4 +24,97 @@ function tryExtractEvent(logs, address, abi, eventName, filter, logger) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQU1MLGNBQWMsR0FDZixNQUFNLE1BQU0sQ0FBQztBQVNkLE1BQU0sVUFBVSxZQUFZLENBSzFCLElBQVcsRUFDWCxPQUFZLEVBQ1osR0FBUyxFQUNULFNBQXFCLEVBQ3JCLE1BQXFDLEVBQ3JDLE1BQWU7SUFFZixNQUFNLEtBQUssR0FBRyxlQUFlLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM3RSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLGlDQUFpQyxTQUFTLGlCQUFpQixPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRCxTQUFTLGVBQWUsQ0FLdEIsSUFBVyxFQUNYLE9BQVksRUFDWixHQUFTLEVBQ1QsU0FBcUIsRUFDckIsTUFBcUMsRUFDckMsTUFBZTtJQUVmLEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDdkIsSUFBSSxHQUFHLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxLQUFLLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDO1lBQ3hELElBQUksQ0FBQztnQkFDSCxNQUFNLFlBQVksR0FBRyxjQUFjLENBQUMsRUFBRSxHQUFHLEVBQUUsR0FBRyxHQUFHLEVBQUUsQ0FBQyxDQUFDO2dCQUNyRCxJQUFJLFlBQVksQ0FBQyxTQUFTLEtBQUssU0FBUyxFQUFFLENBQUM7b0JBQ3pDLE1BQU0sYUFBYSxHQUFHLFlBQTBCLENBQUM7b0JBQ2pELElBQUksQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUM7d0JBQ3JDLE9BQU8sYUFBYSxDQUFDO29CQUN2QixDQUFDO2dCQUNILENBQUM7WUFDSCxDQUFDO1lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztnQkFDYixNQUFNLEVBQUUsSUFBSSxDQUFDLDJDQUEyQyxPQUFPLEtBQUssR0FBRyxFQUFFLENBQUMsQ0FBQztZQUM3RSxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7QUFDSCxDQUFDIn0=
+export function prettyLogViemErrorMsg(err) {
+    if (err instanceof BaseError) {
+        const revertError = err.walk(err => err instanceof ContractFunctionRevertedError);
+        if (revertError instanceof ContractFunctionRevertedError) {
+            const errorName = revertError.data?.errorName ?? '';
+            const args = revertError.metaMessages && revertError.metaMessages?.length > 1 ? revertError.metaMessages[1].trimStart() : '';
+            return `${errorName}${args}`;
+        }
+    }
+    return err?.message ?? err;
+}
+export function formatViemError(error) {
+    const truncateHex = (hex, length = 100) => {
+        if (!hex || typeof hex !== 'string') {
+            return hex;
+        }
+        if (!hex.startsWith('0x')) {
+            return hex;
+        }
+        if (hex.length <= length * 2) {
+            return hex;
+        }
+        return `${hex.slice(0, length)}...${hex.slice(-length)}`;
+    };
+    const formatRequestBody = (body) => {
+        try {
+            const parsed = JSON.parse(body);
+            // Recursively process all parameters that might contain hex strings
+            const 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;
+            };
+            // Process the entire request body
+            const processed = processParams(parsed);
+            return JSON.stringify(processed, null, 2);
+        }
+        catch {
+            return body;
+        }
+    };
+    const truncateHexStringsInText = (text) => {
+        const hexRegex = /\b0x[a-fA-F0-9]{10,}/g;
+        return text.replace(hexRegex, hex => truncateHex(hex));
+    };
+    const extractAndFormatRequestBody = (message) => {
+        // 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 hexMatches = content.match(/0x[a-fA-F0-9]+/g) || [];
+                        let processedContent = content;
+                        hexMatches.forEach(hex => {
+                            processedContent = processedContent.replace(hex, truncateHex(hex));
+                        });
+                        return `${prefix} ${processedContent}`;
+                    }
+                }
+                return line;
+            });
+            return processedLines.join('\n');
+        });
+        // Finally, catch any remaining hex strings in the message
+        result = truncateHexStringsInText(result);
+        return result;
+    };
+    return JSON.stringify({ error: extractAndFormatRequestBody(error?.message || String(error)) }, null, 2).replace(/\\n/g, '\n');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "0.69.0-devnet",
+  "version": "0.69.1-devnet",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -29,11 +29,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/foundation": "0.69.0-devnet",
-    "@aztec/l1-artifacts": "0.69.0-devnet",
+    "@aztec/foundation": "0.69.1-devnet",
+    "@aztec/l1-artifacts": "0.69.1-devnet",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
-    "get-port": "^7.1.0",
     "tslib": "^2.4.0",
     "viem": "^2.7.15",
     "zod": "^3.23.8"

package/src/deploy_l1_contracts.ts

@@ -404,7 +404,7 @@ export const deployL1Contracts = async (
   logger.verbose(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
 
   const slashFactoryAddress = await deployer.deploy(l1Artifacts.slashFactory, [rollupAddress.toString()]);
-  logger.info(`Deployed SlashFactory at ${slashFactoryAddress}`);
+  logger.verbose(`Deployed SlashFactory at ${slashFactoryAddress}`);
 
   await deployer.waitForDeployments();
   logger.verbose(`All core contracts have been deployed`);
@@ -762,7 +762,7 @@ export async function deployL1Contract(
   } else {
     // Regular deployment path
     const deployData = encodeDeployData({ abi, bytecode, args });
-    const receipt = await l1TxUtils.sendAndMonitorTransaction({
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
       to: null,
       data: deployData,
     });

package/src/l1_tx_utils.ts

@@ -22,6 +22,8 @@ import {
   formatGwei,
 } from 'viem';
 
+import { formatViemError } from './utils.js';
+
 // 1_000_000_000 Gwei = 1 ETH
 // 1_000_000_000 Wei = 1 Gwei
 // 1_000_000_000_000_000_000 Wei = 1 ETH
@@ -30,7 +32,11 @@ const WEI_CONST = 1_000_000_000n;
 
 // setting a minimum bump percentage to 10% due to geth's implementation
 // https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
-const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10n;
+const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
+
+// setting a minimum bump percentage to 100% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
+const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
 
 // Avg ethereum block time is ~12s
 const BLOCK_TIME_MS = 12_000;
@@ -39,7 +45,7 @@ export interface L1TxUtilsConfig {
   /**
    * How much to increase calculated gas limit.
    */
-  gasLimitBufferPercentage?: bigint;
+  gasLimitBufferPercentage?: number;
   /**
    * Maximum gas price in gwei
    */
@@ -48,14 +54,22 @@ export interface L1TxUtilsConfig {
    * Minimum gas price in gwei
    */
   minGwei?: bigint;
+  /**
+   * Maximum blob fee per gas in gwei
+   */
+  maxBlobGwei?: bigint;
   /**
    * Priority fee bump percentage
    */
-  priorityFeeBumpPercentage?: bigint;
+  priorityFeeBumpPercentage?: number;
   /**
    * How much to increase priority fee by each attempt (percentage)
    */
-  priorityFeeRetryBumpPercentage?: bigint;
+  priorityFeeRetryBumpPercentage?: number;
+  /**
+   * Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage config
+   */
+  fixedPriorityFeePerGas?: number;
   /**
    * Maximum number of speed-up attempts
    */
@@ -83,7 +97,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   gasLimitBufferPercentage: {
     description: 'How much to increase gas price by each attempt (percentage)',
     env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-    ...bigintConfigHelper(20n),
+    ...numberConfigHelper(10),
   },
   minGwei: {
     description: 'Minimum gas price in gwei',
@@ -95,15 +109,25 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_GAS_PRICE_MAX',
     ...bigintConfigHelper(100n),
   },
+  maxBlobGwei: {
+    description: 'Maximum blob fee per gas in gwei',
+    env: 'L1_BLOB_FEE_PER_GAS_MAX',
+    ...bigintConfigHelper(1_500n),
+  },
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
     env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-    ...bigintConfigHelper(20n),
+    ...numberConfigHelper(20),
   },
   priorityFeeRetryBumpPercentage: {
     description: 'How much to increase priority fee by each retry attempt (percentage)',
     env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-    ...bigintConfigHelper(50n),
+    ...numberConfigHelper(50),
+  },
+  fixedPriorityFeePerGas: {
+    description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
+    env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
+    ...numberConfigHelper(0),
   },
   maxAttempts: {
     description: 'Maximum number of speed-up attempts',
@@ -118,7 +142,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   stallTimeMs: {
     description: 'How long before considering tx stalled',
     env: 'L1_TX_MONITOR_STALL_TIME_MS',
-    ...numberConfigHelper(30_000),
+    ...numberConfigHelper(45_000),
   },
   txTimeoutMs: {
     description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
@@ -143,12 +167,13 @@ export interface L1TxRequest {
 export interface L1BlobInputs {
   blobs: Uint8Array[];
   kzg: any;
-  maxFeePerBlobGas: bigint;
+  maxFeePerBlobGas?: bigint;
 }
 
-interface GasPrice {
+export interface GasPrice {
   maxFeePerGas: bigint;
   maxPriorityFeePerGas: bigint;
+  maxFeePerBlobGas?: bigint;
 }
 
 export class L1TxUtils {
@@ -174,37 +199,57 @@ export class L1TxUtils {
    */
   public async sendTransaction(
     request: L1TxRequest,
-    _gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint },
-    _blobInputs?: L1BlobInputs,
+    _gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint; txTimeoutAt?: Date },
+    blobInputs?: L1BlobInputs,
   ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
-    const gasConfig = { ...this.config, ..._gasConfig };
-    const account = this.walletClient.account;
-    let gasLimit: bigint;
-
-    if (gasConfig.fixedGas) {
-      gasLimit = gasConfig.fixedGas;
-    } else {
-      gasLimit = await this.estimateGas(account, request);
-    }
+    try {
+      const gasConfig = { ...this.config, ..._gasConfig };
+      const account = this.walletClient.account;
+      let gasLimit: bigint;
+
+      if (gasConfig.fixedGas) {
+        gasLimit = gasConfig.fixedGas;
+      } else {
+        gasLimit = await this.estimateGas(account, request);
+      }
 
-    const gasPrice = await this.getGasPrice(gasConfig);
+      const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-    const blobInputs = _blobInputs || {};
-    const txHash = await this.walletClient.sendTransaction({
-      ...request,
-      ...blobInputs,
-      gas: gasLimit,
-      maxFeePerGas: gasPrice.maxFeePerGas,
-      maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-    });
-
-    this.logger?.verbose(`Sent L1 transaction ${txHash}`, {
-      gasLimit,
-      maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
-      maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
-    });
+      if (gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime()) {
+        throw new Error('Transaction timed out before sending');
+      }
 
-    return { txHash, gasLimit, gasPrice };
+      let txHash: Hex;
+      if (blobInputs) {
+        txHash = await this.walletClient.sendTransaction({
+          ...request,
+          ...blobInputs,
+          gas: gasLimit,
+          maxFeePerGas: gasPrice.maxFeePerGas,
+          maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+          maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
+        });
+      } else {
+        txHash = await this.walletClient.sendTransaction({
+          ...request,
+          gas: gasLimit,
+          maxFeePerGas: gasPrice.maxFeePerGas,
+          maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+        });
+      }
+      this.logger?.verbose(`Sent L1 transaction ${txHash}`, {
+        gasLimit,
+        maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
+        maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
+        ...(gasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas) }),
+      });
+
+      return { txHash, gasLimit, gasPrice };
+    } catch (err: any) {
+      const formattedErr = formatViemError(err);
+      this.logger?.error(`Failed to send transaction`, formattedErr);
+      throw formattedErr;
+    }
   }
 
   /**
@@ -218,7 +263,7 @@ export class L1TxUtils {
     request: L1TxRequest,
     initialTxHash: Hex,
     params: { gasLimit: bigint },
-    _gasConfig?: Partial<L1TxUtilsConfig>,
+    _gasConfig?: Partial<L1TxUtilsConfig> & { txTimeoutAt?: Date },
     _blobInputs?: L1BlobInputs,
   ): Promise<TransactionReceipt> {
     const gasConfig = { ...this.config, ..._gasConfig };
@@ -246,7 +291,12 @@ export class L1TxUtils {
     let attempts = 0;
     let lastAttemptSent = Date.now();
     const initialTxTime = lastAttemptSent;
+
     let txTimedOut = false;
+    const isTimedOut = () =>
+      (gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime()) ||
+      (gasConfig.txTimeoutMs !== undefined && Date.now() - initialTxTime > gasConfig.txTimeoutMs) ||
+      false;
 
     while (!txTimedOut) {
       try {
@@ -284,11 +334,9 @@ export class L1TxUtils {
           this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
 
           // Check timeout before continuing
-          if (gasConfig.txTimeoutMs) {
-            txTimedOut = Date.now() - initialTxTime > gasConfig.txTimeoutMs;
-            if (txTimedOut) {
-              break;
-            }
+          txTimedOut = isTimedOut();
+          if (txTimedOut) {
+            break;
           }
 
           await sleep(gasConfig.checkIntervalMs!);
@@ -299,15 +347,25 @@ export class L1TxUtils {
           attempts++;
           const newGasPrice = await this.getGasPrice(
             gasConfig,
+            !!blobInputs,
             attempts,
             tx.maxFeePerGas && tx.maxPriorityFeePerGas
-              ? { maxFeePerGas: tx.maxFeePerGas, maxPriorityFeePerGas: tx.maxPriorityFeePerGas }
+              ? {
+                  maxFeePerGas: tx.maxFeePerGas,
+                  maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+                  maxFeePerBlobGas: tx.maxFeePerBlobGas,
+                }
               : undefined,
           );
 
           this.logger?.debug(
             `L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
               `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`,
+            {
+              maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
+              maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
+              ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
+            },
           );
 
           currentTxHash = await this.walletClient.sendTransaction({
@@ -324,16 +382,15 @@ export class L1TxUtils {
         }
         await sleep(gasConfig.checkIntervalMs!);
       } catch (err: any) {
-        this.logger?.warn(`Error monitoring tx ${currentTxHash}:`, err);
+        const formattedErr = formatViemError(err);
+        this.logger?.warn(`Error monitoring tx ${currentTxHash}:`, formattedErr);
         if (err.message?.includes('reverted')) {
-          throw err;
+          throw formattedErr;
         }
         await sleep(gasConfig.checkIntervalMs!);
       }
       // Check if tx has timed out.
-      if (gasConfig.txTimeoutMs) {
-        txTimedOut = Date.now() - initialTxTime > gasConfig.txTimeoutMs!;
-      }
+      txTimedOut = isTimedOut();
     }
     throw new Error(`L1 transaction ${currentTxHash} timed out`);
   }
@@ -346,11 +403,12 @@ export class L1TxUtils {
    */
   public async sendAndMonitorTransaction(
     request: L1TxRequest,
-    gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint },
+    gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint; txTimeoutAt?: Date },
     blobInputs?: L1BlobInputs,
-  ): Promise<TransactionReceipt> {
-    const { txHash, gasLimit } = await this.sendTransaction(request, gasConfig, blobInputs);
-    return this.monitorTransaction(request, txHash, { gasLimit }, gasConfig, blobInputs);
+  ): Promise<{ receipt: TransactionReceipt; gasPrice: GasPrice }> {
+    const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
+    const receipt = await this.monitorTransaction(request, txHash, { gasLimit }, gasConfig, blobInputs);
+    return { receipt, gasPrice };
   }
 
   /**
@@ -358,6 +416,7 @@ export class L1TxUtils {
    */
   private async getGasPrice(
     _gasConfig?: L1TxUtilsConfig,
+    isBlobTx: boolean = false,
     attempt: number = 0,
     previousGasPrice?: typeof attempt extends 0 ? never : GasPrice,
   ): Promise<GasPrice> {
@@ -365,26 +424,54 @@ export class L1TxUtils {
     const block = await this.publicClient.getBlock({ blockTag: 'latest' });
     const baseFee = block.baseFeePerGas ?? 0n;
 
-    // Get initial priority fee from the network
-    let priorityFee = await this.publicClient.estimateMaxPriorityFeePerGas();
+    // Get blob base fee if available
+    let blobBaseFee = 0n;
+    try {
+      const blobBaseFeeHex = await this.publicClient.request({ method: 'eth_blobBaseFee' });
+      blobBaseFee = BigInt(blobBaseFeeHex);
+      this.logger?.debug('Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
+    } catch {
+      this.logger?.warn('Failed to get blob base fee', attempt);
+    }
+
+    let priorityFee: bigint;
+    if (gasConfig.fixedPriorityFeePerGas) {
+      this.logger?.debug('Using fixed priority fee per gas', {
+        fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
+      });
+      // try to maintain precision up to 1000000 wei
+      priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
+    } else {
+      // Get initial priority fee from the network
+      priorityFee = await this.publicClient.estimateMaxPriorityFeePerGas();
+    }
     let maxFeePerGas = baseFee;
 
+    let maxFeePerBlobGas = blobBaseFee;
+
     // Bump base fee so it's valid for next blocks if it stalls
     const numBlocks = Math.ceil(gasConfig.stallTimeMs! / BLOCK_TIME_MS);
     for (let i = 0; i < numBlocks; i++) {
       // each block can go up 12.5% from previous baseFee
       maxFeePerGas = (maxFeePerGas * (1_000n + 125n)) / 1_000n;
+      // same for blob gas fee
+      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n)) / 1_000n;
     }
 
     if (attempt > 0) {
       const configBump =
         gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage!;
-      const bumpPercentage =
-        configBump > MIN_REPLACEMENT_BUMP_PERCENTAGE ? configBump : MIN_REPLACEMENT_BUMP_PERCENTAGE;
+
+      // if this is a blob tx, we have to use the blob bump percentage
+      const minBumpPercentage = isBlobTx ? MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE : MIN_REPLACEMENT_BUMP_PERCENTAGE;
+
+      const bumpPercentage = configBump > minBumpPercentage ? configBump : minBumpPercentage;
 
       // Calculate minimum required fees based on previous attempt
-      const minPriorityFee = (previousGasPrice!.maxPriorityFeePerGas * (100n + bumpPercentage)) / 100n;
-      const minMaxFee = (previousGasPrice!.maxFeePerGas * (100n + bumpPercentage)) / 100n;
+      // multiply by 100 & divide by 100 to maintain some precision
+      const minPriorityFee =
+        (previousGasPrice!.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
+      const minMaxFee = (previousGasPrice!.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
 
       // Add priority fee to maxFeePerGas
       maxFeePerGas += priorityFee;
@@ -393,8 +480,11 @@ export class L1TxUtils {
       priorityFee = priorityFee > minPriorityFee ? priorityFee : minPriorityFee;
       maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
     } else {
-      // first attempt, just bump priority fee
-      priorityFee = (priorityFee * (100n + (gasConfig.priorityFeeBumpPercentage || 0n))) / 100n;
+      // first attempt, just bump priority fee, unless it's a fixed config
+      // multiply by 100 & divide by 100 to maintain some precision
+      if (!gasConfig.fixedPriorityFeePerGas) {
+        priorityFee = (priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00))) / 100_00n;
+      }
       maxFeePerGas += priorityFee;
     }
 
@@ -402,17 +492,41 @@ export class L1TxUtils {
     const maxGweiInWei = gasConfig.maxGwei! * WEI_CONST;
     maxFeePerGas = maxFeePerGas > maxGweiInWei ? maxGweiInWei : maxFeePerGas;
 
+    // Ensure we don't exceed maxBlobGwei
+    if (maxFeePerBlobGas) {
+      const maxBlobGweiInWei = gasConfig.maxBlobGwei! * WEI_CONST;
+      maxFeePerBlobGas = maxFeePerBlobGas > maxBlobGweiInWei ? maxBlobGweiInWei : maxFeePerBlobGas;
+    }
+
     // Ensure priority fee doesn't exceed max fee
     const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
 
+    if (attempt > 0 && previousGasPrice?.maxFeePerBlobGas) {
+      const bumpPercentage =
+        gasConfig.priorityFeeRetryBumpPercentage! > MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE
+          ? gasConfig.priorityFeeRetryBumpPercentage!
+          : MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE;
+
+      // calculate min blob fee based on previous attempt
+      const minBlobFee = (previousGasPrice.maxFeePerBlobGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
+
+      // use max between current network values and min required values
+      maxFeePerBlobGas = maxFeePerBlobGas > minBlobFee ? maxFeePerBlobGas : minBlobFee;
+    }
+
     this.logger?.debug(`Computed gas price`, {
       attempt,
       baseFee: formatGwei(baseFee),
       maxFeePerGas: formatGwei(maxFeePerGas),
       maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
+      ...(maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(maxFeePerBlobGas) }),
     });
 
-    return { maxFeePerGas, maxPriorityFeePerGas };
+    return {
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      ...(maxFeePerBlobGas && { maxFeePerBlobGas: maxFeePerBlobGas }),
+    };
   }
 
   /**
@@ -430,14 +544,22 @@ export class L1TxUtils {
     // Strangely, the only way to get gas and send blobs is prepareTransactionRequest().
     // See: https://github.com/wevm/viem/issues/2075
     if (_blobInputs) {
-      initialEstimate = (await this.walletClient.prepareTransactionRequest({ account, ...request, ..._blobInputs }))
-        .gas;
+      const gasPrice = await this.getGasPrice(gasConfig, true, 0);
+      initialEstimate = (
+        await this.walletClient.prepareTransactionRequest({
+          account,
+          ...request,
+          ..._blobInputs,
+          maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
+        })
+      )?.gas;
     } else {
       initialEstimate = await this.publicClient.estimateGas({ account, ...request });
     }
 
     // Add buffer based on either fixed amount or percentage
-    const withBuffer = initialEstimate + (initialEstimate * (gasConfig.gasLimitBufferPercentage ?? 0n)) / 100n;
+    const withBuffer =
+      initialEstimate + (initialEstimate * BigInt((gasConfig.gasLimitBufferPercentage || 0) * 1_00)) / 100_00n;
 
     return withBuffer;
   }

package/src/test/start_anvil.ts

@@ -2,38 +2,47 @@ import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { fileURLToPath } from '@aztec/foundation/url';
 
 import { type Anvil, createAnvil } from '@viem/anvil';
-import getPort from 'get-port';
 import { dirname, resolve } from 'path';
 
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
 export async function startAnvil(l1BlockTime?: number): Promise<{ anvil: Anvil; rpcUrl: string }> {
-  let ethereumHostPort: number | undefined;
-
   const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
 
+  let port: number | undefined;
+
   // Start anvil.
   // We go via a wrapper script to ensure if the parent dies, anvil dies.
   const anvil = await retry(
     async () => {
-      ethereumHostPort = await getPort();
       const anvil = createAnvil({
         anvilBinary,
-        port: ethereumHostPort,
+        port: 0,
         blockTime: l1BlockTime,
+        stopTimeout: 1000,
+      });
+
+      // Listen to the anvil output to get the port.
+      const removeHandler = anvil.on('message', (message: string) => {
+        if (port === undefined && message.includes('Listening on')) {
+          port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)![2]);
+        }
       });
       await anvil.start();
+      removeHandler();
+
       return anvil;
     },
     'Start anvil',
     makeBackoff([5, 5, 5]),
   );
 
-  if (!ethereumHostPort) {
+  if (!port) {
     throw new Error('Failed to start anvil');
   }
 
-  const rpcUrl = `http://127.0.0.1:${ethereumHostPort}`;
-  return { anvil, rpcUrl };
+  // Monkeypatch the anvil instance to include the actually assigned port
+  Object.defineProperty(anvil, 'port', { value: port, writable: false });
+  return { anvil, rpcUrl: `http://127.0.0.1:${port}` };
 }