Charge l1 data availability fee

contracts/src/v0.8/ccip/AggregateRateLimiter.sol

@@ -13,7 +13,7 @@ import {USDPriceWith18Decimals} from "./libraries/USDPriceWith18Decimals.sol";
 /// token transfers, using a price registry to convert to a numeraire asset (e.g. USD).
 contract AggregateRateLimiter is OwnerIsCreator {
   using RateLimiter for RateLimiter.TokenBucket;
-  using USDPriceWith18Decimals for uint192;
+  using USDPriceWith18Decimals for uint224;
 
   error PriceNotFoundForToken(address token);
   event AdminSet(address newAdmin);
@@ -45,7 +45,7 @@ contract AggregateRateLimiter is OwnerIsCreator {
     for (uint256 i = 0; i < numberOfTokens; ++i) {
       // not fetching validated price, as price staleness is not important for value-based rate limiting
       // we only need to verify price is not 0
-      uint192 pricePerToken = priceRegistry.getTokenPrice(tokenAmounts[i].token).value;
+      uint224 pricePerToken = priceRegistry.getTokenPrice(tokenAmounts[i].token).value;
       if (pricePerToken == 0) revert PriceNotFoundForToken(tokenAmounts[i].token);
       value += pricePerToken._calcUSDValueFromTokenAmount(tokenAmounts[i].amount);
     }

contracts/src/v0.8/ccip/PriceRegistry.sol

@@ -13,7 +13,7 @@ import {EnumerableSet} from "../vendor/openzeppelin-solidity/v4.8.0/contracts/ut
 /// and the price of a token in USD allowing the owner or priceUpdater to update this value.
 contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
   using EnumerableSet for EnumerableSet.AddressSet;
-  using USDPriceWith18Decimals for uint192;
+  using USDPriceWith18Decimals for uint224;
 
   error TokenNotSupported(address token);
   error ChainNotSupported(uint64 chain);
@@ -34,15 +34,15 @@ contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
   ///     Very Expensive:   1 unit of gas costs 1 USD                  -> 1e18
   ///     Expensive:        1 unit of gas costs 0.1 USD                -> 1e17
   ///     Cheap:            1 unit of gas costs 0.000001 USD           -> 1e12
-  mapping(uint64 destChainSelector => Internal.TimestampedUint192Value price)
+  mapping(uint64 destChainSelector => Internal.TimestampedPackedUint224 price)
     private s_usdPerUnitGasByDestChainSelector;
 
   /// @dev The price, in USD with 18 decimals, per 1e18 of the smallest token denomination.
   /// @dev Price of 1e18 represents 1 USD per 1e18 token amount.
   ///     1 USDC = 1.00 USD per full token, each full token is 1e6 units -> 1 * 1e18 * 1e18 / 1e6 = 1e30
   ///     1 ETH = 2,000 USD per full token, each full token is 1e18 units -> 2000 * 1e18 * 1e18 / 1e18 = 2_000e18
   ///     1 LINK = 5.00 USD per full token, each full token is 1e18 units -> 5 * 1e18 * 1e18 / 1e18 = 5e18
-  mapping(address token => Internal.TimestampedUint192Value price) private s_usdPerToken;
+  mapping(address token => Internal.TimestampedPackedUint224 price) private s_usdPerToken;
 
   // Price updaters are allowed to update the prices.
   EnumerableSet.AddressSet private s_priceUpdaters;
@@ -63,21 +63,21 @@ contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
   // ================================================================
 
   // @inheritdoc IPriceRegistry
-  function getTokenPrice(address token) public view override returns (Internal.TimestampedUint192Value memory) {
+  function getTokenPrice(address token) public view override returns (Internal.TimestampedPackedUint224 memory) {
     return s_usdPerToken[token];
   }
 
   // @inheritdoc IPriceRegistry
-  function getValidatedTokenPrice(address token) external view override returns (uint192) {
+  function getValidatedTokenPrice(address token) external view override returns (uint224) {
     return _getValidatedTokenPrice(token);
   }
 
   // @inheritdoc IPriceRegistry
   function getTokenPrices(
     address[] calldata tokens
-  ) external view override returns (Internal.TimestampedUint192Value[] memory) {
+  ) external view override returns (Internal.TimestampedPackedUint224[] memory) {
     uint256 length = tokens.length;
-    Internal.TimestampedUint192Value[] memory tokenPrices = new Internal.TimestampedUint192Value[](length);
+    Internal.TimestampedPackedUint224[] memory tokenPrices = new Internal.TimestampedPackedUint224[](length);
     for (uint256 i = 0; i < length; ++i) {
       tokenPrices[i] = getTokenPrice(tokens[i]);
     }
@@ -93,15 +93,15 @@ contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
   // @inheritdoc IPriceRegistry
   function getDestinationChainGasPrice(
     uint64 destChainSelector
-  ) external view override returns (Internal.TimestampedUint192Value memory) {
+  ) external view override returns (Internal.TimestampedPackedUint224 memory) {
     return s_usdPerUnitGasByDestChainSelector[destChainSelector];
   }
 
   function getTokenAndGasPrices(
     address token,
     uint64 destChainSelector
-  ) external view override returns (uint192 tokenPrice, uint192 gasPriceValue) {
-    Internal.TimestampedUint192Value memory gasPrice = s_usdPerUnitGasByDestChainSelector[destChainSelector];
+  ) external view override returns (uint224 tokenPrice, uint224 gasPriceValue) {
+    Internal.TimestampedPackedUint224 memory gasPrice = s_usdPerUnitGasByDestChainSelector[destChainSelector];
     // We do allow a gas price of 0, but no stale or unset gas prices
     if (gasPrice.timestamp == 0) revert ChainNotSupported(destChainSelector);
     uint256 timePassed = block.timestamp - gasPrice.timestamp;
@@ -131,8 +131,8 @@ contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
   /// not supported or the price is stale.
   /// @param token The address of the token to get the price for
   /// @return the token price
-  function _getValidatedTokenPrice(address token) internal view returns (uint192) {
-    Internal.TimestampedUint192Value memory tokenPrice = s_usdPerToken[token];
+  function _getValidatedTokenPrice(address token) internal view returns (uint224) {
+    Internal.TimestampedPackedUint224 memory tokenPrice = s_usdPerToken[token];
     if (tokenPrice.timestamp == 0 || tokenPrice.value == 0) revert TokenNotSupported(token);
     uint256 timePassed = block.timestamp - tokenPrice.timestamp;
     if (timePassed > i_stalenessThreshold) revert StaleTokenPrice(token, i_stalenessThreshold, timePassed);
@@ -187,17 +187,17 @@ contract PriceRegistry is IPriceRegistry, OwnerIsCreator {
 
     for (uint256 i = 0; i < priceUpdatesLength; ++i) {
       Internal.TokenPriceUpdate memory update = priceUpdates.tokenPriceUpdates[i];
-      s_usdPerToken[update.sourceToken] = Internal.TimestampedUint192Value({
+      s_usdPerToken[update.sourceToken] = Internal.TimestampedPackedUint224({
         value: update.usdPerToken,
-        timestamp: uint64(block.timestamp)
+        timestamp: uint32(block.timestamp)
       });
       emit UsdPerTokenUpdated(update.sourceToken, update.usdPerToken, block.timestamp);
     }
 
     if (priceUpdates.destChainSelector != 0) {
-      s_usdPerUnitGasByDestChainSelector[priceUpdates.destChainSelector] = Internal.TimestampedUint192Value({
+      s_usdPerUnitGasByDestChainSelector[priceUpdates.destChainSelector] = Internal.TimestampedPackedUint224({
         value: priceUpdates.usdPerUnitGas,
-        timestamp: uint64(block.timestamp)
+        timestamp: uint32(block.timestamp)
       });
       emit UsdPerUnitGasUpdated(priceUpdates.destChainSelector, priceUpdates.usdPerUnitGas, block.timestamp);
     }

contracts/src/v0.8/ccip/interfaces/IPriceRegistry.sol

@@ -11,24 +11,24 @@ interface IPriceRegistry {
   /// @notice Get the `tokenPrice` for a given token.
   /// @param token The token to get the price for.
   /// @return tokenPrice The tokenPrice for the given token.
-  function getTokenPrice(address token) external view returns (Internal.TimestampedUint192Value memory);
+  function getTokenPrice(address token) external view returns (Internal.TimestampedPackedUint224 memory);
 
   /// @notice Get the `tokenPrice` for a given token, checks if the price is valid.
   /// @param token The token to get the price for.
   /// @return tokenPrice The tokenPrice for the given token if it exists and is valid.
-  function getValidatedTokenPrice(address token) external view returns (uint192);
+  function getValidatedTokenPrice(address token) external view returns (uint224);
 
   /// @notice Get the `tokenPrice` for an array of tokens.
   /// @param tokens The tokens to get prices for.
   /// @return tokenPrices The tokenPrices for the given tokens.
-  function getTokenPrices(address[] calldata tokens) external view returns (Internal.TimestampedUint192Value[] memory);
+  function getTokenPrices(address[] calldata tokens) external view returns (Internal.TimestampedPackedUint224[] memory);
 
   /// @notice Get the `gasPrice` for a given destination chain ID.
   /// @param destChainSelector The destination chain to get the price for.
   /// @return gasPrice The gasPrice for the given destination chain ID.
   function getDestinationChainGasPrice(
     uint64 destChainSelector
-  ) external view returns (Internal.TimestampedUint192Value memory);
+  ) external view returns (Internal.TimestampedPackedUint224 memory);
 
   /// @notice Gets the fee token price and the gas price, both denominated in dollars.
   /// @param token The source token to get the price for.
@@ -38,7 +38,7 @@ interface IPriceRegistry {
   function getTokenAndGasPrices(
     address token,
     uint64 destChainSelector
-  ) external view returns (uint192 tokenPrice, uint192 gasPrice);
+  ) external view returns (uint224 tokenPrice, uint224 gasPrice);
 
   /// @notice Convert a given token amount to target token amount.
   /// @param fromToken The given token address.

contracts/src/v0.8/ccip/libraries/Internal.sol

@@ -9,19 +9,24 @@ library Internal {
   struct PriceUpdates {
     TokenPriceUpdate[] tokenPriceUpdates;
     uint64 destChainSelector; // --┐ Destination chain selector
-    uint192 usdPerUnitGas; // -----┘ 1e18 USD per smallest unit (e.g. wei) of destination chain gas
+    uint224 usdPerUnitGas; // -----┘ 1e18 USD per smallest unit (e.g. wei) of destination chain gas
   }
 
   struct TokenPriceUpdate {
     address sourceToken; // Source token
-    uint192 usdPerToken; // 1e18 USD per smallest unit of token
+    uint224 usdPerToken; // 1e18 USD per smallest unit of token
   }
 
-  struct TimestampedUint192Value {
-    uint192 value; // -------┐ The price, in 1e18 USD.
-    uint64 timestamp; // ----┘ Timestamp of the most recent price update.
+  struct TimestampedPackedUint224 {
+    uint224 value; // -------┐ Value in uint224, packed.
+    uint32 timestamp; // ----┘ Timestamp of the most recent update.
   }
 
+  /// @dev Gas price is stored in 112-bit unsigned int. uint224 can pack 2 prices.
+  /// When packing L1 and L2 gas prices, L1 gas price is left-shifted to the higher-order bits.
+  /// Using uint8, which is strictly lower than 1st shift operand, to avoid shift operand type warning.
+  uint8 public constant GAS_PRICE_BITS = 112;
+
   struct PoolUpdate {
     address token; // The IERC20 token address
     address pool; // The token pool address
@@ -53,6 +58,16 @@ library Internal {
     bytes32 messageId;
   }
 
+  /// @dev EVM2EVMMessage struct has 12 fields, including 2 variable arrays.
+  /// Each variable array takes 1 more slot to store its length.
+  /// Hence, when abiEncoded, excluding the dynamic contents of variable arrays,
+  /// EVM2EVMMessage takes up a fixed number of 14 lots, 32 bytes each.
+  uint256 public constant MESSAGE_FIXED_BYTES = 32 * 14;
+
+  /// @dev Each token transfer adds 1 instance of EVMTokenAmount struct to EVM2EVMMessage.
+  /// EVMTokenAmount struct contains 2 fields, 32 bytes each when abiEncoded.
+  uint256 public constant MESSAGE_BYTES_PER_TOKEN = 32 * 2;
+
   function _toAny2EVMMessage(
     EVM2EVMMessage memory original,
     Client.EVMTokenAmount[] memory destTokenAmounts

contracts/src/v0.8/ccip/libraries/USDPriceWith18Decimals.sol

@@ -11,7 +11,7 @@ library USDPriceWith18Decimals {
   /// @dev this function assumes that no more than 1e59 US dollar worth of token is passed in.
   /// If more is sent, this function will overflow and revert.
   /// Since there isn't even close to 1e59 dollars, this is ok for all legit tokens.
-  function _calcUSDValueFromTokenAmount(uint192 tokenPrice, uint256 tokenAmount) internal pure returns (uint256) {
+  function _calcUSDValueFromTokenAmount(uint224 tokenPrice, uint256 tokenAmount) internal pure returns (uint256) {
     /// LINK Example:
     /// tokenPrice:         8e18 -> $8/LINK, as 1e18 token amount is 1 LINK, worth 8 USD, or 8e18 with 18 decimals
     /// tokenAmount:        2e18 -> 2 LINK
@@ -30,7 +30,7 @@ library USDPriceWith18Decimals {
   /// @param tokenPrice The USD price of the token.
   /// @param usdValue USD value with 18 decimals.
   /// @return Amount of the smallest token denomination.
-  function _calcTokenAmountFromUSDValue(uint192 tokenPrice, uint256 usdValue) internal pure returns (uint256) {
+  function _calcTokenAmountFromUSDValue(uint224 tokenPrice, uint256 usdValue) internal pure returns (uint256) {
     /// LINK Example:
     /// tokenPrice:          8e18 -> $8/LINK, as 1e18 token amount is 1 LINK, worth 8 USD, or 8e18 with 18 decimals
     /// usdValue:           16e18 -> $16