> loading_
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/**
* @title GasPricingTest
* @dev This contract demonstrates how different resource usage might be priced
* under ArbOS 60 Elara's proposed multi-dimensional gas model.
* The upgrade separates the pricing for computation, calldata, and storage.
* This means a function heavy on computation but light on calldata may see
* its relative cost change compared to a function that is the opposite.
*/
contract GasPricingTest {
uint256 public counter;
/**
* @notice This function is light on computation but heavy on calldata.
* @dev Under ArbOS 60, the cost will be primarily driven by the L1 calldata price.
* If calldata is congested, this will be expensive, but it won't affect
* the price of L2 computation as much.
* @param data Large arbitrary data payload.
*/
function calldataHeavy(bytes calldata data) external {
// The main cost here is the `data` being passed in and stored in calldata.
// The actual computation is minimal.
require(data.length > 0, "Data cannot be empty");
}
/**
* @notice This function is heavy on L2 computation but light on calldata.
* @dev Under ArbOS 60, its cost will be driven by the L2 computation price.
* This could become relatively cheaper if the network isn't compute-bound,
* encouraging more complex on-chain logic.
* @param iterations The number of loops to execute.
*/
function computationHeavy(uint256 iterations) external {
for (uint256 i = 0; i < iterations; i++) {
counter++;
}
}
}
// TO TRY:
// 1. Deploy this contract on a testnet once ArbOS 60 is available.
// 2. Call `calldataHeavy` with a large byte string (e.g., 10KB) and record the gas cost.
// 3. Call `computationHeavy` with a high number of iterations (e.g., 1000) and record the gas cost.
// 4. Analyze the gas cost breakdown. Notice how the new model allows the network
// to price these distinct operations independently, leading to more accurate fee structures.
// 5. Review your own contracts: could you reduce calldata usage in favor of more efficient
// on-chain computation to optimize for the new gas model?
```