From 625ab0adcd69885c40147cf89ef3a7635fb5e56a Mon Sep 17 00:00:00 2001 From: Dan Forbes Date: Wed, 9 Oct 2024 16:27:46 -0700 Subject: [PATCH] Add Gas Estimation Guide Closes #7299 --- .../guides/04_transactions/gas-and-fees.md | 52 +++++++++++++++++++ packages/web3-eth/src/web3_eth.ts | 4 +- 2 files changed, 54 insertions(+), 2 deletions(-) create mode 100644 docs/docs/guides/04_transactions/gas-and-fees.md diff --git a/docs/docs/guides/04_transactions/gas-and-fees.md b/docs/docs/guides/04_transactions/gas-and-fees.md new file mode 100644 index 00000000000..59fba1e37b8 --- /dev/null +++ b/docs/docs/guides/04_transactions/gas-and-fees.md @@ -0,0 +1,52 @@ +--- +sidebar_position: 3 +sidebar_label: 'Gas and Priority Fees' +--- + +# Gas and Priority Fees + +To prevent spam and reward node operators, Ethereum uses a mechanism called ["gas"](https://ethereum.org/en/gas/), which is a cost that is charged to execute a transaction. Gas costs are associated with all transactions that require computation or update state (e.g. transferring tokens from one account to another). Gas costs are not applied to requests that only involve reading state (e.g. querying the balance of an account). The amount of gas required to pay for a transaction is calculated based on the actual computational actions that are required to execute that transaction. For instance, a simple transaction to transfer ETH from one account to another will require less gas than invoking a complicated smart contract function that involves lots of computation and storage. The cost of gas varies based on network usage. Gas costs more during period of high network activity. The cost per unit of gas is known as the "base fee". + +In addition to the calculated gas cost, an Ethereum transaction can specify an optional priority fee, which is an additional fee that is paid directly to the operator of the node that executes the transaction. Priority fees are intended to incentive node operators to execute transactions. A priority fee is specified as a value in addition to the base fee, which means that the total cost of the priority fee is always a factor of the amount of gas required to execute a transaction. + +With the above in mind, the total cost of fees associated with a transaction are calculated as: _units of gas used _ (base fee + priority fee)\*. + +## Estimating Gas + +The Ethereum JSON-RPC specifies the [eth_estimateGas](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas) method, which accepts a transaction and returns an estimate of the amount of gas required to execute that transaction. The transaction will not be executed and added to the blockchain. The estimate may be different (typically more) than the amount of gas actually used by the transaction for a variety of reasons, including EVM mechanics, node performance, and changes to the state of a smart contract. To invoke the `eth_estimateGas` RPC method, use the [`Web3Eth.estimateGas` method](/api/web3-eth/class/Web3Eth#estimateGas) and provide the [`Transaction`](/api/web3-types/interface/Transaction) for which to estimate gas. + +Web3.js transactions may specifying a gas limit (the maximum amount of gas they are able to consume) by providing the [`Transaction.gas` property](/api/web3/namespace/types#gas). If the specified gas limit is less than the actual amount of gas required to execute the transaction, the transaction will consume an amount of gas equal to the gas limit, which is not refunded, before failing and reverting any state changes made by the transaction. + +```ts +const transaction: Transaction = { + from: '', + to: '', + value: web3.utils.ethUnitMap.ether, +}; + +const gas: bigint = await web3.eth.estimateGas(transaction); +transaction.gas = gas; +``` + +## Calculating Fees + +Web3.js exposes a helper, the [`Web3Eth.calculateFeeData` method](/api/web3-eth/class/Web3Eth#calculateFeeData), that can be used to intelligently calculate the value of the base and priority fees to specify for a transaction. `Web3Eth.calculateFeeData` accepts two optional parameters: `baseFeePerGasFactor` (default value: 2) and `alternativeMaxPriorityFeePerGas` (default value: 1 gwei). Both optional parameters are used in calculating the `maxFeePerGas`, which is described below. The return type of `Web3Eth.calculateFeeData` implements the [`FeeData` interface](/api/web3/namespace/types/#FeeData), which specifies four values: + +- `baseFeePerGas`: base fee from the last block +- `gasPrice`: result of the [`eth_gasPrice` RPC method](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gasprice) (legacy purposes only) +- `maxPriorityFeePerGas`: result of the [`eth_maxPriorityFeePerGas` RPC method](https://github.com/ethereum/execution-apis/blob/4140e528360fea53c34a766d86a000c6c039100e/src/eth/fee_market.yaml#L29-L42) +- `maxFeePerGas`: calculated as `baseFeePerGas * baseFeePerGasFactor + (maxPriorityFeePerGas ?? alternativeMaxPriorityFeePerGas)` + +Web3.js transactions may specify `maxFeePerGas` and `maxPriorityFeePerGas` values. If both values are specified, `maxFeePerGas` must be greater than or equal to `maxPriorityFeePerGas`. If `maxFeePerGas` is less than the current base fee, the transaction will not execute until the base fee drops to a value that is less than or equal to the `maxFeePerGas`. + +```ts +const transaction: Transaction = { + from: '', + to: '', + value: web3.utils.ethUnitMap.ether, +}; + +const feeData: FeeData = await web3.eth.calculateFeeData(); +transaction.maxFeePerGas = feeData.maxFeePerGas; +transaction.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas; +``` diff --git a/packages/web3-eth/src/web3_eth.ts b/packages/web3-eth/src/web3_eth.ts index a9db13d5abb..c397bbb515b 100644 --- a/packages/web3-eth/src/web3_eth.ts +++ b/packages/web3-eth/src/web3_eth.ts @@ -276,8 +276,8 @@ export class Web3Eth extends Web3Context