Solve merge conflict

packages/web3.js-plugin-fee-estimation/.prettierignore

+artifacts
+cache
+typechain
+.deps
+.envrc
+.env 
+/dist/

packages/web3.js-plugin-fee-estimation/.prettierrc.cjs

+module.exports = {
+  ...require('../../.prettierrc.js'),
+}

packages/web3.js-plugin-fee-estimation/CHANGELOG.md

+# @eth-optimism/web3.js-plugin-fee-estimation

packages/web3.js-plugin-fee-estimation/LICENSE

+MIT License
+
+Copyright (c) 2022 Optimism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/web3.js-plugin-fee-estimation/README.md

+# @eth-optimism/web3.js-plugin-fee-estimation
+
+This web3.js plugin adds utility functions for estimating L1 and L2 gas for OP chains by wrapping the [GasPriceOracle](../contracts-bedrock/contracts/l2/GasPriceOracle.sol) contract
+
+The GasPriceOracle is [deployed to Optimism](https://optimistic.etherscan.io/address/0x420000000000000000000000000000000000000F) and other OP chains at a predeployed address of `0x420000000000000000000000000000000000000F`
+
+For more detailed information about gas fees on Optimism's Layer 2, you can visit the [official documentation](https://community.optimism.io/docs/developers/build/transaction-fees/#the-l2-execution-fee)
+
+## Installation
+
+This plugin is intended to be [registered](https://docs.web3js.org/guides/web3_plugin_guide/plugin_users#registering-the-plugin) onto an instance of `Web3`. It has a [peerDependency](https://nodejs.org/es/blog/npm/peer-dependencies) of `web3` version `4.x`, so make sure you have that latest version of `web3` installed for your project before installing the plugin
+
+### Installing the Plugin
+
+```bash
+pnpm install @eth-optimism/web3.js-plugin-fee-estimation
+```
+
+```bash
+npm install @eth-optimism/web3.js-plugin-fee-estimation
+```
+
+```bash
+yarn add @eth-optimism/web3.js-plugin-fee-estimation
+```
+
+### Registering the Plugin
+
+```typescript
+import Web3 from 'web3'
+import OptimismFeeEstimationPlugin from '@eth-optimism/web3.js-plugin-fee-estimation'
+
+const web3 = new Web3('http://yourProvider.com')
+web3.registerPlugin(new OptimismFeeEstimationPlugin())
+```
+
+You will now have access to the following functions under the `op` namespace, i.e. `web3.op.someMethod`
+
+## API
+
+| Function Name                            | Returns                                                                                                                                                                                                                |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [estimateFees](#estimatefees)            | The combined estimated L1 and L2 fees for a transaction                                                                                                                                                                |
+| [getL1Fee](#getl1fee)                    | The L1 portion of the fee based on the size of the [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/) encoded transaction, the current L1 base fee, and other various dynamic parameters |
+| [getL2Fee](#getl2fee)                    | The L2 portion of the fee based on the simulated execution of the provided transaction and current `gasPrice`                                                                                                          |
+| [getBaseFee](#getbasefee)                | The current L2 base fee                                                                                                                                                                                                |
+| [getDecimals](#getdecimals)              | The decimals used in the scalar                                                                                                                                                                                        |
+| [getGasPrice](#getgasprice)              | The current L2 gas price                                                                                                                                                                                               |
+| [getL1GasUsed](#getl1gasused)            | The amount of L1 gas estimated to be used to execute a transaction                                                                                                                                                     |
+| [getL1BaseFee](#getdegetl1basefeecimals) | The L1 base fee                                                                                                                                                                                                        |
+| [getOverhead](#getoverhead)              | The current overhead                                                                                                                                                                                                   |
+| [getScalar](#getscalar)                  | The current fee scalar                                                                                                                                                                                                 |
+| [getVersion](#getversion)                | The current version of `GasPriceOracle`                                                                                                                                                                                |
+
+---
+
+### `estimateFees`
+
+Computes the total (L1 + L2) fee estimate to execute a transaction
+
+```typescript
+async estimateFees(transaction: Transaction, options?: { blockNumber?: BlockNumberOrTag, returnFormat?: ReturnFormat })
+```
+
+#### Parameters
+
+- `transaction: Transaction` - An unsigned web3.js [transaction](https://docs.web3js.org/api/web3-types/interface/Transaction) object
+- `options?: { blockNumber?: BlockNumberOrTag, returnFormat?: ReturnFormat }` - An optional object with properties:
+  - `blockNumber?: BlockNumberOrTag` - Specifies what block to use for gas estimation. Can be either:
+    - **Note** Specifying a block to estimate L2 gas for is currently not working
+    - A web3.js [Numbers](https://docs.web3js.org/api/web3-types#Numbers)
+    - A web3.js [BlockTags](https://docs.web3js.org/api/web3-types/enum/BlockTags)
+    - If not provided, `BlockTags.LATEST` is used
+  - `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+    - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The estimated total fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+import Web3 from 'web3'
+import {
+  l2StandardBridgeABI,
+  l2StandardBridgeAddress,
+} from '@eth-optimism/contracts-ts'
+
+const web3 = new Web3('https://mainnet.optimism.io')
+const l2BridgeContract = new web3.eth.Contract(
+  l2StandardBridgeABI,
+  optimistAddress[420]
+)
+const encodedWithdrawMethod = l2BridgeContract.methods
+  .withdraw(
+    // l2 token address
+    '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
+    // amount
+    Web3.utils.toWei('0.00000001', 'ether'),
+    // l1 gas
+    0,
+    // extra data
+    '0x00'
+  )
+  .encodeABI()
+
+const totalFee = await web3.op.estimateFees({
+  chainId: 10,
+  data: encodedWithdrawMethod,
+  value: Web3.utils.toWei('0.00000001', 'ether'),
+  type: 2,
+  to: '0x420000000000000000000000000000000000000F',
+  from: '0x6387a88a199120aD52Dd9742C7430847d3cB2CD4',
+  maxFeePerGas: Web3.utils.toWei('0.2', 'gwei'),
+  maxPriorityFeePerGas: Web3.utils.toWei('0.1', 'gwei'),
+})
+
+console.log(totalFee) // 26608988767659n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+import Web3 from 'web3'
+import {
+  l2StandardBridgeABI,
+  l2StandardBridgeAddress,
+} from '@eth-optimism/contracts-ts'
+
+const web3 = new Web3('https://mainnet.optimism.io')
+const l2BridgeContract = new web3.eth.Contract(
+  l2StandardBridgeABI,
+  optimistAddress[420]
+)
+const encodedWithdrawMethod = l2BridgeContract.methods
+  .withdraw(
+    // l2 token address
+    '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
+    // amount
+    Web3.utils.toWei('0.00000001', 'ether'),
+    // l1 gas
+    0,
+    // extra data
+    '0x00'
+  )
+  .encodeABI()
+
+const totalFee = await web3.op.estimateFees(
+  {
+    chainId: 10,
+    data: encodedWithdrawMethod,
+    value: Web3.utils.toWei('0.00000001', 'ether'),
+    type: 2,
+    to: '0x420000000000000000000000000000000000000F',
+    from: '0x6387a88a199120aD52Dd9742C7430847d3cB2CD4',
+    maxFeePerGas: Web3.utils.toWei('0.2', 'gwei'),
+    maxPriorityFeePerGas: Web3.utils.toWei('0.1', 'gwei'),
+  },
+  { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX }
+)
+
+console.log(totalFee) // 0x18336352c5ab
+```
+
+### `getL1Fee`
+
+Computes the L1 portion of the fee based on the size of the rlp encoded input transaction, the current L1 base fee, and the various dynamic parameters
+
+```typescript
+async getL1Fee(transaction: Transaction, returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `transaction: Transaction` - An unsigned web3.js [transaction](https://docs.web3js.org/api/web3-types/interface/Transaction) object
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The estimated L1 fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l1Fee = await web3.op.getL1Fee({
+  chainId: 10,
+  data: encodedBurnMethod,
+  type: 2,
+})
+
+console.log(l1Fee) // 18589035222172n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l1Fee = await web3.op.getL1Fee(
+  {
+    chainId: 10,
+    data: encodedBurnMethod,
+    type: 2,
+  },
+  { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX }
+)
+
+console.log(l1Fee) // 0x10e818d7549c
+```
+
+### `getL2Fee`
+
+Retrieves the amount of L2 gas estimated to execute `transaction`
+
+```typescript
+async getL2Fee(transaction: Transaction, returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `transaction: Transaction` - An unsigned web3.js [transaction](https://docs.web3js.org/api/web3-types/interface/Transaction) object
+- `options?: { blockNumber?: BlockNumberOrTag, returnFormat?: ReturnFormat }` - An optional object with properties:
+  - `blockNumber?: BlockNumberOrTag` - Specifies what block to use for gas estimation. Can be either:
+    - **Note** Specifying a block to estimate L2 gas for is currently not working
+    - A web3.js [Numbers](https://docs.web3js.org/api/web3-types#Numbers)
+    - A web3.js [BlockTags](https://docs.web3js.org/api/web3-types/enum/BlockTags)
+    - If not provided, `BlockTags.LATEST` is used
+  - `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+    - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The estimated total fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l2Fee = await web3.op.getL2Fee({
+  chainId: '0xa',
+  data: encodedBurnMethod,
+  type: '0x2',
+  to: optimistAddress[420],
+  from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+})
+
+console.log(l2Fee) // 2659500n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l2Fee = await web3.op.getL2Fee(
+  {
+    chainId: '0xa',
+    data: encodedBurnMethod,
+    type: '0x2',
+    to: optimistAddress[420],
+    from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+  },
+  {
+    returnFormat: { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX },
+  }
+)
+
+console.log(l2Fee) // 0x2894ac
+```
+
+### `getBaseFee`
+
+Retrieves the current L2 base fee
+
+```typescript
+async getBaseFee(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The L2 base fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const baseFee = await web3.op.getBaseFee()
+
+console.log(baseFee) // 68n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const baseFee = await web3.op.getBaseFee({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(baseFee) // 0x44
+```
+
+### `getDecimals`
+
+Retrieves the decimals used in the scalar
+
+```typescript
+async getDecimals(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The number of decimals as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const decimals = await web3.op.getDecimals()
+
+console.log(decimals) // 6n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const decimals = await web3.op.getDecimals({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(decimals) // 0x6
+```
+
+### `getGasPrice`
+
+Retrieves the current L2 gas price (base fee)
+
+```typescript
+async getGasPrice(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The current L2 gas price as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const gasPrice = await web3.op.getGasPrice()
+
+console.log(gasPrice) // 77n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const gasPrice = await web3.op.getGasPrice({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(gasPrice) // 0x4d
+```
+
+### `getL1GasUsed`
+
+Computes the amount of L1 gas used for {transaction}. Adds the overhead which represents the per-transaction gas overhead of posting the {transaction} and state roots to L1. Adds 68 bytes of padding to account for the fact that the input does not have a signature.
+
+```typescript
+async getL1GasUsed(transaction: Transaction, returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `transaction: Transaction` - An unsigned web3.js [transaction](https://docs.web3js.org/api/web3-types/interface/Transaction) object
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The amount of gas as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l1GasUsed = await web3.op.getL1GasUsed({
+  chainId: 10,
+  data: encodedBurnMethod,
+  type: 2,
+})
+
+console.log(l1GasUsed) // 1884n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+import { Contract } from 'web3'
+import { optimistABI, optimistAddress } from '@eth-optimism/contracts-ts'
+
+const optimistContract = new Contract(optimistABI, optimistAddress[420])
+const encodedBurnMethod = optimistContract.methods
+  .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+  .encodeABI()
+
+const l1GasUsed = await web3.op.getL1GasUsed(
+  {
+    chainId: 10,
+    data: encodedBurnMethod,
+    type: 2,
+  },
+  { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX }
+)
+
+console.log(l1GasUsed) // 0x75c
+```
+
+### `getL1BaseFee`
+
+Retrieves the latest known L1 base fee
+
+```typescript
+async getL1BaseFee(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The L1 base fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const baseFee = await web3.op.getL1BaseFee()
+
+console.log(baseFee) // 13752544112n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const baseFee = await web3.op.getL1BaseFee({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(baseFee) // 0x333b72b70
+```
+
+### `getOverhead`
+
+Retrieves the current fee overhead
+
+```typescript
+async getOverhead(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The current overhead as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const overhead = await web3.op.getOverhead()
+
+console.log(overhead) // 188n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const overhead = await web3.op.getOverhead({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(overhead) // 0xbc
+```
+
+### `getScalar`
+
+Retrieves the current fee scalar
+
+```typescript
+async getScalar(returnFormat?: ReturnFormat)
+```
+
+#### Parameters
+
+- `returnFormat?: ReturnFormat` - A web3.js [DataFormat](https://docs.web3js.org/api/web3-types#DataFormat) object that specifies how to format number and bytes values
+  - If `returnFormat` is not provided, [DEFAULT_RETURN_FORMAT](https://docs.web3js.org/api/web3-types#DEFAULT_RETURN_FORMAT) is used which will format numbers to `BigInt`s
+
+#### Returns
+
+- `Promise<Numbers>` - The current scalar fee as a `BigInt` by default, but `returnFormat` determines type
+
+#### Example
+
+```typescript
+const scalarFee = await web3.op.getScalar()
+
+console.log(scalarFee) // 684000n
+```
+
+##### Formatting Response as a Hex String
+
+```typescript
+const scalarFee = await web3.op.getScalar({
+  number: FMT_NUMBER.HEX,
+  bytes: FMT_BYTES.HEX,
+})
+
+console.log(scalarFee) // 0xa6fe0
+```
+
+### `getVersion`
+
+Retrieves the full semver version of GasPriceOracle
+
+```typescript
+async getVersion()
+```
+
+#### Returns
+
+- `Promise<string>` - The semver version
+
+#### Example
+
+```typescript
+const version = await web3.op.getVersion()
+
+console.log(version) // 1.0.0
+```
+
+## Known Issues
+
+- `input` and `data`
+- `blockNumber` for `estimateFees` doesn't work

packages/web3.js-plugin-fee-estimation/package.json

+{
+  "name": "@eth-optimism/web3.js-plugin-fee-estimation",
+  "version": "0.1.0",
+  "description": "A Web3.js plugin for doing OP-Chain gas estimation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ethereum-optimism/optimism.git",
+    "directory": "packages/web3js-plugin-fee-estimation"
+  },
+  "homepage": "https://optimism.io",
+  "type": "module",
+  "main": "dist/plugin.js",
+  "module": "dist/plugin.mjs",
+  "types": "src/plugin.ts",
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "prettier --check .",
+    "lint:fix": "prettier --write .",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@eth-optimism/contracts-ts": "workspace:^",
+    "@vitest/coverage-istanbul": "^0.33.0",
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6",
+    "viem": "^1.3.1",
+    "vite": "^4.4.6",
+    "vitest": "^0.33.0"
+  },
+  "dependencies": {
+    "@ethereumjs/rlp": "^4.0.1",
+    "web3-eth": "^4.0.3",
+    "web3-eth-accounts": "^4.0.3"
+  },
+  "peerDependencies": {
+    "web3": ">= 4.0.3 < 5.x"
+  }
+}

packages/web3.js-plugin-fee-estimation/src/plugin.spec.ts

+import { beforeAll, describe, expect, test } from 'vitest'
+import Web3, { Contract, FMT_BYTES, FMT_NUMBER } from 'web3'
+import {
+  l2StandardBridgeABI,
+  l2StandardBridgeAddress,
+  optimistABI,
+  optimistAddress,
+} from '@eth-optimism/contracts-ts'
+
+import OptimismFeeEstimationPlugin from './plugin'
+
+const provider = process.env.VITE_L2_RPC_URL ?? 'https://mainnet.optimism.io'
+
+describe('OptimismFeeEstimationPlugin', () => {
+  let web3: Web3
+
+  beforeAll(() => {
+    web3 = new Web3(provider)
+    web3.registerPlugin(new OptimismFeeEstimationPlugin())
+  })
+
+  test('should be registered under .op namespace', () =>
+    expect(web3.op).toBeDefined())
+
+  describe('should return a bigint by default', () => {
+    test('getBaseFee', async () =>
+      expect(typeof (await web3.op.getBaseFee())).toBe('bigint'))
+
+    test('getDecimals should return 6n', async () =>
+      expect(await web3.op.getDecimals()).toBe(BigInt(6)))
+
+    test('getGasPrice', async () =>
+      expect(typeof (await web3.op.getGasPrice())).toBe('bigint'))
+
+    test('getL1BaseFee', async () =>
+      expect(typeof (await web3.op.getL1BaseFee())).toBe('bigint'))
+
+    test('getOverhead should return 188n', async () =>
+      expect(await web3.op.getOverhead()).toBe(BigInt(188)))
+
+    test('getScalar should return 684000n', async () =>
+      expect(await web3.op.getScalar()).toBe(BigInt(684000)))
+  })
+
+  describe('should return a number', () => {
+    const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+
+    test('getBaseFee', async () =>
+      expect(typeof (await web3.op.getBaseFee(numberFormat))).toBe('number'))
+
+    test('getDecimals should return 6', async () =>
+      expect(await web3.op.getDecimals(numberFormat)).toBe(6))
+
+    test('getGasPrice', async () =>
+      expect(typeof (await web3.op.getGasPrice(numberFormat))).toBe('number'))
+
+    test('getL1BaseFee', async () =>
+      expect(typeof (await web3.op.getL1BaseFee(numberFormat))).toBe('number'))
+
+    test('getOverhead should return 188', async () =>
+      expect(await web3.op.getOverhead(numberFormat)).toBe(188))
+
+    test('getScalar should return 684000', async () =>
+      expect(await web3.op.getScalar(numberFormat)).toBe(684000))
+  })
+
+  test('getVersion should return the string 1.0.0', async () =>
+    expect(await web3.op.getVersion()).toBe('1.0.0'))
+
+  describe('Contract transaction gas estimates - optimistABI.burn', () => {
+    let optimistContract: Contract<typeof optimistABI>
+    let encodedBurnMethod: string
+
+    beforeAll(() => {
+      optimistContract = new web3.eth.Contract(optimistABI)
+      encodedBurnMethod = optimistContract.methods
+        .burn('0x77194aa25a06f932c10c0f25090f3046af2c85a6')
+        .encodeABI()
+    })
+
+    describe('should return a bigint by default', () => {
+      test('getL1Fee', async () => {
+        expect(
+          typeof (await web3.op.getL1Fee({
+            chainId: '0xa',
+            data: encodedBurnMethod,
+            type: '0x2',
+          }))
+        ).toBe('bigint')
+      })
+
+      test('getL1GasUsed should return 1884n', async () =>
+        expect(
+          await web3.op.getL1GasUsed({
+            chainId: '0xa',
+            data: encodedBurnMethod,
+            type: '0x2',
+          })
+        ).toBe(BigInt(1884)))
+
+      test('estimateFees', async () =>
+        expect(
+          typeof (await web3.op.estimateFees({
+            chainId: 10,
+            data: encodedBurnMethod,
+            type: 2,
+            to: optimistAddress[10],
+            from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+          }))
+        ).toBe('bigint'))
+
+      test('getL2Fee', async () => {
+        expect(
+          typeof (await web3.op.getL2Fee({
+            chainId: '0xa',
+            data: encodedBurnMethod,
+            type: '0x2',
+            to: optimistAddress[10],
+            from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+          }))
+        ).toBe('bigint')
+      })
+
+      test('estimateFees', async () =>
+        expect(
+          typeof (await web3.op.estimateFees(
+            {
+              chainId: 10,
+              data: encodedBurnMethod,
+              type: 2,
+              to: optimistAddress[10],
+              from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+            },
+            { blockNumber: 107028270 }
+          ))
+        ).toBe('bigint'))
+    })
+
+    describe('should return a hexString', () => {
+      const hexStringFormat = { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX }
+
+      test('getL1Fee', async () => {
+        expect(
+          typeof (await web3.op.getL1Fee(
+            {
+              chainId: '0xa',
+              data: encodedBurnMethod,
+              type: '0x2',
+            },
+            hexStringFormat
+          ))
+        ).toBe('string')
+      })
+
+      test('getL1GasUsed should return 0x75c', async () =>
+        expect(
+          await web3.op.getL1GasUsed(
+            {
+              chainId: '0xa',
+              data: encodedBurnMethod,
+              type: '0x2',
+            },
+            hexStringFormat
+          )
+        ).toBe('0x75c'))
+
+      test('estimateFees', async () =>
+        expect(
+          typeof (await web3.op.estimateFees(
+            {
+              chainId: 10,
+              data: encodedBurnMethod,
+              type: 2,
+              to: optimistAddress[10],
+              from: '0x77194aa25a06f932c10c0f25090f3046af2c85a6',
+            },
+            { returnFormat: hexStringFormat }
+          ))
+        ).toBe('string'))
+    })
+  })
+
+  describe('Contract transaction gas estimates - l2StandardBridgeABI.withdraw', () => {
+    let l2BridgeContract: Contract<typeof l2StandardBridgeABI>
+    let encodedWithdrawMethod: string
+
+    beforeAll(() => {
+      l2BridgeContract = new Contract(
+        l2StandardBridgeABI,
+        l2StandardBridgeAddress[420]
+      )
+      encodedWithdrawMethod = l2BridgeContract.methods
+        .withdraw(
+          // l2 token address
+          '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
+          // amount
+          Web3.utils.toWei('0.00000001', 'ether'),
+          // l1 gas
+          0,
+          // extra data
+          '0x00'
+        )
+        .encodeABI()
+    })
+
+    describe('should return a bigint by default', () => {
+      test('getL1Fee', async () => {
+        expect(
+          typeof (await web3.op.getL1Fee({
+            chainId: '0xa',
+            data: encodedWithdrawMethod,
+            type: '0x2',
+          }))
+        ).toBe('bigint')
+      })
+
+      test('getL1GasUsed should return 2592n', async () =>
+        expect(
+          await web3.op.getL1GasUsed({
+            chainId: '0xa',
+            data: encodedWithdrawMethod,
+            type: '0x2',
+          })
+        ).toBe(BigInt(2592)))
+
+      test('estimateFees', async () =>
+        expect(
+          typeof (await web3.op.estimateFees({
+            chainId: 10,
+            data: encodedWithdrawMethod,
+            value: Web3.utils.toWei('0.00000001', 'ether'),
+            type: 2,
+            to: l2StandardBridgeAddress[420],
+            from: '0x6387a88a199120aD52Dd9742C7430847d3cB2CD4',
+            maxFeePerGas: Web3.utils.toWei('0.2', 'gwei'),
+            maxPriorityFeePerGas: Web3.utils.toWei('0.1', 'gwei'),
+          }))
+        ).toBe('bigint'))
+    })
+  })
+})

packages/web3.js-plugin-fee-estimation/src/plugin.ts

+import Web3, {
+  BlockNumberOrTag,
+  BlockTags,
+  Contract,
+  DataFormat,
+  DEFAULT_RETURN_FORMAT,
+  FMT_BYTES,
+  FMT_NUMBER,
+  Numbers,
+  Transaction,
+  Web3PluginBase,
+} from 'web3'
+import { TransactionFactory, TxData } from 'web3-eth-accounts'
+import { estimateGas, formatTransaction } from 'web3-eth'
+import {
+  gasPriceOracleABI,
+  gasPriceOracleAddress,
+} from '@eth-optimism/contracts-ts'
+import { RLP } from '@ethereumjs/rlp'
+
+export default class OptimismFeeEstimationPlugin extends Web3PluginBase {
+  public pluginNamespace = 'op'
+
+  private _gasPriceOracleContract:
+    | Contract<typeof gasPriceOracleABI>
+    | undefined
+
+  /**
+   * Retrieves the current L2 base fee
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<bigint>} - The L2 base fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const baseFeeValue: bigint = await web3.op.getBaseFee();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const baseFeeValue: number = await web3.op.getBaseFee(numberFormat);
+   */
+  public async getBaseFee<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.baseFee().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the decimals used in the scalar
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The number of decimals as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const decimalsValue: bigint = await web3.op.getDecimals();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const decimalsValue: number = await web3.op.getDecimals(numberFormat);
+   */
+  public async getDecimals<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.decimals().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the current L2 gas price (base fee)
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The current L2 gas price as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const gasPriceValue: bigint = await web3.op.getGasPrice();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const gasPriceValue: number = await web3.op.getGasPrice(numberFormat);
+   */
+  public async getGasPrice<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.gasPrice().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Computes the L1 portion of the fee based on the size of the rlp encoded input
+   * transaction, the current L1 base fee, and the various dynamic parameters
+   * @param transaction - An unsigned web3.js {Transaction} object
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const l1FeeValue: bigint = await getL1Fee(transaction);
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const l1FeeValue: number = await getL1Fee(transaction, numberFormat);
+   */
+  public async getL1Fee<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(transaction: Transaction, returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance()
+        .methods.getL1Fee(this._serializeTransaction(transaction, returnFormat))
+        .call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Computes the amount of L1 gas used for {transaction}. Adds the overhead which
+   * represents the per-transaction gas overhead of posting the {transaction} and state
+   * roots to L1. Adds 68 bytes of padding to account for the fact that the input does
+   * not have a signature.
+   * @param transaction - An unsigned web3.js {Transaction} object
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The amount gas as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const gasUsedValue: bigint = await getL1GasUsed(transaction);
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const gasUsedValue: number = await getL1GasUsed(transaction, numberFormat);
+   */
+  public async getL1GasUsed<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(transaction: Transaction, returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance()
+        .methods.getL1GasUsed(
+          this._serializeTransaction(transaction, returnFormat)
+        )
+        .call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the latest known L1 base fee
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The L1 base fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const baseFeeValue: bigint = await web3.op.getL1BaseFee();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const baseFeeValue: number = await web3.op.getL1BaseFee(numberFormat);
+   */
+  public async getL1BaseFee<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.l1BaseFee().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the current fee overhead
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The current overhead fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const overheadValue: bigint = await web3.op.getOverhead();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const overheadValue: number = await web3.op.getOverhead(numberFormat);
+   */
+  public async getOverhead<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.overhead().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the current fee scalar
+   * @param {DataFormat} [returnFormat=DEFAULT_RETURN_FORMAT] - The web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The current scalar fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const scalarValue: bigint = await web3.op.getScalar();
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const scalarValue: number = await web3.op.getScalar(numberFormat);
+   */
+  public async getScalar<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(returnFormat?: ReturnFormat) {
+    return Web3.utils.format(
+      { format: 'uint' },
+      await this._getPriceOracleContractInstance().methods.scalar().call(),
+      returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Retrieves the full semver version of GasPriceOracle
+   * @returns {Promise<string>} - The semver version
+   * @example
+   * const version = await web3.op.getVersion();
+   */
+  public async getVersion() {
+    return this._getPriceOracleContractInstance().methods.version().call()
+  }
+
+  /**
+   * Retrieves the amount of L2 gas estimated to execute {transaction}
+   * @param transaction - An unsigned web3.js {Transaction} object
+   * @param {{ blockNumber: BlockNumberOrTag, returnFormat: DataFormat }} [options={blockNumber: BlockTags.LATEST, returnFormat: DEFAULT_RETURN_FORMAT}] -
+   * An options object specifying what block to use for gas estimates and the web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The gas estimate as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const l2Fee: bigint = await getL2Fee(transaction);
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const l2Fee: number = await getL2Fee(transaction, numberFormat);
+   */
+  public async getL2Fee<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(
+    transaction: Transaction,
+    options?: {
+      blockNumber?: BlockNumberOrTag
+      returnFormat?: ReturnFormat
+    }
+  ) {
+    const [gasCost, gasPrice] = await Promise.all([
+      estimateGas(
+        this,
+        transaction,
+        options?.blockNumber ?? BlockTags.LATEST,
+        DEFAULT_RETURN_FORMAT
+      ),
+      this.getGasPrice(),
+    ])
+
+    return Web3.utils.format(
+      { format: 'uint' },
+      gasCost * gasPrice,
+      options?.returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Computes the total (L1 + L2) fee estimate to execute {transaction}
+   * @param transaction - An unsigned web3.js {Transaction} object
+   * @param {{ blockNumber: BlockNumberOrTag, returnFormat: DataFormat }} [options={blockNumber: BlockTags.LATEST, returnFormat: DEFAULT_RETURN_FORMAT}] -
+   * An options object specifying what block to use for gas estimates and the web3.js format object that specifies how to format number and bytes values
+   * @returns {Promise<Numbers>} - The estimated total fee as a BigInt by default, but {returnFormat} determines type
+   * @example
+   * const estimatedFees: bigint = await estimateFees(transaction);
+   * @example
+   * const numberFormat = { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }
+   * const estimatedFees: number = await estimateFees(transaction, numberFormat);
+   */
+  public async estimateFees<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(
+    transaction: Transaction,
+    options?: {
+      blockNumber?: BlockNumberOrTag
+      returnFormat?: ReturnFormat
+    }
+  ) {
+    const [l1Fee, l2Fee] = await Promise.all([
+      this.getL1Fee(transaction),
+      this.getL2Fee(transaction, {
+        blockNumber: options?.blockNumber,
+      }),
+    ])
+
+    return Web3.utils.format(
+      { format: 'uint' },
+      l1Fee + l2Fee,
+      options?.returnFormat ?? DEFAULT_RETURN_FORMAT
+    )
+  }
+
+  /**
+   * Used to get the web3.js contract instance for gas price oracle contract
+   * @returns {Contract<typeof gasPriceOracleABI>} - A web.js contract instance with an RPC provider inherited from root {web3} instance
+   */
+  private _getPriceOracleContractInstance() {
+    if (this._gasPriceOracleContract === undefined) {
+      this._gasPriceOracleContract = new Contract(
+        gasPriceOracleABI,
+        gasPriceOracleAddress[420]
+      )
+      // This plugin's Web3Context is overridden with main Web3 instance's context
+      // when the plugin is registered. This overwrites the Contract instance's context
+      this._gasPriceOracleContract.link(this)
+    }
+
+    return this._gasPriceOracleContract
+  }
+
+  /**
+   * Returns the RLP encoded hex string for {transaction}
+   * @param transaction - A web3.js {Transaction} object
+   * @returns {string} - The RLP encoded hex string
+   */
+  private _serializeTransaction<
+    ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT
+  >(transaction: Transaction, returnFormat?: ReturnFormat) {
+    const ethereumjsTransaction = TransactionFactory.fromTxData(
+      formatTransaction(transaction, {
+        number: FMT_NUMBER.HEX,
+        bytes: FMT_BYTES.HEX,
+      }) as TxData
+    )
+
+    return Web3.utils.bytesToHex(
+      Web3.utils.uint8ArrayConcat(
+        Web3.utils.hexToBytes(
+          ethereumjsTransaction.type.toString(16).padStart(2, '0')
+        ),
+        // If <transaction> doesn't include a signature,
+        // <ethereumjsTransaction.raw()> will autofill v, r, and s
+        // with empty uint8Array. Because L1 fee calculation
+        // is dependent on the number of bytes, we are removing
+        // the zero values bytes
+        RLP.encode(ethereumjsTransaction.raw().slice(0, -3))
+      )
+    )
+  }
+}
+
+// Module Augmentation to add op namespace to root {web3} instance
+declare module 'web3' {
+  interface Web3Context {
+    op: OptimismFeeEstimationPlugin
+  }
+}

packages/web3.js-plugin-fee-estimation/tsconfig.json

+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "strict": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "jsx": "react",
+    "target": "ESNext",
+    "noEmit": true
+  },
+  "include": ["./src"]
+}

packages/web3.js-plugin-fee-estimation/tsup.config.ts

+import { defineConfig } from 'tsup'
+import packageJson from './package.json'
+
+// @see https://tsup.egoist.dev/
+export default defineConfig({
+  name: packageJson.name,
+  entry: ['src/plugin.ts'],
+  outDir: 'dist',
+  format: ['esm', 'cjs'],
+  splitting: false,
+  sourcemap: true,
+  clean: false,
+})

packages/web3.js-plugin-fee-estimation/vite.config.ts

+import { defineConfig } from 'vitest/config'
+
+// @see https://vitest.dev/config/
+export default defineConfig({
+  test: {
+    environment: 'jsdom',
+    coverage: {
+      provider: 'istanbul',
+    },
+  },
+})