Building Secure Contracts

https://secure-contracts.com/
Admin
This repository offers comprehensive guidelines and best practices for developing secure smart...
Tokens:157,071
Snippets:999
Trust Score:7.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Clone and set up MetaCoin example for Echidna

Source: https://secure-contracts.com/program-analysis/echidna/advanced/working-with-libraries

Commands to clone the MetaCoin repository, navigate into it, and install Node.js dependencies, preparing the project for Echidna testing with Solidity libraries.

```Bash
git clone https://github.com/truffle-box/metacoin-box
cd metacoin-box
npm i
```

--------------------------------

### Install Basic System Dependencies

Source: https://secure-contracts.com/program-analysis/echidna/advanced/smart-contract-fuzzing-at-scale

This command installs fundamental system packages required for subsequent setup steps. 'unzip' is needed for extracting compressed archives, and 'python3-pip' is essential for managing Python packages.

```bash
sudo apt install unzip python3-pip
```

--------------------------------

### Setup Damn Vulnerable DeFi Echidna Exercise Environment

Source: https://secure-contracts.com/program-analysis/echidna/exercises/Exercise-8

Provides the necessary steps to set up the local development environment for the 'damn-vulnerable-defi-echidna' challenge. This involves cloning the project repository from GitHub and then installing all required dependencies using Yarn.

```bash
git clone https://github.com/crytic/damn-vulnerable-defi-echidna
```

```bash
yarn install
```

--------------------------------

### Initialize Project for Echidna Property Testing

Source: https://secure-contracts.com/program-analysis/echidna/exercises/Exercise-7

These shell commands are used to prepare the development environment for Exercise 7. The first command clones the 'damn-vulnerable-defi-echidna' repository, and the second installs its required Node.js dependencies using Yarn.

```Shell
git clone https://github.com/crytic/damn-vulnerable-defi-echidna
```

```Shell
yarn install
```

--------------------------------

### Install Smart Contract Build Tools and Fuzzing Utilities

Source: https://secure-contracts.com/program-analysis/echidna/advanced/smart-contract-fuzzing-at-scale

These commands install Python-based tools crucial for smart contract development and analysis. 'solc-select' manages Solidity compiler versions, 'slither_analyzer' provides static analysis capabilities, and 'echidna_parade' is a utility for orchestrating multiple Echidna fuzzing instances.

```bash
pip3 install solc-select
solc-select install all
pip3 install slither_analyzer
pip3 install echidna_parade
```

--------------------------------

### Install Medusa using Go Install

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

This command downloads, compiles, and installs the latest version of `medusa` to your `$GOPATH/bin` directory. Ensure `$GOPATH/bin` is in your system's PATH environment variable for global access.

```Shell
go install github.com/crytic/medusa@latest
```

--------------------------------

### Install Echidna Fuzzer from Precompiled Release

Source: https://secure-contracts.com/program-analysis/echidna/advanced/smart-contract-fuzzing-at-scale

This sequence of commands downloads a precompiled binary release of Echidna from its GitHub repository, extracts the contents from the tar.gz archive, and then moves the executable to the user's local bin directory, making it accessible from the command line.

```bash
wget "https://github.com/crytic/echidna/releases/download/v2.0.0/echidna-test-2.0.0-Ubuntu-18.04.tar.gz"
tar -xf echidna-test-2.0.0-Ubuntu-18.04.tar.gz
mv echidna-test /home/echidna/.local/bin
```

--------------------------------

### Setting up Solidity Compiler and Navigating Directory within Docker

Source: https://secure-contracts.com/program-analysis/manticore

After entering the Docker container, these commands set the Solidity compiler version to 0.5.11 using `solc-select` and navigate to the `/home/trufflecon/` directory, preparing the environment for further operations.

```shell
solc-select 0.5.11
cd /home/trufflecon/
```

--------------------------------

### Echidna Output for Side Entrance Vulnerability Discovery

Source: https://secure-contracts.com/program-analysis/echidna/exercises/Exercise-7

Example output from Echidna demonstrating the failure of the 'testPoolBalance' property and the sequence of calls that lead to the vulnerability discovery, specifically involving 'flashLoan', 'deposit', and 'withdraw' operations.

```Shell
echidna . --contract EchidnaSideEntranceLenderPool --config config.yaml
...
testPoolBalance(): failed!💥
  Call sequence:
    execute() Value: 0x103
    setEnableDeposit(true,256)
    flashLoan(1)
    setEnableWithdraw(true)
    setEnableDeposit(false,0)
    execute()
    testPoolBalance()
...
```

--------------------------------

### Installing Manticore via pip

Source: https://secure-contracts.com/program-analysis/manticore/index

This command installs the Manticore analysis framework using pip, the Python package installer. It's recommended to use Solidity compiler version 0.5.11 with this setup.

```shell
pip3 install --user manticore
```

--------------------------------

### Installing Manticore via pip

Source: https://secure-contracts.com/program-analysis/manticore

This command installs the Manticore analysis framework using `pip3` for the current user. It is recommended to use Solidity compiler version 0.5.11 for compatibility with Manticore.

```shell
pip3 install --user manticore
```

--------------------------------

### Create and Configure Echidna User

Source: https://secure-contracts.com/program-analysis/echidna/advanced/smart-contract-fuzzing-at-scale

These commands create a new system user named 'echidna' and then add this user to the 'sudo' group, granting them administrative privileges necessary for installing system-wide packages and tools.

```bash
adduser echidna
usermod -aG sudo echidna
```

--------------------------------

### Slither Constructor Calls Printer Output Example

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example output showing constructor call sequences and definitions for multiple contracts.

```text
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;
    }
```

--------------------------------

### Clone Drizzle-box and Install Truffle Dependencies

Source: https://secure-contracts.com/program-analysis/echidna/advanced/end-to-end-testing

This command sequence clones the example Drizzle-box repository and installs the necessary Node.js packages, including Truffle, required for compiling and testing the smart contract project.

```Shell
git clone https://github.com/truffle-box/drizzle-box
cd drizzle-box
npm i truffle
```

--------------------------------

### Solidity Example: Get and Deploy Contract Creation Bytecode

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/cheatcodes/get_code

This Solidity code snippet illustrates the usage of the `getCode` cheatcode to fetch the creation bytecode of a contract by its file path. It then proceeds to deploy the contract using the retrieved bytecode and includes a verification step to ensure successful deployment. This pattern is valuable for testing frameworks or scenarios requiring dynamic contract instantiation.

```Solidity
contract TestContract {
    function test() public {
        // Obtain cheat code contract reference
        IStdCheats cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

        // Get the creation bytecode for a contract
        bytes memory bytecode = cheats.getCode("MyContract.sol");

        // Deploy the contract using the bytecode
        address deployed;
        assembly {
            deployed := create(0, add(bytecode, 0x20), mload(bytecode))
        }

        // Verify the contract was deployed successfully
        require(deployed != address(0), "Deployment failed");
    }
}
```

--------------------------------

### Install Project Dependencies with Yarn

Source: https://secure-contracts.com/program-analysis/echidna/exercises/Exercise-5

Installs all required project dependencies listed in the `package.json` file using Yarn, necessary for running the secure contracts exercise.

```Shell
yarn install
```

--------------------------------

### Executing a Python Script

Source: https://secure-contracts.com/program-analysis/manticore/index

This command demonstrates how to execute a Python script using the 'python3' interpreter. It's a standard way to run Python programs from the command line.

```shell
python3 script.py
```

--------------------------------

### Solidity Example Function for Differential Fuzzing

Source: https://secure-contracts.com/program-analysis/echidna/advanced/testing-bytecode

A Solidity `my_func` mirroring the Vyper example, designed to be compared against the Vyper version in a differential fuzzing setup.

```Solidity
contract SolidityVersion {
    function my_func(uint256 a, uint256 b, uint256 c) public view {
        return (a * b) / c;
    }
}
```

--------------------------------

### Initialize and Start Fuzzer with Custom Test Case Provider (Go)

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/api/api_overview

This Go code snippet demonstrates the basic steps to initialize a Fuzzer instance, attach a custom test case provider (like an AssertionTestCaseProvider), and then start the fuzzing process. It shows the typical flow for integrating custom testing logic.

```Go
	// Create our fuzzer
	fuzzer, err := fuzzing.NewFuzzer(*projectConfig)
	if err != nil {
		return err
	}

	// Attach our custom test case provider
	attachAssertionTestCaseProvider(fuzzer)

	// Start the fuzzer
	err = fuzzer.Start()
	if err != nil {
		return err
	}
```

--------------------------------

### Start Etheno with Ganache Integration

Source: https://secure-contracts.com/program-analysis/echidna/advanced/end-to-end-testing

This command initiates Etheno, a tool for capturing transaction traces, by integrating it with Ganache. It configures Ganache with specific arguments like block gas limit and uses an init.json file for initial setup, preparing the environment for trace collection.

```Shell
etheno --ganache --ganache-args="--miner.blockGasLimit 10000000" -x init.json
```

--------------------------------

### Slither Constructor Calls Printer Example Command

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example command execution for the constructor calls printer.

```bash
$ slither examples/printers/constructors.sol --print constructor-calls
```

--------------------------------

### Pulling and Running Manticore Docker Container

Source: https://secure-contracts.com/program-analysis/manticore/index

This snippet provides commands to pull the 'trailofbits/eth-security-toolbox' Docker image and run it, mounting the current host directory for file access. This allows users to interact with tools inside the container while managing files from their host machine.

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

--------------------------------

### Install Medusa using Homebrew (Development)

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

This command installs the latest development version of `medusa` using Homebrew. This method is recommended for macOS and Linux users who want the bleeding-edge features.

```Shell
brew install --HEAD medusa
```

--------------------------------

### Install Medusa to Nix Profile

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

After building `medusa` with Nix, this command adds the built binary to your Nix profile, making it accessible via your system's PATH.

```Shell
nix profile install ./result
```

--------------------------------

### Solidity Example: Complete Echidna Test Contract

Source: https://secure-contracts.com/program-analysis/echidna/introduction/how-to-test-a-property

A complete Solidity contract demonstrating an Echidna test setup. It inherits from the "Token" contract, includes an empty constructor, and defines the "echidna_balance_under_1000" property for testing.

```Solidity
contract TestToken is Token {
    constructor() public {}

    function echidna_balance_under_1000() public view returns (bool) {
        return balances[msg.sender] <= 1000;
    }
}
```

--------------------------------

### Install and Run Echidna Docker Container

Source: https://secure-contracts.com/program-analysis/echidna/introduction/installation

Commands to pull the `trailofbits/eth-security-toolbox` Docker image and run it, mounting the current host directory (`$PWD`) to `/home/training` inside the container. This allows host files to be accessible within the container.

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

--------------------------------

### Install Slither via pip

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tutorials/index

Installs the Slither static analysis tool for smart contracts using pip. This command installs the package for the current user's Python environment.

```Shell
pip3 install --user slither-analyzer
```

--------------------------------

### Pulling and Running eth-security-toolbox Docker Container

Source: https://secure-contracts.com/program-analysis/manticore

This snippet provides commands to pull the `eth-security-toolbox` Docker image and run a container, mounting the current host directory for file access. This allows users to run security tools on local files from within the Docker environment.

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

--------------------------------

### Create and Start Medusa Fuzzer in Go

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/api/api_overview

This Go code snippet illustrates how to instantiate a new Medusa fuzzer using a pre-configured 'ProjectConfig' object. It then shows how to start the fuzzing process and subsequently fetch the results, including generated test cases. Note that 'Fuzzer.Start()' is a blocking operation.

```Go
	// Create our fuzzer
	fuzzer, err := fuzzing.NewFuzzer(*projectConfig)
	if err != nil {
		return err
	}

	// Start the fuzzer
	err = fuzzer.Start()
	if err != nil {
		return err
	}

    // Fetch test cases results
    testCases := fuzzer.TestCases()
```

--------------------------------

### Install Medusa using Homebrew (Stable)

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

This command installs the latest stable release of `medusa` using Homebrew. This method is recommended for macOS and Linux users.

```Shell
brew install medusa
```

--------------------------------

### Slither EVM Printer Output Example

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example output showing the detailed EVM instructions for a Solidity function, including JUMPDESTs, opcodes, and associated source lines.

```text
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
```

--------------------------------

### Install Slither via pip

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tutorials

Installs the Slither static analysis tool for smart contracts using pip, requiring Python 3.8 or higher. The '--user' flag installs it in the user's home directory.

```Shell
pip3 install --user slither-analyzer
```

--------------------------------

### Slither EVM Printer Example Command

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example command execution for the EVM printer.

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

--------------------------------

### Start Continuous Echidna Fuzzing Campaign with echidna-parade

Source: https://secure-contracts.com/program-analysis/echidna/advanced/smart-contract-fuzzing-at-scale

This command initiates a continuous fuzzing campaign using 'echidna-parade', a tool that orchestrates multiple Echidna instances. It specifies the target contract, configuration file, initial and generation run times, number of cores, and redirects output to log files, running the process in the background.

```bash
echidna-parade test.sol --config exploration.yaml --initial_time 3600 --gen_time 1800 --timeout -1 --ncores 8 --contract C > parade.log 2> parade.err &
```

--------------------------------

### slither-find-paths Example Output

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/Path-Finding-Utility

This example demonstrates the output of `slither-find-paths` when run on a sample Solidity file. It identifies target functions, lists functions that can reach those targets, and details the specific call paths found.

```Shell
$ slither-find-paths paths.sol A.destination
Target functions:
- A.destination()

The following functions reach the specified targets:
- A.call()
- B.call2(A)

The following paths reach the specified targets:
A.call() -> A.destination()

B.call2(A) -> A.call() -> A.destination()
```

--------------------------------

### Configure Nix for Medusa Installation

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

These commands create a configuration file to enable `nix-command` and `flake` experimental features, which are required for building `medusa` with Nix.

```Shell
mkdir -p ~/.config/nix
echo 'experimental-features = nix-command flakes' > ~/.config/nix/nix.conf
```

--------------------------------

### Compile Smart Contracts with crytic-compile

Source: https://secure-contracts.com/program-analysis/echidna/frequently_asked_questions

This command attempts to compile smart contracts within the current directory using `crytic-compile`. It's a crucial first step to diagnose compilation issues when Echidna fails to start or compile contracts, especially when using frameworks like Truffle or Hardhat.

```Shell
crytic-compile .
```

--------------------------------

### Solidity Code Example for Assertion Failure Coverage

Source: https://secure-contracts.com/program-analysis/echidna/frequently_asked_questions

This Solidity function demonstrates how Echidna's coverage information highlights the exact line where an assertion fails. The `e` marker in the output indicates the path leading to the assertion failure, helping pinpoint the root cause.

```Solidity
  function test(int x, address y, address z) public {
    require(x > 0 || x <= 0);
    assert(z != address(0x0));
    assert(y != z);
    state = x;
  }
```

--------------------------------

### Access and Print Contracts from SlitherCompilationUnit in Python

Source: https://secure-contracts.com/program-analysis/slither/docs/src/api/api

Provides a Python example demonstrating how to load a contract from an address, access its first compilation unit, and then print both all contracts and the most derived contracts within that unit.

```Python
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']
```

--------------------------------

### Install Echidna on MacOS

Source: https://secure-contracts.com/program-analysis/echidna/introduction/installation

This command installs the Echidna fuzzer on macOS systems. It utilizes Homebrew, a package manager for macOS, to fetch and install the pre-compiled binary. Ensure Homebrew is installed and configured correctly before running this command.

```Shell
brew install echidna
```

--------------------------------

### Setting up ZOS for Upgradeability Checks

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/Upgradeability-Checks

Provides a sequence of shell commands to clone, navigate, install dependencies, and remove a conflicting file for the ZOS library, preparing it for use with `slither-check-upgradeability`.

```Shell
git clone https://github.com/zeppelinos/zos
cd zos/packages/lib
npm install
rm contracts/mocks/WithConstructorImplementation.sol
```

--------------------------------

### Slither Data Dependency Printer Output Example

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example output from Slither's data dependency printer, detailing variable dependencies within a contract and its functions.

```text
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 |          []          |
+--------------+----------------------+
```

--------------------------------

### Initial Echidna Run on Contract-Level Ether Example

Source: https://secure-contracts.com/program-analysis/echidna/basic/working-with-eth

Shows an attempt to run Echidna on the `balanceContract.sol` without proper configuration, resulting in a deployment failure due to insufficient ether for the payable constructor.

```Shell
$ echidna balanceContract.sol
...
echidna: Deploying the contract 0x00a329c0648769A73afAc7F9381E08FB43dBEA72 failed (revert, out-of-gas, sending ether to an non-payable constructor, etc.):
```

--------------------------------

### Slither Function ID Printer Output Example

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example output showing function names and their corresponding Keccak-256 IDs for a contract.

```text
INFO:Printers:
MyContract:
+---------------+------------+
|      Name     |     ID     |
+---------------+------------+
| constructor() | 0x90fa17bb |
| mint(uint256) | 0xa0712d68 |
+---------------+------------+
```

--------------------------------

### Install Ganache Globally via Yarn

Source: https://secure-contracts.com/program-analysis/echidna/advanced/end-to-end-testing

This command installs Ganache globally using Yarn, an alternative package manager. It serves the same purpose as the npm installation, providing a local blockchain for development.

```Shell
yarn global add ganache
```

--------------------------------

### Slither Function ID Printer Example Command

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Example command execution for the function ID printer.

```bash
$ slither examples/printers/authorization.sol --print function-id
```

--------------------------------

### Install slither-simil Python Dependencies

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/Code-Similarity-Detector

This snippet provides shell commands to install the required Python packages for `slither-simil`. It includes `pybind11`, `fastText`, `sklearn`, and `matplotlib`. Users should ensure they are using `pip3.6` or later and remove the `--user` flag if running within a virtual environment.

```Shell
$ 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
```

--------------------------------

### Example output of Manticore CLI execution

Source: https://secure-contracts.com/program-analysis/manticore/running-under-manticore

Shows a typical log output from Manticore after analyzing a smart contract, detailing generated test cases and the results directory.

```text
...
... m.c.manticore:INFO: Generated testcase No. 0 - STOP
... m.c.manticore:INFO: Generated testcase No. 1 - REVERT
... m.c.manticore:INFO: Generated testcase No. 2 - RETURN
... m.c.manticore:INFO: Generated testcase No. 3 - REVERT
... m.c.manticore:INFO: Generated testcase No. 4 - STOP
... m.c.manticore:INFO: Generated testcase No. 5 - REVERT
... m.c.manticore:INFO: Generated testcase No. 6 - REVERT
... m.c.manticore:INFO: Results in /home/ethsec/workshops/Automated Smart Contracts Audit - TruffleCon 2018/manticore/examples/mcore_t6vi6ij3
...
```

--------------------------------

### Solidity function calling a linked library

Source: https://secure-contracts.com/program-analysis/echidna/advanced/working-with-libraries

An example Solidity function `getBalanceInEth` demonstrating how a contract calls a function (`convert`) from a deployed and linked `ConvertLib`.

```Solidity
    function getBalanceInEth(address addr) public view returns(uint){
            return ConvertLib.convert(getBalance(addr),2);
    }
```

--------------------------------

### Install Ganache Globally via npm

Source: https://secure-contracts.com/program-analysis/echidna/advanced/end-to-end-testing

This command installs Ganache, a personal blockchain for Ethereum development, globally using npm. Ganache is essential for local smart contract deployment and testing.

```Shell
npm -g i ganache
```

--------------------------------

### Build Medusa from Source

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

These commands clone the `medusa` repository and then build the project using Go. The resulting binary (`medusa` or `medusa.exe`) needs to be manually moved to a directory in your system's PATH environment variable.

```Shell
git clone https://github.com/crytic/medusa
cd medusa
go build -trimpath
```

--------------------------------

### balanceContract Configuration Parameter

Source: https://secure-contracts.com/program-analysis/echidna/configuration

Sets the initial Ether balance for the contract address being tested. This is useful for scenarios requiring a specific starting balance for the contract.

```APIDOC
balanceContract: Int
  Description: Initial Ether balance of contractAddr. See our tutorial on working with ETH for more details.
  Type: Int
  Default: 0
  Available in: *
```

--------------------------------

### targetContractsBalances Configuration

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/project_configuration/fuzzing_config

The starting balance for each contract in `targetContracts`. If the `constructor` for a target contract is marked `payable`, this configuration option can be used to send ether during contract deployment. Note that this array has a one-to-one mapping to `targetContracts`. Thus, if `targetContracts` is `[A, B, C]` and `targetContractsBalances` is `["1234", "0x1234", "1.2e18"]`, then `A` will have a starting balance of `1,234 wei`, `B` will have `4,660 wei (0x1234 in decimal)`, and `C` will have `1.2 ETH (1.2 × 10^18 wei)`.

```APIDOC
Type: [Base-10 Strings, Hexadecimal Strings, Scientific notation for base-10 values] (e.g. ["1234", "0x1234", "1.2e18"])
Default: []
```

--------------------------------

### Running a Python Script

Source: https://secure-contracts.com/program-analysis/manticore

This command executes a Python script named `script.py` using the `python3` interpreter. It's a standard way to run Python programs from the command line.

```shell
python3 script.py
```

--------------------------------

### Initialize Medusa for a Project

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/first_steps

This snippet shows how to change into a project directory and initialize `medusa` using the `medusa init` command. This command creates a `medusa.json` configuration file, which holds various project settings.

```Shell
cd my_project

medusa init
```

--------------------------------

### Configuring Environment Inside Manticore Docker Container

Source: https://secure-contracts.com/program-analysis/manticore/index

After entering the Docker container, these commands set the Solidity compiler version to 0.5.11 and change the current directory to '/home/trufflecon/', preparing the environment for Manticore operations.

```shell
solc-select 0.5.11
cd /home/trufflecon/
```

--------------------------------

### Execute Echidna with configured Solidity library linking

Source: https://secure-contracts.com/program-analysis/echidna/advanced/working-with-libraries

Bash command to run Echidna in exploration mode, targeting the `MetaCoin` contract and loading library deployment and linking settings from `echidna.yaml`.

```Bash
echidna . --test-mode exploration --corpus-dir corpus --contract MetaCoin --config echidna.yaml
```

--------------------------------

### Medusa CLI: `init` Command API Reference

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/cli/init

Comprehensive API documentation for the `medusa init` command, detailing its parameters, supported platforms, and available flags. This reference outlines how to initialize a Medusa project and customize its configuration.

```APIDOC
medusa init command:
  Description: Generates the project configuration file within your current working directory.
  Syntax: medusa init [platform] [flags]
  Default Config File: medusa.json
  Default Compilation Platform: crytic-compile
  Supported Platforms:
    - crytic-compile
    - solc
  Flags:
    --out:
      Description: Specifies the output path for the project configuration file.
      Type: string (path)
      Example: medusa init --out myConfig.json
    --compilation-target:
      Description: Specifies the compilation target.
      Type: string (target)
      Example: medusa init --compilation-target TestMyContract.sol
```

--------------------------------

### Build Medusa with Nix

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/getting_started/installation

These commands clone the `medusa` repository and then build the project using Nix. The resulting binary will be located at `./result/bin/medusa`.

```Shell
git clone https://github.com/crytic/medusa
cd medusa
nix build
```

--------------------------------

### Running Echidna with Initial Contract Ether Configuration

Source: https://secure-contracts.com/program-analysis/echidna/basic/working-with-eth

Demonstrates running Echidna with a specified configuration file (`balanceContract.yaml`) to provide the necessary initial ether to the contract's constructor, leading to a successful fuzzer run.

```Shell
$ echidna balanceContract.sol --config balanceContract.yaml
...
echidna_C_has_some_value: failed!💥
  Call sequence:
    payToContract(12000)
```

--------------------------------

### Solidity Assertion Test for Echidna (Expected Failure)

Source: https://secure-contracts.com/program-analysis/echidna/frequently_asked_questions

This Solidity function contains an assertion that is designed to always fail. It is used to test whether Echidna correctly identifies and reports assertion failures in assertion mode, aiding in debugging the tool's behavior and ensuring proper setup.

```Solidity
function test_assert_false() public {
    assert(false);
}
```

--------------------------------

### Echidna configuration for Solidity library deployment

Source: https://secure-contracts.com/program-analysis/echidna/advanced/working-with-libraries

YAML configuration for Echidna's `deployContracts` option, specifying the `ConvertLib` library and its arbitrary deployment address, a prerequisite for linking.

```YAML
deployContracts: [["0x1f", "ConvertLib"]]
```

--------------------------------

### Configure Solidity Version and Navigate in Echidna Docker

Source: https://secure-contracts.com/program-analysis/echidna/introduction/installation

Commands to be executed inside the running `eth-security-toolbox` Docker container. It sets the Solidity compiler version to 0.8.0 using `solc-select` and changes the current directory to `/home/training`, which is the mounted host directory.

```Shell
solc-select use 0.8.0
cd /home/training
```

--------------------------------

### Using `snapshot` and `revertTo` Cheatcodes in Solidity

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/cheatcodes/snapshot

This example demonstrates how to use the `snapshot` and `revertTo` cheatcodes within a Solidity test contract. The `snapshot` function saves the current EVM state, returning an identifier, while `revertTo` restores the state to a previously saved point. This functionality is crucial for isolating test cases, ensuring consistent starting conditions, and efficiently testing state-dependent logic in smart contracts.

```Solidity
interface CheatCodes {
    function warp(uint256) external;

    function deal(address, uint256) external;

    function snapshot() external returns (uint256);

    function revertTo(uint256) external returns (bool);
}

struct Storage {
    uint slot0;
    uint slot1;
}

contract TestContract {
    Storage store;
    uint256 timestamp;

    function test() public {
        // Obtain our cheat code contract reference.
        CheatCodes cheats = CheatCodes(
            0x7109709ECfa91a80626fF3989D68f67F5b1DD12D
        );

        store.slot0 = 10;
        store.slot1 = 20;
        timestamp = block.timestamp;
        cheats.deal(address(this), 5 ether);

        // Save state
        uint256 snapshot = cheats.snapshot();

        // Change state
        store.slot0 = 300;
        store.slot1 = 400;
        cheats.deal(address(this), 500 ether);
        cheats.warp(12345);

        // Assert that state has been changed
        assert(store.slot0 == 300);
        assert(store.slot1 == 400);
        assert(address(this).balance == 500 ether);
        assert(block.timestamp == 12345);

        // Revert to snapshot
        cheats.revertTo(snapshot);

        // Ensure state has been reset
        assert(store.slot0 == 10);
        assert(store.slot1 == 20);
        assert(address(this).balance == 5 ether);
        assert(block.timestamp == timestamp);
    }
}
```

--------------------------------

### Run Echidna with allContracts Configuration

Source: https://secure-contracts.com/program-analysis/echidna/advanced/using-all-contracts

Command-line instruction to execute Echidna for fuzzing the `EchidnaTest` contract, using the `allContracts.sol` file and the specified YAML configuration. This command demonstrates how to initiate the fuzzing process.

```Shell
echidna allContracts.sol --contract EchidnaTest --config allContracts.yaml
```

--------------------------------

### Install LCOV Tools on MacOS (Homebrew)

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/testing/reporting

This command installs the LCOV tools on MacOS using Homebrew. LCOV is a prerequisite for converting raw coverage data into human-readable HTML reports.

```bash
brew install lcov
```

--------------------------------

### Clone Damn Vulnerable DeFi Echidna Repository

Source: https://secure-contracts.com/program-analysis/echidna/exercises/Exercise-5

Clones the 'damn-vulnerable-defi-echidna' Git repository, which contains the challenge files for the secure contracts exercise.

```Shell
git clone https://github.com/crytic/damn-vulnerable-defi-echidna
```

--------------------------------

### Complete Manticore Symbolic Execution Workflow for Smart Contracts

Source: https://secure-contracts.com/program-analysis/manticore/running-under-manticore

This comprehensive example outlines a full Manticore workflow for analyzing a Solidity smart contract. It covers initializing ManticoreEVM, loading source code, creating user and contract accounts, executing a symbolic transaction against a contract function, printing the workspace path, and finalizing the exploration to generate test cases.

```Python
from manticore.ethereum import ManticoreEVM

m = ManticoreEVM()

with open('example.sol') as f:
    source_code = f.read()

user_account = m.create_account(balance=1*10**18)
contract_account = m.solidity_create_contract(source_code, owner=user_account)

symbolic_var = m.make_symbolic_value()
contract_account.f(symbolic_var)

print("Results are in {}".format(m.workspace))
m.finalize() # stop the exploration
```

--------------------------------

### Install LCOV Tools on Linux (apt-get)

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/testing/reporting

This command installs the LCOV tools on Debian/Ubuntu-based Linux systems using the `apt-get` package manager. LCOV is necessary for processing and generating reports from coverage data.

```bash
apt-get install lcov
```

--------------------------------

### Slither-mutate CLI Help Output

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/Mutator

This snippet provides the complete command-line interface help output for `slither-mutate`. It details the tool's usage, positional arguments like `codebase`, and various options for configuring mutation testing, including test commands, directories, timeouts, and specific mutators to run.

```Shell
$ slither-mutate --help
usage: slither-mutate <codebase> --test-cmd <test command> <options>

Experimental smart contract mutator. Based on https://arxiv.org/abs/2006.11597

positional arguments:
  codebase              Codebase to analyze (.sol file, project directory, ...)

options:
  -h, --help            show this help message and exit
  --list-mutators       List available detectors
  --test-cmd TEST_CMD   Command to run the tests for your project
  --test-dir TEST_DIR   Tests directory
  --ignore-dirs IGNORE_DIRS
                        Directories to ignore
  --timeout TIMEOUT     Set timeout for test command (by default 30 seconds)
  --output-dir OUTPUT_DIR
                        Name of output directory (by default 'mutation_campaign')
  -v, --verbose         log mutants that are caught, uncaught, and fail to compile
  --mutators-to-run MUTATORS_TO_RUN
                        mutant generators to run
  --contract-names CONTRACT_NAMES
                        list of contract names you want to mutate
  --comprehensive       continue testing minor mutations if severe mutants are uncaught
```

--------------------------------

### Echidna configuration for crytic-compile library linking

Source: https://secure-contracts.com/program-analysis/echidna/advanced/working-with-libraries

YAML configuration for Echidna's `cryticArgs` option, passing the `--compile-libraries` argument to `crytic-compile` to link `ConvertLib` at the specified address.

```YAML
cryticArgs: ["--compile-libraries=(ConvertLib,0x1f)"]
```

--------------------------------

### allContracts Configuration Parameter

Source: https://secure-contracts.com/program-analysis/echidna/configuration

Instructs Echidna to fuzz not only the explicitly provided test contracts but also any other deployed contracts whose Application Binary Interface (ABI) is known at runtime. This expands the scope of the fuzzing analysis.

```APIDOC
allContracts: Bool
  Description: Makes Echidna fuzz the provided test contracts and any other deployed contract whose ABI is known at runtime.
  Type: Bool
  Default: false
  Available in: 2.1.0+ (previously multi-abi)
  CLI equivalent: --all-contracts
```

--------------------------------

### Solidity Simple Contract Example for Manticore Analysis

Source: https://secure-contracts.com/program-analysis/manticore/running-under-manticore

This Solidity contract defines a simple function `f` that reverts if the input `a` is 65. It serves as a basic example for demonstrating symbolic execution and analysis with tools like Manticore.

```Solidity
pragma solidity >=0.4.24 <0.6.0;

contract Simple {
    function f(uint256 a) public payable {
        if (a == 65) {
            revert();
        }
    }
}
```

--------------------------------

### Install xdot for Graph Visualization

Source: https://secure-contracts.com/program-analysis/slither/docs/src/printers/Printer-documentation

Installs the xdot tool, which is required by several Slither printers for visualizing generated graph files (e.g., call graphs, CFGs). This command is typically run on Debian-based Linux systems.

```Bash
sudo apt install xdot
```

--------------------------------

### Initialize Medusa Project Configuration

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/cli/init

Generates the `medusa.json` project configuration file. By default, it uses `crytic-compile` as the compilation platform, but `solc` is also supported. This command sets up the basic project structure.

```Shell
medusa init [platform] [flags]
```

--------------------------------

### Solidity Example: Using `parseBytes` Cheatcode

Source: https://secure-contracts.com/program-analysis/medusa/docs/src/cheatcodes/parse_bytes

This Solidity example demonstrates how to use the `parseBytes` cheatcode within a smart contract. It shows how to obtain a reference to the `IStdCheats` interface, call `parseBytes` with a string input, and assert the result against expected bytes.

```Solidity
contract TestContract {\n    uint x = 123;\n    function test() public {\n        // Obtain our cheat code contract reference.\n        IStdCheats cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n\n        bytes memory expectedBytes = "medusa";\n        string memory test = "medusa";\n\n        // Call cheats.parseBytes\n        bytes memory result = cheats.parseBytes(test);\n        assert(keccak256(expectedBytes) == keccak256(result));\n    }\n}
```

--------------------------------

### Run Truffle Initialization Unit Tests

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/Property-generation

This command executes the `InitializationTestERC20BuggyTransferable.js` Truffle unit test file. The output shows the successful verification of the contract's constructor initialization, ensuring that initial balances and total supply are set up correctly before property tests are run.

```Shell
$ truffle test test/crytic/InitializationTestERC20BuggyTransferable.js
[..]
  Contract: TestERC20BuggyTransferable
    ✓ The total supply is correctly initialized. (47ms)
    ✓ Owner's balance is correctly initialized.
    ✓ User's balance is correctly initialized.
    ✓ Attacker's balance is correctly initialized.
    ✓ All the users have a positive balance. (69ms)
    ✓ The total supply is the user and owner balance. (38ms)
```

--------------------------------

### Generic Echidna Blacklist Configuration Example

Source: https://secure-contracts.com/program-analysis/echidna/basic/filtering-functions

This YAML configuration provides a general example of blacklisting functions in Echidna. It illustrates the use of 'filterBlacklist: true' and 'filterFunctions' to exclude specific functions from the fuzzing process, improving test focus.

```YAML
filterBlacklist: true
filterFunctions: ["C.f1()", "C.f2()", "C.f3()"]
```

--------------------------------

### Example ERC20 Solidity Contract for slither-check-erc Analysis

Source: https://secure-contracts.com/program-analysis/slither/docs/src/tools/ERC-Conformance

This Solidity code provides a minimal, incomplete ERC20 contract example. It includes a `Transfer` event and a `transfer` function, designed to demonstrate how `slither-check-erc` identifies missing required components of the ERC20 standard.

```Solidity
contract ERC20{

    event Transfer(address indexed,address,uint256);

    function transfer(address, uint256) public{

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

}
```

--------------------------------

### Two's Complement Negation Example

Source: https://secure-contracts.com/learn_evm/arithmetic-checks

Demonstrates how to compute the negative of a number in two's complement by flipping all bits and adding one, using the example of -3. This applies to signed integer types like Solidity's `int256`.

```Hexadecimal
0x0000000000000000000000000000000000000000000000000000000000000003 // 3
0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc // ~3
0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd // -3 = ~3 + 1
```

--------------------------------

### Initialize ManticoreEVM for Python API interaction

Source: https://secure-contracts.com/program-analysis/manticore/running-under-manticore

Imports the ManticoreEVM class and creates an instance, setting up the environment for programmatic smart contract analysis.

```python
from manticore.ethereum import ManticoreEVM

m = ManticoreEVM()
```
Tokens:
Raw