fix: blob fees

bootstrap.sh

@@ -203,6 +203,7 @@ case "$cmd" in
     image=aztecprotocol/aztec:$(git rev-parse HEAD)
     docker pull $image &>/dev/null || true
     if docker_has_image $image; then
+      echo "Image $image already exists and has been downloaded." && exit
       exit
     fi
     github_group "image-aztec"

yarn-project/ethereum/src/l1_tx_utils.test.ts

@@ -1,3 +1,4 @@
+import { Blob } from '@aztec/foundation/blob';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
@@ -106,8 +107,9 @@ describe('GasUtils', () => {
     await cheatCodes.setAutomine(false);
     await cheatCodes.setIntervalMining(0);
 
-    // Ensure initial base fee is low
-    await cheatCodes.setNextBlockBaseFeePerGas(initialBaseFee);
+    // Add blob data
+    const blobData = new Uint8Array(131072).fill(1);
+    const kzg = Blob.getViemKzgInstance();
 
     const request = {
       to: '0x1234567890123456789012345678901234567890' as `0x${string}`,
@@ -119,12 +121,16 @@ describe('GasUtils', () => {
 
     const originalMaxFeePerGas = WEI_CONST * 10n;
     const originalMaxPriorityFeePerGas = WEI_CONST;
+    const originalMaxFeePerBlobGas = WEI_CONST * 10n;
 
     const txHash = await walletClient.sendTransaction({
       ...request,
       gas: estimatedGas,
       maxFeePerGas: originalMaxFeePerGas,
       maxPriorityFeePerGas: originalMaxPriorityFeePerGas,
+      blobs: [blobData],
+      kzg,
+      maxFeePerBlobGas: originalMaxFeePerBlobGas,
     });
 
     const rawTx = await cheatCodes.getRawTransaction(txHash);
@@ -142,11 +148,12 @@ describe('GasUtils', () => {
       params: [rawTx],
     });
 
-    // keeping auto-mining disabled to simulate a stuck transaction
-    // The monitor should detect the stall and create a replacement tx
-
     // Monitor should detect stall and replace with higher gas price
-    const monitorFn = gasUtils.monitorTransaction(request, txHash, { gasLimit: estimatedGas });
+    const monitorFn = gasUtils.monitorTransaction(request, txHash, { gasLimit: estimatedGas }, undefined, {
+      blobs: [blobData],
+      kzg,
+      maxFeePerBlobGas: WEI_CONST * 20n,
+    });
 
     await sleep(2000);
     // re-enable mining
@@ -156,11 +163,12 @@ describe('GasUtils', () => {
     // Verify that a replacement transaction was created
     expect(receipt.transactionHash).not.toBe(txHash);
 
-    // Get details of replacement tx to verify higher gas price
+    // Get details of replacement tx to verify higher gas prices
     const replacementTx = await publicClient.getTransaction({ hash: receipt.transactionHash });
 
     expect(replacementTx.maxFeePerGas!).toBeGreaterThan(originalMaxFeePerGas);
     expect(replacementTx.maxPriorityFeePerGas!).toBeGreaterThan(originalMaxPriorityFeePerGas);
+    expect(replacementTx.maxFeePerBlobGas!).toBeGreaterThan(originalMaxFeePerBlobGas);
   }, 20_000);
 
   it('respects max gas price limits during spikes', async () => {
@@ -299,4 +307,52 @@ describe('GasUtils', () => {
     const expectedEstimate = baseEstimate + (baseEstimate * 20n) / 100n;
     expect(bufferedEstimate).toBe(expectedEstimate);
   });
+
+  it('correctly handles transactions with blobs', async () => {
+    // Create a sample blob
+    const blobData = new Uint8Array(131072).fill(1); // 128KB blob
+    const kzg = Blob.getViemKzgInstance();
+
+    const receipt = await gasUtils.sendAndMonitorTransaction(
+      {
+        to: '0x1234567890123456789012345678901234567890',
+        data: '0x',
+        value: 0n,
+      },
+      undefined,
+      {
+        blobs: [blobData],
+        kzg,
+        maxFeePerBlobGas: 10000000000n, // 10 gwei
+      },
+    );
+
+    expect(receipt.status).toBe('success');
+    expect(receipt.blobGasUsed).toBeDefined();
+    expect(receipt.blobGasPrice).toBeDefined();
+  }, 20_000);
+
+  it('estimates gas correctly for blob transactions', async () => {
+    // Create a sample blob
+    const blobData = new Uint8Array(131072).fill(1); // 128KB blob
+    const kzg = Blob.getViemKzgInstance();
+
+    const request = {
+      to: '0x1234567890123456789012345678901234567890' as `0x${string}`,
+      data: '0x' as `0x${string}`,
+      value: 0n,
+    };
+
+    // Estimate gas without blobs first
+    const baseEstimate = await gasUtils.estimateGas(walletClient.account!, request);
+
+    // Estimate gas with blobs
+    const blobEstimate = await gasUtils.estimateGas(walletClient.account!, request, undefined, {
+      blobs: [blobData],
+      kzg,
+      maxFeePerBlobGas: 10000000000n,
+    });
+    // Blob transactions should require more gas
+    expect(blobEstimate).toBeGreaterThan(baseEstimate);
+  }, 20_000);
 });

yarn-project/ethereum/src/l1_tx_utils.ts

@@ -32,6 +32,10 @@ const WEI_CONST = 1_000_000_000n;
 // https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
 const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10n;
 
+// 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 = 100n;
+
 // Avg ethereum block time is ~12s
 const BLOCK_TIME_MS = 12_000;
 
@@ -149,6 +153,7 @@ export interface L1BlobInputs {
 interface GasPrice {
   maxFeePerGas: bigint;
   maxPriorityFeePerGas: bigint;
+  maxFeePerBlobGas?: bigint;
 }
 
 export class L1TxUtils {
@@ -175,7 +180,7 @@ export class L1TxUtils {
   public async sendTransaction(
     request: L1TxRequest,
     _gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint },
-    _blobInputs?: L1BlobInputs,
+    blobInputs?: L1BlobInputs,
   ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
     const gasConfig = { ...this.config, ..._gasConfig };
     const account = this.walletClient.account;
@@ -189,15 +194,24 @@ export class L1TxUtils {
 
     const gasPrice = await this.getGasPrice(gasConfig);
 
-    const blobInputs = _blobInputs || {};
-    const txHash = await this.walletClient.sendTransaction({
-      ...request,
-      ...blobInputs,
-      gas: gasLimit,
-      maxFeePerGas: gasPrice.maxFeePerGas,
-      maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-    });
-
+    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),
@@ -301,7 +315,11 @@ export class L1TxUtils {
             gasConfig,
             attempts,
             tx.maxFeePerGas && tx.maxPriorityFeePerGas
-              ? { maxFeePerGas: tx.maxFeePerGas, maxPriorityFeePerGas: tx.maxPriorityFeePerGas }
+              ? {
+                  maxFeePerGas: tx.maxFeePerGas,
+                  maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+                  maxFeePerBlobGas: tx.maxFeePerBlobGas,
+                }
               : undefined,
           );
 
@@ -365,15 +383,29 @@ export class L1TxUtils {
     const block = await this.publicClient.getBlock({ blockTag: 'latest' });
     const baseFee = block.baseFeePerGas ?? 0n;
 
+    // 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);
+    }
+
     // Get initial priority fee from the network
     let 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) {
@@ -405,14 +437,32 @@ export class L1TxUtils {
     // 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 * (100n + bumpPercentage)) / 100n;
+
+      // 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 }),
+    };
   }
 
   /**