gas: Скилл для работы с ценами на Monad

--- name: gas description: How gas pricing works on Monad and how it differs from Ethereum. Monad charges gas based on gas_limit (not gas used), has a different base fee controller, and different block gas limits. Fetch this skill whenever writing smart contracts, setting gas limits, estimating gas, or building any transaction-related UI on Monad incorrect gas handling can cost users real money. --- Monad's gas pricing is EIP-1559 compatible but differs from Ethereum in critical ways. If you're building apps that submit transactions, estimate gas, or display gas costs, you need to understand these differences. ## Key Difference: Monad Charges on Gas Limit, Not Gas Used On Ethereum, users pay for the gas actually consumed by their transaction. On Monad, users pay based on the **gas limit** they set: ``` gas_paid = gas_limit * price_per_gas ``` This exists because Monad uses asynchronous execution — block leaders build blocks before executing them, so actual gas consumption isn't known at inclusion time. This prevents DOS attacks where transactions claim cheap gas but consume expensive computation. **What this means for developers:** - Setting an unnecessarily high gas limit directly costs users more MON. - Always set tight, accurate gas limits especially for transactions with known fixed costs. - For native MON transfers, the gas cost is always 21,000. Hardcode this instead of relying on `eth_estimateGas`. ## EIP-1559 Transaction Pricing Monad uses type 2 (EIP-1559) transactions: ``` price_per_gas = min(base_price_per_gas + priority_price_per_gas, max_price_per_gas) ``` Users specify two values when signing: - `priority_price_per_gas` — tip for transaction prioritization within a block - `max_price_per_gas` — safety cap on total gas price The network controls `base_price_per_gas`, which is the same for all transactions in a block. ## Block and Transaction Limits | Parameter | Value | |-----------|-------| | Block gas limit | 200M gas | | Transaction gas limit | 30M gas | | Minimum base fee | 100 MON-gwei (100 x 10^-9 MON) | These are significantly higher than Ethereum's 30M block gas limit, which means Monad blocks can fit more transactions. ## Base Fee Controller Monad's base fee controller is different from Ethereum's. It **increases more slowly and decreases more quickly** to prevent blockspace underutilization from overpricing. **Controller parameters:** - max_step_size = 1/28 - target = 160M gas (80% of block capacity) - beta = 0.96 - epsilon = 160M The base fee updates each block using an exponential adjustment based on how full the block was relative to the target. The formula uses exponential smoothing (beta = 0.96) to track historical variance in block fullness, producing smoother fee transitions than Ethereum's simpler mechanism. In practice, this means gas prices on Monad are more stable and recover faster after spikes. ## Transaction Ordering The default Monad client orders transactions using a **Priority Gas Auction**, transactions are sorted by descending total gas price (base fee + priority fee). ## Developer Guidelines ### Always Set Explicit Gas Limits for Known Costs For operations with fixed gas costs, set the gas limit explicitly before submitting to wallets: ```typescript // Good: explicit gas limit for a native transfer const tx = { to: recipient, value: parseEther("1.0"), gasLimit: 21000n, }; ``` This is important because some wallets (like MetaMask) use `eth_estimateGas` to determine the gas limit. If that call reverts (e.g., the contract call would fail), the wallet may fall back to a very high gas limit. On Monad, the user would then pay for that entire inflated limit since **gas is charged on the limit, not on actual usage**. ### Gas Estimation in Frontend Code When using viem or wagmi to estimate gas, remember that the estimate is what users will actually pay not a lower bound. Add only a small buffer if needed: ```typescript // If you must estimate, keep the buffer small const estimate = await publicClient.estimateGas({ ... }); const gasLimit = estimate + (estimate / 10n); // 10% buffer at most ``` ### Displaying Gas Costs to Users When showing gas costs in your UI, calculate from the gas limit (not "gas used" from receipts on other chains): ```typescript const gasCost = gasLimit * gasPrice; ``` ### Smart Contract Considerations - Monad's 30M transaction gas limit is the same as Ethereum's block gas limit, so individual transactions can be very large. - Optimize your contracts to use less gas on Monad this directly saves users money since they pay for the limit, and tighter estimates mean tighter limits. - If your contract has functions with predictable gas costs, document them so frontends can set explicit limits. ## Opcode Pricing Differences Monad adjusts a few opcode prices **upward** rather than discounting everything. This achieves the same relative effect with minimal disruption. The changes reflect different resource scarcity in Monad's high-performance architecture, particularly for disk-based state operations. ### Cold State Access is Much More Expensive | Operation | Ethereum | Monad | Increase | |-----------|----------|-------|----------| | Account access (cold) | 2,600 gas | 10,100 gas | +7,500 | | Storage access (cold) | 2,100 gas | 8,100 gas | +6,000 | | Account access (warm) | 100 gas | 100 gas | unchanged | | Storage access (warm) | 100 gas | 100 gas | unchanged | **Affected opcodes:** - Account access: `BALANCE`, `EXTCODESIZE`, `EXTCODECOPY`, `EXTCODEHASH`, `CALL`, `CALLCODE`, `DELEGATECALL`, `STATICCALL`, `SELFDESTRUCT` - Storage access: `SLOAD`, `SSTORE` **What this means for developers:** - Contracts that touch many cold storage slots or call many external contracts will cost significantly more on Monad. - Warm access is identical to Ethereum, so accessing the same slot/account repeatedly within a transaction has no extra cost. - Batch operations that access a storage slot once (cold) and then reuse it (warm) are fine. But patterns that do single cold reads across many different slots will be more expensive. - If your contract reads from many different storage slots in a single call, the gas estimate will be higher on Monad. Account for this when setting gas limits. ### Precompile Repricing Cryptographic precompiles cost 2-5x more on Monad: | Precompile | Address | Ethereum | Monad | Multiplier | |------------|---------|----------|-------|------------| | ecRecover | 0x01 | 3,000 | 6,000 | 2x | | ecAdd | 0x06 | 150 | 300 | 2x | | ecMul | 0x07 | 6,000 | 30,000 | 5x | | ecPairing | 0x08 | 45,000 | 225,000 | 5x | | blake2f | 0x09 | rounds x 1 | rounds x 2 | 2x | | point evaluation | 0x0a | 50,000 | 200,000 | 4x | **What this means for developers:** - Contracts relying heavily on signature verification (`ecRecover`) will use 2x the gas for those operations. - ZK-related operations (`ecMul`, `ecPairing`, point evaluation) are 4-5x more expensive. If your contract does on-chain ZK proof verification, gas estimates from Ethereum will be significantly off. - Factor these higher precompile costs into gas limit calculations if your contract uses them.