hardhat-gas-reporter
Version:
Gas Analytics plugin for Hardhat
377 lines (341 loc) • 11.4 kB
text/typescript
import { serializeTransaction, Hex } from 'viem';
import { compress } from 'brotli-wasm';
import {
EVM_BASE_TX_COST,
OPTIMISM_BEDROCK_DYNAMIC_OVERHEAD,
OPTIMISM_BEDROCK_FIXED_OVERHEAD,
RANDOM_R_COMPONENT,
RANDOM_S_COMPONENT
} from "../constants";
import { GasReporterOptions, JsonRpcTx } from "../types";
/**
==========================
OPTIMISM BEDROCK
==========================
Given:
+ A fixed overhead cost for publishing a transaction (currently set to 188 gas).
+ A dynamic overhead cost which scales with the size of the transaction (currently set to 0.684).
Count the number of zero bytes and non-zero bytes in the transaction data. Each zero byte
costs 4 gas and each non-zero byte costs 16 gas.
```
tx_data_gas = count_zero_bytes(tx_data) * 4 + count_non_zero_bytes(tx_data) * 16
tx_total_gas = (tx_data_gas + fixed_overhead) * dynamic_overhead
l1_data_fee = tx_total_gas * ethereum_base_fee
```
Source: https://docs.optimism.io/stack/transactions/fees#formula
*/
/**
* Gets calldata gas plus overhead for a tx (an input into the function below)
* @param tx JSONRPC formatted getTransaction response
* @returns
*/
export function getOptimismBedrockL1Gas(tx: JsonRpcTx): number {
const txDataGas = getOPStackDataGas(tx);
return txDataGas + OPTIMISM_BEDROCK_FIXED_OVERHEAD;
}
/**
* Gets the native token denominated cost of registering tx calldata to L1
* @param txDataGas amount obtained from `getOptimismBedrockL1Gas`
* @param baseFee amount obtained from previous block
* @returns
*/
export function getOptimismBedrockL1Cost(txDataGas: number, baseFee: number): number {
return Math.floor(OPTIMISM_BEDROCK_DYNAMIC_OVERHEAD * txDataGas) * baseFee;
}
/*
* ==========================
* OPTIMISM ECOTONE
* ==========================
*
* The Ecotone L1 Data Fee calculation begins with counting the number of zero bytes and non-zero bytes
* in the transaction data. Each zero byte costs 4 gas and each non-zero byte costs 16 gas. This value,
* when divided by 16, can be thought of as a rough estimate of the size of the transaction data after
* compression.
*
* ```
* tx_compressed_size = [(count_zero_bytes(tx_data)*4 + count_non_zero_bytes(tx_data)*16)] / 16
* ``
* Next, the two scalars are applied to the base fee and blob base fee parameters to compute a weighted
* gas price multiplier.
*
* ```
* weighted_gas_price = 16*base_fee_scalar*base_fee + blob_base_fee_scalar*blob_base_fee
* ```
*
* The l1 data fee is then:
*
* ```
* l1_data_fee = tx_compressed_size * weighted_gas_price
* ```
*
*
* Source: https://github.com/ethereum-optimism/optimism/blob/e57787ea7d0b9782cea5f32bcb92d0fdeb7bd870/ +
* packages/contracts-bedrock/src/L2/GasPriceOracle.sol#L88-L92
*
* DECIMALS = 6
*
* function _getL1FeeEcotone(bytes memory _data) internal view returns (uint256) {
* uint256 l1GasUsed = _getCalldataGas(_data);
* uint256 scaledBaseFee = baseFeeScalar() * 16 * l1BaseFee();
* uint256 scaledBlobBaseFee = blobBaseFeeScalar() * blobBaseFee();
* uint256 fee = l1GasUsed * (scaledBaseFee + scaledBlobBaseFee);
* return fee / (16 * 10 ** DECIMALS);
* }
*/
/**
* Gets the native token denominated cost of registering tx calldata to L1
* @param txSerialized
* @param txCompressed
* @param baseFee
* @param blobBaseFee
* @param opStackBaseFeeScalar
* @param opStackBlobBaseFeeScalar
* @returns
*/
export function getOPStackEcotoneL1Cost(
txSerialized: number,
baseFee: number,
blobBaseFee: number,
opStackBaseFeeScalar: number,
opStackBlobBaseFeeScalar: number
): number {
const weightedBaseFee = 16 * opStackBaseFeeScalar * baseFee;
const weightedBlobBaseFee = opStackBlobBaseFeeScalar * blobBaseFee;
return (txSerialized * (weightedBaseFee + weightedBlobBaseFee)) / 16000000;
}
/**
* Computes the amount of L1 gas used for a transaction. The overhead represents the per batch
* gas overhead of posting both transaction and state roots to L1 given larger batch sizes.
*
* 4 gas for 0 byte
* 16 gas for non zero byte
*
* Account for the transaction being unsigned. Padding is added to account for lack of signature
* on transaction. (Assume VRS components are non-zero)
*
* 1 byte for RLP V prefix
* 1 byte for V
* 1 byte for RLP R prefix
* 32 bytes for R
* 1 byte for RLP S prefix
* 32 bytes for S
* ----------
* Total: 68 bytes of padding
*
* SOURCE: optimism/packages/contracts/contracts/L2/predeploys/OVM_GasPriceOracle.sol
*/
export function getOPStackDataGas(tx: JsonRpcTx): number {
const serializedTx = getSerializedTx (tx);
const total = getCalldataBytesGas(serializedTx);
return total + (68 * 16);
}
// ==========================
// ARBITRUM OS20
// ==========================
export function getArbitrumL1Bytes(tx: JsonRpcTx) {
const serializedTx = getSerializedTx(tx, true);
const compressedTx = compress(Buffer.from(serializedTx), {quality: 2});
const compressedLength = Buffer.from(compressedTx).toString('utf8').length;
return compressedLength + 140;
}
export function getArbitrumL1Cost(bytes: number, gasPrice: number, baseFeePerByte: number) {
// Debit 10% estimate buffer
const adjustedBaseFeePerByte = Math.round(baseFeePerByte - (baseFeePerByte/10))
const l1Gas = adjustedBaseFeePerByte * 1e9 * bytes;
const l1Cost = l1Gas / (gasPrice * 1e9)
return l1Cost;
}
/**
* Serializes transaction
* @param tx
* @returns
*/
export function getSerializedTx(tx: JsonRpcTx, emulateSignatureComponents = false): string {
let signature;
const type = normalizeTxType(tx.type);
const maxFeePerGas = (tx.maxFeePerGas)
? hexToBigInt(tx.maxFeePerGas)
: BigInt(0);
const maxPriorityFeePerGas = (tx.maxPriorityFeePerGas)
? hexToBigInt(tx.maxPriorityFeePerGas)
: BigInt(0);
// For arbitrum - part of their estimation flow at nitro
if (emulateSignatureComponents) {
signature = {
v: BigInt(0),
r: RANDOM_R_COMPONENT as `0x${string}`,
s: RANDOM_S_COMPONENT as `0x${string}`
}
}
return serializeTransaction ({
to: tx.to as Hex,
maxFeePerGas,
maxPriorityFeePerGas,
data: tx.data as Hex ? tx.data! as Hex : tx.input! as Hex,
value: hexToBigInt(tx.value),
chainId: parseInt(tx.chainId!),
type,
accessList: tx.accessList,
nonce: parseInt(tx.nonce)
}, signature)
}
/**
* Computes the intrinsic gas overhead for the data component of a transaction
* @param data
* @returns
*/
export function getCalldataBytesGas(data: string): number {
let total = 0;
// String hex-prefixed, 1 byte = 2 hex chars
for (let i = 2; i < data.length; i++) {
if (i % 2 === 0) {
total = (data[i] === "0" && data[i + 1] === "0")
? total + 4
: total + 16;
}
}
return total;
}
/**
* Returns estimate of the intrinsic gas used for executing a tx on L1 EVM;
* @param tx
* @returns
*/
export function getIntrinsicGas(data: string): number {
const gas = getCalldataBytesGas(data);
return gas + EVM_BASE_TX_COST;
}
/**
* Returns gas cost minus the intrinsic gas call overhead for a transaction
* @param data
* @param gas
* @returns
*/
export function getGasSubIntrinsic(data: string, gas: number) {
const intrinsic = getIntrinsicGas(data);
return gas - intrinsic;
}
/**
* Gets calldata gas amount for network by hardfork
* @param options GasReporterOptions
* @param tx JSONRPC formatted transaction
* @returns
*/
export function getCalldataGasForNetwork(
options: GasReporterOptions,
tx: JsonRpcTx
) : number {
if (options.L2 === "optimism" || options.L2 === "base") {
switch (options.optimismHardfork){
case "bedrock": return getOptimismBedrockL1Gas(tx);
case "ecotone": return getOPStackDataGas(tx);
default: return 0; /** This shouldn't happen */
}
}
if (options.L2 === "arbitrum") {
return getArbitrumL1Bytes(tx);
}
// If not configured for L2
return 0;
}
/**
* Gets calldata gas X gas price for network by hardfork
* @param options GasReporterOptions
* @param gas Scaled gas value collected
* @param baseFee Network fee from block
* @param blobBaseFee Network fee from block
* @returns
*/
export function getCalldataCostForNetwork(
options: GasReporterOptions,
gas: number,
) : number {
if (options.L2 === "optimism" || options.L2 === "base") {
switch (options.optimismHardfork){
case "bedrock": return getOptimismBedrockL1Cost(gas, options.baseFee!);
case "ecotone": return getOPStackEcotoneL1Cost(
gas,
options.baseFee!,
options.blobBaseFee!,
options.opStackBaseFeeScalar!,
options.opStackBlobBaseFeeScalar!
);
default: return 0; /** This shouldn't happen */
}
}
if (options.L2 === "arbitrum") {
return getArbitrumL1Cost(gas, options.gasPrice!, options.baseFeePerByte!);
}
// If not configured for L2
return 0;
}
/**
* Expresses gas usage as a nation-state currency price
* @param {Number} executionGas execution gas used
* @param {Number} calldataGas data gas used
* @param {GasReporterOptions} options
* @return {string} cost of gas used "0.00"
*/
export function gasToCost(
executionGas: number,
calldataGas: number,
options: GasReporterOptions
): string {
let calldataCost: number = 0;
if (options.L2) {
const cost = getCalldataCostForNetwork(options, calldataGas);
if (options.L2 === "optimism" || options.L2 === "base") {
calldataCost = (cost / 1e9) * parseFloat(options.tokenPrice!);
}
if (options.L2 === "arbitrum") {
executionGas += cost;
}
}
const executionCost = (options.gasPrice! / 1e9) * executionGas * parseFloat(options.tokenPrice!);
return (executionCost + calldataCost).toFixed(options.currencyDisplayPrecision);
}
/**
* Expresses gas usage as a % of the block gasLimit. Source: NeuFund (see issues)
* @param {Number} gasUsed gas value
* @param {Number} blockLimit gas limit of a block
* @return {Number} percent (0.0)
*/
export function gasToPercentOfLimit(gasUsed: number, blockLimit: number): number {
return Math.round((1000 * gasUsed) / blockLimit) / 10;
}
/**
* Converts hex to decimal
* @param {string} hex JSONRPC val
* @return {Number} decimal
*/
export function hexToDecimal(val: string): number {
return parseInt(val.toString(), 16);
}
/**
* Converts hex to bigint
* @param {string} hex JSONRPC val
* @return {BigInt} bigint
*/
export function hexToBigInt(val: string): bigint {
return BigInt(val);
}
export function hexWeiToIntGwei(val: string): number {
return hexToDecimal(val) / Math.pow(10, 9);
}
/**
* Converts wei `l1 fee estimate` to gwei estimated price per byte
* @param val
*/
export function getArbitrumBaseFeePerByte(val: number): number {
const gwei = (BigInt(16) * BigInt(val)) / BigInt(Math.pow(10, 9));
return parseInt(gwei.toString());
}
export function normalizeTxType(_type: string): ("legacy" | "eip1559" | "eip2930" | "eip4844") {
switch(hexToDecimal(_type)) {
case 0: return 'legacy';
case 1: return 'eip2930';
case 2: return 'eip1559';
case 3: return 'eip4844';
default: return 'legacy';
}
}