feat: Update PDP proof fee (#214)

* feat: Update PDP proof fee

* feat: make PDP fee calc use verifier-managed rate; stateless Fees.sol; update interfaces/tests

* feat(pdp): address review feedback for FIL-based fee update

-Remove manual apply; auto-apply new fee on read paths after delay
-Commit any elapsed pending update in updateProofFee to avoid “reset”
-Use transitionTime > 0 check (supports proposed fee = 0)
-Pack fee fields into FeeStatus and expose only views (uint96)
-Shift-based TiB conversion in PDPFees: (feePerTiB * rawSize) >> 40
-Trim IPDPVerifier to feePerTiB() only; drop mutation endpoints
-Update tests to use getters and verify delayed auto-apply

* Update src/PDPVerifier.sol

* Update src/PDPVerifier.sol

* Update src/PDPVerifier.sol

* Update src/PDPVerifier.sol

* Update src/PDPVerifier.sol

* Update src/PDPVerifier.sol

---------

Co-authored-by: William Morriss <[email protected]>

Author: Chaitu-Tatipamula

src/Fees.sol

@@ -10,68 +10,23 @@ library PDPFees {
     // 0.1 FIL
     uint256 constant SYBIL_FEE = FIL_TO_ATTO_FIL / 10;
 
-    // 2 USD/Tib/month is the current reward earned by Storage Providers
-    uint256 constant ESTIMATED_MONTHLY_TIB_STORAGE_REWARD_USD = 2;
-    // 1% of reward per period
-    uint256 constant PROOF_FEE_PERCENTAGE = 1;
-    // 4% of reward per period for gas limit left bound
-    uint256 constant GAS_LIMIT_LEFT_PERCENTAGE = 4;
-    // 5% of reward per period for gas limit right bound
-    uint256 constant GAS_LIMIT_RIGHT_PERCENTAGE = 5;
-    uint256 constant USD_DECIMALS = 1e18;
+    // Default FIL-based proof fee: 0.00023 FIL per TiB (used for initialization)
+    // Based on: 0.00067 USD per TiB / 2.88 USD per FIL = 0.00023 FIL per TiB
+    uint96 constant DEFAULT_FEE_PER_TIB = 230000 gwei; // 0.00023 FIL in attoFIL
 
     // 1 TiB in bytes (2^40)
     uint256 constant TIB_IN_BYTES = 2 ** 40;
-    // Number of epochs per month (30 days * 2880 epochs per day)
-    uint256 constant EPOCHS_PER_MONTH = 86400;
 
-    /// @notice Calculates the proof fee based on the gas fee and the raw size of the proof.
-    /// @param estimatedGasFee The estimated gas fee in AttoFIL.
-    /// @param filUsdPrice The price of FIL in USD.
-    /// @param filUsdPriceExpo The exponent of the price of FIL in USD.
+    /// @notice Calculates the proof fee based on the dataset size and a provided per-TiB fee.
     /// @param rawSize The raw size of the proof in bytes.
-    /// @param nProofEpochs The number of proof epochs.
+    /// @param feePerTiB The fee rate per TiB in AttoFIL (source of truth lives in PDPVerifier).
     /// @return proof fee in AttoFIL
-    /// @dev The proof fee is calculated based on the gas fee and the raw size of the proof
-    /// The fee is 1% of the projected reward and is reduced in the case gas cost of proving is too high.
-    function proofFeeWithGasFeeBound(
-        uint256 estimatedGasFee, // in AttoFIL
-        uint64 filUsdPrice,
-        int32 filUsdPriceExpo,
-        uint256 rawSize,
-        uint256 nProofEpochs
-    ) internal view returns (uint256) {
-        require(
-            estimatedGasFee > 0 || block.basefee == 0, "failed to validate: estimated gas fee must be greater than 0"
-        );
-        require(filUsdPrice > 0, "failed to validate: AttoFIL price must be greater than 0");
+    /// @dev The proof fee is calculated as: fee_perTiB * datasetSize_in_TiB
+    function calculateProofFee(uint256 rawSize, uint96 feePerTiB) internal pure returns (uint256) {
         require(rawSize > 0, "failed to validate: raw size must be greater than 0");
 
-        // Calculate reward per epoch per byte (in AttoFIL)
-        uint256 rewardPerEpochPerByte;
-        if (filUsdPriceExpo >= 0) {
-            rewardPerEpochPerByte = (ESTIMATED_MONTHLY_TIB_STORAGE_REWARD_USD * FIL_TO_ATTO_FIL)
-                / (TIB_IN_BYTES * EPOCHS_PER_MONTH * filUsdPrice * (10 ** uint32(filUsdPriceExpo)));
-        } else {
-            rewardPerEpochPerByte = (
-                ESTIMATED_MONTHLY_TIB_STORAGE_REWARD_USD * FIL_TO_ATTO_FIL * (10 ** uint32(-filUsdPriceExpo))
-            ) / (TIB_IN_BYTES * EPOCHS_PER_MONTH * filUsdPrice);
-        }
-
-        // Calculate total reward for the proving period
-        uint256 estimatedCurrentReward = rewardPerEpochPerByte * nProofEpochs * rawSize;
-
-        // Calculate gas limits
-        uint256 gasLimitRight = (estimatedCurrentReward * GAS_LIMIT_RIGHT_PERCENTAGE) / 100;
-        uint256 gasLimitLeft = (estimatedCurrentReward * GAS_LIMIT_LEFT_PERCENTAGE) / 100;
-
-        if (estimatedGasFee >= gasLimitRight) {
-            return 0; // No proof fee if gas fee is above right limit
-        } else if (estimatedGasFee >= gasLimitLeft) {
-            return gasLimitRight - estimatedGasFee; // Partial discount on proof fee
-        } else {
-            return (estimatedCurrentReward * PROOF_FEE_PERCENTAGE) / 100;
-        }
+        // Calculate fee as: (feePerTiB * rawSize) >> 40 (since TIB_IN_BYTES == 2**40)
+        return (feePerTiB * rawSize) >> 40;
     }
 
     // sybil fee adds cost to adding state to the pdp verifier contract to prevent

src/PDPVerifier.sol

@@ -9,8 +9,6 @@ import {ERC1967Utils} from "../lib/openzeppelin-contracts/contracts/proxy/ERC196
 import {Initializable} from "../lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol";
 import {UUPSUpgradeable} from "../lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
 import {OwnableUpgradeable} from "../lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol";
-import {IPyth} from "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
-import {PythStructs} from "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";
 import {IPDPTypes} from "./interfaces/IPDPTypes.sol";
 
 /// @title PDPListener
@@ -46,10 +44,7 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
     uint256 public constant MAX_ENQUEUED_REMOVALS = 2000;
     address public constant RANDOMNESS_PRECOMPILE = 0xfE00000000000000000000000000000000000006;
     uint256 public constant EXTRA_DATA_MAX_SIZE = 2048;
-    IPyth public constant PYTH = IPyth(0xA2aa501b19aff244D90cc15a4Cf739D2725B5729);
-
-    // FIL/USD price feed query ID on the Pyth network
-    bytes32 public constant FIL_USD_PRICE_FEED_ID = 0x150ac9b959aee0051e4091f0ef5216d941f590e1c5e7f91cf7635b5c11628c0e;
+    uint256 public constant SECONDS_IN_DAY = 86400;
     uint256 public constant NO_CHALLENGE_SCHEDULED = 0;
     uint256 public constant NO_PROVEN_EPOCH = 0;
 
@@ -64,7 +59,8 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
     event PiecesAdded(uint256 indexed setId, uint256[] pieceIds, Cids.Cid[] pieceCids);
     event PiecesRemoved(uint256 indexed setId, uint256[] pieceIds);
 
-    event ProofFeePaid(uint256 indexed setId, uint256 fee, uint64 price, int32 expo);
+    event ProofFeePaid(uint256 indexed setId, uint256 fee);
+    event FeeUpdateProposed(uint256 currentFee, uint256 newFee, uint256 effectiveTime);
 
     event PossessionProven(uint256 indexed setId, IPDPTypes.PieceIdAndOffset[] challenges);
     event NextProvingPeriod(uint256 indexed setId, uint256 challengeEpoch, uint256 leafCount);
@@ -142,6 +138,15 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
     mapping(uint256 => address) dataSetProposedStorageProvider;
     mapping(uint256 => uint256) dataSetLastProvenEpoch;
 
+    // Packed fee status
+    struct FeeStatus {
+        uint96 currentFeePerTiB;
+        uint96 nextFeePerTiB;
+        uint64 transitionTime;
+    }
+
+    FeeStatus private feeStatus;
+
     // Methods
 
     /// @custom:oz-upgrades-unsafe-allow constructor
@@ -154,6 +159,7 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
         __UUPSUpgradeable_init();
         challengeFinality = _challengeFinality;
         nextDataSetId = 1; // Data sets start at 1
+        feeStatus.nextFeePerTiB = PDPFees.DEFAULT_FEE_PER_TIB;
     }
 
     string public constant VERSION = "2.1.0";
@@ -575,7 +581,7 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
         //
         // (add 32 bytes to the `callDataSize` to also account for the `setId` calldata param)
         uint256 gasUsed = (initialGas - gasleft()) + ((calculateCallDataSize(proofs) + 32) * 1300);
-        uint256 refund = calculateAndBurnProofFee(setId, gasUsed);
+        uint256 refund = calculateAndBurnProofFee(setId);
 
         {
             address listenerAddr = dataSetListener[setId];
@@ -595,29 +601,43 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
         }
     }
 
-    function calculateProofFee(uint256 setId, uint256 estimatedGasFee) public view returns (uint256) {
+    function calculateProofFee(uint256 setId) public view returns (uint256) {
         uint256 rawSize = 32 * challengeRange[setId];
-        (uint64 filUsdPrice, int32 filUsdPriceExpo) = getFILUSDPrice();
+        return calculateProofFeeForSize(rawSize);
+    }
 
-        return PDPFees.proofFeeWithGasFeeBound(
-            estimatedGasFee, filUsdPrice, filUsdPriceExpo, rawSize, block.number - dataSetLastProvenEpoch[setId]
-        );
+    function calculateProofFeeForSize(uint256 rawSize) public view returns (uint256) {
+        require(rawSize > 0, "failed to validate: raw size must be greater than 0");
+        return PDPFees.calculateProofFee(rawSize, _currentFeePerTiB());
     }
 
-    function calculateAndBurnProofFee(uint256 setId, uint256 gasUsed) internal returns (uint256 refund) {
-        uint256 estimatedGasFee = gasUsed * block.basefee;
+    function calculateAndBurnProofFee(uint256 setId) internal returns (uint256 refund) {
         uint256 rawSize = 32 * challengeRange[setId];
-        (uint64 filUsdPrice, int32 filUsdPriceExpo) = getFILUSDPrice();
+        uint256 proofFee = calculateProofFeeForSize(rawSize);
 
-        uint256 proofFee = PDPFees.proofFeeWithGasFeeBound(
-            estimatedGasFee, filUsdPrice, filUsdPriceExpo, rawSize, block.number - dataSetLastProvenEpoch[setId]
-        );
         burnFee(proofFee);
-        emit ProofFeePaid(setId, proofFee, filUsdPrice, filUsdPriceExpo);
+        emit ProofFeePaid(setId, proofFee);
 
         return msg.value - proofFee; // burnFee asserts that proofFee <= msg.value;
     }
 
+    function _currentFeePerTiB() internal view returns (uint96) {
+        return block.timestamp >= feeStatus.transitionTime ? feeStatus.nextFeePerTiB : feeStatus.currentFeePerTiB;
+    }
+
+    // Public getters for packed fee status
+    function feePerTiB() public view returns (uint96) {
+        return _currentFeePerTiB();
+    }
+
+    function proposedFeePerTiB() public view returns (uint96) {
+        return feeStatus.nextFeePerTiB;
+    }
+
+    function feeEffectiveTime() public view returns (uint64) {
+        return feeStatus.transitionTime;
+    }
+
     function calculateCallDataSize(IPDPTypes.Proof[] calldata proofs) internal pure returns (uint256) {
         uint256 callDataSize = 0;
         for (uint256 i = 0; i < proofs.length; i++) {
@@ -837,10 +857,15 @@ contract PDPVerifier is Initializable, UUPSUpgradeable, OwnableUpgradeable {
         return BitOps.ctz(index + 1);
     }
 
-    // Add function to get FIL/USD price
-    function getFILUSDPrice() public view returns (uint64, int32) {
-        PythStructs.Price memory priceData = PYTH.getPriceUnsafe(FIL_USD_PRICE_FEED_ID);
-        require(priceData.price > 0, "failed to validate: price must be greater than 0");
-        return (uint64(priceData.price), priceData.expo);
+    /// @notice Proposes a new proof fee with 7-day delay
+    /// @param newFeePerTiB The new fee per TiB in AttoFIL
+    function updateProofFee(uint256 newFeePerTiB) external onlyOwner {
+        // Auto-commit any pending update that has reached its transition time
+        if (block.timestamp >= feeStatus.transitionTime) {
+            feeStatus.currentFeePerTiB = feeStatus.nextFeePerTiB;
+        }
+        feeStatus.nextFeePerTiB = uint96(newFeePerTiB);
+        feeStatus.transitionTime = uint64(block.timestamp + 7 days);
+        emit FeeUpdateProposed(feeStatus.currentFeePerTiB, newFeePerTiB, feeStatus.transitionTime);
     }
 }

src/interfaces/IPDPEvents.sol

@@ -15,7 +15,8 @@ interface IPDPEvents {
     event DataSetEmpty(uint256 indexed setId);
     event PiecesAdded(uint256 indexed setId, uint256[] pieceIds, Cids.Cid[] pieceCids);
     event PiecesRemoved(uint256 indexed setId, uint256[] pieceIds);
-    event ProofFeePaid(uint256 indexed setId, uint256 fee, uint64 price, int32 expo);
+    event ProofFeePaid(uint256 indexed setId, uint256 fee);
+    event FeeUpdateProposed(uint256 currentFee, uint256 newFee, uint256 effectiveTime);
     event PossessionProven(uint256 indexed setId, IPDPTypes.PieceIdAndOffset[] challenges);
     event NextProvingPeriod(uint256 indexed setId, uint256 challengeEpoch, uint256 leafCount);
     event ContractUpgraded(string version, address newImplementation);

src/interfaces/IPDPVerifier.sol

@@ -40,4 +40,7 @@ interface IPDPVerifier is IPDPEvents {
         external
         view
         returns (IPDPTypes.PieceIdAndOffset[] memory);
+
+    // Fee view: returns the current effective fee per TiB
+    function feePerTiB() external view returns (uint96);
 }