itsnickbarry/hardhat-contract-sizer

Output Ethereum contract sizes with Hardhat 📐

Hardhat Contract Sizer

Output Solidity contract sizes with Hardhat.

Versions of this plugin prior to 2.0.0 were released as buidler-contract-sizer.

Installation

npm install --save-dev hardhat-contract-sizer
# or
yarn add --dev hardhat-contract-sizer

Usage

Load plugin in Hardhat config:

require("hardhat-contract-sizer");

Add configuration under the contractSizer key:

option	description	default
alphaSort	whether to sort results table alphabetically (default sort is by contract size)	false
runOnCompile	whether to output contract sizes automatically after compilation	false
disambiguatePaths	whether to output the full path to the compilation artifact (relative to the Hardhat root directory)	false
strict	whether to throw an error if any contracts exceed the size limit (may cause compatibility issues with solidity-coverage)	false
only	Array of String matchers used to select included contracts, defaults to all contracts if length is 0	[]
except	Array of String matchers used to exclude contracts	[]
outputFile	file path to write contract size report	null
unit	unit of measurement for the size of contracts, which can be expressed in 'B' (bytes), 'kB' (kilobytes) or 'KiB' (kibibytes)	KiB

contractSizer: {
  alphaSort: true,
  disambiguatePaths: false,
  runOnCompile: true,
  strict: true,
  only: [':ERC20$'],
}

Run the included Hardhat task to output compiled contract sizes:

npx hardhat size-contracts
# or
yarn run hardhat size-contracts

By default, the hardhat compile task is run before sizing contracts. This behavior can be disabled with the --no-compile flag:

npx hardhat size-contracts --no-compile
# or
yarn run hardhat size-contracts --no-compile

hardhat-contract-sizer's Issues

Contract size issue

Getting contract size issue as while compiling the size of contract is 13.631 (kiB) but while compiling through Remix Got contract size limit excedded.
I tried with both enabling and disabling optimizer. Previously it worked fine.

Rename `disambiguatePaths` option to `flat` (with inverse behavior)

The flat option is also used in hardhat-abi-exporter to similar effect.

Add feature to fail the command when contract size exceeds

Fail the command when the contract size exceeds contract size limit.

This feature would be helpful in setting up CI job.

Contracts that use libraries are not sized accurately

Hi @ItsNickBarry! Love this plugin

When sizing a contract whose bytecode includes library address placeholders, e.g. __$....$__, it seems like the size measurement is incorrect - it only returns size up to the first placeholder entry.

A repro based on how length is measured here is:

const a = "aaaa__$aaaa$__aaaa";
const b = "bbbbbbbbbbbbbbbbbb";

a_bufferLength = Buffer.from(a, 'hex').length;  // Issue w/ non-hex chars?
b_bufferLength = Buffer.from(b, 'hex').length;

a_stringLength = a.length;
b_stringLength = b.length;

console.log(`a_bufferLength: ${a_bufferLength}`);
console.log(`b_bufferLength: ${b_bufferLength}`);
console.log(`a_stringLength: ${a_stringLength}`);
console.log(`b_stringLength: ${b_stringLength}`);

> a_bufferLength: 2  // Short
> b_bufferLength: 9  // OK
> a_stringLength: 18
> b_stringLength: 18

Testing - Include a hardhat test project

Not sure what process is being followed for testing at the moment but I suggest including a typescript hardhat test project, that should improve the development and testing experience.

Seeing red for contract size less than 24.576kb

hardhat-contract-sizer is telling me is that my contract is 24.1kb and is producing the warning message:
Warning: 1 contracts exceed the size limit for mainnet deployment.

My understanding is that contracts can be as much as 24.675kb.

Is this a bug in hardhat-contract-sizer or is there some other legitimate reason I'm seeing Warning: 1 contracts exceed the size limit for mainnet deployment. ?

Inconsistency between hardhat sizer & manual computation

Hey, thanks for this cool tool :)

I am having the following issue. Hardhat sizer shows that my contract is over the limit in color even though the size in number is ok.

Moreover, when I manually check the size of the contract, it's considerably larger.

cat artifacts/contracts/Loadout.sol/Loadout.json | jq -r '.deployedBytecode' | wc -c
   49863

Any ideas?

Support EIP3860 after Shanghai upgrade

With EIP 3860, the contract size limit should be doubled from 24KB to 48KB?

hardhat-contract-sizer/tasks/size_contracts.js

Line 22 in 95b202e

const SIZE_LIMIT = 24576;

-  const SIZE_LIMIT = 24576
+ const SIZE_LIMIT = 24576 * 2

Cache size data by commit hash, and enable direct commit comparison via CLI

Example usage: hh size-contracts --compare 103541870332c9fb9125fad3684fcee613f13960

Inconsistency between output and compiler warning

Observed in this commit: https://github.com/PremiaFinance/premia-contracts-private/commit/a24214cf43e64b469cb9ca672dd909c0752505f5

Can you get contract size with low-run compiler?

More of a question than an issue
I want to see how much less size would I get if I used low-run compiler

Support for NPM?

If this works with NPM as well, could you add that to readme and how to install?

Display appropriate compiler metadata when multiple compilers are in use

If multiple compilers are in use, the displayed "Solc version" and optimizer information output will only match the first entry. This could be confusing, but I've published as-is because the behavior matches that of hardhat-gas-reporter.

Sometimes Sizer/Compiler will give me different compile sizes in Test v's Coverage - hardhat deploy project

Hi there,

I'm using this plug to help me along with some ethereum development and I'm seeing different contract sizing values when I run the tasks in my hardhat project and I wondered what I was doing wrong?

Testing locally I will run some tests against hardhat using the test command:

"test": "HARDHAT_DEPLOY_FIXTURE=true HARDHAT_COMPILE=true mocha --recursive test",

And my hardhat.config.ts is:

import 'dotenv/config';
import {HardhatUserConfig} from 'hardhat/types';
import 'hardhat-deploy';
import '@nomiclabs/hardhat-ethers';
import 'hardhat-gas-reporter';
import '@typechain/hardhat';
import 'solidity-coverage';
import {node_url, accounts} from './utils/network';
import 'hardhat-tracer';
import 'hardhat-contract-sizer';

// While waiting for hardhat PR: https://github.com/nomiclabs/hardhat/pull/1542
if (process.env.HARDHAT_FORK) {
  process.env['HARDHAT_DEPLOY_FORK'] = process.env.HARDHAT_FORK;
}

const config: HardhatUserConfig = {
  solidity: {
    version: '0.8.7',
    settings: {
      optimizer: {
        runs: 200, // Default 200
        enabled: !process.env.DEBUG,
      },
    },
  },
  namedAccounts: {
    deployer: 0,
    minter: 1,
    gameWallet: 2,
    buybackWallet: 3,
    player1: 4,
    player2: 5,
    player3: 6,
    player4: 7,
  },
  networks: {
    hardhat: {
      initialBaseFeePerGas: 0, // to fix : https://github.com/sc-forks/solidity-coverage/issues/652, see https://github.com/sc-forks/solidity-coverage/issues/652#issuecomment-896330136
      // process.env.HARDHAT_FORK will specify the network that the fork is made from.
      // this line ensure the use of the corresponding accounts
      accounts: accounts(process.env.HARDHAT_FORK),
      forking: process.env.HARDHAT_FORK
        ? {
            // TODO once PR merged : network: process.env.HARDHAT_FORK,
            url: node_url(process.env.HARDHAT_FORK),
            blockNumber: process.env.HARDHAT_FORK_NUMBER
              ? parseInt(process.env.HARDHAT_FORK_NUMBER)
              : undefined,
          }
        : undefined,
    },
    localhost: {
      url: node_url('localhost'),
      accounts: accounts(),
    },
   
  },
  paths: {
    sources: 'src',
  },
  gasReporter: {
    currency: 'USD',
    gasPrice: 100,
    enabled: process.env.REPORT_GAS ? true : false,
    coinmarketcap: process.env.COINMARKETCAP_API_KEY,
    maxMethodDiff: 10,
  },
  typechain: {
    outDir: 'typechain',
    target: 'ethers-v5',
  },
  mocha: {
    timeout: 10_000,
  },
  contractSizer: {
    alphaSort: true,
    disambiguatePaths: true,
    runOnCompile: true,
    strict: true,
  },
};

export default config;

So when I run a test my contracts are sized like this:

Nothing to compile
No need to generate any newer typings.
 ·---------------------------------------------------------------------------------------------------------|-------------·
 |  Contract Name                                                                                          ·  Size (Kb)  │
 ··········································································································|··············
 |  @openzeppelin/contracts/token/ERC1155/ERC1155.sol:ERC1155                                              ·       4.95  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Address.sol:Address                                                      ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Counters.sol:Counters                                                    ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Strings.sol:Strings                                                      ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/structs/EnumerableSet.sol:EnumerableSet                                  ·       0.08  │
 ··········································································································|··············
 |  src/test/TestPackNFT.sol:TestPackNFT                                                                   ·      10.64  │
 ·---------------------------------------------------------------------------------------------------------|-------------·
✨  Done in 3.15s.

but if I do run the coverage task:

 "coverage": "HARDHAT_DEPLOY_FIXTURE=true hardhat coverage",

I get the following:

Network Info
============
> HardhatEVM: v2.6.4
> network:    hardhat

Nothing to compile
No need to generate any newer typings.
 ·---------------------------------------------------------------------------------------------------------|-------------·
 |  Contract Name                                                                                          ·  Size (Kb)  │
 ··········································································································|··············
 |  @openzeppelin/contracts/token/ERC1155/ERC1155.sol:ERC1155                                              ·       9.42  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Address.sol:Address                                                      ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Counters.sol:Counters                                                    ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/Strings.sol:Strings                                                      ·       0.08  │
 ··········································································································|··············
 |  @openzeppelin/contracts/utils/structs/EnumerableSet.sol:EnumerableSet                                  ·       0.08  │
 ··········································································································|··············
 |  src/test/TestPackNFT.sol:TestPackNFT                                                                   ·      23.24  │
 ·---------------------------------------------------------------------------------------------------------|-------------·

Thats almost double the size value so I'm not sure what I'm doing wrong or does it do something else when running tests locally?

Sorry for the n00b question.

Disable `strict` option when `hardhat-coverage` is in use

The hardhat-coverage plugin greatly increases the size of contracts, and therefore cannot be used if the strict option is enabled. Should check whether that plugin is running, or perhaps rely on the allowUnlimitedContractSize option.

Uncompiled Internal Functions

Overview

We use the contract sizer to analyze our contract size a lot. An issue we find is if internal functions are not been called in the contract, they will not be compiled into the contract, so it's hard to analyze the size of internal functions. This case does happen if I have a contract A with some internal functions, and then contract B inherits A and calls the internal functions.

Proposed Solution

Show how many internal functions that are igonre when compiling. I'm not sure whether it's doable. It's just an idea. Hope someone can propose better ideas or guidance.

Validate initcode size

As mentioned in #32, there is now a limit on initialization code size in addition to deployed code size. Initialization code size is also exposed in the compilation artifacts, so the plugin could (optionally?) also validate initialization code size.

See here: https://eips.ethereum.org/EIPS/eip-3860#parameters

Contracts are repeating twice, not sure why...

Some contracts are calculated twice, can we have an option to either have a filter function or just prevent it? also would be nice to just print it to a file.

Skip `runOnCompile` if no files have been changed

If Hardhat returns "nothing to compile", size report should not be printed.

Hardhat and Truffle output different contract sizes

I can deploy contract using Truffle, but not Hardhat. i don't know which one is true.

it's truffle output

it's Hardhat output

Display contract sizes in KiB rather than KB

Contract size limit is 24 KB, or 24576 bytes. The current implementation divides contract size by 1000, rather than 1024, giving a slightly different impression of what the actual contract size is.

Add feature to skip files

Add a feature to skip the list of files to check for the contract size.