Prettier Solidity cannot always distinguish between a modifier and a base constructor. Consequently, modifiers with no arguments are formatted with their parentheses removed in standard functions, but not in constructors.

Example behavior:

contract Foo is Bar {
  // Parentheses are KEPT in constructors
  constructor() Bar() modifier1 modifier2() modifier3(42) {}

  // Parentheses are REMOVED in functions
  function f() modifier1 modifier2 modifier3(42) {}
}

The following rules apply to variable and mapping declarations:

• Mappings: Do not include a space between the mapping keyword and its type. This applies to both standard and nested mappings.
• Arrays: Do not include a space between the type and the square brackets [].
• Strings: Use double-quotes (") instead of single-quotes (') for strings.

mapping(uint => uint) map;
mapping(address => bool) registeredAddresses;
mapping(uint => mapping(bool => Data[])) public data;

uint[] x;

str = "foo";

The compiler option allows you to specify a Solidity version to ensure formatting is compatible with specific compiler behaviors.

• v0.7.4+: Enables multi-line import statements. Prior to this, imports were forced to a single line to avoid compiler bugs.
• v0.8.0+: Adjusts formatting for changes like the removal of the byte type and the change to right-associative exponentiation (a**b**c).

You can use Prettier overrides to apply different compiler settings to different directories in a multi-version project.

{
  "overrides": [
    {
      "files": "contracts/v1/**/*.sol",
      "options": {
        "compiler": "0.6.3"
      }
    },
    {
      "files": "contracts/v2/**/*.sol",
      "options": {
        "compiler": "0.8.4"
      }
    }
  ]
}

To maintain readability, keep lines under 79 or 99 characters. When lines are wrapped, follow these rules:

1. The first argument must not be attached to the opening parenthesis.
2. Use exactly one level of indentation for wrapped elements.
3. Each argument must fall on its own line.
4. The terminating element (e.g., ); or ];) must be placed on its own line at the end.

This applies to:

• Function Calls
• Assignment Statements
• Event Definitions and Emitters

thisFunctionCallIsReallyLong(
    longArgument1,
    longArgument2,
    longArgument3
);

thisIsALongNestedMapping[being][set][to_some_value] = someFunction(
    argument1,
    argument2,
    argument3,
    argument4
);

event LongAndLotsOfArgs(
    address sender,
    address recipient,
    uint256 publicKey,
    uint256 amount,
    bytes32[] options
);

Use the Prettier CLI to format your contracts. You must explicitly specify the plugin using the --plugin flag.

Note: The plugin only works with valid Solidity code. Syntax errors will cause a parser error and no formatting will be performed.

npx prettier --write --plugin=prettier-plugin-solidity 'contracts/**/*.sol'

To use the plugin in a browser environment, you must load Prettier's standalone bundle before the plugin. When using unpkg, the plugin populates the global prettierPlugins object.

To format code, use prettier.format with the slang parser and include prettierPlugins.solidity in the plugins array.

<script type="module">
  await import('https://unpkg.com/prettier@latest');
  await import('https://unpkg.com/prettier-plugin-solidity@latest');

  // The global variables `prettier` and `prettierPlugins` are automatically
  // created and populated by importing each module.

  async function format(code) {
    return await prettier.format(code, {
      parser: 'slang',
      plugins: [prettierPlugins.solidity]
    });
  }

  const originalCode = 'contract Foo    {}';
  const formattedCode = format(originalCode);
</script>

For more granular control, use the prettier-vscode extension. To ensure it works with this plugin, you must have prettier and prettier-plugin-solidity installed locally in your project's node_modules via package.json.

1. Install the extension: esbenp.prettier-vscode.
2. Install local dependencies: npm install --save-dev prettier prettier-plugin-solidity.
3. Configure the language-specific default formatter in VSCode settings.

Important: If a .prettierrc file exists in your project, it will take precedence over VSCode's settings.json rules.

code --install-extension esbenp.prettier-vscode
npm install --save-dev prettier prettier-plugin-solidity

After configuring via Command Palette:

{
  "editor.formatOnSave": true,
  "[solidity]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode"
  }
}

To upgrade, install the latest version:

npm install prettier-plugin-solidity@latest

If you previously had an explicit parser defined in your .prettierrc, you will encounter an error: [error] Couldn't resolve parser "solidity-parse". To fix this, update your .prettierrc to use the new parser name: slang.

{
  "parser": "slang"
}

VSCode requires a Solidity language extension for formatting support. The recommended approach is using the hardhat-solidity extension.

1. Install the extension: NomicFoundation.hardhat-solidity.
2. Ensure editor.formatOnSave is enabled.
3. Set the default formatter for Solidity to NomicFoundation.hardhat-solidity in your settings.json.

Note: These extensions typically provide basic integration with Prettier automatically.

code --install-extension NomicFoundation.hardhat-solidity

{
  "editor.formatOnSave": true,
  "solidity.formatter": "prettier",
  "[solidity]": {
    "editor.defaultFormatter": "NomicFoundation.hardhat-solidity"
  }
}