
This article provides detailed instructions on deploying smart contracts on the Scroll Alpha Testnet using different Ethereum development environments: Truffle, Hardhat, Hardhat combined with Truffle, Brownie, and Foundry.

## Truffle

Truffle is a popular development environment, testing framework, and asset pipeline for Ethereum. To deploy with Truffle, follow the steps below:

Install Truffle globally using npm:

```bash
npm install -g truffle
```

You can run the following command to create a starter project:
    
```bash
truffle unbox metacoin
```

If you want to create a complete blank project run:

```bash
truffle init
```

Remove the old contracts and test files that came with the Metacoin project.
Replace the old contract file name with your contract. This is the new contract you're deploying.

Make sure the solidity version in the **truffle.config.js** is the same as the version in your **.sol** file.

Next run the dashboard:
```bash
truffle dashboard
```

This should spin up a localhost with the truffle dashboard.

Now if this doesn't work, you can adjust the **truffle.config.js** in the following way.
```js
// Configure your compilers
  compilers: {
    solc: {
      version: "0.8.17",      // Fetch exact version from solc-bin
    }
  },
  dashboard: {
    port: 24013,
    host:"localhost" ,
  },
  
  networks: { 
    // ... network configurations, including the network named 'dashboard'
  }  
```
By running truffle migrate, the contract will compile and your browser should pop-up.
If it doesn't go to localhost:24013.
    

```bash
truffle migrate --network dashboard
```
Approve the transaction and check the deployment status on the Truffle dashboard.
    
## Hardhat

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software. To deploy with Hardhat, follow these steps:

Install Hardhat and dotenv, a module that loads environment variables from a `.env` file into `process.env`.
    
```bash
npm install --save-dev hardhat
yarn add --dev hardhat
npm install dotenv
```

Set up a new Hardhat project.

```bash
npx hardhat
```
Remove any old contract files in the newly created project.
Update the Solidity version in the Hardhat config file and paste your new contract code into a new file.
Create a `.env` file in the root of your project, where you'll store environment variables.

MAKE SURE YOU HAVE A **.gitignore** FILE WITH *.env IN IT.
Committing your .env means committing your private keys.

Update your `hardhat.config.js` file to include the Scroll Alpha Testnet and Truffle dashboard networks.
    
```js
networks: {
  scroll: {
    url: "https://scroll-alphanet.public.blastapi.io",
    accounts: [process.env.PRIVATE_KEY]
  }
}
```
Add these lines at the top of your `hardhat.config.js` file to include dotenv.
    
```js
const dotenv = require("dotenv");
dotenv.config({ path: __dirname + '/.env' });
```

Add these lines to the top of your `scripts/deploy.js` file.
    
```js
const [deployer] = await ethers.getSigners();
console.log("Deploying contracts with the account:", deployer.address);
```

Run your deployment script with Hardhat.
    
```bash
npx hardhat run --network scroll scripts/deploy.js
```

## Hardhat with Truffle Dashboard

If you prefer to develop with Hardhat, but don't want to pass your private keys manually, then I got good news.
You can use Truffle dashboard together with Hardhat. Here's how

Add truffle dashboard to the **hardhat.config.js** file.

```js
networks: {
  scroll: {
    url: "https://scroll-alphanet.public.blastapi.io",
    accounts: [process.env.PRIVATE_KEY]
  },
  'truffle-dashboard': {
    url: "http://localhost:24012/rpc"
  }
}
```

To deploy with Hardhat using the Truffle dashboard, repeat the same steps as the regular Hardhat setup, but to deploy your smartcontract, run the deployment script with the `truffle-dashboard` network.

```bash
npx hardhat run --network truffle-dashboard scripts/deploy.js
```

## Brownie

Brownie is a Python framework for Ethereum smart contract testing, debugging, interaction and deployment. To deploy with Brownie:

Install the Brownie library and the `python-dotenv` library to handle environment variables.

Before we do that, I'm assuming that you your own virtual environment up and running. 
If you don't and you want to create one on the fly, install these dependencies first.

```bash
python3 -m pip install --user pipx
python3 -m pipx ensurepath
```

Then you can go ahead and use the **pipx** command instead of the **pip** command to create a virtual environment and install brownie at the same time.

```bash
pipx install python-dotenv eth-brownie
```

If you want to do it the old school way:
```bash
python3 -m venv ./myv
source ./myv/bin/activate
pip install python-dotenv eth-brownie
```

Set up a new Brownie project with a standard ERC20 smartcontract

```bash
brownie bake token
cd token
```

Create a `network-config.yaml` file with the Scroll Alpha Testnet information.
    
```yaml
live:
- name: Ethereum
  networks:
  - chainid: 534353
   explorer: https://blockscout.scroll.io/
   host: https://scroll-alphanet.public.blastapi.io
   id: testnet-scroll
   name: Testnet (scroll)
```

Import the network configuration and create a new account with your private key.
**my-new-account** is the name I gave, you can pass any name you want here.
After this prompt, you will be asked to input the private key and choose a password.
    
```bash
brownie networks import ./network-config.yaml
brownie accounts new my-new-account
```

Compile your contract.

```bash
brownie compile
```

If you choose to use an **.env** file, you will need to load your private key from an `.env` file in your deploy script.
MAKE SURE YOU HAVE A **.gitignore** FILE WITH *.env IN IT.
Committing your .env means committing your private keys.

```python
import os
from dotenv import load_dotenv 

load_dotenv()  # loads .env

private_key = os.getenv("PRIVATE_KEY")

account = accounts.add(os.getenv("PRIVATE_KEY"))
```

Adjust your deployment script, [`token.py`](http://token.py), to use the new account and network.
    
```python
from brownie import Token, accounts

account = accounts.load("my-new-account")

def main():
    return Token.deploy("Test Token", "TST", 18, 1e21, {'from': account})
```

Run your deployment script with Brownie.

```bash
brownie run token.py --network testnet-scroll
```

## Foundry

Foundry is a Rust-based Ethereum smart contract development toolkit. It features built-in testing, automatic contract API generation, and support for different Ethereum networks.

Initialize a new Foundry project and build it.
    
```bash
forge init foundry-demo
cd foundry-demo && forge build
```

Install OpenZeppelin contracts.

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

Create a remappings file inside the root folder that allows you to specify Solidity remappings for your project's dependencies.
    
```bash
forge remappings > remappings.txt
```

Compile your contract
```bash
forge build
```

Deploy your contract.
Just so you know, you can do it like this, bypassing the creation of a deploy script, but this isn't recommended.
For hackathons it might be fine, but for any smartcontract development, you shouldn't pass your **Private Keys** like this.

**Don't forget the legacy flag at the end**

```bash
forge create --rpc-url https://alpha-rpc.scroll.io/l2 --private-key <PRIVATE_KEY_HERE> src/EtherWallet.sol:EtherWallet --legacy
```

Instead you could create a **.env** file. Again...make sure you have a **.gitignore** file and include *.env.

Next create the folder **script** if it doesn't already exist and include your deployment script.
It should look something like this. This is an example from the official docs.

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

import "forge-std/Script.sol";
import "../src/NFT.sol";

contract MyScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);

        NFT nft = new NFT("NFT_tutorial", "TUT", "baseUri");

        vm.stopBroadcast();
    }
}
```

At the root of the project run
```bash
source .env
```

Followed by
```bash
forge script script/<SCRIPTNAME>.s.sol:MyScript --rpc-url https://alpha-rpc.scroll.io/l2 --broadcast --verify -vvvv --legacy
```

If you passed the rpc url as an environment variable, you can also run the following command. In this command I'm assuming you named the variable for the rpc url **SCROLL_RPC_URL**

```bash
forge script script/NFT.s.sol:MyScript --rpc-url $SCROLL_RPC_URL --broadcast --verify -vvvv --legace
```

Each development environment has its strengths and features. Try deploying your contracts on the Scroll Alpha Testnet with each of them and see which one suits your workflow best. Remember to keep your private keys secure and happy coding!