Introduction to smart contract development using Foundry
Tags: web3, ethereum, foundry, smartcontract
Published: 2023-07-06 03:37:49

Foundry is a smart contract development toolchain for Ethereum written in rust.

Foundry simplifies the development and deployment of smart contracts. It streamlines the process by managing dependencies, running tests, and facilitating deployment.

In this article, we will explore the following:

* What is Foundry, and why should you use it?
    
* Different tools provided by Foundry for smart contract development
    
* How to get started with Foundry: create, deploy and test smart contracts in Solidity
    

Let's dive right in!

## About Foundry

Foundry is a smart contract development toolchain for Ethereum written in rust.

> Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command-line and via Solidity scripts.

Foundry is created by [**Paradigm,**](https://www.paradigm.xyz/) an investment firm focused on crypto.

## Why use Foundry?

* You can write tests for your smart contract in Solidity (when using other smart contract development frameworks like Hardhat or Truffle, you would test Solidity using JavaScript or TypeScript). You can read why you should be writing tests in Solidity [**here.**](https://www.paradigm.xyz/2021/12/introducing-the-foundry-ethereum-development-toolbox#you-should-be-writing-your-tests-in-solidity)
    
* Foundry has a powerful built-in fuzzing capability. Fuzzing, in essence, is a technique used to find vulnerabilities or bugs in software by providing random, unexpected inputs to the program. Fuzzing lets the Solidity test runner choose the arguments for you randomly, by simply giving arguments to your Solidity test function.
    

Foundry also provides you with different tools for smart contract development:

* **Forge:** tests, builds, and deploys your smart contracts.
    
* **Cast:** Foundry's CLI tool for performing Ethereum RPC calls. You can make smart contract calls, send transactions, or retrieve any type of chain data.
    
* **Anvil**: local testnet node shipped with Foundry. You can use it for testing your contracts from frontends or for interacting over RPC.
    
* **Chisel:** an advanced Solidity REPL shipped with Foundry. It can be used to quickly test the behaviour of Solidity snippets on a local or forked network.
    

You can explore more about Foundry toolkit from the [**Foundry Book**](https://book.getfoundry.sh/) and the [**GitHub repo**](https://github.com/foundry-rs/foundry).

Also, [**here's**](https://github.com/crisgarner/awesome-foundry) a list of Foundry resources including tools, tutorials, libraries & projects using Foundry.

You can read more about the comparison between the Foundry and Hardhat smart contract development toolkit [here](https://eattheblocks.com/foundry-vs-hardhat/#:~:text=Foundry%20provides%20a%20faster%20compile,Vs%20~26.22s%20with%20Foundry.).

## Building, testing and Deploying Smart contracts with Foundry

### Installation

On Linux and macOS:

1. Open your terminal and run the following command:
    
    ```bash
    curl -L https://foundry.paradigm.xyz | bash
    ```
    
    This will install Foundryup, then simply follow the instructions on-screen, which will make the `foundryup` command available in your CLI.
    
2. Now run the `foundryup` command in the terminal to install Foundry toolchain:
    
    ```bash
    foundryup
    ```
    

On Windows:

If you're on Windows, you will need to install and use [Git BASH](https://gitforwindows.org/) or [WSL](https://learn.microsoft.com/en-us/windows/wsl/install), as your terminal, since Foundryup currently does not support Powershell or Cmd.

### Initialize the project

To start a new project with Foundry, use `forge init`:

```bash
forge init foundry_project
```

This will generate a new project folder called **foundry\_project**. The folder will contain the following:

* **src:** default directory for your smart contracts
    
* **tests:** default directory for tests
    
* **foundry.toml:** foundry project configuration file
    
* **lib:** contains the dependencies
    
* **script:** solidity scripting files
    

Inside the `src` folder, you'll find an included sample smart contract named `Counter.sol` .

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
}
```

To compile the smart contract use `forge build` :

```bash
forge build
```

If your contract compiles successfully, you will see the following output in your terminal:

![Compiled contract output in terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tbe9y2f01mo3ju1cxb2z.png)

This will compile the smart contracts in the `src` folder and also create a new folder named `out` which will contain the bytecode of the compiled contract.

### Testing the contract

Foundry generates a directory named `tests` , which is the default folder for storing all the tests for smart contracts. The name of the test files has an extension of `.t.sol`

If you navigate into the test folder, you'll come across a specifically named test file called `Counter.t.sol` .

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "../src/Counter.sol";

contract CounterTest is Test {
    Counter public counter;

    function setUp() public {
        counter = new Counter();
        counter.setNumber(0);
    }

    function testIncrement() public {
        counter.increment();
        assertEq(counter.number(), 1);
    }

    function testSetNumber(uint256 x) public {
        counter.setNumber(x);
        assertEq(counter.number(), x);
    }
}
```

To run this file to test the `Couter.sol` smart contract use `forge test` :

```bash
forge test
```

If all the test passes then you will see the following output in your terminal:

![All test passed output in terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0dn71yxw7my6ycufbrzq.png)

You can also see the gas cost being printed for the functions in the test contract.

On the other hand if some tests fail, this will be the output.

![Test failed output in terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/903nbmg0xx5ivh6xq18o.png)


You can replicate this by make some changes in the `Counter.sol` smart contract(I've changed the **increment** function so that it increments the number by 2 instead of 1).

```solidity
function increment() public {
    number += 2;
}
```

### Deploying the smart contract

To deploy the smart contract tot a network use `forge create` command:

```bash
forge create --rpc-url <your_rpc_endpoint> --private-key <wallet_private_key> src/Counter.sol:Counter
```

You can get the RPC for the network from Alchemy by following [this guide](https://www.alchemy.com/overviews/private-rpc-endpoint)**.**

If the smart contract is deployed successfully you will see the following output in your terminal:

![Successful deployment output in terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0u9uk1hm98buj41okrdt.png)

### Writing tests for smart contract

Now let's add some of our own functions and tests to the existing `Counter.sol` smart contract.

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract Counter {
    uint256 public number;
    uint256 public myNumber = 42;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }

    function decrement() public {
        myNumber--;
    }
}
```

In the above smart contract we have added variable `myNumber` which has a value of 42 and the function `decrement()` which decrements the value of `myNumber` by 1.

To test these functions we need to add some functions in the `Counter.t.sol` test file.

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "../src/Counter.sol";

contract CounterTest is Test {
    Counter public counter;

    function setUp() public {
        counter = new Counter();
        counter.setNumber(0);
    }

    function testIncrement() public {
        counter.increment();
        assertEq(counter.number(), 1);
    }

    function testSetNumber(uint256 x) public {
        counter.setNumber(x);
        assertEq(counter.number(), x);
    }

    function testMyNumber() public {
        assertEq(counter.myNumber(), 42);
    }

    function testDecrement() public {
        counter.decrement();
        assertEq(counter.myNumber(), 41);
    }
}
```

In the above test file we have added test functions `testMyNumber()` and `testDecrement()` . The `testMyNumber()` function checks the assigned value of `myNumber` and `testDecrement()` function checks the working of the decrement function. Both of these functions use `assertEq` to equate the value assigned to `myNumber` .

Now let's run these new tests with the `forge test` command:

```bash
forge test
```

If all the test passes you will get the following output in your terminal:

![All updated test passed output in termainl](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/exs7o5al3im3vbjeirx5.png)

As you can see all the test passed, and we also got the amount of gas used to run each test function.

## Using libraries

The libraries that you install will go in the `lib` folder , of your project by default, *ds-test* is installed, this one allows you to run tests, create asserts or logs. If you want to install other libraries(e.g. openzeppelin) you can run:

```bash
forge install openzeppelin/openzeppelin-contracts
```

This will add the openzeppelin repository in your project under the `lib/openzeppelin-contracts` folder. Now you can import and use the openzeppelin smart contracts in your project.

## Next Steps

With this we have learned the most basic applications of the foundry toolkit. Further we will learn how to develop, test and deploy more complex contracts like ERC20, ERC721 tokens, DEXs and many more using foundry.

Hope you enjoyed the article! If you have any questions or comments, feel free to drop them below or reach out to me on

* [Twitter](https://twitter.com/AbhinavXT)
    
* [LinkedIn](https://www.linkedin.com/in/abhinavpathak21/)