slither Documentation

Technical Documentation: crytic/slither

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`) Copy Section

[Slither, the smart contract static analyzer](https://crytic.github.io/slither/slither.html)

Join the Empire Hacking Slack

- Discussions and Support

Slither is a Solidity & Vyper static analysis framework written in Python3. It runs a suite of vulnerability detectors, prints visual information about contract details, and provides an API to easily write custom analyses. Slither enables developers to find vulnerabilities, enhance their code comprehension, and quickly prototype custom analyses.

• Features
• Usage
• How to install
  • Using uv (Recommended)
  • Using Pip
  • Using Git
  • Using Docker
  • Integration
• Detectors
• Printers
  • Quick Review Printers
  • In-Depth Review Printers
• Tools
• API Documentation
• Getting Help
• FAQ
• License
• Publications
  • Trail of Bits publication
  • External publications

Features Copy Chapter

• Detects vulnerable Solidity code with low false positives (see the list of trophies)
• Identifies where the error condition occurs in the source code
• Easily integrates into continuous integration and Hardhat/Foundry builds
• Built-in 'printers' quickly report crucial contract information
• Detector API to write custom analyses in Python
• Ability to analyze contracts written with Solidity >= 0.4
• Intermediate representation (SlithIR) enables simple, high-precision analyses
• Correctly parses 99.9% of all public Solidity code
• Average execution time of less than 1 second per contract
• Integrates with Github's code scanning in CI
• Support for Vyper smart contracts

Usage Copy Chapter

Run Slither on a Hardhat/Foundry/Dapp/Brownie application:

slither .

This is the preferred option if your project has dependencies as Slither relies on the underlying compilation framework to compile source code.

However, you can run Slither on a single file that does not import dependencies:

slither tests/uninitialized.sol

How to install Copy Chapter

Note
Slither requires Python 3.10+.
If you're not going to use one of the supported compilation frameworks, you need solc, the Solidity compiler; we recommend using solc-select to conveniently switch between solc versions.

Using uv (Recommended) Copy Section

uv is a fast Python package manager that's 10-100x faster than pip.

# Install uv if you haven't already
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install slither as a tool
uv tool install slither-analyzer

# Or run slither without installation
uvx --from slither-analyzer slither <target>

To upgrade:

uv tool upgrade slither-analyzer

Using Pip Copy Section

python3 -m pip install slither-analyzer

To upgrade:

python3 -m pip install --upgrade slither-analyzer

Using Brew Copy Section

brew install slither-analyzer

Using Git (Development) Copy Section

git clone https://github.com/crytic/slither.git && cd slither

# Install as editable for development
uv tool install -e .

# Or use uv run for testing without installation
uv run slither <target>

The -e flag installs in editable mode, meaning changes to the source code are immediately reflected without reinstalling.

Using Docker Copy Section

Use the eth-security-toolbox docker image. It includes all of our security tools and every major version of Solidity in a single image. /home/share will be mounted to /share in the container.

docker pull trailofbits/eth-security-toolbox

To share a directory in the container:

docker run -it -v /home/share:/share trailofbits/eth-security-toolbox

Integration Copy Section

• For GitHub action integration, use slither-action.
• For pre-commit integration, use (replace $GIT_TAG with real tag)
  yaml Copy

  - repo: https://github.com/crytic/slither
    rev: $GIT_TAG
    hooks:
      - id: slither

• To generate a Markdown report, use slither [target] --checklist.
• To generate a Markdown with GitHub source code highlighting, use slither [target] --checklist --markdown-root https://github.com/ORG/REPO/blob/COMMIT/ (replace ORG, REPO, COMMIT)

Detectors Copy Chapter

For more information, see

• The Detector Documentation for details on each detector
• The Detection Selection to run only selected detectors. By default, all the detectors are run.
• The Triage Mode to filter individual results

Printers Copy Chapter

Quick Review Printers Copy Section

• human-summary: Print a human-readable summary of the contracts
• inheritance-graph: Export the inheritance graph of each contract to a dot file
• contract-summary: Print a summary of the contracts
• loc: Count the total number lines of code (LOC), source lines of code (SLOC), and comment lines of code (CLOC) found in source files (SRC), dependencies (DEP), and test files (TEST).
• entry-points: Print all the state-changing entry point functions and their variables of the contracts

In-Depth Review Printers Copy Section

• call-graph: Export the call-graph of the contracts to a dot file
• cfg: Export the CFG of each functions
• function-summary: Print a summary of the functions
• vars-and-auth: Print the state variables written and the authorization of the functions
• not-pausable: Print functions that do not use whenNotPaused modifier.

To run a printer, use --print and a comma-separated list of printers.

See the Printer documentation for the complete lists.

Tools Copy Chapter

• slither-check-upgradeability: Review delegatecall-based upgradeability
• slither-prop: Automatic unit test and property generation
• slither-flat: Flatten a codebase
• slither-check-erc: Check the ERC's conformance
• slither-read-storage: Read storage values from contracts
• slither-interface: Generate an interface for a contract

See the Tool documentation for additional tools.

Contact us to get help on building custom tools.

API Documentation Copy Chapter

Documentation on Slither's internals is available here.

Getting Help Copy Chapter

Feel free to stop by our Slack channel (#ethereum) for help using or extending Slither.

• The Printer documentation describes the information Slither is capable of visualizing for each contract.

• The Detector documentation describes how to write a new vulnerability analyses.

• The API documentation describes the methods and objects available for custom analyses.

• The SlithIR documentation describes the SlithIR intermediate representation.

FAQ Copy Chapter

How do I exclude mocks or tests?

• View our documentation on path filtering.

How do I fix "unknown file" or compilation issues?

• Because slither requires the solc AST, it must have all dependencies available.
  If a contract has dependencies, slither contract.sol will fail.
  Instead, use slither . in the parent directory of contracts/ (you should see contracts/ when you run ls).
  If you have a node_modules/ folder, it must be in the same directory as contracts/. To verify that this issue is related to slither,
  run the compilation command for the framework you are using e.g npx hardhat compile. That must work successfully;
  otherwise, slither's compilation engine, crytic-compile, cannot generate the AST.

License Copy Chapter

Slither is licensed and distributed under the AGPLv3 license. Contact us if you're looking for an exception to the terms.

Publications Copy Chapter

Trail of Bits publication Copy Section

• Slither: A Static Analysis Framework For Smart Contracts, Josselin Feist, Gustavo Grieco, Alex Groce - WETSEB '19

External publications Copy Section

If you are using Slither on an academic work, consider applying to the Crytic $10k Research Prize.

Overview (`plugin_example/README.md`) Copy Section

Slither, Plugin Example

This repository contains an example of plugin for Slither.

See the detector documentation.

Architecture Copy Chapter

• pyproject.toml: Contains the plugin information and dependencies
• slither_my_plugin/__init__.py: Contains make_plugin(). The function must return the list of new detectors and printers
• slither_my_plugin/detectors/example.py: Detector plugin skeleton.

Installation Copy Chapter

Once these files are updated with your plugin, install it:

uv sync
uv run slither --help  # Verify plugin is loaded

Overview (`docs/src/README.md`) Copy Section

[Slither, the smart contract static analyzer](https://crytic.github.io/slither/slither.html)

Slither is a Solidity & Vyper static analysis framework written in Python3. It runs a suite of vulnerability detectors, prints visual information about contract details, and provides an API to easily write custom analyses. Slither enables developers to find vulnerabilities, enhance their code comprehension, and quickly prototype custom analyses.

If you are looking to use Slither's cli:

• Usage the most common flags

If you are looking to leverage Slither inbuilt features:

• Detectors: Vulnerabilities detectors
• Printers: Printers (code vizualiation)
• Tools: Custom tools

If you are looking to learn how to extend Slither's capabilities:

• API: Introduction to static analysis & Slither's API
• Tutorial: Hands-on exercises

Overview (`docs/src/api/README.md`) Copy Section

Slither API

Slither is fully customizable:

• Static Analysis: learn about the basics of static analysis
• API
• SlithIR
• SSA
• Data dependency
• JSON output

Overview (`docs/src/tools/README.md`) Copy Section

Slither Inbuilt Tools

Slither comes with inbuilt tools

Overview (`docs/src/tutorials/README.md`) Copy Section

Slither

The objective of this tutorial is to demonstrate how to use Slither to automatically find bugs in smart contracts.

• Installation
• Command-line usage
• Introduction to static analysis: A concise introduction to static analysis
• API: Python API description

Once you feel confident with the material in this README, proceed to the exercises:

• Exercise 1: Function override protection
• Exercise 2: Check for access controls
• Exercise 3: Find variable used in conditional statements

Watch Slither's code walkthrough, or API walkthrough to learn about its code structure.

Installation Copy Chapter

Slither requires Python >= 3.9. You can install it through pip or by using Docker.

Installing Slither through pip:

pip3 install --user slither-analyzer

Docker Copy Section

Installing Slither through Docker:

docker pull trailofbits/eth-security-toolbox
docker run -it -v "$PWD":/home/trufflecon trailofbits/eth-security-toolbox

The last command runs the eth-security-toolbox in a Docker container that has access to your current directory. You can modify the files from your host, and run the tools on the files from the Docker container.

Inside the Docker container, run:

solc-select 0.5.11
cd /home/trufflecon/

Command-line Copy Chapter

Command-line vs. user-defined scripts. Slither comes with a set of predefined detectors that can identify many common bugs. Running Slither from the command-line will execute all the detectors without requiring detailed knowledge of static analysis:

slither project_paths

Besides detectors, Slither also offers code review capabilities through its printers and tools.

Overview (`slither/tools/demo/README.md`) Copy Section

Demo

This directory contains an example of Slither utility.

See the utility documentation

Overview (`tests/e2e/compilation/test_data/test_change/README.md`) Copy Section

Foundry

To init this test case, run forge install --no-commit --no-git foundry-rs/forge-std

Overview (`tests/e2e/compilation/test_data/test_source_unit/README.md`) Copy Section

README

Before using this project, run forge init --no-git --no-commit --force to initialize submodules

Overview (`tests/e2e/printers/test_data/test_printer_cheatcode/README.md`) Copy Section

Counter

Init using :

forge install foundry-rs/forge-std

Overview (`tests/tools/mutator/test_data/test_source_unit/README.md`) Copy Section

Counter

Init using :

forge install --no-commit --no-git .

Src SUMMARY (`docs/src/SUMMARY.md`) Copy Section

Summary

• Introduction
• Usage
• API
  • Static Analysis
  • API
  • SlithIR
  • SSA
  • Data dependency
  • JSON output
• Detectors
  • Detectors
  • Adding a detector
• Printers
• Tools
  • Adding a new tool
  • Code Similarity
  • Contract Flattening
  • Documentation
  • Doctor
  • ERC Conformance
  • Interface
  • Mutator
  • Path Finding Utility
  • Property Generation
  • Read Storage
  • Format
  • Upgradeability checks
• Tutorials
  • Exercise 1
  • Exercise 2
  • Exercise 3

Src Usage (`docs/src/Usage.md`) Copy Section

Usage

• How to run Slither
  • Foundry/hardhat
  • solc
  • Etherscan
• Detector selection
• Printer selection
• Path filtering
• Suppressing findings
• Triage mode
• Configuration File

How to run Slither Copy Chapter

All the crytic-compile options are available through Slither.

Foundry/hardhat Copy Section

To run Slither on a Foundry/hardhat directory:

slither .

solc Copy Section

To run Slither from a Solidity file:

slither file.sol

Etherscan Copy Section

To run Slither from a contract hosted on Etherscan, run

slither 0x7F37f78cBD74481E593F9C737776F7113d76B315

We recommend installing solc-select so Slither can switch to the expected solc version automatically.

Detector selection Copy Section

Slither runs all its detectors by default.

To run only selected detectors, use --detect detector1,detector2. For example:

slither file.sol --detect arbitrary-send,pragma

To exclude detectors, use --exclude detector1,detector2. For example:

slither file.sol --exclude naming-convention,unused-state,suicidal

To exclude detectors with an informational or low severity, use --exclude-informational or --exclude-low.

--list-detectors lists available detectors.

Printer selection Copy Section

By default, no printers are run.

To run selected printers, use --print printer1,printer2. For example:

slither file.sol --print inheritance-graph

--list-printers lists available printers.

Path filtering Copy Section

--filter-paths path1 will exclude all the results that are only related to path1. The path specified can be a path directory or a filename. Direct string comparison and Python regular expression are used.

Examples:

slither . --filter-paths "openzepellin"

Filter all the results only related to openzepellin.

slither . --filter-paths "SafeMath.sol|ConvertLib.sol"

Filter all the results only related to the file SafeMath.sol or ConvertLib.sol.

Suppressing findings Copy Section

Slither offers several ways to suppress results:

• By adding //slither-disable-next-line DETECTOR_NAME before the issue
• By adding // slither-disable-start [detector] ... // slither-disable-end [detector] around the code to disable the detector on a large section
• By adding @custom:security non-reentrant before the variable declaration will indicate to Slither that the external calls from this variable are non-reentrant
• By running the triage mode (see below)

Triage mode Copy Section

--triage-mode runs Slither in its triage mode. For every finding, Slither will ask if the result should be shown for the next run. Results are saved in slither.db.json.

Examples:

slither . --triage-mode
[...]
0: C.destination (test.sol#3) is never initialized. It is used in:
 - f (test.sol#5-7)
Reference: https://github.com/trailofbits/slither/wiki/Vulnerabilities-Description#uninitialized-state-variables
Results to hide during next runs: "0,1,..." or "All" (enter to not hide results):  0
[...]

The second run of Slither will hide the above result.

To show the hidden results again, delete slither.db.json.

Configuration File Copy Section

Some options can be set through a json configuration file. By default, slither.config.json is used if present, with slither.conf.json accepted as an alternative (it can be changed through --config-file file.config.json).

Options passed via the CLI have priority over options set in the configuration file.

The following flags are supported:

{
    "detectors_to_run": "all",
    "printers_to_run": None,
    "detectors_to_exclude": None,
    "detectors_to_include": None,
    "exclude_dependencies": False,
    "exclude_informational": False,
    "exclude_optimization": False,
    "exclude_low": False,
    "exclude_medium": False,
    "exclude_high": False,
    "fail_on": FailOnLevel.PEDANTIC,
    "json": None,
    "sarif": None,
    "disable_color": False,
    "filter_paths": None,
    "include_paths": None,
    "generate_patches": False,
    "skip_assembly": False,
    "legacy_ast": False,
    "zip": None,
    "zip_type": "lzma",
    "show_ignored_findings": False,
    "sarif_input": "export.sarif",
    "sarif_triage": "export.sarif.sarifexplorer",
    "triage_database": "slither.db.json",
}

For flags related to the compilation, see the crytic-compile configuration

Src Api Data Dependency (`docs/src/api/Data-dependency.md`) Copy Section

Data dependency

Data dependency allows knowing if the value of a given variable is influenced by another variable's value.

Because smart contracts have a state machine based architecture, the results of the data dependency depend on the context (function/contract) of the analysis. Consider the following example:

contract MyContract{
    uint a = 0;
    uint b = 0;

    function setA(uint input_a) public{
        a = input_a;
    }

    function setB() public{
        b = a;
    }

}

In this example, if we consider only setA, we have the following dependency:

• a is dependent on input_a

If we consider only setB, we have:

• b is dependent on a

If we consider the contract entirely (with all the functions), we have:

• a is dependent on input_a
• b is dependent on a and input_a (by transitivity)

slither.analyses.is_dependent(variable, variable_source, context) allows to know if variable is dependent on variable_source on the given context.

As a result, in our previous example, is_dependent(b, a, funcA) will return False, while is_dependent(b, a, myContract) will return True:

from slither import Slither
from slither.analyses import is_dependent

slither = Slither('data_dependency_simple_example.sol')

myContract = slither.get_contract_from_name('MyContract')
funcA = myContract.get_function_from_signature('setA(uint256)')
input_a = funcA.parameters[0]

a = myContract.get_state_variable_from_name('a')
b = myContract.get_state_variable_from_name('b')

print(f'{b.name} is dependant from {input_a.name}?: {is_dependent(b, a, funcA)}')
print(f'{b.name} is dependant from {input_a.name}?: {is_dependent(b, a, myContract)}')

Src Api JSON Output (`docs/src/api/JSON-output.md`) Copy Section

JSON Output

• Top-level Command Output: Standard top-level (for detectors, printers and tools)
• Detectors output
• Upgradeability output

Top-level Command Output Copy Chapter

At the top level, the JSON output provided by slither will appear in the following format:

{
  "success": true,
  "error": null,
  "results": {}
}

• success (boolean): true if results were output successfully, false if an error occurred.
• error (string | null): If success is false, this will be a string with relevant error information. Otherwise, it will be null.
• results (command-results, see below): If success is true, this will be an object populated with different types of results, depending on the JSON arguments specified.

Command Results Copy Chapter

The underlying results item above will appear in the following format:

{
  "detectors": [],
  "upgradeability-check": {}
}

• detectors (OPTIONAL, vulnerability-results, see below): The results of any detector analysis.
• upgradeability-check (OPTIONAL, upgradeability-results, see below): The results of slither-check-upgradeability.

Detector Results Copy Chapter

A detector result found in the detectors array above will be of the following format:

{
 "check": "...",
 "impact": "...",
 "confidence": "...",
 "description": "...",
 "elements": []
}

• check (string): The detector identifier (see the list of detectors)
• impact (string): representation of the impact (High/ Medium/ Low/ Informational)
• confidence (string): representation of the confidence (High/ Medium/ Low)
• description (string): output of the slither
• elements: (element array, see below): an array of relevant items for this finding which map to some source code.
  • NOTE: When writing a detector, the first element should be carefully chosen to represent the most significant portion of mapped code for the finding (the area of source on which external tooling should primarily focus for the issue).
• additional_fields: (OPTIONAL, any): Offers additional detector-specific information, does not always exist.

Detector Result Elements Copy Chapter

Each element found in elements above is of the form:

{
  "type": "...",
  "name": "...",
  "source_mapping": {},
  "type_specific_fields": {},
  "additional_fields": {}
}

• type (string): Refers to the type of element, this can be either: (contract, function, variable, node, pragma, enum, struct, event).
• name (string): Refers to the name of the element.
  • For contract/function/variable/enum/struct/event types, this refers to the definition name.
  • For node types, this refers to a string representation of any underlying expression. A blank string is used if there is no underlying expression.
  • For pragma types, this refers to a string representation of the version portion of the pragma (ie: ^0.5.0).
• source_mapping (source mapping, see below): Refers to a source mapping object which defines the source range which represents this element.
• type_specific_fields (OPTIONAL, any):
  • For function/event type elements:
    • parent (result-element): Refers to the parent contract of this definition.
    • signature (string): Refers to the full signature of this function
  • For enum/struct type elements:
    • parent (result-element): Refers to the parent contract of this definition.
  • For variable type elements:
    • parent (result-element): Refers to the parent contract if this variable is a state variable. Refers to the parent function if this variable is a local variable.
  • For node type elements:
    • parent (result-element): Refers to the parent function of this node.
  • For pragma type elements:
    • directive (string array): Fully serialized pragma directive (ie: ["solidity", "^", "0.4", ".9"])
• additional_fields (OPTIONAL, any): Offers additional detector-specific element information, does not always exist.

Source Mapping Copy Chapter

Each source_mapping object is used to map an element to some portion of source. It is of the form:

"source_mapping": {
 "start": 45
 "length": 58,
 "filename_relative": "contracts/tests/constant.sol",
 "filename_absolute": "/tmp/contracts/tests/constant.sol",
 "filename_short": "tests/constant.sol",
 "filename_used": "contracts/tests/constant.sol",
 "lines": [
  5,
  6,
  7
  ],
  "starting_column": 1,
  "ending_column": 24,
}

• start (integer): Refers to the starting byte position of the mapped source.
• length (integer): Refers to the byte-length of the mapped source.
• filename_relative (string): A relative file path from the analysis directory.
• filename_absolute (string): An absolute file path to the file.
• filename_short (string): A short version of the filename used for display purposes. Hides platform-specific directories (ex: node_modules).
• filename_used (string): The path used by the platform for analysis (non-standard).
• lines (integer array): An array of line numbers which the mapped source spans. Line numbers begin from 1.
• starting_column (integer): The starting column/character position for the first mapped source line. Begins from 1.
• ending_column (integer): The ending column/character position for the last mapped source line. Begins from 1.

Detector-specific additional fields Copy Chapter

Some detectors have custom elements output via the additional_fields field of their result, or result elements. Annotations here will specify result or result-element to specify the location of the additional fields.

• constant-function:

  • contain_assembly (result, boolean): Specifies if the result is due to the function containing assembly.

• naming-convention:

  • convention (result-element, string): Used to denote the convention used to find the result element/issue. Valid conventions are:
    • CapWords
    • mixedCase
    • l_O_I_should_not_be_used
    • UPPER_CASE_WITH_UNDERSCORES
  • target (result-element, string): Used to denote the type of finding (constant, parameter, etc). Valid targets are:
    • contract
    • structure
    • event
    • function
    • variable
    • variable_constant
    • parameter
    • enum
    • modifier

• reentrancy (all variants):

  • underlying_type (result-element, string): Specifies the type of result element. Is one of external_calls, external_calls_sending_eth, or variables_written.

Slither Check Upgradeability Copy Chapter

The slither-check-upgradeability tool also produces JSON output (with the use of the --json option). At the top level, this JSON output will appear in the format similar to that of Slither above:

{
  "success": true,
  "error": null,
  "results": {
    "upgradeability-check": {}
  }
}

• success (boolean): true if results were output successfully, false if an error occurred.
• error (string | null): If success is false, this will be a string with relevant error information. Otherwise, it will be null.
• results (upgradeability-check-results, see below): If success is true, this will contain an upgradeability-check object populated with the different upgradeability checks. If success is false, upgradeability-check object will be empty.

Upgradeability Check Results Copy Chapter

The underlying upgradeability-check item above will appear in the following format:

{
  "check-initialization": {},
  "check-initialization-v2": {},
  "compare-function-ids": {},
  "compare-variables-order-proxy": {},
  "compare-variables-order-implementation": {}
}

Src Api SlithIR SSA (`docs/src/api/SlithIR-SSA.md`) Copy Section

SSA

Slither possess a Static Single Assignment (SSA) form representation of SlithIR. SSA is a commonly used representation in compilation and static analysis in general. It requires that each variable is assigned at least one time. SSA is a key component for building an efficient data-dependency analysis.

The SSA printer allows to visualize this representation.

Src Api SlithIR (`docs/src/api/SlithIR.md`) Copy Section

SlithIR

Slither translates Solidity an intermediate representation, SlithIR, to enable high-precision analysis via a simple API. It supports taint and value tracking to enable detection of complex patterns.

SlithIR is a work in progress, although it is usable today. New developments in SlithIR are driven by needs identified by new detector modules. Please help us bugtest and enhance SlithIR!

What is an IR? Copy Chapter

In language design, compilers often operate on an “intermediate representation” (IR) of a language that carries extra details about the program as it is parsed. For example, a compiler creates a parse tree of a program that represents a program as written. However, the compiler can continue to enrich this tree with information, such as taint information, source location, and other items that could have impacted an item from control flow. Additionally, languages such as Solidity have inheritance, meaning that functions and methods may be defined outside the scope of a given contract. An IR could linearize these methods, allowing additional transformations and processing of the contract’s source code.

A demonstrative example would be LLVM’s IR vs C or x86 code. While C will clearly demonstrate a function call, it may be missing details about the underlying system, the path to a location, and so on. Likewise, while an analog to the same call would be clear in x86, this would lose all transient details of which variables and which path an application had taken to arrive at a specific call. LLVM’s IR solves this by abstracting away the specific details of a call instruction, while still capturing the variables, environmental state, and other values that lead to this position. In this way, LLVM can perform additional introspection of the resulting code, and use these analyses to drive other optimizations or information to other passes of the compiler.

Why does Slither translate to an IR? Copy Chapter

Solidity is a quirky language with a number of edge cases, both in terms of syntax and semantics. By translating to an IR, Slither normalizes many of these quirks to better analyze the contract. For example, Solidity’s grammar defines an array push as a function call to the array. A straightforward representation of this semantic would be indistinguishable from a normal function call. Slither, in contrast, treats array pushes as a specific operation, allowing further analysis of the accesses to arrays and their impact to the security of a program. Moreover, the operators in SlithIR have a hierarchy, so, for example in a few lines of code you can track all the operators that write to a variable, which makes it trivial to write precise taint analysis.

Additionally, Slither can include non-trivial variable tracking by default by translating to an IR. This can build richer representations of contracts and allow for deeper analysis of potential vulnerabilities. For example, answering the question “can a user control a variable” is central to uncovering more complex vulnerabilities from a static position. Slither will propagate information from function parameters to program state in an iterative fashion, which captures the control flow of information across potentially multiple transactions. In this way, Slither can enrich information and statically provide a large amount of assurance to contracts that standard vulnerabilities exist and are reachable under certain conditions.

Example Copy Chapter

$ slither file.sol --print slithir will output the IR for every function.

$ slither examples/printers/slihtir.sol --printers slithir
Contract UnsafeMath
 Function add(uint256,uint256)
  Expression: a + b
  IRs:
   TMP_0(uint256) = a + b
   RETURN TMP_0
 Function min(uint256,uint256)
  Expression: a - b
  IRs:
   TMP_0(uint256) = a - b
   RETURN TMP_0
Contract MyContract
 Function transfer(address,uint256)
  Expression: balances[msg.sender] = balances[msg.sender].min(val)
  IRs:
   REF_3(uint256) -> balances[msg.sender]
   REF_1(uint256) -> balances[msg.sender]
   TMP_1(uint256) = LIBRARY_CALL, dest:UnsafeMath, function:min, arguments:['REF_1', 'val']
   REF_3 := TMP_1
  Expression: balances[to] = balances[to].add(val)
  IRs:
   REF_3(uint256) -> balances[to]
   REF_1(uint256) -> balances[to]
   TMP_1(uint256) = LIBRARY_CALL, dest:UnsafeMath, function:add, arguments:['REF_1', 'val']
   REF_3 := TMP_1

SlithIR Specification Copy Chapter

Variables Copy Section

• StateVariable
• LocalVariable
• Constant (string or int)
• SolidityVariable
• TupleVariable
• TemporaryVariable (variables added by SlithIR)
• ReferenceVariable (variables added by SlithIR, for mapping/index accesses)

In the following we use:

• LVALUE can be: StateVariable, LocalVariable, TemporaryVariable, ReferenceVariable or TupleVariable
• RVALUE can be: StateVariable, LocalVariable, Constant, SolidityVariable, TemporaryVariable or ReferenceVariable

Operators Copy Section

• All the operators inherit from Operation and have a read attribute returning the list of variables read (see slither/slithir/operations/operation.py).
• All the operators writing to a LVALUE inherit from OperationWithLValue and have the lvalue attribute (see slither/slithir/operations/lvalue.py).

Assignment

• LVALUE := RVALUE
• LVALUE := Tuple
• LVALUE := Function (for dynamic function)

Binary Operation

• LVALUE = RVALUE ** RVALUE
• LVALUE = RVALUE * RVALUE
• LVALUE = RVALUE / RVALUE
• LVALUE = RVALUE % RVALUE
• LVALUE = RVALUE + RVALUE
• LVALUE = RVALUE - RVALUE
• LVALUE = RVALUE << RVALUE
• LVALUE = RVALUE >> RVALUE
• LVALUE = RVALUE & RVALUE
• LVALUE = RVALUE ^ RVALUE
• LVALUE = RVALUE | RVALUE
• LVALUE = RVALUE < RVALUE
• LVALUE = RVALUE > RVALUE
• LVALUE = RVALUE <= RVALUE
• LVALUE = RVALUE >= RVALUE
• LVALUE = RVALUE == RVALUE
• LVALUE = RVALUE != RVALUE
• LVALUE = RVALUE && RVALUE
• LVALUE = RVALUE -- RVALUE

Unary Operation

• LVALUE = ! RVALUE
• LVALUE = ~ RVALUE

Index

• REFERENCE -> LVALUE [ RVALUE ]

Note: The reference points to the memory location

Member

• REFERENCE -> LVALUE . RVALUE
• REFERENCE -> CONTRACT . RVALUE
• REFERENCE -> ENUM . RVALUE

Note: The reference points to the memory location

New Operators

• LVALUE = NEW_ARRAY ARRAY_TYPE DEPTH(:int)

ARRAY_TYPE is a solidity_types

DEPTH is used for arrays of multiple dimensions.

• LVALUE = NEW_CONTRACT CONSTANT
• LVALUE = NEW_STRUCTURE STRUCTURE
• LVALUE = NEW_ELEMENTARY_TYPE ELEMENTARY_TYPE

ELEMENTARY_TYPE is defined in slither/core/solidity_types/elementary_type.py

Push Operator

• PUSH LVALUE RVALUE
• PUSH LVALUE Function (for dynamic function)

Delete Operator

• DELETE LVALUE

Conversion

• CONVERT LVALUE RVALUE TYPE

TYPE is a solidity_types

Unpack

• LVALUE = UNPACK TUPLEVARIABLE INDEX(:int)

Array Initialization

• LVALUE = INIT_VALUES

INIT_VALUES is a list of RVALUE, or a list of lists in case of a multidimensional array.

Calls Operators

In the following, ARG is a variable as defined in SlithIR#variables

• LVALUE = HIGH_LEVEL_CALL DESTINATION FUNCTION [ARG, ..]
• LVALUE = LOW_LEVEL_CALL DESTINATION FUNCTION_NAME [ARG, ..]

FUNCTION_NAME can only be call/delegatecall/codecall

• LVALUE = SOLIDITY_CALL SOLIDITY_FUNCTION [ARG, ..]

SOLIDITY_FUNCTION is defined in slither/core/declarations/solidity_variables.py

• LVALUE = INTERNAL_CALL FUNCTION [ARG, ..]
• LVALUE = INTERNAL_DYNAMIC_CALL FUNCTION_TYPE [ARG, ..]

INTERNAL_DYNAMIC_CALL represents the pointer of function.

FUNCTION_TYPE is defined in slither/core/solidity_types/function_type.py

• LVALUE = LIBRARY_CALL DESTINATION FUNCTION_NAME [ARG, ..]
• LVALUE = EVENT_CALL EVENT_NAME [ARG, ..]
• LVALUE = SEND DESTINATION VALUE
• TRANSFER DESTINATION VALUE

Optional arguments:

• GAS and VALUE for HIGH_LEVEL_CALL / LOW_LEVEL_CALL.

Return

• RETURN RVALUE
• RETURN TUPLE
• RETURN None

Return None represents an empty return statement.

Condition

• CONDITION RVALUE

CONDITION holds the condition in a conditional node.

Src Api Api (`docs/src/api/api.md`) Copy Section

API Basics

Slither has an API that allows you to explore basic attributes of contracts and their functions.

On a high level there are 6 layers:

• Slither - main slither object
• SlitherCompilationUnit - group of files used by one call to solc
• Contract - contract level
• Function - function level
• Node - control flow graph
• SlithrIR - intermediate representation

Watch our API walkthrough for more details

Slither object Copy Chapter

To load a codebase:

from slither import Slither
slither = Slither('/path/to/project')

To load a contract deployed:

from slither import Slither
slither = Slither('0x..') # assuming the code is verified on etherscan

Use etherscan_api_key to provide an Etherscan API KEY

slither = Slither('0x..', etherscan_api_key='..')

You can retrieve the list of compilation units with:

• sl.compilation_units # array of SlitherCompilationUnit

SlitherCompilationUnit object Copy Chapter

• ~ group of files used by one call to solc
• Most targets have 1 compilation, but not always true
  • Partial compilation for optimization
  • Multiple solc version used
  • Etc..
• Why compilation unit matters?
  • Some APIs might be not intuitive
  • Ex: looking for a contract based on the name?
    • Can have multiple contracts
• For hacking you can (probably) use the first compilation unit
  • compilation_unit = sl.compilation_units[0]

A SlitherCompilationUnit has:

• contracts (list(Contract)): A list of contracts
• contracts_derived (list(Contract)): A list of contracts that are not inherited by another contract (a subset of contracts)
• get_contract_from_name (str): Returns a list of contracts matching the name
• [structures | enums | events | variables | functions]_top_level: Top level object

Example

from slither import Slither
sl = Slither("0xdac17f958d2ee523a2206206994597c13d831ec7")
compilation_unit = sl.compilation_units[0]

# Print all the contracts from the USDT address
print([str(c) for c in compilation_unit.contracts])

# Print the most derived contracts from the USDT address
print([str(c) for c in compilation_unit.contracts_derived])

% python test.py
['SafeMath', 'Ownable', 'ERC20Basic', 'ERC20', 'BasicToken', 'StandardToken', 'Pausable', 'BlackList', 'UpgradedStandardToken', 'TetherToken']

['SafeMath', 'UpgradedStandardToken', 'TetherToken']

Contract Object Copy Chapter

A Contract object has:

• name: str: The name of the contract
• functions: list[Function]: A list of functions
• modifiers: list[Modifier]: A list of modifiers
• all_functions_called: list[Function/Modifier]: A list of all internal functions reachable by the contract
• inheritance: list[Contract]: A list of inherited contracts (c3 linearization order)
• derived_contracts: list[Contract]: contracts derived from it
• get_function_from_signature(str): Function: Returns a Function from its signature
• get_modifier_from_signature(str): Modifier: Returns a Modifier from its signature
• get_state_variable_from_name(str): StateVariable: Returns a StateVariable from its name
• state_variables: List[StateVariable]: list of accessible variables
• state_variables_ordered: List[StateVariable]: all variable ordered by declaration

Example

from slither import Slither
sl = Slither("0xdac17f958d2ee523a2206206994597c13d831ec7")
compilation_unit = sl.compilation_units[0]

# Print all the state variables of the USDT token
contract = compilation_unit.get_contract_from_name("TetherToken")[0]
print([str(v) for v in contract.state_variables])

% python test.py
['owner', 'paused', '_totalSupply', 'balances', 'basisPointsRate', 'maximumFee', 'allowed', 'MAX_UINT', 'isBlackListed', 'name', 'symbol', 'decimals', 'upgradedAddress', 'deprecated']

Function object Copy Chapter

A Function or a Modifier object has:

• name: str: The name of the function
• contract: Contract: The contract where the function is declared
• nodes: list[Node]: A list of nodes composing the CFG of the function/modifier
• entry_point: Node: The entry point of the CFG
• [state |local]_variable_[read |write]: list[StateVariable]: A list of local/state variables read/write
  • All can be prefixed by “all_” for recursive lookup
  • Ex: all_state_variable_read: return all the state variables read in internal calls
• slithir_operations: List[Operation]: list of IR operations

from slither import Slither
sl = Slither("0xdac17f958d2ee523a2206206994597c13d831ec7")
compilation_unit = sl.compilation_units[0]
contract = compilation_unit.get_contract_from_name("TetherToken")[0]

transfer = contract.get_function_from_signature("transfer(address,uint256)")

# Print all the state variables read by the transfer function
print([str(v) for v in transfer.state_variables_read])
# Print all the state variables read by the transfer function and its internal calls
print([str(v) for v in transfer.all_state_variables_read])

% python test.py
['deprecated', 'isBlackListed', 'upgradedAddress']
['owner', 'basisPointsRate', 'deprecated', 'paused', 'isBlackListed', 'maximumFee', 'upgradedAddress', 'balances']

Node object Copy Chapter

Node

To explore the nodes:

• If order does not matter
  • for node in function.nodes
• If order matters, walk through the nodes

def visit_node(node: Node, visited: List[Node]):

    if node in visited:
        return
    visited += [node]

    # custom action
    for son in node.sons:
        visit_node(son, visited)

• If need to iterate more than once (advanced usages)
• Bound the iteration X times
• Create a fix-point - abstract interpretation style analysis

SlithIR Copy Chapter

• slither/slithir
• Every IR operation has its own methods
• Check if an operation is of a type:
  • isinstance(ir, TYPE)
  • Ex: isinstance(ir, Call)
• Check if the operation is an addition
• isinstance(ir, Binary) & ir.type == BinaryType.ADDITION
• Check if the operation is a call to MyContract
• isinstance(ir, HighLevelCall) & ir.destination == MyContract

from slither import Slither
sl = Slither("0xdac17f958d2ee523a2206206994597c13d831ec7")
compilation_unit = sl.compilation_units[0]
contract = compilation_unit.get_contract_from_name("TetherToken")[0]
totalSupply = contract.get_function_from_signature("totalSupply()")

# Print the external call made in the totalSupply function
for ir in totalSupply.slithir_operations:
    if isinstance(ir, HighLevelCall):
        print(f"External call found {ir} ({ir.node.source_mapping})")

% python test.py
External call found HIGH_LEVEL_CALL, […]   (...TetherToken.sol#339)

Example: Print Basic Information Copy Section

print_basic_information.py demonstrates how to print basic information about a project.

Src Api Static Analysis (`docs/src/api/static_analysis.md`) Copy Section

Static analysis

The capabilities and design of the Slither static analysis framework have been described in blog posts (1, 2) and an academic paper.

Static analysis comes in different flavors. You may already know that compilers like clang and gcc rely on these research techniques, as do tools like Infer, CodeClimate, FindBugs, and tools based on formal methods like Frama-C and Polyspace.

In this article, we will not provide an exhaustive review of static analysis techniques and research. Instead, we'll focus on what you need to understand about how Slither works, so you can more effectively use it to find bugs and understand code.

• Code representation
• Code analysis
• Intermediate representation

Code representation Copy Chapter

Unlike dynamic analysis, which reasons about a single execution path, static analysis reasons about all paths at once. To do so, it relies on a different code representation. The two most common ones are the abstract syntax tree (AST) and the control flow graph (CFG).

Abstract Syntax Trees (AST) Copy Section

ASTs are used every time a compiler parses code. They are arguably the most basic structure upon which static analysis can be performed.

In a nutshell, an AST is a structured tree where, usually, each leaf contains a variable or a constant, and internal nodes are operands or control flow operations. Consider the following code:

function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a + b <= a) {
        revert();
    }
    return a + b;
}

The corresponding AST is shown in the following illustration:

Slither uses the AST exported by solc.

While simple to build, the AST is a nested structure that's not always straightforward to analyze. For example, to identify the operations used by the expression a + b <= a, you must first analyze <= and then +. A common approach is to use the so-called visitor pattern, which navigates through the tree recursively. Slither contains a generic visitor in ExpressionVisitor.

The following code uses ExpressionVisitor to detect if an expression contains an addition:

from slither.visitors.expression.expression import ExpressionVisitor
from slither.core.expressions.binary_operation import BinaryOperationType

class HasAddition(ExpressionVisitor):

    def result(self):
        return self._result

    def _post_binary_operation(self, expression):
        if expression.type == BinaryOperationType.ADDITION:
            self._result = True

visitor = HasAddition(expression) # expression is the expression to be tested
print(f'The expression {expression} has an addition: {visitor.result()}')

Control Flow Graph (CFG) Copy Section

The second most common code representation is the control flow graph (CFG). As its name suggests, it is a graph-based representation that reveals all the execution paths. Each node contains one or multiple instructions, and edges in the graph represent control flow operations (if/then/else, loop, etc). The CFG of our previous example is as follows:

Most analyses are built on top of the CFG representation.

There are many other code representations, each with its advantages and drawbacks depending on the desired analysis.

Analysis Copy Section

The simplest types of analyses that can be performed with Slither are syntactic analyses.

Syntax analysis Copy Section

Slither can navigate through the different components of the code and their representation to find inconsistencies and flaws using a pattern matching-like approach.

For example, the following detectors look for syntax-related issues:

• State variable shadowing: iterates over all state variables and checks if any shadow a variable from an inherited contract (state.py#L51-L62)

• Incorrect ERC20 interface: searches for incorrect ERC20 function signatures (incorrect_erc20_interface.py#L34-L55)

Semantic analysis Copy Section

In contrast to syntax analysis, semantic analysis delves deeper and analyzes the "meaning" of the code. This category includes a broad range of analyses that yield more powerful and useful results but are more complex to write.

Semantic analyses are used for advanced vulnerability detection.

Data dependency analysis

A variable variable_a is said to be data-dependent on variable_b if there is a path for which the value of variable_a is influenced by variable_b.

In the following code, variable_a is dependent on variable_b:

// ...
variable_a = variable_b + 1;

Slither comes with built-in data dependency capabilities, thanks to its intermediate representation (discussed later).

An example of data dependency usage can be found in the dangerous strict equality detector. Slither looks for strict equality comparisons to dangerous values (incorrect_strict_equality.py#L86-L87) and informs the user that they should use >= or <= instead of == to prevent attackers from trapping the contract. Among other things, the detector considers the return value of a call to balanceOf(address) to be dangerous (incorrect_strict_equality.py#L63-L64) and uses the data dependency engine to track its usage.

Fixed-point computation

If your analysis navigates through the CFG and follows the edges, you're likely to encounter already visited nodes. For example, if a loop is presented as shown below:

for(uint256 i; i < range; ++) {
    variable_a += 1;
}

Your analysis will need to know when to stop. There are two main strategies: (1) iterate on each node a finite number of times, (2) compute a so-called fixpoint. A fixpoint essentially means that analyzing the node doesn't provide any meaningful information.

An example of a fixpoint used can be found in the reentrancy detectors: Slither explores the nodes and looks for external calls, reads, and writes to storage. Once it has reached a fixpoint (reentrancy.py#L125-L131), it stops the exploration and analyzes the results to see if a reentrancy is present, through different reentrancy patterns (reentrancy_benign.py, reentrancy_read_before_write.py, reentrancy_eth.py).

Writing analyses using efficient fixed-point computation requires a good understanding of how the analysis propagates its information.

Intermediate representation Copy Section

An intermediate representation (IR) is a language designed to be more amenable to static analysis than the original one. Slither translates Solidity to its own IR: SlithIR.

Understanding SlithIR is not necessary if you only want to write basic checks. However, it becomes essential if you plan to write advanced semantic analyses. The SlithIR and SSA printers can help you understand how the code is translated.

Src Detectors Adding A New Detector (`docs/src/detectors/Adding-a-new-detector.md`) Copy Section

Adding New Detectors

Slither's plugin architecture lets you integrate new detectors that run from the command-line.

Detector Skeleton Copy Chapter

The skeleton for a detector is:

from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification


class Skeleton(AbstractDetector):
    """
    Documentation
    """

    ARGUMENT = 'mydetector' # slither will launch the detector with slither.py --detect mydetector
    HELP = 'Help printed by slither'
    IMPACT = DetectorClassification.HIGH
    CONFIDENCE = DetectorClassification.HIGH

    WIKI = ''

    WIKI_TITLE = ''
    WIKI_DESCRIPTION = ''
    WIKI_EXPLOIT_SCENARIO = ''
    WIKI_RECOMMENDATION = ''

    def _detect(self):
        info = ['This is an example']
        res = self.generate_result(info)

        return [res]

• ARGUMENT lets you run the detector from the command-line
• HELP is the information printed from the command-line
• IMPACT indicates the impact of the issue. Allowed values are:
  • DetectorClassification.OPTIMIZATION: printed in green
  • DetectorClassification.INFORMATIONAL: printed in green
  • DetectorClassification.LOW: printed in green
  • DetectorClassification.MEDIUM: printed in yellow
  • DetectorClassification.HIGH: printed in red
• CONFIDENCE indicates your confidence in the analysis. Allowed values are:
  • DetectorClassification.LOW
  • DetectorClassification.MEDIUM
  • DetectorClassification.HIGH
• WIKI constants are used to generate automatically the documentation.

_detect() needs to return a list of findings. A finding is an element generated with self.generate_result(info), where info is a list of text or contract's object (contract, function, node, ...)

An AbstractDetector object has the slither attribute, which returns the current Slither object.

Integration Copy Chapter

You can integrate your detector into Slither by:

• Adding it in slither/detectors/all_detectors.py
• or, by creating a plugin package (see the skeleton example).

Test the detector Copy Section

See CONTRIBUTING.md#development-environment

Example Copy Chapter

backdoor.py will detect any function with backdoor in its name.

Src Detectors Detector Documentation (`docs/src/detectors/Detector-Documentation.md`) Copy Section

Public Detectors

List of public detectors

Storage ABIEncoderV2 Array Copy Chapter

Configuration Copy Section

• Check: abiencoderv2-array
• Severity: High
• Confidence: High

Description Copy Section

solc versions 0.4.7-0.5.9 contain a compiler bug leading to incorrect ABI encoder usage.

Exploit Scenario Copy Section

contract A {
    uint[2][3] bad_arr = [[1, 2], [3, 4], [5, 6]];

    /* Array of arrays passed to abi.encode is vulnerable */
    function bad() public {
        bytes memory b = abi.encode(bad_arr);
    }
}

abi.encode(bad_arr) in a call to bad() will incorrectly encode the array as [[1, 2], [2, 3], [3, 4]] and lead to unintended behavior.

Recommendation Copy Section

Use a compiler >= 0.5.10.

Arbitrary `from` in transferFrom Copy Chapter

Configuration Copy Section

• Check: arbitrary-send-erc20
• Severity: High
• Confidence: High

Description Copy Section

Detect when msg.sender is not used as from in transferFrom.

Exploit Scenario Copy Section

function a(address from, address to, uint256 amount) public {
        erc20.transferFrom(from, to, am);
    }

Alice approves this contract to spend her ERC20 tokens. Bob can call a and specify Alice's address as the from parameter in transferFrom, allowing him to transfer Alice's tokens to himself.

Recommendation Copy Section

Use msg.sender as from in transferFrom.

Modifying storage array by value Copy Chapter

Configuration Copy Section

• Check: array-by-reference
• Severity: High
• Confidence: High

Description Copy Section

Detect arrays passed to a function that expects reference to a storage array

Exploit Scenario Copy Section

contract Memory {
    uint[1] public x; // storage

    function f() public {
        f1(x); // update x
        f2(x); // do not update x
    }

    function f1(uint[1] storage arr) internal { // by reference
        arr[0] = 1;
    }

    function f2(uint[1] arr) internal { // by value
        arr[0] = 2;
    }
}

Bob calls f(). Bob assumes that at the end of the call x[0] is 2, but it is 1.
As a result, Bob's usage of the contract is incorrect.

Recommendation Copy Section

Ensure the correct usage of memory and storage in the function parameters. Make all the locations explicit.

ABI encodePacked Collision Copy Chapter

Configuration Copy Section

• Check: encode-packed-collision
• Severity: High
• Confidence: High

Description Copy Section

Detect collision due to dynamic type usages in abi.encodePacked

Exploit Scenario Copy Section

contract Sign {
    function get_hash_for_signature(string name, string doc) external returns(bytes32) {
        return keccak256(abi.encodePacked(name, doc));
    }
}

Bob calls get_hash_for_signature with (bob, This is the content). The hash returned is used as an ID.
Eve creates a collision with the ID using (bo, bThis is the content) and compromises the system.

Recommendation Copy Section

Do not use more than one dynamic type in abi.encodePacked()
(see the Solidity documentation).
Use abi.encode(), preferably.

Incorrect shift in assembly Copy Chapter

Configuration Copy Section

• Check: incorrect-shift
• Severity: High
• Confidence: High

Description Copy Section

Detect if the values in a shift operation are reversed

Exploit Scenario Copy Section

contract C {
    function f() internal returns (uint a) {
        assembly {
            a := shr(a, 8)
        }
    }
}

The shift statement will right-shift the constant 8 by a bits

Recommendation Copy Section

Swap the order of parameters.

Multiple constructor schemes Copy Chapter

Configuration Copy Section

• Check: multiple-constructors
• Severity: High
• Confidence: High

Description Copy Section

Detect multiple constructor definitions in the same contract (using new and old schemes).

Exploit Scenario Copy Section

contract A {
    uint x;
    constructor() public {
        x = 0;
    }
    function A() public {
        x = 1;
    }

    function test() public returns(uint) {
        return x;
    }
}

In Solidity 0.4.22, a contract with both constructor schemes will compile. The first constructor will take precedence over the second, which may be unintended.

Recommendation Copy Section

Only declare one constructor, preferably using the new scheme constructor(...) instead of function <contractName>(...).

Name reused Copy Chapter

Configuration Copy Section

• Check: name-reused
• Severity: High
• Confidence: High

Description Copy Section

If a codebase has two contracts the similar names, the compilation artifacts
will not contain one of the contracts with the duplicate name.

Exploit Scenario Copy Section

Bob's truffle codebase has two contracts named ERC20.
When truffle compile runs, only one of the two contracts will generate artifacts in build/contracts.
As a result, the second contract cannot be analyzed.

Recommendation Copy Section

Rename the contract.

Protected Variables Copy Chapter

Configuration Copy Section

• Check: protected-vars
• Severity: High
• Confidence: High

Description Copy Section

Detect unprotected variable that are marked protected

Exploit Scenario Copy Section

contract Buggy{

    /// @custom:security write-protection="onlyOwner()"
    address owner;

    function set_protected() public onlyOwner(){
        owner = msg.sender;
    }

    function set_not_protected() public{
        owner = msg.sender;
    }
}

owner must be always written by function using onlyOwner (write-protection="onlyOwner()"), however anyone can call set_not_protected.

Recommendation Copy Section

Add access controls to the vulnerable function

Public mappings with nested variables Copy Chapter

Configuration Copy Section

• Check: public-mappings-nested
• Severity: High
• Confidence: High

Description Copy Section

Prior to Solidity 0.5, a public mapping with nested structures returned incorrect values.

Exploit Scenario Copy Section

Bob interacts with a contract that has a public mapping with nested structures. The values returned by the mapping are incorrect, breaking Bob's usage

Recommendation Copy Section

Do not use public mapping with nested structures.

Right-to-Left-Override character Copy Chapter

Configuration Copy Section

• Check: rtlo
• Severity: High
• Confidence: High

Description Copy Section

An attacker can manipulate the logic of the contract by using a right-to-left-override character (U+202E).

Exploit Scenario Copy Section

contract Token
{

    address payable o; // owner
    mapping(address => uint) tokens;

    function withdraw() external returns(uint)
    {
        uint amount = tokens[msg.sender];
        address payable d = msg.sender;
        tokens[msg.sender] = 0;
        _withdraw(/*owner‮/*noitanitsed*/ d, o/*‭
          /*value */, amount);
    }

    function _withdraw(address payable fee_receiver, address payable destination, uint value) internal
    {
  fee_receiver.transfer(1);
  destination.transfer(value);
    }
}

Token uses the right-to-left-override character when calling _withdraw. As a result, the fee is incorrectly sent to msg.sender, and the token balance is sent to the owner.

Recommendation Copy Section

Special control characters must not be allowed.

State variable shadowing Copy Chapter

Configuration Copy Section

• Check: shadowing-state
• Severity: High
• Confidence: High

Description Copy Section

Detection of state variables shadowed.

Exploit Scenario Copy Section

contract BaseContract{
    address owner;

    modifier isOwner(){
        require(owner == msg.sender);
        _;
    }

}

contract DerivedContract is BaseContract{
    address owner;

    constructor(){
        owner = msg.sender;
    }

    function withdraw() isOwner() external{
        msg.sender.transfer(this.balance);
    }
}

owner of BaseContract is never assigned and the modifier isOwner does not work.

Recommendation Copy Section

Remove the state variable shadowing.

Suicidal Copy Chapter

Configuration Copy Section

• Check: suicidal
• Severity: High
• Confidence: High

Description Copy Section

Unprotected call to a function executing selfdestruct/suicide.

Exploit Scenario Copy Section

contract Suicidal{
    function kill() public{
        selfdestruct(msg.sender);
    }
}

Bob calls kill and destructs the contract.

Recommendation Copy Section

Protect access to all sensitive functions.

Uninitialized state variables Copy Chapter

Configuration Copy Section

• Check: uninitialized-state
• Severity: High
• Confidence: High

Description Copy Section

Uninitialized state variables.

Exploit Scenario Copy Section

contract Uninitialized{
    address destination;

    function transfer() payable public{
        destination.transfer(msg.value);
    }
}

Bob calls transfer. As a result, the Ether are sent to the address 0x0 and are lost.

Recommendation Copy Section

Initialize all the variables. If a variable is meant to be initialized to zero, explicitly set it to zero to improve code readability.

Uninitialized storage variables Copy Chapter

Configuration Copy Section

• Check: uninitialized-storage
• Severity: High
• Confidence: High

Description Copy Section

An uninitialized storage variable will act as a reference to the first state variable, and can override a critical variable.

Exploit Scenario Copy Section

contract Uninitialized{
    address owner = msg.sender;

    struct St{
        uint a;
    }

    function func() {
        St st;
        st.a = 0x0;
    }
}

Bob calls func. As a result, owner is overridden to 0.

Recommendation Copy Section

Initialize all storage variables.

Unprotected upgradeable contract Copy Chapter

Configuration Copy Section

• Check: unprotected-upgrade
• Severity: High
• Confidence: High

Description Copy Section

Detects logic contract that can be destructed.

Exploit Scenario Copy Section

contract Buggy is Initializable{
    address payable owner;

    function initialize() external initializer{
        require(owner == address(0));
        owner = msg.sender;
    }
    function kill() external{
        require(msg.sender == owner);
        selfdestruct(owner);
    }
}

Buggy is an upgradeable contract. Anyone can call initialize on the logic contract, and destruct the contract.

Recommendation Copy Section

Add a constructor to ensure initialize cannot be called on the logic contract.

Arbitrary `from` in transferFrom used with permit Copy Chapter

Configuration Copy Section

• Check: arbitrary-send-erc20-permit
• Severity: High
• Confidence: Medium

Description Copy Section

Detect when msg.sender is not used as from in transferFrom and permit is used.

Exploit Scenario Copy Section

function bad(address from, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s, address to) public {
        erc20.permit(from, address(this), value, deadline, v, r, s);
        erc20.transferFrom(from, to, value);
    }

If an ERC20 token does not implement permit and has a fallback function e.g. WETH, transferFrom allows an attacker to transfer all tokens approved for this contract.

Recommendation Copy Section

Ensure that the underlying ERC20 token correctly implements a permit function.

Functions that send Ether to arbitrary destinations Copy Chapter

Configuration Copy Section

• Check: arbitrary-send-eth
• Severity: High
• Confidence: Medium

Description Copy Section

Unprotected call to a function sending Ether to an arbitrary address.

Exploit Scenario Copy Section

contract ArbitrarySendEth{
    address destination;
    function setDestination(){
        destination = msg.sender;
    }

    function withdraw() public{
        destination.transfer(this.balance);
    }
}

Bob calls setDestination and withdraw. As a result he withdraws the contract's balance.

Recommendation Copy Section

Ensure that an arbitrary user cannot withdraw unauthorized funds.

Array Length Assignment Copy Chapter

Configuration Copy Section

• Check: controlled-array-length
• Severity: High
• Confidence: Medium

Description Copy Section

Detects the direct assignment of an array's length.

Exploit Scenario Copy Section

contract A {
 uint[] testArray; // dynamic size array

 function f(uint usersCount) public {
  // ...
  testArray.length = usersCount;
  // ...
 }

 function g(uint userIndex, uint val) public {
  // ...
  testArray[userIndex] = val;
  // ...
 }
}

Contract storage/state-variables are indexed by a 256-bit integer.
The user can set the array length to 2**256-1 in order to index all storage slots.
In the example above, one could call the function f to set the array length, then call the function g to control any storage slot desired.
Note that storage slots here are indexed via a hash of the indexers; nonetheless, all storage will still be accessible and could be controlled by the attacker.

Recommendation Copy Section

Do not allow array lengths to be set directly set; instead, opt to add values as needed.
Otherwise, thoroughly review the contract to ensure a user-controlled variable cannot reach an array length assignment.

Controlled Delegatecall Copy Chapter

Configuration Copy Section

• Check: controlled-delegatecall
• Severity: High
• Confidence: Medium

Description Copy Section

Delegatecall or callcode to an address controlled by the user.

Exploit Scenario Copy Section

contract Delegatecall{
    function delegate(address to, bytes data){
        to.delegatecall(data);
    }
}

Bob calls delegate and delegates the execution to his malicious contract. As a result, Bob withdraws the funds of the contract and destructs it.

Recommendation Copy Section

Avoid using delegatecall. Use only trusted destinations.

Payable functions using `delegatecall` inside a loop Copy Chapter

Configuration Copy Section

• Check: delegatecall-loop
• Severity: High
• Confidence: Medium

Description Copy Section

Detect the use of delegatecall inside a loop in a payable function.

Exploit Scenario Copy Section

contract DelegatecallInLoop{

    mapping (address => uint256) balances;

    function bad(address[] memory receivers) public payable {
        for (uint256 i = 0; i < receivers.length; i++) {
            address(this).delegatecall(abi.encodeWithSignature("addBalance(address)", receivers[i]));
        }
    }

    function addBalance(address a) public payable {
        balances[a] += msg.value;
    }

}

When calling bad the same msg.value amount will be accredited multiple times.

Recommendation Copy Section

Carefully check that the function called by delegatecall is not payable/doesn't use msg.value.

Incorrect exponentiation Copy Chapter

Configuration Copy Section

• Check: incorrect-exp
• Severity: High
• Confidence: Medium

Description Copy Section

Detect use of bitwise xor ^ instead of exponential **

Exploit Scenario Copy Section

contract Bug{
    uint UINT_MAX = 2^256 - 1;
    ...
}

Alice deploys a contract in which UINT_MAX incorrectly uses ^ operator instead of ** for exponentiation

Recommendation Copy Section

Use the correct operator ** for exponentiation.

Incorrect return in assembly Copy Chapter

Configuration Copy Section

• Check: incorrect-return
• Severity: High
• Confidence: Medium

Description Copy Section

Detect if return in an assembly block halts unexpectedly the execution.

Exploit Scenario Copy Section

contract C {
    function f() internal returns (uint a, uint b) {
        assembly {
            return (5, 6)
        }
    }

    function g() returns (bool){
        f();
        return true;
    }
}

The return statement in f will cause execution in g to halt.
The function will return 6 bytes starting from offset 5, instead of returning a boolean.

Recommendation Copy Section

Use the leave statement.

`msg.value` inside a loop Copy Chapter

Configuration Copy Section

• Check: msg-value-loop
• Severity: High
• Confidence: Medium

Description Copy Section

Detect the use of msg.value inside a loop.

Exploit Scenario Copy Section

contract MsgValueInLoop{

    mapping (address => uint256) balances;

    function bad(address[] memory receivers) public payable {
        for (uint256 i=0; i < receivers.length; i++) {
            balances[receivers[i]] += msg.value;
        }
    }

}

Recommendation Copy Section

Provide an explicit array of amounts alongside the receivers array, and check that the sum of all amounts matches msg.value.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-balance
• Severity: High
• Confidence: Medium

Description Copy Section

Detects reentrancy vulnerabilities where a balance is saved (e.g., balanceOf) before an external call,
and the same balance is checked again after the call. An attacker could manipulate the balance during the reentrant call,
causing the post-call check to use an outdated value.

Exploit Scenario Copy Section

interface IERC20 {
   function balanceOf(address account) external view returns (uint256);
}

interface I {
  function pay(uint256 amount) external;
}

function mint(IERC20 tk) public {
    uint amount_to_pay = 100;
    uint balance_before = tk.balanceOf(address(this));
    I(msg.sender).pay(amount_to_pay);
    require(tk.balanceOf(address(this)) - balance_before >= amount_to_pay);
    // Mint liquidity
}

The balanceBefore variable could be outdated if the external call reenter the mint function N times, allowing to pay the funds only once.

Recommendation Copy Section

Use transferFrom to transfer funds of a standard ERC20 token, or use reentrancy guards to prevent reentering the function.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-eth
• Severity: High
• Confidence: Medium

Description Copy Section

Detection of the reentrancy bug.
Do not report reentrancies that don't involve Ether (see reentrancy-no-eth)

Exploit Scenario Copy Section

function withdrawBalance(){
        // send userBalance[msg.sender] Ether to msg.sender
        // if msg.sender is a contract, it will call its fallback function
        if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
            throw;
        }
        userBalance[msg.sender] = 0;
    }

Bob uses the re-entrancy bug to call withdrawBalance two times, and withdraw more than its initial deposit to the contract.

Recommendation Copy Section

Apply the check-effects-interactions pattern.

Return instead of leave in assembly Copy Chapter

Configuration Copy Section

• Check: return-leave
• Severity: High
• Confidence: Medium

Description Copy Section

Detect if a return is used where a leave should be used.

Exploit Scenario Copy Section

contract C {
    function f() internal returns (uint a, uint b) {
        assembly {
            return (5, 6)
        }
    }

}

The function will halt the execution, instead of returning a two uint.

Recommendation Copy Section

Use the leave statement.

Storage Signed Integer Array Copy Chapter

Configuration Copy Section

• Check: storage-array
• Severity: High
• Confidence: Medium

Description Copy Section

solc versions 0.4.7-0.5.9 contain a compiler bug
leading to incorrect values in signed integer arrays.

Exploit Scenario Copy Section

contract A {
 int[3] ether_balances; // storage signed integer array
 function bad0() private {
  // ...
  ether_balances = [-1, -1, -1];
  // ...
 }
}

bad0() uses a (storage-allocated) signed integer array state variable to store the ether balances of three accounts.
-1 is supposed to indicate uninitialized values but the Solidity bug makes these as 1, which could be exploited by the accounts.

Recommendation Copy Section

Use a compiler version >= 0.5.10.

Unchecked transfer Copy Chapter

Configuration Copy Section

• Check: unchecked-transfer
• Severity: High
• Confidence: Medium

Description Copy Section

The return value of an external transfer/transferFrom call is not checked

Exploit Scenario Copy Section

contract Token {
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract MyBank{
    mapping(address => uint) balances;
    Token token;
    function deposit(uint amount) public{
        token.transferFrom(msg.sender, address(this), amount);
        balances[msg.sender] += amount;
    }
}

Several tokens do not revert in case of failure and return false. If one of these tokens is used in MyBank, deposit will not revert if the transfer fails, and an attacker can call deposit for free..

Recommendation Copy Section

Use SafeERC20, or ensure that the transfer/transferFrom return value is checked.

Weak PRNG Copy Chapter

Configuration Copy Section

• Check: weak-prng
• Severity: High
• Confidence: Medium

Description Copy Section

Weak PRNG due to a modulo on block.timestamp, now or blockhash. These can be influenced by miners to some extent so they should be avoided.

Exploit Scenario Copy Section

contract Game {

    uint reward_determining_number;

    function guessing() external{
      reward_determining_number = uint256(block.blockhash(10000)) % 10;
    }
}

Eve is a miner. Eve calls guessing and re-orders the block containing the transaction.
As a result, Eve wins the game.

Recommendation Copy Section

Do not use block.timestamp, now or blockhash as a source of randomness

Domain separator collision Copy Chapter

Configuration Copy Section

• Check: domain-separator-collision
• Severity: Medium
• Confidence: High

Description Copy Section

An ERC20 token has a function whose signature collides with EIP-2612's DOMAIN_SEPARATOR(), causing unanticipated behavior for contracts using permit functionality.

Exploit Scenario Copy Section

contract Contract{
    function some_collisions() external() {}
}

some_collision clashes with EIP-2612's DOMAIN_SEPARATOR() and will interfere with contract's using permit.

Recommendation Copy Section

Remove or rename the function that collides with DOMAIN_SEPARATOR().

Dangerous enum conversion Copy Chapter

Configuration Copy Section

• Check: enum-conversion
• Severity: Medium
• Confidence: High

Description Copy Section

Detect out-of-range enum conversion (solc < 0.4.5).

Exploit Scenario Copy Section

pragma solidity 0.4.2;
    contract Test{

    enum E{a}

    function bug(uint a) public returns(E){
        return E(a);
    }
}

Attackers can trigger unexpected behaviour by calling bug(1).

Recommendation Copy Section

Use a recent compiler version. If solc <0.4.5 is required, check the enum conversion range.

Incorrect erc20 interface Copy Chapter

Configuration Copy Section

• Check: erc20-interface
• Severity: Medium
• Confidence: High

Description Copy Section

Incorrect return values for ERC20 functions. A contract compiled with Solidity > 0.4.22 interacting with these functions will fail to execute them, as the return value is missing.

Exploit Scenario Copy Section

contract Token{
    function transfer(address to, uint value) external;
    //...
}

Token.transfer does not return a boolean. Bob deploys the token. Alice creates a contract that interacts with it but assumes a correct ERC20 interface implementation. Alice's contract is unable to interact with Bob's contract.

Recommendation Copy Section

Set the appropriate return values and types for the defined ERC20 functions.

Incorrect erc721 interface Copy Chapter

Configuration Copy Section

• Check: erc721-interface
• Severity: Medium
• Confidence: High

Description Copy Section

Incorrect return values for ERC721 functions. A contract compiled with solidity > 0.4.22 interacting with these functions will fail to execute them, as the return value is missing.

Exploit Scenario Copy Section

contract Token{
    function ownerOf(uint256 _tokenId) external view returns (bool);
    //...
}

Token.ownerOf does not return an address like ERC721 expects. Bob deploys the token. Alice creates a contract that interacts with it but assumes a correct ERC721 interface implementation. Alice's contract is unable to interact with Bob's contract.

Recommendation Copy Section

Set the appropriate return values and vtypes for the defined ERC721 functions.

Dangerous strict equalities Copy Chapter

Configuration Copy Section

• Check: incorrect-equality
• Severity: Medium
• Confidence: High

Description Copy Section

Use of strict equalities that can be easily manipulated by an attacker.

Exploit Scenario Copy Section

contract Crowdsale{
    function fund_reached() public returns(bool){
        return this.balance == 100 ether;
    }

Crowdsale relies on fund_reached to know when to stop the sale of tokens.
Crowdsale reaches 100 Ether. Bob sends 0.1 Ether. As a result, fund_reached is always false and the crowdsale never ends.

Recommendation Copy Section

Don't use strict equality to determine if an account has enough Ether or tokens.

Contracts that lock Ether Copy Chapter

Configuration Copy Section

• Check: locked-ether
• Severity: Medium
• Confidence: High

Description Copy Section

Contract with a payable function, but without a withdrawal capacity.

Exploit Scenario Copy Section

pragma solidity 0.4.24;
contract Locked{
    function receive() payable public{
    }
}

Every Ether sent to Locked will be lost.

Recommendation Copy Section

Remove the payable attribute or add a withdraw function.

Deletion on mapping containing a structure Copy Chapter

Configuration Copy Section

• Check: mapping-deletion
• Severity: Medium
• Confidence: High

Description Copy Section

A deletion in a structure containing a mapping will not delete the mapping (see the Solidity documentation). The remaining data may be used to compromise the contract.

Exploit Scenario Copy Section

struct BalancesStruct{
        address owner;
        mapping(address => uint) balances;
    }
    mapping(address => BalancesStruct) public stackBalance;

    function remove() internal{
         delete stackBalance[msg.sender];
    }

remove deletes an item of stackBalance.
The mapping balances is never deleted, so remove does not work as intended.

Recommendation Copy Section

Use a lock mechanism instead of a deletion to disable structure containing a mapping.

Pyth deprecated functions Copy Chapter

Configuration Copy Section

• Check: pyth-deprecated-functions
• Severity: Medium
• Confidence: High

Description Copy Section

Detect when a Pyth deprecated function is used

Exploit Scenario Copy Section

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract C {

    IPyth pyth;

    constructor(IPyth _pyth) {
        pyth = _pyth;
    }

    function A(bytes32 priceId) public {
        PythStructs.Price memory price = pyth.getPrice(priceId);
        ...
    }
}

The function A uses the deprecated getPrice Pyth function.

Recommendation Copy Section

Do not use deprecated Pyth functions. Visit https://api-reference.pyth.network/.

Pyth unchecked confidence level Copy Chapter

Configuration Copy Section

• Check: pyth-unchecked-confidence
• Severity: Medium
• Confidence: High

Description Copy Section

Detect when the confidence level of a Pyth price is not checked

Exploit Scenario Copy Section

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract C {
    IPyth pyth;

    constructor(IPyth _pyth) {
        pyth = _pyth;
    }

    function bad(bytes32 id, uint256 age) public {
        PythStructs.Price memory price = pyth.getEmaPriceNoOlderThan(id, age);
        // Use price
    }
}

The function A uses the price without checking its confidence level.

Recommendation Copy Section

Check the confidence level of a Pyth price. Visit https://docs.pyth.network/price-feeds/best-practices#confidence-intervals for more information.

Pyth unchecked publishTime Copy Chapter

Configuration Copy Section

• Check: pyth-unchecked-publishtime
• Severity: Medium
• Confidence: High

Description Copy Section

Detect when the publishTime of a Pyth price is not checked

Exploit Scenario Copy Section

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract C {
    IPyth pyth;

    constructor(IPyth _pyth) {
        pyth = _pyth;
    }

    function bad(bytes32 id) public {
        PythStructs.Price memory price = pyth.getEmaPriceUnsafe(id);
        // Use price
    }
}

The function A uses the price without checking its publishTime coming from the getEmaPriceUnsafe function.

Recommendation Copy Section

Check the publishTime of a Pyth price.

State variable shadowing from abstract contracts Copy Chapter

Configuration Copy Section

• Check: shadowing-abstract
• Severity: Medium
• Confidence: High

Description Copy Section

Detection of state variables shadowed from abstract contracts.

Exploit Scenario Copy Section

contract BaseContract{
    address owner;
}

contract DerivedContract is BaseContract{
    address owner;
}

owner of BaseContract is shadowed in DerivedContract.

Recommendation Copy Section

Remove the state variable shadowing.

Tautological compare Copy Chapter

Configuration Copy Section

• Check: tautological-compare
• Severity: Medium
• Confidence: High

Description Copy Section

A variable compared to itself is probably an error as it will always return true for ==, >=, <= and always false for <, > and !=.

Exploit Scenario Copy Section

function check(uint a) external returns(bool){
        return (a >= a);
    }

check always return true.

Recommendation Copy Section

Remove comparison or compare to different value.

Tautology or contradiction Copy Chapter

Configuration Copy Section

• Check: tautology
• Severity: Medium
• Confidence: High

Description Copy Section

Detects expressions that are tautologies or contradictions.

Exploit Scenario Copy Section

contract A {
 function f(uint x) public {
  // ...
        if (x >= 0) { // bad -- always true
           // ...
        }
  // ...
 }

 function g(uint8 y) public returns (bool) {
  // ...
        return (y < 512); // bad!
  // ...
 }
}

x is a uint256, so x >= 0 will be always true.
y is a uint8, so y <512 will be always true.

Recommendation Copy Section

Fix the incorrect comparison by changing the value type or the comparison.

Write after write Copy Chapter

Configuration Copy Section

• Check: write-after-write
• Severity: Medium
• Confidence: High

Description Copy Section

Detects variables that are written but never read and written again.

Exploit Scenario Copy Section

```solidity
contract Buggy{
    function my_func() external initializer{
        // ...
        a = b;
        a = c;
        // ..
    }
}
```
`a` is first assigned to `b`, and then to `c`. As a result the first write does nothing.

Recommendation Copy Section

Fix or remove the writes.

Misuse of a Boolean constant Copy Chapter

Configuration Copy Section

• Check: boolean-cst
• Severity: Medium
• Confidence: Medium

Description Copy Section

Detects the misuse of a Boolean constant.

Exploit Scenario Copy Section

contract A {
 function f(uint x) public {
  // ...
        if (false) { // bad!
           // ...
        }
  // ...
 }

 function g(bool b) public returns (bool) {
  // ...
        return (b || true); // bad!
  // ...
 }
}

Boolean constants in code have only a few legitimate uses.
Other uses (in complex expressions, as conditionals) indicate either an error or, most likely, the persistence of faulty code.

Recommendation Copy Section

Verify and simplify the condition.

Chronicle unchecked price Copy Chapter

Configuration Copy Section

• Check: chronicle-unchecked-price
• Severity: Medium
• Confidence: Medium

Description Copy Section

Chronicle oracle is used and the price returned is not checked to be valid. For more information https://docs.chroniclelabs.org/Resources/FAQ/Oracles#how-do-i-check-if-an-oracle-becomes-inactive-gets-deprecated.

Exploit Scenario Copy Section

contract C {
    IChronicle chronicle;

    constructor(address a) {
        chronicle = IChronicle(a);
    }

    function bad() public {
        uint256 price = chronicle.read();
    }

The bad function gets the price from Chronicle by calling the read function however it does not check if the price is valid.

Recommendation Copy Section

Validate that the price returned by the oracle is valid.

Constant functions using assembly code Copy Chapter

Configuration Copy Section

• Check: constant-function-asm
• Severity: Medium
• Confidence: Medium

Description Copy Section

Functions declared as constant/pure/view using assembly code.

constant/pure/view was not enforced prior to Solidity 0.5.
Starting from Solidity 0.5, a call to a constant/pure/view function uses the STATICCALL opcode, which reverts in case of state modification.

As a result, a call to an incorrectly labeled function may trap a contract compiled with Solidity 0.5.

Exploit Scenario Copy Section

contract Constant{
    uint counter;
    function get() public view returns(uint){
       counter = counter +1;
       return counter
    }
}

Constant was deployed with Solidity 0.4.25. Bob writes a smart contract that interacts with Constant in Solidity 0.5.0.
All the calls to get revert, breaking Bob's smart contract execution.

Recommendation Copy Section

Ensure the attributes of contracts compiled prior to Solidity 0.5.0 are correct.

Constant functions changing the state Copy Chapter

Configuration Copy Section

• Check: constant-function-state
• Severity: Medium
• Confidence: Medium

Description Copy Section

Functions declared as constant/pure/view change the state.

constant/pure/view was not enforced prior to Solidity 0.5.
Starting from Solidity 0.5, a call to a constant/pure/view function uses the STATICCALL opcode, which reverts in case of state modification.

As a result, a call to an incorrectly labeled function may trap a contract compiled with Solidity 0.5.

Exploit Scenario Copy Section

contract Constant{
    uint counter;
    function get() public view returns(uint){
       counter = counter +1;
       return counter
    }
}

Constant was deployed with Solidity 0.4.25. Bob writes a smart contract that interacts with Constant in Solidity 0.5.0.
All the calls to get revert, breaking Bob's smart contract execution.

Recommendation Copy Section

Ensure that attributes of contracts compiled prior to Solidity 0.5.0 are correct.

Divide before multiply Copy Chapter

Configuration Copy Section

• Check: divide-before-multiply
• Severity: Medium
• Confidence: Medium

Description Copy Section

Solidity's integer division truncates. Thus, performing division before multiplication can lead to precision loss.

Exploit Scenario Copy Section

contract A {
 function f(uint n) public {
        coins = (oldSupply / n) * interest;
    }
}

If n is greater than oldSupply, coins will be zero. For example, with oldSupply = 5; n = 10, interest = 2, coins will be zero.
If (oldSupply * interest / n) was used, coins would have been 1.
In general, it's usually a good idea to re-arrange arithmetic to perform multiplication before division, unless the limit of a smaller type makes this dangerous.

Recommendation Copy Section

Consider ordering multiplication before division.

Gelato unprotected randomness Copy Chapter

Configuration Copy Section

• Check: gelato-unprotected-randomness
• Severity: Medium
• Confidence: Medium

Description Copy Section

Detect calls to _requestRandomness within an unprotected function.

Exploit Scenario Copy Section

contract C is GelatoVRFConsumerBase {
    function _fulfillRandomness(
        uint256 randomness,
        uint256,
        bytes memory extraData
    ) internal override {
        // Do something with the random number
    }

    function bad() public {
        _requestRandomness(abi.encode(msg.sender));
    }
}

The function bad is uprotected and requests randomness.

Recommendation Copy Section

Function that request randomness should be allowed only to authorized users.

Out-of-order retryable transactions Copy Chapter

Configuration Copy Section

• Check: out-of-order-retryable
• Severity: Medium
• Confidence: Medium

Description Copy Section

Out-of-order retryable transactions

Exploit Scenario Copy Section

contract L1 {
    function doStuffOnL2() external {
        // Retryable A
        IInbox(inbox).createRetryableTicket({
            to: l2contract,
            l2CallValue: 0,
            maxSubmissionCost: maxSubmissionCost,
            excessFeeRefundAddress: msg.sender,
            callValueRefundAddress: msg.sender,
            gasLimit: gasLimit,
            maxFeePerGas: maxFeePerGas,
            data: abi.encodeCall(l2contract.claim_rewards, ())
        });
        // Retryable B
        IInbox(inbox).createRetryableTicket({
            to: l2contract,
            l2CallValue: 0,
            maxSubmissionCost: maxSubmissionCost,
            excessFeeRefundAddress: msg.sender,
            callValueRefundAddress: msg.sender,
            gasLimit: gas,
            maxFeePerGas: maxFeePerGas,
            data: abi.encodeCall(l2contract.unstake, ())
        });
    }
}

contract L2 {
    function claim_rewards() public {
        // rewards is computed based on balance and staking period
        uint unclaimed_rewards = _compute_and_update_rewards();
        token.safeTransfer(msg.sender, unclaimed_rewards);
    }

    // Call claim_rewards before unstaking, otherwise you lose your rewards
    function unstake() public {
        _free_rewards(); // clean up rewards related variables
        balance = balance[msg.sender];
        balance[msg.sender] = 0;
        staked_token.safeTransfer(msg.sender, balance);
    }
}

Bob calls doStuffOnL2 but the first retryable ticket calling claim_rewards fails. The second retryable ticket calling unstake is executed successfully. As a result, Bob loses his rewards.

Recommendation Copy Section

Do not rely on the order or successful execution of retryable tickets.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-no-eth
• Severity: Medium
• Confidence: Medium

Description Copy Section

Detection of the reentrancy bug.
Do not report reentrancies that involve Ether (see reentrancy-eth).

Exploit Scenario Copy Section

function bug(){
        require(not_called);
        if( ! (msg.sender.call() ) ){
            throw;
        }
        not_called = False;
    }

Recommendation Copy Section

Apply the check-effects-interactions pattern.

Reused base constructors Copy Chapter

Configuration Copy Section

• Check: reused-constructor
• Severity: Medium
• Confidence: Medium

Description Copy Section

Detects if the same base constructor is called with arguments from two different locations in the same inheritance hierarchy.

Exploit Scenario Copy Section

pragma solidity ^0.4.0;

contract A{
    uint num = 5;
    constructor(uint x) public{
        num += x;
    }
}

contract B is A{
    constructor() A(2) public { /* ... */ }
}

contract C is A {
    constructor() A(3) public { /* ... */ }
}

contract D is B, C {
    constructor() public { /* ... */ }
}

contract E is B {
    constructor() A(1) public { /* ... */ }
}

The constructor of A is called multiple times in D and E:

• D inherits from B and C, both of which construct A.
• E only inherits from B, but B and E construct A.
  .

Recommendation Copy Section

Remove the duplicate constructor call.

Dangerous usage of `tx.origin` Copy Chapter

Configuration Copy Section

• Check: tx-origin
• Severity: Medium
• Confidence: Medium

Description Copy Section

tx.origin-based protection can be abused by a malicious contract if a legitimate user interacts with the malicious contract.

Exploit Scenario Copy Section

contract TxOrigin {
    address owner = msg.sender;

    function bug() {
        require(tx.origin == owner);
    }

Bob is the owner of TxOrigin. Bob calls Eve's contract. Eve's contract calls TxOrigin and bypasses the tx.origin protection.

Recommendation Copy Section

Do not use tx.origin for authorization.

Unchecked low-level calls Copy Chapter

Configuration Copy Section

• Check: unchecked-lowlevel
• Severity: Medium
• Confidence: Medium

Description Copy Section

The return value of a low-level call is not checked.

Exploit Scenario Copy Section

contract MyConc{
    function my_func(address payable dst) public payable{
        dst.call.value(msg.value)("");
    }
}

The return value of the low-level call is not checked, so if the call fails, the Ether will be locked in the contract.
If the low level is used to prevent blocking operations, consider logging failed calls.

Recommendation Copy Section

Ensure that the return value of a low-level call is checked or logged.

Unchecked Send Copy Chapter

Configuration Copy Section

• Check: unchecked-send
• Severity: Medium
• Confidence: Medium

Description Copy Section

The return value of a send is not checked.

Exploit Scenario Copy Section

contract MyConc{
    function my_func(address payable dst) public payable{
        dst.send(msg.value);
    }
}

The return value of send is not checked, so if the send fails, the Ether will be locked in the contract.
If send is used to prevent blocking operations, consider logging the failed send.

Recommendation Copy Section

Ensure that the return value of send is checked or logged.

Uninitialized local variables Copy Chapter

Configuration Copy Section

• Check: uninitialized-local
• Severity: Medium
• Confidence: Medium

Description Copy Section

Uninitialized local variables.

Exploit Scenario Copy Section

contract Uninitialized is Owner{
    function withdraw() payable public onlyOwner{
        address to;
        to.transfer(this.balance)
    }
}

Bob calls transfer. As a result, all Ether is sent to the address 0x0 and is lost.

Recommendation Copy Section

Initialize all the variables. If a variable is meant to be initialized to zero, explicitly set it to zero to improve code readability.

Unused return Copy Chapter

Configuration Copy Section

• Check: unused-return
• Severity: Medium
• Confidence: Medium

Description Copy Section

The return value of an external call is not stored in a local or state variable.

Exploit Scenario Copy Section

contract MyConc{
    using SafeMath for uint;
    function my_func(uint a, uint b) public{
        a.add(b);
    }
}

MyConc calls add of SafeMath, but does not store the result in a. As a result, the computation has no effect.

Recommendation Copy Section

Ensure that all the return values of the function calls are used.

Chainlink Feed Registry usage Copy Chapter

Configuration Copy Section

• Check: chainlink-feed-registry
• Severity: Low
• Confidence: High

Description Copy Section

Detect when Chainlink Feed Registry is used. At the moment is only available on Ethereum Mainnet.

Exploit Scenario Copy Section

import "chainlink/contracts/src/v0.8/interfaces/FeedRegistryInteface.sol"

contract A {
    FeedRegistryInterface public immutable registry;

    constructor(address _registry) {
        registry = _registry;
    }

    function getPrice(address base, address quote) public return(uint256) {
        (, int256 price,,,) = registry.latestRoundData(base, quote);
        // Do price validation
        return uint256(price);
    }
}

If the contract is deployed on a different chain than Ethereum Mainnet the getPrice function will revert.

Recommendation Copy Section

Do not use Chainlink Feed Registry outside of Ethereum Mainnet.

Incorrect modifier Copy Chapter

Configuration Copy Section

• Check: incorrect-modifier
• Severity: Low
• Confidence: High

Description Copy Section

If a modifier does not execute _ or revert, the execution of the function will return the default value, which can be misleading for the caller.

Exploit Scenario Copy Section

modifier myModif(){
        if(..){
           _;
        }
    }
    function get() myModif returns(uint){

    }

If the condition in myModif is false, the execution of get() will return 0.

Recommendation Copy Section

All the paths in a modifier must execute _ or revert.

Optimism deprecated predeploy or function Copy Chapter

Configuration Copy Section

• Check: optimism-deprecation
• Severity: Low
• Confidence: High

Description Copy Section

Detect when deprecated Optimism predeploy or function is used.

Exploit Scenario Copy Section

interface GasPriceOracle {
    function scalar() external view returns (uint256);
}

contract Test {
    GasPriceOracle constant OPT_GAS = GasPriceOracle(0x420000000000000000000000000000000000000F);

    function a() public {
        OPT_GAS.scalar();
    }
}

The call to the scalar function of the Optimism GasPriceOracle predeploy always revert.

Recommendation Copy Section

Do not use the deprecated components.

Built-in Symbol Shadowing Copy Chapter

Configuration Copy Section

• Check: shadowing-builtin
• Severity: Low
• Confidence: High

Description Copy Section

Detection of shadowing built-in symbols using local variables, state variables, functions, modifiers, or events.

Exploit Scenario Copy Section

pragma solidity ^0.4.24;

contract Bug {
    uint now; // Overshadows current time stamp.

    function assert(bool condition) public {
        // Overshadows built-in symbol for providing assertions.
    }

    function get_next_expiration(uint earlier_time) private returns (uint) {
        return now + 259200; // References overshadowed timestamp.
    }
}

now is defined as a state variable, and shadows with the built-in symbol now. The function assert overshadows the built-in assert function. Any use of either of these built-in symbols may lead to unexpected results.

Recommendation Copy Section

Rename the local variables, state variables, functions, modifiers, and events that shadow a built-in symbol.

Local variable shadowing Copy Chapter

Configuration Copy Section

• Check: shadowing-local
• Severity: Low
• Confidence: High

Description Copy Section

Detection of shadowing using local variables.

Exploit Scenario Copy Section

pragma solidity ^0.4.24;

contract Bug {
    uint owner;

    function sensitive_function(address owner) public {
        // ...
        require(owner == msg.sender);
    }

    function alternate_sensitive_function() public {
        address owner = msg.sender;
        // ...
        require(owner == msg.sender);
    }
}

sensitive_function.owner shadows Bug.owner. As a result, the use of owner in sensitive_function might be incorrect.

Recommendation Copy Section

Rename the local variables that shadow another component.

Uninitialized function pointers in constructors Copy Chapter

Configuration Copy Section

• Check: uninitialized-fptr-cst
• Severity: Low
• Confidence: High

Description Copy Section

solc versions 0.4.5-0.4.26 and 0.5.0-0.5.8 contain a compiler bug leading to unexpected behavior when calling uninitialized function pointers in constructors.

Exploit Scenario Copy Section

contract bad0 {

  constructor() public {
    /* Uninitialized function pointer */
    function(uint256) internal returns(uint256) a;
    a(10);
  }

}

The call to a(10) will lead to unexpected behavior because function pointer a is not initialized in the constructor.

Recommendation Copy Section

Initialize function pointers before calling. Avoid function pointers if possible.

Pre-declaration usage of local variables Copy Chapter

Configuration Copy Section

• Check: variable-scope
• Severity: Low
• Confidence: High

Description Copy Section

Detects the possible usage of a variable before the declaration is stepped over (either because it is later declared, or declared in another scope).

Exploit Scenario Copy Section

contract C {
    function f(uint z) public returns (uint) {
        uint y = x + 9 + z; // 'x' is used pre-declaration
        uint x = 7;

        if (z % 2 == 0) {
            uint max = 5;
            // ...
        }

        // 'max' was intended to be 5, but it was mistakenly declared in a scope and not assigned (so it is zero).
        for (uint i = 0; i < max; i++) {
            x += 1;
        }

        return x;
    }
}

In the case above, the variable x is used before its declaration, which may result in unintended consequences.
Additionally, the for-loop uses the variable max, which is declared in a previous scope that may not always be reached. This could lead to unintended consequences if the user mistakenly uses a variable prior to any intended declaration assignment. It also may indicate that the user intended to reference a different variable.

Recommendation Copy Section

Move all variable declarations prior to any usage of the variable, and ensure that reaching a variable declaration does not depend on some conditional if it is used unconditionally.

Void constructor Copy Chapter

Configuration Copy Section

• Check: void-cst
• Severity: Low
• Confidence: High

Description Copy Section

Detect the call to a constructor that is not implemented

Exploit Scenario Copy Section

contract A{}
contract B is A{
    constructor() public A(){}
}

When reading B's constructor definition, we might assume that A() initiates the contract, but no code is executed.

Recommendation Copy Section

Remove the constructor call.

Calls inside a loop Copy Chapter

Configuration Copy Section

• Check: calls-loop
• Severity: Low
• Confidence: Medium

Description Copy Section

Calls inside a loop might lead to a denial-of-service attack.

Exploit Scenario Copy Section

contract CallsInLoop{

    address[] destinations;

    constructor(address[] newDestinations) public{
        destinations = newDestinations;
    }

    function bad() external{
        for (uint i=0; i < destinations.length; i++){
            destinations[i].transfer(i);
        }
    }

}

If one of the destinations has a fallback function that reverts, bad will always revert.

Recommendation Copy Section

Favor pull over push strategy for external calls.

Missing events access control Copy Chapter

Configuration Copy Section

• Check: events-access
• Severity: Low
• Confidence: Medium

Description Copy Section

Detect missing events for critical access control parameters

Exploit Scenario Copy Section

contract C {

  modifier onlyAdmin {
    if (msg.sender != owner) throw;
    _;
  }

  function updateOwner(address newOwner) onlyAdmin external {
    owner = newOwner;
  }
}

updateOwner() has no event, so it is difficult to track off-chain owner changes.

Recommendation Copy Section

Emit an event for critical parameter changes.

Missing events arithmetic Copy Chapter

Configuration Copy Section

• Check: events-maths
• Severity: Low
• Confidence: Medium

Description Copy Section

Detect missing events for critical arithmetic parameters.

Exploit Scenario Copy Section

contract C {

    modifier onlyOwner {
        if (msg.sender != owner) throw;
        _;
    }

    function setBuyPrice(uint256 newBuyPrice) onlyOwner public {
        buyPrice = newBuyPrice;
    }

    function buy() external {
     ... // buyPrice is used to determine the number of tokens purchased
    }
}

setBuyPrice() does not emit an event, so it is difficult to track changes in the value of buyPrice off-chain.

Recommendation Copy Section

Emit an event for critical parameter changes.

Dangerous unary expressions Copy Chapter

Configuration Copy Section

• Check: incorrect-unary
• Severity: Low
• Confidence: Medium

Description Copy Section

Unary expressions such as x=+1 probably typos.

Exploit Scenario Copy Section

contract Bug{
    uint public counter;

    function increase() public returns(uint){
        counter=+1;
        return counter;
    }
}

increase() uses =+ instead of +=, so counter will never exceed 1.

Recommendation Copy Section

Remove the unary expression.

Missing zero address validation Copy Chapter

Configuration Copy Section

• Check: missing-zero-check
• Severity: Low
• Confidence: Medium

Description Copy Section

Detect missing zero address validation.

Exploit Scenario Copy Section

contract C {

  modifier onlyAdmin {
    if (msg.sender != owner) throw;
    _;
  }

  function updateOwner(address newOwner) onlyAdmin external {
    owner = newOwner;
  }
}

Bob calls updateOwner without specifying the newOwner, so Bob loses ownership of the contract.

Recommendation Copy Section

Check that the address is not zero.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-benign
• Severity: Low
• Confidence: Medium

Description Copy Section

Detection of the reentrancy bug.
Only report reentrancy that acts as a double call (see reentrancy-eth, reentrancy-no-eth).

Exploit Scenario Copy Section

function callme(){
        if( ! (msg.sender.call()() ) ){
            throw;
        }
        counter += 1
    }

callme contains a reentrancy. The reentrancy is benign because it's exploitation would have the same effect as two consecutive calls.

Recommendation Copy Section

Apply the check-effects-interactions pattern.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-events
• Severity: Low
• Confidence: Medium

Description Copy Section

Detects reentrancies that allow manipulation of the order or value of events.

Exploit Scenario Copy Section

contract ReentrantContract {
 function f() external {
  if (BugReentrancyEvents(msg.sender).counter() == 1) {
   BugReentrancyEvents(msg.sender).count(this);
  }
 }
}
contract Counter {
 uint public counter;
 event Counter(uint);

}
contract BugReentrancyEvents is Counter {
    function count(ReentrantContract d) external {
        counter += 1;
        d.f();
        emit Counter(counter);
    }
}
contract NoReentrancyEvents is Counter {
 function count(ReentrantContract d) external {
        counter += 1;
        emit Counter(counter);
        d.f();
    }
}

If the external call d.f() re-enters BugReentrancyEvents, the Counter events will be incorrect (Counter(2), Counter(2)) whereas NoReentrancyEvents will correctly emit
(Counter(1), Counter(2)). This may cause issues for offchain components that rely on the values of events e.g. checking for the amount deposited to a bridge.

Recommendation Copy Section

Apply the check-effects-interactions pattern.

Return Bomb Copy Chapter

Configuration Copy Section

• Check: return-bomb
• Severity: Low
• Confidence: Medium

Description Copy Section

A low level callee may consume all callers gas unexpectedly.

Exploit Scenario Copy Section

//Modified from https://github.com/nomad-xyz/ExcessivelySafeCall
contract BadGuy {
    function youveActivateMyTrapCard() external pure returns (bytes memory) {
        assembly{
            revert(0, 1000000)
        }
    }
}

contract Mark {
    function oops(address badGuy) public{
        bool success;
        bytes memory ret;

        // Mark pays a lot of gas for this copy
        //(success, ret) = badGuy.call{gas:10000}(
        (success, ret) = badGuy.call(
            abi.encodeWithSelector(
                BadGuy.youveActivateMyTrapCard.selector
            )
        );

        // Mark may OOG here, preventing local state changes
        //importantCleanup();
    }
}

After Mark calls BadGuy bytes are copied from returndata to memory, the memory expansion cost is paid. This means that when using a standard solidity call, the callee can "returnbomb" the caller, imposing an arbitrary gas cost.
Callee unexpectedly makes the caller OOG.

Recommendation Copy Section

Avoid unlimited implicit decoding of returndata.

Block timestamp Copy Chapter

Configuration Copy Section

• Check: timestamp
• Severity: Low
• Confidence: Medium

Description Copy Section

Dangerous usage of block.timestamp. block.timestamp can be manipulated by miners.

Exploit Scenario Copy Section

"Bob's contract relies on block.timestamp for its randomness. Eve is a miner and manipulates block.timestamp to exploit Bob's contract.

Recommendation Copy Section

Avoid relying on block.timestamp.

Assembly usage Copy Chapter

Configuration Copy Section

• Check: assembly
• Severity: Informational
• Confidence: High

Description Copy Section

The use of assembly is error-prone and should be avoided.

Recommendation Copy Section

Do not use evm assembly.

Assert state change Copy Chapter

Configuration Copy Section

• Check: assert-state-change
• Severity: Informational
• Confidence: High

Description Copy Section

Incorrect use of assert(). See Solidity best practices.

Exploit Scenario Copy Section

contract A {

  uint s_a;

  function bad() public {
    assert((s_a += 1) > 10);
  }
}

The assert in bad() increments the state variable s_a while checking for the condition.

Recommendation Copy Section

Use require for invariants modifying the state.

Boolean equality Copy Chapter

Configuration Copy Section

• Check: boolean-equal
• Severity: Informational
• Confidence: High

Description Copy Section

Detects the comparison to boolean constants.

Exploit Scenario Copy Section

contract A {
 function f(bool x) public {
  // ...
        if (x == true) { // bad!
           // ...
        }
  // ...
 }
}

Boolean constants can be used directly and do not need to be compare to true or false.

Recommendation Copy Section

Remove the equality to the boolean constant.

Cyclomatic complexity Copy Chapter

Configuration Copy Section

• Check: cyclomatic-complexity
• Severity: Informational
• Confidence: High

Description Copy Section

Detects functions with high (> 11) cyclomatic complexity.

Recommendation Copy Section

Reduce cyclomatic complexity by splitting the function into several smaller subroutines.

Deprecated standards Copy Chapter

Configuration Copy Section

• Check: deprecated-standards
• Severity: Informational
• Confidence: High

Description Copy Section

Detect the usage of deprecated standards.

Exploit Scenario Copy Section

contract ContractWithDeprecatedReferences {
    // Deprecated: Change block.blockhash() -> blockhash()
    bytes32 globalBlockHash = block.blockhash(0);

    // Deprecated: Change constant -> view
    function functionWithDeprecatedThrow() public constant {
        // Deprecated: Change msg.gas -> gasleft()
        if(msg.gas == msg.value) {
            // Deprecated: Change throw -> revert()
            throw;
        }
    }

    // Deprecated: Change constant -> view
    function functionWithDeprecatedReferences() public constant {
        // Deprecated: Change sha3() -> keccak256()
        bytes32 sha3Result = sha3("test deprecated sha3 usage");

        // Deprecated: Change callcode() -> delegatecall()
        address(this).callcode();

        // Deprecated: Change suicide() -> selfdestruct()
        suicide(address(0));
    }
}

Recommendation Copy Section

Replace all uses of deprecated symbols.

Unindexed ERC20 event parameters Copy Chapter

Configuration Copy Section

• Check: erc20-indexed
• Severity: Informational
• Confidence: High

Description Copy Section

Detects whether events defined by the ERC20 specification that should have some parameters as indexed are missing the indexed keyword.

Exploit Scenario Copy Section

contract ERC20Bad {
    // ...
    event Transfer(address from, address to, uint value);
    event Approval(address owner, address spender, uint value);

    // ...
}

Transfer and Approval events should have the 'indexed' keyword on their two first parameters, as defined by the ERC20 specification.
Failure to include these keywords will exclude the parameter data in the transaction/block's bloom filter, so external tooling searching for these parameters may overlook them and fail to index logs from this token contract.

Recommendation Copy Section

Add the indexed keyword to event parameters that should include it, according to the ERC20 specification.

Function Initializing State Copy Chapter

Configuration Copy Section

• Check: function-init-state
• Severity: Informational
• Confidence: High

Description Copy Section

Detects the immediate initialization of state variables through function calls that are not pure/constant, or that use non-constant state variable.

Exploit Scenario Copy Section

contract StateVarInitFromFunction {

    uint public v = set(); // Initialize from function (sets to 77)
    uint public w = 5;
    uint public x = set(); // Initialize from function (sets to 88)
    address public shouldntBeReported = address(8);

    constructor(){
        // The constructor is run after all state variables are initialized.
    }

    function set() public  returns(uint)  {
        // If this function is being used to initialize a state variable declared
        // before w, w will be zero. If it is declared after w, w will be set.
        if(w == 0) {
            return 77;
        }

        return 88;
    }
}

In this case, users might intend a function to return a value a state variable can initialize with, without realizing the context for the contract is not fully initialized.
In the example above, the same function sets two different values for state variables because it checks a state variable that is not yet initialized in one case, and is initialized in the other.
Special care must be taken when initializing state variables from an immediate function call so as not to incorrectly assume the state is initialized.

Recommendation Copy Section

Remove any initialization of state variables via non-constant state variables or function calls. If variables must be set upon contract deployment, locate initialization in the constructor instead.

Incorrect usage of using-for statement Copy Chapter

Configuration Copy Section

• Check: incorrect-using-for
• Severity: Informational
• Confidence: High

Description Copy Section

In Solidity, it is possible to use libraries for certain types, by the using-for statement (using <library> for <type>). However, the Solidity compiler doesn't check whether a given library has at least one function matching a given type. If it doesn't, such a statement has no effect and may be confusing.

Exploit Scenario Copy Section

```solidity
library L {
    function f(bool) public pure {}
}

using L for uint;
```
Such a code will compile despite the fact that `L` has no function with `uint` as its first argument.

Recommendation Copy Section

Make sure that the libraries used in using-for statements have at least one function matching a type used in these statements.

Low-level calls Copy Chapter

Configuration Copy Section

• Check: low-level-calls
• Severity: Informational
• Confidence: High

Description Copy Section

The use of low-level calls is error-prone. Low-level calls do not check for code existence or call success.

Recommendation Copy Section

Avoid low-level calls. Check the call success. If the call is meant for a contract, check for code existence.

Missing inheritance Copy Chapter

Configuration Copy Section

• Check: missing-inheritance
• Severity: Informational
• Confidence: High

Description Copy Section

Detect missing inheritance.

Exploit Scenario Copy Section

interface ISomething {
    function f1() external returns(uint);
}

contract Something {
    function f1() external returns(uint){
        return 42;
    }
}

Something should inherit from ISomething.

Recommendation Copy Section

Inherit from the missing interface or contract.

Conformance to Solidity naming conventions Copy Chapter

Configuration Copy Section

• Check: naming-convention
• Severity: Informational
• Confidence: High

Description Copy Section

Solidity defines a naming convention that should be followed.

Rule exceptions

• Allow constant variable name/symbol/decimals to be lowercase (ERC20).
• Allow _ at the beginning of the mixed_case match for private variables and unused parameters.

Recommendation Copy Section

Follow the Solidity naming convention.

Different pragma directives are used Copy Chapter

Configuration Copy Section

• Check: pragma
• Severity: Informational
• Confidence: High

Description Copy Section

Detect whether different Solidity versions are used.

Recommendation Copy Section

Use one Solidity version.

Redundant Statements Copy Chapter

Configuration Copy Section

• Check: redundant-statements
• Severity: Informational
• Confidence: High

Description Copy Section

Detect the usage of redundant statements that have no effect.

Exploit Scenario Copy Section

contract RedundantStatementsContract {

    constructor() public {
        uint; // Elementary Type Name
        bool; // Elementary Type Name
        RedundantStatementsContract; // Identifier
    }

    function test() public returns (uint) {
        uint; // Elementary Type Name
        assert; // Identifier
        test; // Identifier
        return 777;
    }
}

Each commented line references types/identifiers, but performs no action with them, so no code will be generated for such statements and they can be removed.

Recommendation Copy Section

Remove redundant statements if they congest code but offer no value.

Incorrect versions of Solidity Copy Chapter

Configuration Copy Section

• Check: solc-version
• Severity: Informational
• Confidence: High

Description Copy Section

solc frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.
We also recommend avoiding complex pragma statement.

Recommendation Copy Section

Deploy with a recent version of Solidity (at least 0.8.0) with no known severe issues.

Use a simple pragma version that allows any of these versions.
Consider using the latest version of Solidity for testing.

Unimplemented functions Copy Chapter

Configuration Copy Section

• Check: unimplemented-functions
• Severity: Informational
• Confidence: High

Description Copy Section

Detect functions that are not implemented on derived-most contracts.

Exploit Scenario Copy Section

interface BaseInterface {
    function f1() external returns(uint);
    function f2() external returns(uint);
}

interface BaseInterface2 {
    function f3() external returns(uint);
}

contract DerivedContract is BaseInterface, BaseInterface2 {
    function f1() external returns(uint){
        return 42;
    }
}

DerivedContract does not implement BaseInterface.f2 or BaseInterface2.f3.
As a result, the contract will not properly compile.
All unimplemented functions must be implemented on a contract that is meant to be used.

Recommendation Copy Section

Implement all unimplemented functions in any contract you intend to use directly (not simply inherit from).

Unindexed event address parameters Copy Chapter

Configuration Copy Section

• Check: unindexed-event-address
• Severity: Informational
• Confidence: High

Description Copy Section

Detects events that have address-type parameters but no indexed parameters. Indexing event parameters enables efficient off-chain filtering.

Exploit Scenario Copy Section

contract Token {
    event Transfer(address from, address to, uint256 value);

    function transfer(address to, uint256 value) external {
        // ...
        emit Transfer(msg.sender, to, value);
    }
}

The Transfer event has address parameters but none are indexed.
Off-chain tools cannot efficiently filter transfers by sender or recipient address.

Recommendation Copy Section

Add the indexed keyword to address parameters in events to enable efficient off-chain filtering.

Unused state variable Copy Chapter

Configuration Copy Section

• Check: unused-state
• Severity: Informational
• Confidence: High

Description Copy Section

Unused state variable.

Recommendation Copy Section

Remove unused state variables.

Costly operations inside a loop Copy Chapter

Configuration Copy Section

• Check: costly-loop
• Severity: Informational
• Confidence: Medium

Description Copy Section

Costly operations inside a loop might waste gas, so optimizations are justified.

Exploit Scenario Copy Section

contract CostlyOperationsInLoop{

    uint loop_count = 100;
    uint state_variable=0;

    function bad() external{
        for (uint i=0; i < loop_count; i++){
            state_variable++;
        }
    }

    function good() external{
      uint local_variable = state_variable;
      for (uint i=0; i < loop_count; i++){
        local_variable++;
      }
      state_variable = local_variable;
    }
}

Incrementing state_variable in a loop incurs a lot of gas because of expensive SSTOREs, which might lead to an out-of-gas.

Recommendation Copy Section

Use a local variable to hold the loop computation result.

Dead-code Copy Chapter

Configuration Copy Section

• Check: dead-code
• Severity: Informational
• Confidence: Medium

Description Copy Section

Functions that are not used.

Exploit Scenario Copy Section

contract Contract{
    function dead_code() internal() {}
}

dead_code is not used in the contract, and make the code's review more difficult.

Recommendation Copy Section

Remove unused functions.

Reentrancy vulnerabilities Copy Chapter

Configuration Copy Section

• Check: reentrancy-unlimited-gas
• Severity: Informational
• Confidence: Medium

Description Copy Section

Detection of the reentrancy bug.
Only report reentrancy that is based on transfer or send.

Exploit Scenario Copy Section

function callme(){
        msg.sender.transfer(balances[msg.sender]):
        balances[msg.sender] = 0;
    }

send and transfer do not protect from reentrancies in case of gas price changes.

Recommendation Copy Section

Apply the check-effects-interactions pattern.

Too many digits Copy Chapter

Configuration Copy Section

• Check: too-many-digits
• Severity: Informational
• Confidence: Medium

Description Copy Section

Literals with many digits are difficult to read and review. Use scientific notation or suffixes to make the code more readable.

Exploit Scenario Copy Section

contract MyContract{
    uint 1_ether = 10000000000000000000;
}

While 1_ether looks like 1 ether, it is 10 ether. As a result, it's likely to be used incorrectly.

Recommendation Copy Section

Use:

• Ether suffix,
• Time suffix, or
• The scientific notation

Cache array length Copy Chapter

Configuration Copy Section

• Check: cache-array-length
• Severity: Optimization
• Confidence: High

Description Copy Section

Detects for loops that use length member of some storage array in their loop condition and don't modify it.

Exploit Scenario Copy Section

contract C
{
    uint[] array;

    function f() public
    {
        for (uint i = 0; i < array.length; i++)
        {
            // code that does not modify length of `array`
        }
    }
}

Since the for loop in f doesn't modify array.length, it is more gas efficient to cache it in some local variable and use that variable instead, like in the following example:

contract C
{
    uint[] array;

    function f() public
    {
        uint array_length = array.length;
        for (uint i = 0; i < array_length; i++)
        {
            // code that does not modify length of `array`
        }
    }
}

Recommendation Copy Section

Cache the lengths of storage arrays if they are used and not modified in for loops.

State variables that could be declared constant Copy Chapter

Configuration Copy Section

• Check: constable-states
• Severity: Optimization
• Confidence: High

Description Copy Section

State variables that are not updated following deployment should be declared constant to save gas.

Recommendation Copy Section

Add the constant attribute to state variables that never change.

Public function that could be declared external Copy Chapter

Configuration Copy Section

• Check: external-function
• Severity: Optimization
• Confidence: High

Description Copy Section

public functions that are never called by the contract should be declared external, and its immutable parameters should be located in calldata to save gas.

Recommendation Copy Section

Use the external attribute for functions never called from the contract, and change the location of immutable parameters to calldata to save gas.

State variables that could be declared immutable Copy Chapter

Configuration Copy Section

• Check: immutable-states
• Severity: Optimization
• Confidence: High

Description Copy Section

State variables that are not updated following deployment should be declared immutable to save gas.

Recommendation Copy Section

Add the immutable attribute to state variables that never change or are set only in the constructor.

Public variable read in external context Copy Chapter

Configuration Copy Section

• Check: var-read-using-this
• Severity: Optimization
• Confidence: High

Description Copy Section

The contract reads its own variable using this, adding overhead of an unnecessary STATICCALL.

Exploit Scenario Copy Section

contract C {
    mapping(uint => address) public myMap;
    function test(uint x) external returns(address) {
        return this.myMap(x);
    }
}

Recommendation Copy Section

Read the variable directly from storage instead of calling the contract.

Src Printers Printer Documentation (`docs/src/printers/Printer-documentation.md`) Copy Section

Slither allows printing contracts information through its printers.

Several printers require xdot installed for visualization:

sudo apt install xdot

Call Graph Copy Chapter

slither file.sol --print call-graph

Export the call-graph of the contracts to a dot file

Example Copy Section

slither examples/printers/call_graph.sol --print call-graph

The output format is dot.
To visualize the graph:

xdot examples/printers/call_graph.sol.dot

To convert the file to svg:

dot examples/printers/call_graph.sol.dot -Tpng -o examples/printers/call_graph.sol.png

CFG Copy Chapter

Export the control flow graph of each function

slither file.sol --print cfg

Example Copy Section

The output format is dot.
To visualize the graph:

xdot function.sol.dot

To convert the file to svg:

dot function.dot -Tsvg -o function.sol.png

Contract Summary Copy Chapter

Output a quick summary of the contract.

slither file.sol --print contract-summary

Example Copy Section

slither examples/printers/quick_summary.sol --print contract-summary

Data Dependencies Copy Chapter

Print the data dependencies of the variables
slither file.sol --print data-dependency

Example Copy Section

slither examples/printers/data_dependencies.sol --print data-dependency

Contract MyContract
+----------+----------------------+
| Variable |     Dependencies     |
+----------+----------------------+
|    a     |     ['input_a']      |
|    b     | ['input_b', 'input'] |
|    c     |          []          |
+----------+----------------------+

Function setA(uint256,uint256)
+--------------+--------------+
|   Variable   | Dependencies |
+--------------+--------------+
|   input_a    |      []      |
|   input_b    |      []      |
| MyContract:a | ['input_a']  |
| MyContract:b |      []      |
| MyContract:c |      []      |
+--------------+--------------+
Function setB(uint256)
+--------------+----------------------+
|   Variable   |     Dependencies     |
+--------------+----------------------+
|    input     |     ['input_b']      |
| MyContract:a |          []          |
| MyContract:b | ['input_b', 'input'] |
| MyContract:c |          []          |
+--------------+----------------------+

Constructor Calls Copy Chapter

slither file.sol --print constructor-calls

Print the calling sequence of constructors based on C3 linearization.

Example Copy Section

...
$ slither examples/printers/constructors.sol --print constructor-calls
[..]

Contact Name: test2
        Constructor Call Sequence:   test--> test2
 Constructor Definitions:

  contract name : test2
     constructor()public{
        a=10;
    }

  contract name : test
     constructor()public{
        a =5;
    }


Contact Name: test3
        Constructor Call Sequence:   test--> test2--> test3
 Constructor Definitions:

  contract name : test3
     constructor(bytes32 _name)public{
        owner = msg.sender;
        name = _name;
        a=20;
    }

  contract name : test2
     constructor()public{
        a=10;
    }

  contract name : test
     constructor()public{
        a =5;
    }

Echidna Copy Chapter

This printer is meant to improve Echidna code coverage. The printer is a WIP and is not yet used by Echidna.

EVM Copy Chapter

slither file.sol --print evm

Print the EVM representation of the functions

Note: Requires evm-cfg-builder to be installed:

text Copy

pip install evm-cfg-builder

Example Copy Section

$ slither examples/printers/evm.sol --print evm

INFO:Printers:Contract Test
 Function Test.foo()
  Node: ENTRY_POINT None
  Source line 5:   function foo() public returns (address) {
  EVM Instructions:
   0x44: JUMPDEST
   0x45: CALLVALUE
   0x50: POP
   0x51: PUSH1 0x56
   0x53: PUSH1 0x98
   0x55: JUMP
   0x56: JUMPDEST
   0x57: PUSH1 0x40
   0x59: MLOAD
   0x5a: DUP1
   0x5b: DUP3
   0x5c: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
   0x71: AND
   0x72: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
   0x87: AND
   0x88: DUP2
   0x89: MSTORE
   0x8a: PUSH1 0x20
   0x8c: ADD
   0x8d: SWAP2
   0x8e: POP
   0x8f: POP
   0x90: PUSH1 0x40
   0x92: MLOAD
   0x93: DUP1
   0x94: SWAP2
   0x95: SUB
   0x96: SWAP1
   0x97: RETURN
   0x98: JUMPDEST
   0x99: PUSH1 0x0
   0xa2: POP
   0xa3: SWAP1
                        0xa4: JUMP
                Node: NEW VARIABLE from = msg.sender
                Source line 6:     address from = msg.sender;
                EVM Instructions:
                        0x9b: DUP1
                        0x9c: CALLER
                        0x9d: SWAP1
                        0x9e: POP
                Node: RETURN (from)
                Source line 7:     return(from);
                EVM Instructions:
                        0x9f: DUP1
                        0xa0: SWAP2
                        0xa1: POP

Function ID Copy Chapter

slither file.sol --print function-id
Print the keccack256 signature of the functions

Examples Copy Section

$ slither examples/printers/authorization.sol --print function-id
INFO:Printers:
MyContract:
+---------------+------------+
|      Name     |     ID     |
+---------------+------------+
| constructor() | 0x90fa17bb |
| mint(uint256) | 0xa0712d68 |
+---------------+------------+

Function Summary Copy Chapter

slither file.sol --print function-summary

Output a summary of the contract showing for each function:

• What are the visibility and the modifiers
• What are the state variables read or written
• What are the calls

Example Copy Section

slither tests/backdoor.sol --print function-summary

[...]

Contract C
Contract vars: []
Inheritances:: []

+-----------------+------------+-----------+----------------+-------+---------------------------+----------------+
|     Function    | Visibility | Modifiers |      Read      | Write |       Internal Calls      | External Calls |
+-----------------+------------+-----------+----------------+-------+---------------------------+----------------+
| i_am_a_backdoor |   public   |     []    | ['msg.sender'] |   []  | ['selfdestruct(address)'] |       []       |
+-----------------+------------+-----------+----------------+-------+---------------------------+----------------+

+-----------+------------+------+-------+----------------+----------------+
| Modifiers | Visibility | Read | Write | Internal Calls | External Calls |
+-----------+------------+------+-------+----------------+----------------+
+-----------+------------+------+-------+----------------+----------------+

Human Summary Copy Chapter

slither file.sol --print human-summary

Print a human-readable summary of the contracts

Example Copy Section

slither examples/printers/human_printer.sol --print human-summary

Inheritance Copy Chapter

slither file.sol --print inheritance
Print the inheritance relations between contracts

Example Copy Section

slither examples/printers/inheritances.sol --print inheritance

Inheritance Graph Copy Chapter

slither file.sol --print inheritance-graph

Output a graph showing the inheritance interaction between the contracts.

Example Copy Section

$ slither examples/printers/inheritances.sol --print inheritance-graph
[...]
INFO:PrinterInheritance:Inheritance Graph: examples/DAO.sol.dot

The output format is dot.
To visualize the graph:

xdot examples/printers/inheritances.sol.dot

To convert the file to svg:

dot examples/printers/inheritances.sol.dot -Tsvg -o examples/printers/inheritances.sol.png

Indicators:

• If a contract has multiple inheritance, the connecting edges will be labelled in order of declaration.
• Functions highlighted orange override a parent's function.
• Functions which do not override each other directly (but collide due to multiple inheritance) will be emphasized at the bottom of the affected contract node in grey font.
• Variables highlighted red overshadow a parent's variable declaration.
• Variables of type contract specify the contract name in parentheses in a blue font.

Modifiers Copy Chapter

slither file.sol --print modifiers

Print the modifiers called by each function.

Example Copy Section

$ slither examples/printers/modifier.sol --print modifiers
INFO:Printers:
Contract C
+-------------+-------------+
|   Function  |  Modifiers  |
+-------------+-------------+
| constructor |      []     |
|     set     | ['isOwner'] |
+-------------+-------------+

Require Copy Chapter

slither file.sol --print require

Print the require and assert calls of each function.

Example Copy Section

$ slither examples/printers/require.sol --print require
INFO:Printers:
Contract Lib
+----------+--------------------------------------+
| Function |          require or assert           |
+----------+--------------------------------------+
|   set    | require(bool)(msg.sender == s.owner) |
+----------+--------------------------------------+
INFO:Printers:
Contract C
+-------------+--------------------------------------+
|   Function  |          require or assert           |
+-------------+--------------------------------------+
| constructor |                                      |
|     set     | require(bool)(msg.sender == s.owner) |
+-------------+--------------------------------------+

SlithIR Copy Chapter

slither file.sol --print slithir

Print the slithIR representation of the functions

Example Copy Section

$ slither examples/printers/slihtir.sol --print slithir
Contract UnsafeMath
 Function add(uint256,uint256)
  Expression: a + b
  IRs:
   TMP_0(uint256) = a + b
   RETURN TMP_0
 Function min(uint256,uint256)
  Expression: a - b
  IRs:
   TMP_0(uint256) = a - b
   RETURN TMP_0
Contract MyContract
 Function transfer(address,uint256)
  Expression: balances[msg.sender] = balances[msg.sender].min(val)
  IRs:
   REF_3(uint256) -> balances[msg.sender]
   REF_1(uint256) -> balances[msg.sender]
   TMP_1(uint256) = LIBRARY_CALL, dest:UnsafeMath, function:min, arguments:['REF_1', 'val']
   REF_3 := TMP_1
  Expression: balances[to] = balances[to].add(val)
  IRs:
   REF_3(uint256) -> balances[to]
   REF_1(uint256) -> balances[to]
   TMP_1(uint256) = LIBRARY_CALL, dest:UnsafeMath, function:add, arguments:['REF_1', 'val']
   REF_3 := TMP_1

SlithIR-SSA Copy Chapter

slither file.sol --print slithir-ssa

Print the slithIR representation of the functions (SSA version)

Variable order Copy Chapter

slither file.sol --print variable-order

Print the storage order of the state variables

Example Copy Section

$ slither tests/check-upgradability/contractV2_bug.sol --print variable-order
INFO:Printers:
ContractV2:
+-------------+---------+
|     Name    |   Type  |
+-------------+---------+
| destination | uint256 |
|    myFunc   | uint256 |
+-------------+---------+

Variables written and authorization Copy Chapter

slither file.sol --print vars-and-auth

Print the variables written and the check on msg.sender of each function.

Example Copy Section

...
$ slither examples/printers/authorization.sol --print vars-and-auth
[..]
INFO:Printers:
Contract MyContract
+-------------+-------------------------+----------------------------------------+
|   Function  | State variables written |        Conditions on msg.sender        |
+-------------+-------------------------+----------------------------------------+
| constructor |        ['owner']        |                   []                   |
|     mint    |       ['balances']      | ['require(bool)(msg.sender == owner)'] |
+-------------+-------------------------+----------------------------------------+

Src Tools Adding A New Utility (`docs/src/tools/Adding-a-new-utility.md`) Copy Section

Adding New Utility

Slither can be used as a library to create new utilities.
Official utils are present in tools

Skeleton Copy Chapter

The skeleton util is present in tools/demo

Integration Copy Chapter

To enable an util from the command-line, update project.scripts in pyproject.toml.
Installing Slither will then install the util.

Guidelines Copy Chapter

• Favor the logging module rather than print
• Favor raising an exception rather than sys.exit
• Add unit-tests (ex: scripts/travis_test_find_paths.sh)

Getting Help Copy Chapter

Join our slack channel to get any help (#ethereum).

Src Tools Code Similarity Detector (`docs/src/tools/Code-Similarity-Detector.md`) Copy Section

slither-simil uses state-of-the-art machine learning to detect similar (vulnerable) Solidity functions. We have provided a pretrained model from etherscan_verified_contracts with 60,000 contracts and more than 850,000 functions to get you started quickly. We included the capability to easily train new models if you have access to larger or different datasets.

slither-simil uses FastText, a vector embedding technique, to generate compact numerical representations of every function. We used FastText because it:

• implements several state-of-the-art techniques such as nbow and skipgrams,
• has high performance (it is C++ code with Python bindings),
• has MIT license, and
• is well maintained (by Facebook).

Requirements Copy Chapter

Install the required packages before using slither-simil:

pip3 install pybind11 --user
pip3 install https://github.com/facebookresearch/fastText/archive/0.2.0.zip --user
pip3 install sklearn matplotlib --user # for plot mode

Make sure that you are using pip3.6 or later. If you are running from inside a virtualenv, remove the --user parameter.

Usage Copy Chapter

Note that these examples will use the following files:

• etherscan_verified_contracts.bin
• cache.npz
• MetaCoin.sol

slither-simil has three modes:

• test - finds similar functions to your own in a dataset of contracts
• plot - provide a visual representation of similarity of multiple sampled functions
• train - builds new models of large datasets of contracts
• info - inspects the internal information of the pre-trained model or the assessed code

Test mode Copy Section

This mode transforms a function into a vector and uses it to find similar functions.

Test mode requires the following parameters:

1. A pre-trained model: this file will be used to transform every function into a vector, you can train your own or use our pre-trained one (etherscan_verified_contracts.bin).
2. A contract filename: this file will contain the code that you want to compare,
3. A function name (e.g. SafeMath.add or add),
4. An input directory or file: this can be either a directory with contracts or a cache file with a pre-computed list of vectors for every contract (cache.npz).

Use the cache to avoid long processing times to compile and vectorize the input contracts.

Here's an example that finds functions similar to sendCoin in MetaCoin (compiled with solc-0.4.25). Searching for similar functions among more than 800,000 functions takes only 20 seconds.

/* Detailed source-code truncated for AI context efficiency. */

Train mode Copy Section

Train mode trains new models used to vectorize functions. You will need a large amount of contracts/functions if you plan to train a new model.

$ slither-simil train model.bin --input contracts
INFO:Slither-simil:Saving extracted data into last_data_train.txt
INFO:Slither-simil:Starting training
Read 0M words
Number of words:  348
Number of labels: 0
Progress: 100.0% words/sec/thread:   53124 lr:  0.000000 loss:  2.066949 ETA:   0h 0m
INFO:Slither-simil:Training complete
INFO:Slither-simil:Saving model
INFO:Slither-simil:Saving cache in cache.npz
INFO:Slither-simil:Done!

After it runs, the slither-simil will output the trained model in model.bin, a cache of every function for use in test mode in cache.npz, and the SlithIR of every function for debugging in last_data_train.txt.

Plot mode Copy Section

Plot mode plots sets of functions to visually detect clusters of similar ones.

Here's an example to plot all the functions named add from contracts named SafeMath sampling from 500 random contracts:

$ slither-simil plot etherscan_verified_contracts.bin --fname SafeMath.add --input cache.npz --nsamples 500
INFO:Slither-simil:Loading data..
INFO:Slither-simil:Processing data..
INFO:Slither-simil:Plotting data..
INFO:Slither-simil:Saving figure to plot.png..

This mode performs dimensionality reduction using PCA, so the axes you see here are not associated with any particular unit.

It can also be used to plot sets of functions using only a name from any contract (e.g. burn) .

Info mode Copy Section

This mode has two features. You can inspect the internal information about a pre-trained model. Info mode is typically used for debugging.

$ slither-simil info etherscan_verified_contracts.bin
INFO:Slither-simil:etherscan_verified_contracts.bin uses the following words:
INFO:Slither-simil:</s>
INFO:Slither-simil:index(uint256)
INFO:Slither-simil:return
INFO:Slither-simil:condition(temporary_variable)
INFO:Slither-simil:member
INFO:Slither-simil:solidity_call(require(bool))
INFO:Slither-simil:library_call
INFO:Slither-simil:binary(+)
INFO:Slither-simil:event
INFO:Slither-simil:(local_solc_variable(default)):=(temporary_variable)
...

... or examine the internal representation of function:

$ slither-simil info etherscan_verified_contracts.bin --filename MetaCoin.sol --fname MetaCoin.sendCoin --solc solc-0.4.25
INFO:Slither-simil:Function sendCoin in contract MetaCoin is encoded as:
INFO:Slither-simil:index(uint256) binary(<) condition(temporary_variable) return index(uint256) binary(-) index(uint256) binary(+) event return
INFO:Slither-simil:[ 0.00689753 -0.05349572 -0.06854086 -0.01667773  0.1259813  -0.05974023
  0.06719872 -0.04520541  0.13745852  0.14690697 -0.03721125  0.00579037
  0.06865194 -0.03804035  0.01224702 -0.1014601  -0.02655532 -0.15334933
...

Src Tools Contract Flattening (`docs/src/tools/Contract-Flattening.md`) Copy Section

slither-flat

slither-flat produces a flattened version of the codebase.

Features Copy Chapter

• Code flattening
• Support multiple strategies
• Support circular dependency
• Support all the compilation platforms (Truffle, embark, buidler, etherlime, ...).

Usage Copy Chapter

slither-flat target

• --contract ContractName: flatten only one contract (standalone file)

Strategies Copy Section

slither-flat contains three strategies that can be specified with the --strategy flag:

• MostDerived: Export all the most derived contracts (every file is standalone)
• OneFile: Export all the contracts in one standalone file
• LocalImport: Export every contract in one separate file, and include import ".." in their preludes

Default: MostDerived

Patching Copy Section

slither-flat can transform the codebase to help some usage (eg. Echidna)

• --convert-external: convert external function to public. This is meant to facilitate Echidna usage.
• --contract name: To flatten only a target contract
• --remove-assert: Remove call to assert().

Export option Copy Section

• --dir DirName: output directory
• --json file.json: export the results to a json file (--json - output to the standard output
• --zip file.zip: export to a ZIP file
• --zip-type type: ZIP compression type (default lzma))

Src Tools Doctor (`docs/src/tools/Doctor.md`) Copy Section

Slither doctor

Slither doctor is a tool designed to troubleshoot running Slither on a project.

Src Tools Documentation (`docs/src/tools/Documentation.md`) Copy Section

slither-documentation

slither-documentation uses codex to generate natspec documentation.

This tool is experimental. See solmate documentation for an example of usage.

Src Tools ERC Conformance (`docs/src/tools/ERC-Conformance.md`) Copy Section

slither-check-erc

slither-check-erc checks for ERC's conformance.

Features Copy Chapter

slither-check-erc will check that:

• All the functions are present
• All the events are present
• Functions return the correct type
• Functions that must be view are view
• Events' parameters are correctly indexed
• The functions emit the events
• Derived contracts do not break the conformance

Supported ERCs Copy Chapter

• ERC20: Token standard
• ERC223: Token standard
• ERC777: Token standard
• ERC721: Non-fungible token standard
• ERC165: Standard interface detection
• ERC1155: Multi Token Standard
• ERC1820: Pseudo-introspection registry contract
• ERC4524: Safer ERC-20
• ERC1363: Payable Token
• ERC2612: Permit Extension for EIP-20 Signed Approvals
• ERC4626: Tokenized Vaults

Usage Copy Chapter

slither-check-erc contract.sol ContractName

For example, on

contract ERC20{

    event Transfer(address indexed,address,uint256);

    function transfer(address, uint256) public{

        emit Transfer(msg.sender,msg.sender,0);
    }

}