chore: update proving cost changes (#13833)

Fixes #13600. 


Accompanying update tohe engineering design in
AztecProtocol/engineering-designs#59

The diff looks very large, but is mostly because we generated a new
fixture structure.

Author: LHerskind

l1-contracts/src/core/libraries/rollup/EpochProofLib.sol

@@ -296,7 +296,7 @@ library EpochProofLib {
         t.totalBurn += burn;
 
         // Compute the proving fee in the fee asset
-        v.proverFee = Math.min(v.manaUsed * feeHeader.getProvingCost(), fee - burn);
+        v.proverFee = Math.min(v.manaUsed * feeHeader.getProverCost(), fee - burn);
         $er.rewards += v.proverFee;
 
         v.sequencerFee = fee - burn - v.proverFee;

l1-contracts/src/core/libraries/rollup/FeeLib.sol

@@ -38,17 +38,16 @@ struct OracleInput {
 struct ManaBaseFeeComponents {
   uint256 congestionCost;
   uint256 congestionMultiplier;
-  uint256 dataCost;
-  uint256 gasCost;
-  uint256 provingCost;
+  uint256 sequencerCost;
+  uint256 proverCost;
 }
 
 struct FeeHeader {
   uint256 excessMana;
   uint256 manaUsed;
   uint256 feeAssetPriceNumerator;
   uint256 congestionCost;
-  uint256 provingCost;
+  uint256 proverCost;
 }
 
 struct L1FeeData {
@@ -113,7 +112,7 @@ library PriceLib {
 
 struct CompressedFeeHeader {
   uint64 congestionCost;
-  uint64 provingCost;
+  uint64 proverCost;
   uint48 feeAssetPriceNumerator;
   uint48 excessMana;
   uint32 manaUsed;
@@ -138,12 +137,12 @@ library FeeHeaderLib {
     return _compressedFeeHeader.congestionCost;
   }
 
-  function getProvingCost(CompressedFeeHeader storage _compressedFeeHeader)
+  function getProverCost(CompressedFeeHeader storage _compressedFeeHeader)
     internal
     view
     returns (uint256)
   {
-    return _compressedFeeHeader.provingCost;
+    return _compressedFeeHeader.proverCost;
   }
 
   function compress(FeeHeader memory _feeHeader) internal pure returns (CompressedFeeHeader memory) {
@@ -152,7 +151,7 @@ library FeeHeaderLib {
       manaUsed: _feeHeader.manaUsed.toUint32(),
       feeAssetPriceNumerator: _feeHeader.feeAssetPriceNumerator.toUint48(),
       congestionCost: _feeHeader.congestionCost.toUint64(),
-      provingCost: _feeHeader.provingCost.toUint64()
+      proverCost: _feeHeader.proverCost.toUint64()
     });
   }
 
@@ -166,7 +165,7 @@ library FeeHeaderLib {
       manaUsed: _compressedFeeHeader.manaUsed,
       feeAssetPriceNumerator: _compressedFeeHeader.feeAssetPriceNumerator,
       congestionCost: _compressedFeeHeader.congestionCost,
-      provingCost: _compressedFeeHeader.provingCost
+      proverCost: _compressedFeeHeader.proverCost
     });
   }
 }
@@ -209,7 +208,7 @@ library FeeLib {
       feeAssetPriceNumerator: 0,
       manaUsed: 0,
       congestionCost: 0,
-      provingCost: 0
+      proverCost: 0
     }).compress();
 
     feeStore.l1GasOracleValues = L1GasOracleValues({
@@ -231,7 +230,7 @@ library FeeLib {
     int256 _feeAssetPriceModifier,
     uint256 _manaUsed,
     uint256 _congestionCost,
-    uint256 _provingCost
+    uint256 _proverCost
   ) internal {
     require(
       SignedMath.abs(_feeAssetPriceModifier) <= MAX_FEE_ASSET_PRICE_MODIFIER,
@@ -246,7 +245,7 @@ library FeeLib {
       ),
       manaUsed: _manaUsed,
       congestionCost: _congestionCost,
-      provingCost: _provingCost
+      proverCost: _proverCost
     }).compress();
   }
 
@@ -285,30 +284,49 @@ library FeeLib {
 
     if (manaTarget == 0) {
       return ManaBaseFeeComponents({
-        dataCost: 0,
-        gasCost: 0,
-        provingCost: 0,
+        sequencerCost: 0,
+        proverCost: 0,
         congestionCost: 0,
         congestionMultiplier: 0
       });
     }
 
-    EthValue gasCostPerMana;
-    EthValue dataCostPerMana;
+    EthValue sequencerCostPerMana;
+    EthValue proverCostPerMana;
     EthValue total;
-    {
-      uint256 gasUsed = L1_GAS_PER_BLOCK_PROPOSED + BLOBS_PER_BLOCK * GAS_PER_BLOB_POINT_EVALUATION
-        + L1_GAS_PER_EPOCH_VERIFIED / TimeLib.getStorage().epochDuration;
 
+    {
       L1FeeData memory fees = FeeLib.getL1FeesAt(_timestamp);
-      gasCostPerMana =
-        EthValue.wrap(Math.mulDiv(gasUsed, fees.baseFee, manaTarget, Math.Rounding.Ceil));
-      dataCostPerMana = EthValue.wrap(
-        Math.mulDiv(
-          BLOBS_PER_BLOCK * BLOB_GAS_PER_BLOB, fees.blobFee, manaTarget, Math.Rounding.Ceil
-        )
-      );
-      total = dataCostPerMana + gasCostPerMana + feeStore.provingCostPerMana;
+
+      // Sequencer cost per mana
+      {
+        uint256 gasUsed =
+          L1_GAS_PER_BLOCK_PROPOSED + BLOBS_PER_BLOCK * GAS_PER_BLOB_POINT_EVALUATION;
+        uint256 ethUsed = gasUsed * fees.baseFee;
+        ethUsed += (BLOBS_PER_BLOCK * BLOB_GAS_PER_BLOB * fees.blobFee);
+
+        sequencerCostPerMana =
+          EthValue.wrap(Math.mulDiv(ethUsed, 1, manaTarget, Math.Rounding.Ceil));
+      }
+
+      // Prover cost per mana
+      {
+        proverCostPerMana = EthValue.wrap(
+          Math.mulDiv(
+            Math.mulDiv(
+              L1_GAS_PER_EPOCH_VERIFIED,
+              fees.baseFee,
+              TimeLib.getStorage().epochDuration,
+              Math.Rounding.Ceil
+            ),
+            1,
+            manaTarget,
+            Math.Rounding.Ceil
+          )
+        ) + feeStore.provingCostPerMana;
+      }
+
+      total = sequencerCostPerMana + proverCostPerMana;
     }
 
     CompressedFeeHeader storage parentFeeHeader = feeStore.feeHeaders[_blockOfInterest];
@@ -329,9 +347,8 @@ library FeeLib {
       _inFeeAsset ? FeeLib.getFeeAssetPerEthAtBlock(_blockOfInterest) : FeeAssetPerEthE9.wrap(1e9);
 
     return ManaBaseFeeComponents({
-      dataCost: FeeAssetValue.unwrap(dataCostPerMana.toFeeAsset(feeAssetPrice)),
-      gasCost: FeeAssetValue.unwrap(gasCostPerMana.toFeeAsset(feeAssetPrice)),
-      provingCost: FeeAssetValue.unwrap(feeStore.provingCostPerMana.toFeeAsset(feeAssetPrice)),
+      sequencerCost: FeeAssetValue.unwrap(sequencerCostPerMana.toFeeAsset(feeAssetPrice)),
+      proverCost: FeeAssetValue.unwrap(proverCostPerMana.toFeeAsset(feeAssetPrice)),
       congestionCost: FeeAssetValue.unwrap(congestionCost.toFeeAsset(feeAssetPrice)),
       congestionMultiplier: congestionMultiplier_
     });
@@ -369,8 +386,7 @@ library FeeLib {
   }
 
   function summedBaseFee(ManaBaseFeeComponents memory _components) internal pure returns (uint256) {
-    return _components.dataCost + _components.gasCost + _components.provingCost
-      + _components.congestionCost;
+    return _components.sequencerCost + _components.proverCost + _components.congestionCost;
   }
 
   function getStorage() internal pure returns (FeeStore storage storageStruct) {

l1-contracts/src/core/libraries/rollup/ProposeLib.sol

@@ -138,7 +138,7 @@ library ProposeLib {
       _args.oracleInput.feeAssetPriceModifier,
       header.totalManaUsed,
       components.congestionCost,
-      components.provingCost
+      components.proverCost
     );
 
     rollupStore.blobPublicInputsHashes[blockNumber] = v.blobPublicInputsHash;

l1-contracts/test/Rollup.t.sol

@@ -38,6 +38,7 @@ import {IERC20} from "@oz/token/ERC20/IERC20.sol";
 import {
   Timestamp, Slot, Epoch, SlotLib, EpochLib, TimeLib
 } from "@aztec/core/libraries/TimeLib.sol";
+import {FeeLib, L1_GAS_PER_EPOCH_VERIFIED} from "@aztec/core/libraries/rollup/FeeLib.sol";
 
 import {RollupBase, IInstance} from "./base/RollupBase.sol";
 import {stdStorage, StdStorage} from "forge-std/StdStorage.sol";
@@ -357,8 +358,38 @@ contract RollupTest is RollupBase {
     _proveBlocks("mixed_block_", 1, 2, address(this));
 
     // 1e6 mana at 1000 and 2000 cost per manage multiplied by 10 for the price conversion to fee asset.
-    uint256 provingFees = 1e6 * (1000 + 2000) * 10;
-    uint256 expectedProverRewards = rewardDistributor.BLOCK_REWARD() / 2 * 2 + provingFees;
+    uint256 proverFees = 1e6 * (1000 + 2000);
+    // Then we also need the component that is for covering the gas
+    proverFees += (
+      Math.mulDiv(
+        Math.mulDiv(
+          L1_GAS_PER_EPOCH_VERIFIED,
+          rollup.getL1FeesAt(rollup.getTimestampForSlot(Slot.wrap(1))).baseFee,
+          rollup.getEpochDuration(),
+          Math.Rounding.Ceil
+        ),
+        1,
+        rollup.getManaTarget(),
+        Math.Rounding.Ceil
+      ) * 1e6
+    );
+
+    proverFees += (
+      Math.mulDiv(
+        Math.mulDiv(
+          L1_GAS_PER_EPOCH_VERIFIED,
+          rollup.getL1FeesAt(rollup.getTimestampForSlot(Slot.wrap(2))).baseFee,
+          rollup.getEpochDuration(),
+          Math.Rounding.Ceil
+        ),
+        1,
+        rollup.getManaTarget(),
+        Math.Rounding.Ceil
+      ) * 1e6
+    );
+    proverFees *= 10; // the price conversion
+
+    uint256 expectedProverRewards = rewardDistributor.BLOCK_REWARD() / 2 * 2 + proverFees;
 
     assertEq(
       rollup.getCollectiveProverRewardsForEpoch(Epoch.wrap(0)),

l1-contracts/test/benchmark/happy.t.sol

@@ -155,7 +155,7 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
         slashingQuorum: TestConstants.AZTEC_SLASHING_QUORUM,
         slashingRoundSize: TestConstants.AZTEC_SLASHING_ROUND_SIZE,
         manaTarget: MANA_TARGET,
-        provingCostPerMana: TestConstants.AZTEC_PROVING_COST_PER_MANA
+        provingCostPerMana: provingCost
       })
     );
     fakeCanonical.setCanonicalRollup(address(rollup));
@@ -306,10 +306,6 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
     Slot nextSlot = Slot.wrap(EPOCH_DURATION + 1);
     Epoch nextEpoch = Epoch.wrap(2);
 
-    rollup.setProvingCostPerMana(
-      EthValue.wrap(points[0].outputs.mana_base_fee_components_in_wei.proving_cost)
-    );
-
     // Loop through all of the L1 metadata
     for (uint256 i = 0; i < l1Metadata.length; i++) {
       if (rollup.getPendingBlockNumber() >= 100) {
@@ -323,9 +319,6 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
       // will be accepted as a proposal so very useful for testing a long range of blocks.
       if (rollup.getCurrentSlot() == nextSlot) {
         TestPoint memory point = points[nextSlot.unwrap() - 1];
-        rollup.setProvingCostPerMana(
-          EthValue.wrap(point.outputs.mana_base_fee_components_in_wei.proving_cost)
-        );
 
         Block memory b = getBlock();
         address proposer = rollup.getCurrentProposer();

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

@@ -7,7 +7,8 @@ import {TestBase} from "../base/Base.sol";
 import {OracleInput} from "@aztec/core/libraries/rollup/FeeLib.sol";
 import {
   MAX_FEE_ASSET_PRICE_MODIFIER,
-  MINIMUM_CONGESTION_MULTIPLIER
+  MINIMUM_CONGESTION_MULTIPLIER,
+  EthValue
 } from "@aztec/core/libraries/rollup/FeeLib.sol";
 import {Math} from "@oz/utils/math/Math.sol";
 
@@ -47,9 +48,8 @@ struct L1GasOracleValuesModel {
 struct ManaBaseFeeComponentsModel {
   uint256 congestion_cost;
   uint256 congestion_multiplier;
-  uint256 data_cost;
-  uint256 gas_cost;
-  uint256 proving_cost;
+  uint256 prover_cost;
+  uint256 sequencer_cost;
 }
 
 struct BlockHeaderModel {
@@ -81,11 +81,13 @@ struct TestPoint {
 struct FullFeeData {
   L1Metadata[] l1_metadata;
   TestPoint[] points;
+  uint256 proving_cost;
 }
 
 contract FeeModelTestPoints is TestBase {
   L1Metadata[] public l1Metadata;
   TestPoint[] public points;
+  EthValue public provingCost;
 
   constructor() {
     string memory root = vm.projectRoot();
@@ -101,6 +103,8 @@ contract FeeModelTestPoints is TestBase {
     for (uint256 i = 0; i < data.points.length; i++) {
       points.push(data.points[i]);
     }
+
+    provingCost = EthValue.wrap(data.proving_cost);
   }
 
   function assertEq(L1FeesModel memory a, L1FeesModel memory b) internal pure {
@@ -149,8 +153,9 @@ contract FeeModelTestPoints is TestBase {
       b.congestion_multiplier,
       string.concat(_message, " congestion_multiplier mismatch")
     );
-    assertEq(a.data_cost, b.data_cost, string.concat(_message, " data_cost mismatch"));
-    assertEq(a.gas_cost, b.gas_cost, string.concat(_message, " gas_cost mismatch"));
-    assertEq(a.proving_cost, b.proving_cost, string.concat(_message, " proving_cost mismatch"));
+    assertEq(a.prover_cost, b.prover_cost, string.concat(_message, " prover_cost mismatch"));
+    assertEq(
+      a.sequencer_cost, b.sequencer_cost, string.concat(_message, " sequencer_cost mismatch")
+    );
   }
 }