feat: blobs 2.

barretenberg/cpp/src/barretenberg/world_state/world_state.cpp

@@ -807,7 +807,7 @@ bb::fr WorldState::compute_initial_archive(const StateReference& initial_state_r
                               // last archive - which, at genesis, is all 0s
                               0,
                               0,
-                              // content commitment - at genesis all 0s
+                              // content commitment - all 0s
                               0,
                               0,
                               0,

l1-contracts/src/core/Rollup.sol

@@ -38,7 +38,6 @@ import {SafeERC20} from "@oz/token/ERC20/utils/SafeERC20.sol";
 import {EIP712} from "@oz/utils/cryptography/EIP712.sol";
 import {Math} from "@oz/utils/math/Math.sol";
 import {SafeCast} from "@oz/utils/math/SafeCast.sol";
-import {Vm} from "forge-std/Vm.sol";
 
 struct ChainTips {
   uint256 pendingBlockNumber;
@@ -64,6 +63,7 @@ struct SubmitEpochRootProofInterimValues {
  * @author Aztec Labs
  * @notice Rollup contract that is concerned about readability and velocity of development
  * not giving a damn about gas costs.
+ * @dev WARNING: This contract is VERY close to the size limit (500B at time of writing).
  */
 contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
   using SafeCast for uint256;
@@ -181,7 +181,7 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     });
     l1GasOracleValues = L1GasOracleValues({
       pre: L1FeeData({baseFee: 1 gwei, blobFee: 1}),
-      post: L1FeeData({baseFee: block.basefee, blobFee: _getBlobBaseFee()}),
+      post: L1FeeData({baseFee: block.basefee, blobFee: BlobLib.getBlobBaseFee(VM_ADDRESS)}),
       slotOfChange: LIFETIME
     });
     for (uint256 i = 0; i < _validators.length; i++) {
@@ -474,9 +474,15 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     bytes32 _blobsHash,
     DataStructures.ExecutionFlags memory _flags
   ) external view override(IRollup) {
-    uint256 manaBaseFee = getManaBaseFeeAt(_currentTime, true);
-    HeaderLib.Header memory header = HeaderLib.decode(_header);
-    _validateHeader(header, _signatures, _digest, _currentTime, manaBaseFee, _blobsHash, _flags);
+    _validateHeader(
+      HeaderLib.decode(_header),
+      _signatures,
+      _digest,
+      _currentTime,
+      getManaBaseFeeAt(_currentTime, true),
+      _blobsHash,
+      _flags
+    );
   }
 
   /**
@@ -588,8 +594,7 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     // TODO(#7218): Revert to fixed height tree for outbox, currently just providing min as interim
     // Min size = smallest path of the rollup tree + 1
     (uint256 min,) = MerkleLib.computeMinMaxPathLength(header.contentCommitment.numTxs);
-    uint256 l2ToL1TreeMinHeight = min + 1;
-    OUTBOX.insert(blockNumber, header.contentCommitment.outHash, l2ToL1TreeMinHeight);
+    OUTBOX.insert(blockNumber, header.contentCommitment.outHash, min + 1);
 
     emit L2BlockProposed(blockNumber, _args.archive);
 
@@ -628,7 +633,8 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     }
 
     l1GasOracleValues.pre = l1GasOracleValues.post;
-    l1GasOracleValues.post = L1FeeData({baseFee: block.basefee, blobFee: _getBlobBaseFee()});
+    l1GasOracleValues.post =
+      L1FeeData({baseFee: block.basefee, blobFee: BlobLib.getBlobBaseFee(VM_ADDRESS)});
     l1GasOracleValues.slotOfChange = slot + LAG;
   }
 
@@ -649,11 +655,9 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     override(IRollup)
     returns (L1FeeData memory)
   {
-    Slot slot = getSlotAt(_timestamp);
-    if (slot < l1GasOracleValues.slotOfChange) {
-      return l1GasOracleValues.pre;
-    }
-    return l1GasOracleValues.post;
+    return getSlotAt(_timestamp) < l1GasOracleValues.slotOfChange
+      ? l1GasOracleValues.pre
+      : l1GasOracleValues.post;
   }
 
   /**
@@ -699,8 +703,12 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
       -int256(FeeMath.MANA_TARGET)
     );
 
-    uint256 dataCost =
-      Math.mulDiv(3 * BLOB_GAS_PER_BLOB, getL1FeesAt(_timestamp).blobFee, FeeMath.MANA_TARGET, Math.Rounding.Ceil);
+    uint256 dataCost = Math.mulDiv(
+      3 * BLOB_GAS_PER_BLOB,
+      getL1FeesAt(_timestamp).blobFee,
+      FeeMath.MANA_TARGET,
+      Math.Rounding.Ceil
+    );
     uint256 gasUsed = FeeMath.L1_GAS_PER_BLOCK_PROPOSED + 3 * GAS_PER_BLOB_POINT_EVALUATION
       + FeeMath.L1_GAS_PER_EPOCH_VERIFIED / EPOCH_DURATION;
     uint256 gasCost =
@@ -1029,10 +1037,7 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
    * @return bytes32 - The archive root of the block
    */
   function archiveAt(uint256 _blockNumber) public view override(IRollup) returns (bytes32) {
-    if (_blockNumber <= tips.pendingBlockNumber) {
-      return blocks[_blockNumber].archive;
-    }
-    return bytes32(0);
+    return _blockNumber <= tips.pendingBlockNumber ? blocks[_blockNumber].archive : bytes32(0);
   }
 
   function canPrune() public view override(IRollup) returns (bool) {
@@ -1244,15 +1249,14 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
     returns (BlockLog memory)
   {
     FeeHeader memory parentFeeHeader = blocks[_blockNumber - 1].feeHeader;
-    uint256 excessMana = (parentFeeHeader.excessMana + parentFeeHeader.manaUsed).clampedAdd(
-      -int256(FeeMath.MANA_TARGET)
-    );
     return BlockLog({
       archive: _args.archive,
       blockHash: _args.blockHash,
       slotNumber: Slot.wrap(uint256(bytes32(_args.header[0x0194:0x01b4]))),
       feeHeader: FeeHeader({
-        excessMana: excessMana,
+        excessMana: (parentFeeHeader.excessMana + parentFeeHeader.manaUsed).clampedAdd(
+          -int256(FeeMath.MANA_TARGET)
+        ),
         feeAssetPriceNumerator: parentFeeHeader.feeAssetPriceNumerator.clampedAdd(
           _args.oracleInput.feeAssetPriceModifier
         ),
@@ -1283,19 +1287,4 @@ contract Rollup is EIP712("Aztec Rollup", "1"), Leonidas, IRollup, ITestRollup {
       }
     }
   }
-
-  /**
-   * @notice  Get the blob base fee
-   *
-   * @dev     If we are in a foundry test, we use the cheatcode to get the blob base fee.
-   *          Otherwise, we use the `block.blobbasefee`
-   *
-   * @return uint256 - The blob base fee
-   */
-  function _getBlobBaseFee() private view returns (uint256) {
-    if (IS_FOUNDRY_TEST) {
-      return Vm(VM_ADDRESS).getBlobBaseFee();
-    }
-    return block.blobbasefee;
-  }
 }

l1-contracts/src/core/libraries/BlobLib.sol

@@ -4,48 +4,34 @@ pragma solidity >=0.8.27;
 
 import {Hash} from "@aztec/core/libraries/crypto/Hash.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
+import {Vm} from "forge-std/Vm.sol";
 
 library BlobLib {
   /**
-   * @notice  Validate a blob.
-   * Input bytes:
-   * input[:32]     - versioned_hash
-   * input[32:64]   - z
-   * input[64:96]   - y
-   * input[96:144]  - commitment C
-   * input[144:192] - proof (a commitment to the quotient polynomial q(X))
-   *  - This can be relaxed to happen at the time of `submitProof` instead
-   * @notice Apparently there is no guarantee that the blobs will be processed in the order sent
-   * so the use of blobhash(_blobNumber) may fail in production
-   * @param _blobInput - The above bytes to verify a blob
+   * @notice  Get the blob base fee
+   *
+   * @dev     If we are in a foundry test, we use the cheatcode to get the blob base fee.
+   *          Otherwise, we use the `block.blobbasefee`
+   *
+   * @return uint256 - The blob base fee
    */
-  function validateBlob(bytes calldata _blobInput, uint256 _blobNumber, bool _checkBlob)
-    internal
-    view
-    returns (bytes32 blobHash)
-  {
-    if (!_checkBlob) {
-      return bytes32(_blobInput[0:32]);
+  function getBlobBaseFee(address _vmAddress) public view returns (uint256) {
+    if (_vmAddress.code.length > 0) {
+      return Vm(_vmAddress).getBlobBaseFee();
     }
-    assembly {
-      blobHash := blobhash(_blobNumber)
-    }
-    require(blobHash == bytes32(_blobInput[0:32]), Errors.Rollup__InvalidBlobHash(blobHash));
-
-    // Staticcall the point eval precompile https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile :
-    (bool success,) = address(0x0a).staticcall(_blobInput);
-    require(success, Errors.Rollup__InvalidBlobProof(blobHash));
+    return block.blobbasefee;
   }
 
   /**
    * @notice  Validate an L2 block's blobs and return the hashed blobHashes and public inputs.
    * Input bytes:
    * input[:1] - num blobs in block
    * input[1:] - 192 * num blobs of the above _blobInput
+   * @dev Marked as public to reduce Rollup.sol contract size
    * @param _blobsInput - The above bytes to verify a blob
    */
   function validateBlobs(bytes calldata _blobsInput, bool _checkBlob)
-    internal
+    public
     view
     returns (bytes32 blobsHash, bytes32 blobPublicInputsHash)
   {
@@ -74,13 +60,44 @@ library BlobLib {
     blobsHash = Hash.sha256ToField(abi.encodePacked(blobHashes));
   }
 
+  /**
+   * @notice  Validate a blob.
+   * Input bytes:
+   * input[:32]     - versioned_hash
+   * input[32:64]   - z
+   * input[64:96]   - y
+   * input[96:144]  - commitment C
+   * input[144:192] - proof (a commitment to the quotient polynomial q(X))
+   *  - This can be relaxed to happen at the time of `submitProof` instead
+   * @notice Apparently there is no guarantee that the blobs will be processed in the order sent
+   * so the use of blobhash(_blobNumber) may fail in production
+   * @param _blobInput - The above bytes to verify a blob
+   */
+  function validateBlob(bytes calldata _blobInput, uint256 _blobNumber, bool _checkBlob)
+    internal
+    view
+    returns (bytes32 blobHash)
+  {
+    if (!_checkBlob) {
+      return bytes32(_blobInput[0:32]);
+    }
+    assembly {
+      blobHash := blobhash(_blobNumber)
+    }
+    require(blobHash == bytes32(_blobInput[0:32]), Errors.Rollup__InvalidBlobHash(blobHash));
+
+    // Staticcall the point eval precompile https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile :
+    (bool success,) = address(0x0a).staticcall(_blobInput);
+    require(success, Errors.Rollup__InvalidBlobProof(blobHash));
+  }
+
   /**
    * @notice  Converts a BLS12 field element from bytes32 to a nr BigNum type
    * The nr bignum type for BLS12 fields is encoded as 3 nr fields - see blob_public_inputs.ts:
    * firstLimb = last 15 bytes;
    * secondLimb = bytes 2 -> 17;
    * thirdLimb = first 2 bytes;
-   * Used when verifying epoch proofs to gather public inputs.
+   * Used when verifying epoch proofs to gather blob specific public inputs.
    * @param _input - The field in bytes32
    */
   function bytes32ToBigNum(bytes32 _input)

l1-contracts/src/core/libraries/HeaderLib.sol

@@ -110,10 +110,11 @@ library HeaderLib {
 
   /**
    * @notice Decodes the header
+   * @dev Marked as public to reduce Rollup.sol contract size
    * @param _header - The header calldata
    * @return The decoded header
    */
-  function decode(bytes calldata _header) internal pure returns (Header memory) {
+  function decode(bytes calldata _header) public pure returns (Header memory) {
     require(
       _header.length == HEADER_LENGTH,
       Errors.HeaderLib__InvalidHeaderSize(HEADER_LENGTH, _header.length)

l1-contracts/src/core/libraries/crypto/MerkleLib.sol

@@ -11,6 +11,45 @@ import {Errors} from "@aztec/core/libraries/Errors.sol";
  * @notice Library that contains functions useful when interacting with Merkle Trees
  */
 library MerkleLib {
+  /**
+   * @notice Computes the minimum and maximum path size of an unbalanced tree.
+   * @dev Follows structure of rollup circuits by greedy filling subtrees.
+   * @dev Marked as public to reduce Rollup.sol contract size
+   * @param _numTxs - The number of txs to form into subtrees.
+   * @return (min, max) - The min and max path sizes.
+   */
+  function computeMinMaxPathLength(uint256 _numTxs) public pure returns (uint256, uint256) {
+    uint256 numTxs = _numTxs < 2 ? 2 : _numTxs;
+    uint256 numSubtrees = 0;
+    uint256 currentSubtreeSize = 1;
+    uint256 currentSubtreeHeight = 0;
+    uint256 firstSubtreeHeight;
+    uint256 finalSubtreeHeight;
+    while (numTxs != 0) {
+      // If size & txs == 0, the subtree doesn't exist for this number of txs
+      if (currentSubtreeSize & numTxs == 0) {
+        currentSubtreeSize <<= 1;
+        currentSubtreeHeight++;
+        continue;
+      }
+      // Assign the smallest rightmost subtree height
+      if (numSubtrees == 0) finalSubtreeHeight = currentSubtreeHeight;
+      // Assign the largest leftmost subtree height
+      if (numTxs - currentSubtreeSize == 0) firstSubtreeHeight = currentSubtreeHeight;
+      numTxs -= currentSubtreeSize;
+      currentSubtreeSize <<= 1;
+      currentSubtreeHeight++;
+      numSubtrees++;
+    }
+    if (numSubtrees == 1) {
+      // We have a balanced tree
+      return (firstSubtreeHeight, firstSubtreeHeight);
+    }
+    uint256 min = finalSubtreeHeight + numSubtrees - 1;
+    uint256 max = firstSubtreeHeight + 1;
+    return (min, max);
+  }
+
   /**
    * @notice Verifies the membership of a leaf and path against an expected root.
    * @dev In the case of a mismatched root, and subsequent inability to verify membership, this function throws.
@@ -53,44 +92,6 @@ library MerkleLib {
     );
   }
 
-  /**
-   * @notice Computes the minimum and maximum path size of an unbalanced tree.
-   * @dev Follows structure of rollup circuits by greedy filling subtrees.
-   * @param _numTxs - The number of txs to form into subtrees.
-   * @return (min, max) - The min and max path sizes.
-   */
-  function computeMinMaxPathLength(uint256 _numTxs) internal pure returns (uint256, uint256) {
-    uint256 numTxs = _numTxs < 2 ? 2 : _numTxs;
-    uint256 numSubtrees = 0;
-    uint256 currentSubtreeSize = 1;
-    uint256 currentSubtreeHeight = 0;
-    uint256 firstSubtreeHeight;
-    uint256 finalSubtreeHeight;
-    while (numTxs != 0) {
-      // If size & txs == 0, the subtree doesn't exist for this number of txs
-      if (currentSubtreeSize & numTxs == 0) {
-        currentSubtreeSize <<= 1;
-        currentSubtreeHeight++;
-        continue;
-      }
-      // Assign the smallest rightmost subtree height
-      if (numSubtrees == 0) finalSubtreeHeight = currentSubtreeHeight;
-      // Assign the largest leftmost subtree height
-      if (numTxs - currentSubtreeSize == 0) firstSubtreeHeight = currentSubtreeHeight;
-      numTxs -= currentSubtreeSize;
-      currentSubtreeSize <<= 1;
-      currentSubtreeHeight++;
-      numSubtrees++;
-    }
-    if (numSubtrees == 1) {
-      // We have a balanced tree
-      return (firstSubtreeHeight, firstSubtreeHeight);
-    }
-    uint256 min = finalSubtreeHeight + numSubtrees - 1;
-    uint256 max = firstSubtreeHeight + 1;
-    return (min, max);
-  }
-
   /**
    * @notice Calculates a tree height from the amount of elements in the tree
    * @dev - This mirrors the function in TestUtil, but assumes _size is an exact power of 2 or = 1

l1-contracts/test/fees/FeeRollup.t.sol

@@ -230,7 +230,7 @@ contract FeeRollupTest is FeeModelTestPoints, DecoderBase {
       if (rollup.getCurrentSlot() == nextSlot) {
         TestPoint memory point = points[nextSlot.unwrap() - 1];
         Block memory b = getBlock();
-
+        skipBlobCheck(address(rollup));
         rollup.propose(
           ProposeArgs({
             header: b.header,
@@ -243,7 +243,8 @@ contract FeeRollupTest is FeeModelTestPoints, DecoderBase {
             txHashes: b.txHashes
           }),
           b.signatures,
-          b.body
+          b.body,
+          b.blobInputs
         );
         nextSlot = nextSlot + Slot.wrap(1);
       }

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

@@ -22,7 +22,6 @@ export async function startAnvil(l1BlockTime?: number): Promise<{ anvil: Anvil;
         anvilBinary,
         port: ethereumHostPort,
         blockTime: l1BlockTime,
-        codeSizeLimit: 0x7000,
       });
       await anvil.start();
       return anvil;