Foundry

https://getfoundry.sh/
Admin
Foundry is a blazing fast smart contract development toolkit that includes forge for building and...
Tokens:524,025
Snippets:2,652
Trust Score:8.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start Local Anvil Development Node

Source: https://getfoundry.sh/introduction/getting-started

Shows how to start a local Anvil development node, which provides a local Ethereum environment for testing. The example starts Anvil with 10 pre-funded accounts.

```Shell
# Start anvil with 10 pre-funded accounts
anvil
```

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

### Foundry Project Setup Guide

Source: https://getfoundry.sh/introduction/overview

Learn how to organize your projects with Forge's project setup guides for scaling smart contract codebases.

```bash
# Example command for setting up a new Foundry project
forge init my-project
cd my-project

```

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

### Build and Test Contracts with Forge

Source: https://getfoundry.sh/introduction/getting-started

Demonstrates how to compile smart contracts using `forge build` and run the test suite with `forge test`. It also includes an example of running tests against a live chain state by forking.

```Shell
# Compile your contracts
forge build
 
# Run your test suite
forge test
 
# Run tests against live chain state by forking
forge test --fork-url https://reth-ethereum.ithaca.xyz/rpc
```

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

### Deploy Contracts with Forge Scripts

Source: https://getfoundry.sh/introduction/getting-started

This example illustrates deploying smart contracts using Forge scripts. It includes setting the private key as an environment variable and broadcasting the deployment to a local Anvil instance.

```Shell
# Use forge scripts to deploy contracts
# Set your private key
export PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
 
# Deploy to local anvil instance
forge script script/Counter.s.sol --rpc-url http://127.0.0.1:8545 --broadcast --private-key $PRIVATE_KEY
```

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

### Send Transactions with Cast

Source: https://getfoundry.sh/introduction/getting-started

Provides examples for sending transactions using the 'cast send' command. This includes setting the private key as an environment variable and sending Ether to a specified address.

```bash
# Set your private key
export PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"

# Send ETH to an address
cast send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 --value 10000000 --private-key $PRIVATE_KEY
```

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

### Start Chisel REPL

Source: https://getfoundry.sh/introduction/getting-started

Instructions on how to launch the Chisel REPL, a Solidity Read-Eval-Print Loop tool for rapid prototyping and debugging of Solidity code.

```bash
# Launch chisel REPL
chisel
```

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

### Interact with JSON-RPC using Cast

Source: https://getfoundry.sh/introduction/getting-started

Shows how to interact with JSON-RPC methods directly using 'cast rpc' and how to get the latest block number. It includes examples for fetching block headers and the current block number.

```bash
# Call JSON-RPC methods directly
cast rpc eth_getHeaderByNumber $(cast 2h 22539851) --rpc-url https://reth-ethereum.ithaca.xyz/rpc

# Get latest block number
cast block-number --rpc-url https://reth-ethereum.ithaca.xyz/rpc
```

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

### Forge setUp Function Example

Source: https://getfoundry.sh/forge/tests/writing-tests

Provides an example of the `setUp` function in Forge, which is executed before each test case to initialize or reset contract state.

```Solidity
function setUp() public {
    testNumber = 42;
}
```

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

### Install Foundry with Foundryup

Source: https://getfoundry.sh/introduction/installation

Installs Foundry using the Foundryup tool with specified branches or paths. This is a convenient way to manage Foundry installations.

```bash
foundryup --branch master
```

```bash
foundryup --path path/to/foundry
```

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

### Fork Mainnet State with Anvil

Source: https://getfoundry.sh/introduction/getting-started

Demonstrates how to start an Anvil node that forks the latest mainnet state, enabling testing against current blockchain data.

```Shell
# Fork latest mainnet state for testing
anvil --fork-url https://reth-ethereum.ithaca.xyz/rpc
```

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

### Foundry TOML Configuration Example

Source: https://getfoundry.sh/introduction/prompting

An example `foundry.toml` file demonstrating configuration for default profiles, compiler settings, testing parameters, fuzzing, and invariant testing, including remappings for common libraries.

```toml
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
dynamic_test_linking = true
remappings = [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@chimera/=lib/chimera/src/"
]

# Compiler settings
solc_version = "0.8.20"
optimizer = true
optimizer_runs = 200
via_ir = false

# Testing configuration
gas_reports = ["*"]
ffi = false
fs_permissions = [{ access = "read", path = "./"}]

# Fuzz testing
[fuzz]
runs = 1000
max_test_rejects = 65536

# Invariant testing
[invariant]
runs = 256
depth = 15
fail_on_revert = false
show_metrics = true

```

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

### Install nightly versions with foundryup

Source: https://getfoundry.sh/misc/v1

Instructs on how to install nightly versions of Foundry using `foundryup -i nightly` when no specific version is provided.

```bash
foundryup -i nightly
```

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

### Install Foundryup using curl

Source: https://getfoundry.sh/introduction/installation

This command downloads and executes the Foundryup installer script from the provided URL. Foundryup is the official installer for the Foundry toolchain, managing the installation of forge, cast, anvil, and chisel.

```Shell
curl -L https://foundry.paradigm.xyz | bash
```

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

### Import Contracts with Remappings

Source: https://getfoundry.sh/guides/project-setup/dependencies

Provides examples of how to import smart contracts using the remapped paths, demonstrating the syntax for importing from 'forge-std' and 'solady'.

```Solidity
import "forge-std/Contract.sol";
```

```Solidity
import "solady/Contract.sol";
```

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

### Initialize Foundry Project with Forge

Source: https://getfoundry.sh/introduction/getting-started

This snippet shows how to initialize a new Foundry project named 'Counter' using the `forge init` command and then navigate into the project directory.

```Shell
# Create a new project called Counter
forge init Counter
cd Counter
```

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

### Interactive Solidity Development with Chisel

Source: https://getfoundry.sh/introduction/getting-started

Demonstrates interactive development within the Chisel REPL, including creating and querying variables, and testing contract functions. It shows how Chisel displays variable types and values.

```solidity
// Create and query variables
➜ uint256 a = 123;
➜ a
Type: uint256
├ Hex: 0x7b
├ Hex (full word): 0x000000000000000000000000000000000000000000000000000000000000007b
└ Decimal: 123

// Test contract functions
➜ function add(uint256 x, uint256 y) public pure returns (uint256) { return x + y; }
➜ add(5, 10)
Type: uint256
└ Decimal: 15
```

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

### Manual Build and Install Foundry Components

Source: https://getfoundry.sh/introduction/installation

Manually builds and installs Foundry components (Forge, Cast, Anvil, Chisel) from a local clone of the Foundry repository using Cargo. This method provides more control over the build process.

```bash
# clone the repository
git clone https://github.com/foundry-rs/foundry.git
cd foundry
# install Forge
cargo install --path ./crates/forge --profile release --force --locked
# install Cast
cargo install --path ./crates/cast --profile release --force --locked
# install Anvil
cargo install --path ./crates/anvil --profile release --force --locked
# install Chisel
cargo install --path ./crates/chisel --profile release --force --locked
```

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

### Solidity Deployment Script Example

Source: https://getfoundry.sh/introduction/prompting

A Solidity script using Foundry's Scripting module to deploy contracts. It demonstrates setting up the broadcast, deploying contracts, configuring them, and logging important addresses. Requires private key and RPC URL from environment variables.

```solidity
contract DeployScript is Script {
    function run() public {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");

        vm.startBroadcast(deployerPrivateKey);

        // Deploy contracts in dependency order
        Token token = new Token();
        Vault vault = new Vault(token);

        // Configure contracts
        token.grantRole(token.MINTER_ROLE(), address(vault));

        vm.stopBroadcast();

        // Log important addresses
        console.log("Token:", address(token));
        console.log("Vault:", address(vault));
    }
}
```

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

### Add Dependency with Forge Install

Source: https://getfoundry.sh/guides/project-setup/dependencies

Demonstrates how to add a smart contract dependency, such as 'solady', using the `forge install` command. It shows the output of the installation process, including the library name, URL, and the commit hash, and confirms the successful installation by checking the project's directory structure.

```Shell
$ forge install vectorized/solady
Installing solady in /tmp/tmp.qMjuCvaOuK/hello_foundry/lib/solady (url: Some("https://github.com/vectorized/solady"), tag: None)
    Installed solady tag=v0.1.24@a5bb996e91aae5b0c068087af7594d92068b12f1
```

```Shell
$ tree . -d -L 1
.
├── lib
├── script
├── src
└── test
 
5 directories
```

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

### Install Foundry with Cargo

Source: https://getfoundry.sh/introduction/installation

Installs Foundry components (forge, cast, chisel, anvil) directly from the GitHub repository using Cargo. Requires Rust and Cargo to be installed.

```bash
cargo install --git https://github.com/foundry-rs/foundry --profile release --locked forge cast chisel anvil
```

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

### Install Foundryup nightly build

Source: https://getfoundry.sh/introduction/installation

This command installs the latest nightly build of the Foundry toolchain using Foundryup. Nightly builds provide access to the most recent features and fixes.

```Shell
foundryup --install nightly
```

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

### Call Contract Function with Cast

Source: https://getfoundry.sh/introduction/getting-started

Demonstrates how to call a read-only function on a smart contract using the 'cast call' command. It specifies the contract address, the function signature, and the arguments, along with the RPC URL.

```bash
cast call 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 \
"balanceOf(address)" 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 \
--rpc-url https://reth-ethereum.ithaca.xyz/rpc
```

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

### Forge Install Help Command

Source: https://getfoundry.sh/forge/reference/install

Shows how to display the help information for the 'forge install' command, which provides a summary of its functionality and options.

```bash
$ forge install --help
```

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

### Install Foundry

Source: https://getfoundry.sh/index

Downloads and installs the Foundry installer script (`foundryup`) and then uses it to install Forge, Cast, Anvil, and Chisel. It also shows how to install the latest nightly release.

```bash
# Download foundry installer `foundryup`
curl -L https://foundry.paradigm.xyz | bash
# Install forge, cast, anvil, chisel
foundryup
# Install the latest nightly release
foundryup -i nightly
```

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

### EIP-712 Implementation and Testing

Source: https://getfoundry.sh/introduction/prompting

Provides an example of EIP-712 implementation in Solidity, including hashing domain separators and permit structures. Demonstrates testing EIP-712 type and struct hashes using Foundry's cheatcodes.

```solidity
// EIP-712 implementation example
contract EIP712Example {
    bytes32 private constant DOMAIN_TYPEHASH = 
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    bytes32 private constant PERMIT_TYPEHASH = 
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    function _hashTypedDataV4(bytes32 structHash) internal view returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// EIP-712 testing with cheatcodes
contract EIP712Test is Test {
    function test_EIP712TypeHash() public {
        bytes32 expected = vm.eip712HashType("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
        assertEq(PERMIT_TYPEHASH, expected, "Type hash mismatch");
    }

    function test_EIP712StructHash() public {
        Permit memory permit = Permit({
            owner: address(1),
            spender: address(2),
            value: 100,
            nonce: 0,
            deadline: block.timestamp + 1 hours
        });

        bytes32 structHash = vm.eip712HashStruct("Permit", abi.encode(permit));
        bytes32 expected = keccak256(abi.encode(PERMIT_TYPEHASH, permit.owner, permit.spender, permit.value, permit.nonce, permit.deadline));
        assertEq(structHash, expected, "Struct hash mismatch");
    }
}

// Generate type definitions
// forge eip712 --contract MyContract
```

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

### Anvil Local Development Commands

Source: https://getfoundry.sh/introduction/prompting

Commands for starting and configuring the Anvil local Ethereum node, including options for forking mainnet, specifying accounts, setting balances, gas limits, and network parameters.

```bash
anvil
```

```bash
anvil --fork-url <rpc_url>
```

```bash
anvil --fork-block-number <number>
```

```bash
anvil --accounts <number>
```

```bash
anvil --balance <amount>
```

```bash
anvil --gas-limit <limit>
```

```bash
anvil --gas-price <price>
```

```bash
anvil --port <port>
```

```bash
anvil --chain-id <id>
```

```bash
anvil --block-time <seconds>
```

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

### Build Foundry Docker Image Locally

Source: https://getfoundry.sh/introduction/installation

Builds the Foundry Docker image locally from the Foundry repository. This is useful for development or when specific build configurations are needed.

```dockerfile
docker build -t foundry .
```

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

### Read Contract Data with Cast

Source: https://getfoundry.sh/introduction/getting-started

This snippet shows how to use the `cast` command-line tool to read data from a smart contract, specifically checking the ETH balance of an address on the Ethereum mainnet.

```Shell
# Check ETH balance
cast balance vitalik.eth --ether --rpc-url https://reth-ethereum.ithaca.xyz/rpc
```

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

### Start Chisel REPL

Source: https://getfoundry.sh/chisel/overview

Initiates the Chisel REPL environment. Once started, you can directly write and execute Solidity code.

```Shell
chisel
```

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

### v1.0 Migration Guide

Source: https://getfoundry.sh/cast/reference/run

A guide detailing the changes and steps required to migrate projects from older versions of Foundry to v1.0.

```Markdown
## Migrating to Foundry v1.0

1. Update your `foundry.toml`.
2. Adjust your test contracts to use new cheatcode signatures.
```

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

### Forge Install Command Arguments

Source: https://getfoundry.sh/forge/reference/install

Details the arguments accepted by the 'forge install' command, specifically the 'DEPENDENCIES' argument. It explains how dependencies can be specified as URLs or GitHub repository paths, with options to include specific refs like branches or tags. It also covers how to use an alias to control the installation directory.

```bash
Arguments:
  [DEPENDENCIES]...
          The dependencies to install.
          
          A dependency can be a raw URL, or the path to a GitHub repository.
          
          Additionally, a ref can be provided by adding @ to the dependency
          path.
          
          A ref can be: - A branch: master - A tag: v1.2.3 - A commit: 8e8128
          
          For exact match, a ref can be provided with `@tag=`, `@branch=` or
          `@rev=` prefix.
          
          Target installation directory can be added via `<alias>=` suffix. The
          dependency will installed to `lib/<alias>`.
```

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

### Install Dependencies with Forge

Source: https://getfoundry.sh/forge/reference/install

The 'forge install' command is used to add dependencies to your Foundry project. It typically fetches libraries from Git repositories, allowing for easy management of smart contract dependencies.

```bash
forge install
```

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

### Foundry v1.0 Migration Guide

Source: https://getfoundry.sh/cast/reference/tx-pool/content

A guide detailing the changes and steps required to migrate projects from Foundry v0.x to v1.0.

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

### Forge Install Command Options

Source: https://getfoundry.sh/forge/reference/install

Lists and explains the various options available for the 'forge install' command. These options control aspects like the project root path, shallow cloning, Git submodule integration, commit creation, and output verbosity and formatting.

```bash
Options:
      --root <PATH>
          The project's root path.
          
          By default root of the Git repository, if in one, or the current
          working directory.

      --shallow
          Perform shallow clones instead of deep ones.
          
          Improves performance and reduces disk usage, but prevents switching
          branches or tags.

      --no-git
          Install without adding the dependency as a submodule

      --commit
          Create a commit after installing the dependencies

  -h, --help
          Print help (see a summary with '-h')

  -j, --threads <THREADS>
          Number of threads to use. Specifying 0 defaults to the number of
          logical cores
          
          [aliases: --jobs]
```

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

### Deploy and Configure Smart Contract

Source: https://getfoundry.sh/introduction/prompting

Demonstrates deploying a smart contract with constructor parameters, performing post-deployment initialization, logging deployment details, and verifying contract ownership. Includes commands for initial deployment and resuming failed deployments.

```solidity
// Deploy with constructor parameters
MyContract myContract = new MyContract(owner);

// Post-deployment configuration
myContract.initialize();

// Log deployment info
console.log("MyContract deployed to:", address(myContract));
console.log("Deployer:", vm.addr(deployerPrivateKey));
console.log("Owner:", owner);

vm.stopBroadcast();

// Verify deployment
require(myContract.owner() == owner, "Owner not set correctly");
}
```

```bash
# forge script script/Deploy.s.sol --rpc-url sepolia --broadcast --verify -vvvv --interactives 1
# forge script script/Deploy.s.sol --rpc-url sepolia --broadcast --verify --resume  # Resume failed
```

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

### Get Unix Timestamp in Milliseconds (Solidity)

Source: https://getfoundry.sh/reference/cheatcodes/unix-time

The `unixTime` cheatcode returns the current time in milliseconds since the Unix epoch. This is useful for time-based operations in smart contracts. The example shows how to capture the start time, pause execution, and verify the elapsed time.

```Solidity
function unixTime() external returns (uint milliseconds);
```

```Solidity
uint start = vm.unixTime();
vm.sleep(10_000); // Halts execution for 10 seconds
uint end = vm.unixTime();
assertEq(end - start, 10_000);
```

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

### Install Specific Dependency Version

Source: https://getfoundry.sh/guides/project-setup/dependencies

Illustrates how to install a specific version or tag of a dependency using the `forge install` command, by appending the desired tag or commit hash to the repository path.

```Shell
forge install vectorized/solady@v0.1.3
```

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

### Solidity Deployment Script with Broadcast

Source: https://getfoundry.sh/introduction/prompting

A basic Solidity deployment script using Foundry's `Script` and `console` utilities. It demonstrates loading private keys and owner addresses from environment variables, initiating a broadcast transaction, and deploying a contract.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Script, console} from "forge-std/Script.sol";
import {MyContract} from "src/MyContract.sol";

contract DeployScript is Script {
    function run() public {
        // Load deployment parameters
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        address owner = vm.envAddress("OWNER");

        vm.startBroadcast(deployerPrivateKey);


```

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

### Remove Foundry from PATH

Source: https://getfoundry.sh/introduction/installation

Demonstrates how to remove the Foundry installation directory from the system's PATH environment variable by editing shell configuration files.

```bash
export PATH="$PATH:/home/user/.foundry/bin"
```

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

### Initialize a new Forge project

Source: https://getfoundry.sh/forge/overview

Initializes a new smart contract project named 'counter' using the Forge command-line tool. This sets up the basic directory structure and configuration files for a Foundry project.

```bash
forge init counter
```

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

### Get Nonce for Wallet - Foundry

Source: https://getfoundry.sh/reference/cheatcodes/get-nonce

Retrieves the nonce for a given `Wallet` object using the `getNonce` cheatcode. This example shows creating a wallet, getting its nonce, and logging the result.

```Solidity
Wallet memory alice = vm.createWallet("alice");
uint256 nonce = vm.getNonce(alice);
emit log_uint(nonce); // 0
```

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

### Forge Create Command Help

Source: https://getfoundry.sh/forge/reference/create

Displays the help information for the 'forge create' command, outlining its usage, arguments, and available options for deploying smart contracts.

```bash
$ forge create --help
```

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

### Add Hardhat to Foundry Project Example

Source: https://getfoundry.sh/config/hardhat

This snippet illustrates adding Hardhat to an existing Foundry project. It details the process of setting up Hardhat to utilize the same contract directory as Foundry and manage dependencies installed with `forge install`.

```Shell
npm install --save-dev hardhat
npx hardhat init
forge install foundry-rs/forge-std --no-commit
npx hardhat compile
```

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

### Add Foundry to Hardhat Project Example

Source: https://getfoundry.sh/config/hardhat

This snippet demonstrates how to add Foundry to an existing Hardhat project. It outlines the steps to configure Hardhat to recognize Foundry's contract directory and dependencies installed via `forge install`.

```Shell
forge install foundry-rs/forge-std --no-commit
npx hardhat compile
```

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

### Foundry Configuration with foundry.toml

Source: https://getfoundry.sh/introduction/overview

Customize your Foundry setup using the `foundry.toml` file for project configuration and settings.

```toml
# foundry.toml example
[profile.default]
src = "src"
libs = ["lib"]

[rpc_endpoints]
mainnet = "${MAINNET_RPC_URL}"

```

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

### Example Usage of startBroadcast and stopBroadcast (Solidity)

Source: https://getfoundry.sh/reference/cheatcodes/start-broadcast

Demonstrates how to use startBroadcast with an address and a private key to send transactions, followed by stopBroadcast to finalize them. This example shows deploying a contract and interacting with it within broadcasted transactions.

```Solidity
function t(uint256 a) public returns (uint256) {
    uint256 b = 0;
    emit log_string("here");
    return b;
}

function deployOther() public {
    vm.startBroadcast(ACCOUNT_A);
    Test test = new Test();

    // will trigger a transaction
    test.t(1);

    vm.stopBroadcast();

    // broadcast again, this time using a private key from your environment variables
    vm.startBroadcast(vm.envUint("PRIVATE_KEY"));
    test.t(3);
    vm.stopBroadcast();
}
```

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

### Solidity: Shared Setups with Abstract Contracts

Source: https://getfoundry.sh/forge/tests/writing-tests

This example demonstrates how to implement shared setup logic across multiple test contracts using abstract contracts in Solidity. By inheriting from an abstract contract, test contracts can reuse common configurations and deployments, such as initializing contracts with specific addresses or parameters.

```Solidity
abstract contract HelperContract {
    address constant IMPORTANT_ADDRESS = 0x543d...;
    SomeContract someContract;
    constructor() {...}
}
 
contract MyContractTest is Test, HelperContract {
    function setUp() public {
        someContract = new SomeContract(0, IMPORTANT_ADDRESS);
        ...
    }
}
 
contract MyOtherContractTest is Test, HelperContract {
    function setUp() public {
        someContract = new SomeContract(1000, IMPORTANT_ADDRESS);
        ...
    }
}
```

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

### Foundry Cheatcode Reference

Source: https://getfoundry.sh/cast/reference/estimate

A comprehensive reference guide to all available Forge cheatcodes. This includes detailed explanations of each cheatcode's functionality, parameters, and usage examples.

```Solidity
// Example: vm.deal cheatcode to set account balance
// vm.deal(address, amount);
```

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

### Example Output: State Diffs - Bash

Source: https://getfoundry.sh/reference/cheatcodes/start-prank

The expected output from the Solidity example, showing the recorded state differences after a pranked delegate call, including the kind of access, accessor, account, and data.

```bash
== Logs ==
  accountAccesses.kind 1
  accountAccesses.accessor proxy
  accountAccesses.account Impl
  0xcd16ecbf000000000000000000000000000000000000000000000000000000000000002a
```

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

### Update Rust toolchain

Source: https://getfoundry.sh/introduction/installation

This command updates the Rust compiler and Cargo to the latest stable version. Foundry generally supports building only with the latest stable Rust.

```Shell
rustup update stable
```

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

### Forge Install Command Usage

Source: https://getfoundry.sh/forge/reference/install

Provides the general usage syntax for the 'forge install' command, including how to specify dependencies via GitHub projects, aliases, or direct URLs. It also outlines the different ways to reference dependency versions using tags, branches, or commit hashes.

```bash
Usage: forge install [OPTIONS] [DEPENDENCIES]...
    forge install [OPTIONS] <github username>/<github project>@<tag>...
    forge install [OPTIONS] <alias>=<github username>/<github project>@<tag>...
    forge install [OPTIONS] [https://<github token](https://<github token)@git url>...)]
    forge install [OPTIONS] [https:// git url](https:// git url)...
```

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

### Pull Foundry Docker Image

Source: https://getfoundry.sh/introduction/installation

Pulls the latest Foundry release Docker image from the GitHub Container Registry. This allows running Foundry within a Docker container.

```dockerfile
docker pull ghcr.io/foundry-rs/foundry:latest
```

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

### Initialize Soldeer Project

Source: https://getfoundry.sh/guides/project-setup/soldeer

Initializes a new Foundry project with Soldeer, setting up necessary configurations and installing the latest `forge-std`.

```Shell
forge soldeer init
```

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

### Solidity Fuzz Testing with Bounds and Assumptions

Source: https://getfoundry.sh/introduction/prompting

Demonstrates fuzz testing in Solidity using Foundry's vm module. It includes bounding input parameters, using assumptions to skip invalid test cases, and setting up test state with `deal` and `startPrank`. Assertions are used to verify properties after execution.

```solidity
// Use appropriate parameter types and bounds
function testFuzz_Deposit(uint96 amount, uint256 actorSeed) public {
    // Bound inputs to valid ranges
    amount = uint96(bound(amount, 1, type(uint96).max));
    address actor = actors[bound(actorSeed, 0, actors.length - 1)];

    // Use assumptions to exclude invalid cases
    vm.assume(amount > 0.1 ether);
    vm.assume(actor != address(0));

    // Setup state
    vm.startPrank(actor);
    deal(address(token), actor, amount);

    // Execute and verify properties
    uint256 sharesBefore = vault.balanceOf(actor);
    vault.deposit(amount, actor);
    uint256 sharesAfter = vault.balanceOf(actor);

    // Property assertions
    assertGt(sharesAfter, sharesBefore, "Shares should increase");
    assertEq(vault.totalAssets(), amount, "Total assets should equal deposit");

    vm.stopPrank();
}

// Use fixtures for edge cases
uint256[] public amountFixtures = [0, 1, type(uint256).max - 1];
function testFuzz_WithFixtures(uint256 fixtureIndex) public {
    uint256 amount = amountFixtures[bound(fixtureIndex, 0, amountFixtures.length - 1)];
    // Test with specific edge case values
}
```

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

### Anvil Local Blockchain Simulation

Source: https://getfoundry.sh/forge/reference/forge

This guide explains how to use Anvil, Foundry's local blockchain simulator. It covers starting Anvil, connecting to it, and its features for development and testing.

```Shell
# Start Anvil with default settings (RPC on http://127.0.0.1:8545)
anvil

# Start Anvil with a specific port and fork configuration
anvil --port 9000 --fork-url <rpc_url>

# Start Anvil with pre-funded accounts
anvil --fork-block-number 18000000 --auto-mine --chain-id 1

# Connect to Anvil using Cast
cast --rpc-url http://127.0.0.1:8545 balance <address>

# Connect to Anvil using Forge tests (configure in foundry.toml or via command line)
forge test --rpc-url http://127.0.0.1:8545

```

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

### Get Nonce for Address - Foundry

Source: https://getfoundry.sh/reference/cheatcodes/get-nonce

Retrieves the nonce for a specified Ethereum address using the `getNonce` cheatcode. This example demonstrates how to call the function and log the returned nonce.

```Solidity
uint256 nonce = vm.getNonce(address(100));
emit log_uint(nonce); // 0
```

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

### Use forge inspect for table view

Source: https://getfoundry.sh/misc/v1

Demonstrates the removal of the `--pretty` flag for `forge inspect` and how to use the command without it to get a table view.

```bash
forge inspect
```

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

### Deploy and Verify on Sepolia

Source: https://getfoundry.sh/guides/scripting-with-solidity

This snippet shows the process of deploying a Counter contract to the Sepolia testnet and verifying its deployment on Etherscan. It includes simulated on-chain traces, gas estimations, and the contract address.

```bash
forge script script/Counter.s.sol:Counter --rpc-url <SEPOLIA_RPC_URL> --broadcast --verify --etherscan-api-key <ETHERSCAN_API_KEY>
```

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

### Solidity: Invariant Test Setup Example

Source: https://getfoundry.sh/forge/advanced-testing/invariant-testing

A Solidity test contract that deploys `ExampleContract1` and defines invariant functions to test its state. It demonstrates how to set up and run invariant tests.

```solidity
contract InvariantExample1 is Test {
 
    ExampleContract1 foo;
 
    function setUp() external {
        foo = new ExampleContract1();
    }
 
    function invariant_A() external {
        assertEq(foo.val1() + foo.val2(), foo.val3());
    }
 
    function invariant_B() external {
        assertGe(foo.val1() + foo.val2(), foo.val3());
    }
 
}

```

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

### Deterministic Deployments with CREATE2 in Foundry

Source: https://getfoundry.sh/forge/reference/forge

This guide demonstrates how to perform deterministic smart contract deployments using the CREATE2 opcode within the Foundry framework. It covers the setup and execution of such deployments.

```Solidity
// Example of deterministic deployment using CREATE2
// Requires Foundry's testing framework and cheatcodes

import "forge-std/console.sol";

contract Factory {
    function deployDeterministic(bytes memory bytecode, bytes32 salt) public payable returns (address) {
        address deployedAddress;
        assembly {
            deployedAddress := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
        }
        return deployedAddress;
    }

    function getAddress(bytes memory bytecode, bytes32 salt) public view returns (address) {
        uint256 hash = uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(bytecode))));
        return address(hash);
    }
}

contract MyContract { 
    // Contract to be deployed
    constructor() {
        // Constructor logic
    }
}

// Example usage in a test:
// contract FactoryTest is Test {
//     Factory factory;
//     function setUp() public {
//         factory = new Factory();
//     }
//
//     function testDeploy() public {
//         MyContract contractToDeploy = new MyContract();
//         bytes memory bytecode = contractToDeploy.bytecode();
//         bytes32 salt = keccak256("my-salt");
//         address expectedAddress = factory.getAddress(bytecode, salt);
//         address deployedAddress = factory.deployDeterministic{value: 0}(bytecode, salt);
//         assertEq(deployedAddress, expectedAddress);
//     }
// }
```

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

### Foundry Scripting with Solidity

Source: https://getfoundry.sh/introduction/overview

Utilize advanced deployment and automation techniques using Solidity scripts with Foundry.

```solidity
// src/MyScript.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

import "forge-std/Script.sol";
import "./MyContract.sol";

contract MyScript is Script {
    function run() public {
        vm.startBroadcast();
        MyContract deployedContract = new MyContract();
        vm.stopBroadcast();
        // ... interact with deployedContract
    }
}

```

```bash
# Execute the script
forge script src/MyScript.sol:MyScript --rpc-url <rpc_url> --private-key <private_key>

```

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

### Foundry Deployment Commands

Source: https://getfoundry.sh/introduction/prompting

Common Forge commands for deploying and managing smart contracts. Includes options for local simulation, testnet deployment with verification and interactive prompts, resuming interrupted deployments, and mainnet deployment with gas estimation adjustments.

```bash
# Simulate locally
forge script script/Deploy.s.sol
```

```bash
# Deploy to testnet with verification
forge script script/Deploy.s.sol \
  --rpc-url sepolia \
  --broadcast \
  --verify \
  -vvvv \
  --interactives 1
```

```bash
# Resume failed deployment
forge script script/Deploy.s.sol \
  --rpc-url sepolia \
  --resume
```

```bash
# Mainnet deployment (extra caution)
forge script script/Deploy.s.sol \
  --rpc-url mainnet \
  --broadcast \
  --verify \
  --gas-estimate-multiplier 120 \
  --interactives 1
```

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

### Initialize Foundry Project with Custom Template

Source: https://getfoundry.sh/guides/project-setup/creating-a-new-project

Initializes a new Foundry project using a specified template from a GitHub repository. This allows for greater customization of the initial project setup.

```bash
forge init --template https://github.com/foundry-rs/forge-template hello_template
```

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

### Cast Command Example: Get ABI

Source: https://getfoundry.sh/cast/reference/wallet/remove

The `cast abi` command retrieves the ABI (Application Binary Interface) of a smart contract deployed on the blockchain. This is fundamental for understanding how to interact with a contract.

```Shell
cast abi <contract_address> <function_signature>
```

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

### View Forge Remappings

Source: https://getfoundry.sh/guides/project-setup/dependencies

Shows how to view the automatically deduced remappings for installed dependencies using the `forge remappings` command. This output helps in understanding how to import contracts from different libraries.

```Shell
$ forge remappings
forge-std/=lib/forge-std/src/
solady/=lib/solady/src/
```

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

### forge soldeer init Command Help

Source: https://getfoundry.sh/forge/reference/soldeer/init

Displays the help information for the 'forge soldeer init' command, outlining its usage and available options for converting Foundry projects to use Soldeer.

```bash
$ forge soldeer init --help
```

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

### Forge Cheatcodes Overview

Source: https://getfoundry.sh/forge/reference/forge

This guide provides an overview of Forge's cheatcodes, which are special functions available during testing to manipulate the environment, inspect contract states, and more. Examples include `vm.prank` and `vm.expectRevert`.

```Solidity
// Example usage of Forge cheatcodes

import "forge-std/Test.sol";

contract CheatcodeExamples is Test {
    function testPrank() public {
        // Impersonate another address
        address impersonated = address(0x123);
        vm.prank(impersonated);
        // Now, any calls made will appear to be from 'impersonated'
        // For example, calling a function on another contract:
        // targetContract.transfer(msg.sender, 1 ether);
    }

    function testExpectRevert() public {
        // Expect a specific revert message
        vm.expectRevert("Insufficient balance");
        // Call a function that is expected to revert
        // payable(address(0x456)).transfer(1 ether);
    }

    function testDeal() public {
        // Set the balance of an address
        address target = address(0x789);
        uint256 amount = 1 ether;
        vm.deal(target, amount);
        // Now, target address has 'amount' balance
        // assertEq(target.balance, amount);
    }

    function testTimestamp() public {
        // Set the current timestamp
        uint256 newTimestamp = 1678886400; // March 15, 2023 GMT
        vm.warp(newTimestamp);
        // Now, block.timestamp will return 'newTimestamp'
        // assertEq(block.timestamp, newTimestamp);
    }
}
```

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

### Foundry Core Build & Test Commands

Source: https://getfoundry.sh/introduction/prompting

Essential Foundry commands for initializing projects, compiling contracts, running tests with various options (gas reporting, pattern matching, verbosity, fuzzing), and generating code coverage and gas snapshots.

```bash
forge init <project_name>
```

```bash
forge build
```

```bash
forge build --dynamic-test-linking
```

```bash
forge test
```

```bash
forge test --match-test <pattern>
```

```bash
forge test --match-contract <pattern>
```

```bash
forge test -vvv
```

```bash
forge test --fuzz-runs 10000
```

```bash
forge coverage
```

```bash
forge snapshot
```
Tokens:
Raw