```javascript
// .env
PRIVATE_KEY=xxx
GOERLI_RPC_URL=https://eth-goerli.g.alchemy.com/v2/xxx
ETHERSCAN_API_KEY=xxx
COINMARKETCAP_API_KEY=xxx
```

\
```javascript
// hardhat-config.js
require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    hardhat: {
      chainId: 31337,
      blockConfirmations: 1,
    },
    goerli: {
      chainId: 5,
      blockConfirmations: 6,
      url: process.env.GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
  solidity: "0.8.17",
  namedAccounts: {
    deployer: {
      default: 0,
    },
    player: {
      default: 1,
    },
  },
};
```

\
```javascript
// deploy/01-deploy-raffle.js
const { network } = require("hardhat");

module.exports = async function ({ getNamedAccounts, deployments }) {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();

  const raffle = await deploy("Raffle", {
    from: deployer,
    args: [],
    log: true,
    waitConfirmations: network.config.blockConfirmations || 1,
  });
};
```

\
Now it’s time to work on the constructor args.

\


Deploy Raffle smart contract

Types

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {
    // https://docs.soliditylang.org/en/v0.8.17/types.html
    bool hasFavoriteNumber = true;
    uint256 favoriteNumber = 5;
    string favoriteNumberInText = "Five";
    int256 favoriteInt = -5;
    address myAddress = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
    bytes32 favoriteBytes = "cat";
}
```

\


Types

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {
    uint256 favoriteNumber = 5;
    // deploying a contract is also a transaction
    // click on ^  besude /debyg bytton to see metadata
    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }
}
```

\
Deploy and try executing `store`

Function

```
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {
    uint256 public favoriteNumber = 5;
    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }
}
```

\
Try deploy. Now you get 2 button. Each time you execute store, you endup paying gas. Check your contract from dropdown in Remix to see your total going down.

Visibility

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {
    uint256 public favoriteNumber = 5;    
    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    // they are seen as blue button in Remix
    function retrieve() public view returns(uint256) {
        return favoriteNumber;
    }
}
```

\


Gas cost

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {

    uint256 public favoriteNumber = 5;    

    // struct - build your own data type
    struct People {
        uint256 favoriteNumber;
        string name;
    }
    // People is another type like uint256 but custom created
    People public person = People({favoriteNumber: 2, name: 'Ryan'});


    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    function retrieve() public view returns(uint256) {
        return favoriteNumber;
    }
}  
```

\


Struct

In Remix, try passing index 1,2 into the people button input field

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {

    uint256 public favoriteNumber = 5;    

    // struct - build your own data type
    struct People {
        uint256 favoriteNumber;
        string name;
    }

    // array with People type
    People[] public people;

    // push to people array
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        People memory newPerson = People({favoriteNumber: _favoriteNumber, name: _name});
        people.push(newPerson);
    }

    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    function retrieve() public view returns(uint256) {
        return favoriteNumber;
    }
    
}   
```

\


Array

`mapping` is a data structure that allows you to associate keys with values and store them in an unordered collection.

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract SimpleStorage {

    uint256 public favoriteNumber = 5;    

    // struct - build your own data type
    struct People {
        uint256 favoriteNumber;
        string name;
    }

    // array with People type
    People[] public people;

    // associate keys with values and store them in an unordered collection
    mapping(string => uint256) public nameToFavoriteNumber;

    // push to people array
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        People memory newPerson = People({favoriteNumber: _favoriteNumber, name: _name});
        people.push(newPerson);
        // use mapping key(name)/value(fav num) to store fav number
        nameToFavoriteNumber[_name] = _favoriteNumber;
    }

    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    function retrieve() public view returns(uint256) {
        return favoriteNumber;
    }
    
}   
```

\


Mapping

Deploy to testnet. From Remix Environment dropdown, select Injected Provider - MetaMask

\
You will need some test ETH to try on test networks such as Goerli or Rinkby.

\
\


Deploy

```javascript
// StorageFactory.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./SimpleStorage.sol";

contract StorageFactory {
    SimpleStorage public simpleStorage;
    
    function createSimpleStorageContract() public {
        simpleStorage = new SimpleStorage();
    }

}
```

\
After deploy, click the button simpleStorage. you get address as 000000

Click on button createSimpleStorage then click on createSimpleStorage, you get the newly created contract’s address.

Smart contract deploy another smart contract

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./SimpleStorage.sol";

contract StorageFactory {
    SimpleStorage[] public simpleStorageArray;
    
    function createSimpleStorageContract() public {
        SimpleStorage simpleStorage = new SimpleStorage();
        simpleStorageArray.push(simpleStorage);
    }

}
```

\


Store all deployed contracts

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./SimpleStorage.sol";

contract StorageFactory {
    SimpleStorage[] public simpleStorageArray;
    
    function createSimpleStorageContract() public {
        SimpleStorage simpleStorage = new SimpleStorage();
        simpleStorageArray.push(simpleStorage);
    }

    // interact with other deployed contracts - store
    function sfStore(uint256 _simpleStorageIndex, uint256 _simpleStorageNumber) public {
        SimpleStorage simpleStorage = simpleStorageArray[_simpleStorageIndex];
        simpleStorage.store(_simpleStorageNumber);
    }
    // interact with other deployed contracts - get stored fav number
    function sfGet(uint256 _simpleStorageIndex) public view returns(uint256) {
        SimpleStorage simpleStorage = simpleStorageArray[_simpleStorageIndex];
        return simpleStorage.retrieve();
    }

}
```

\
Now deploy and try:

\
* Now you can createSimpleStorage
* Click sfStore to add fav number to contract (by index value)
* Click sfGet with index argument to see the fav number value
* Click simpleStorageArray with index to see the contract address

\


Interacting with other contracts

```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./StorageFactory.sol";

// inherits everything (functions variables etc) from SimpleStorage
// inherit using is keyword
// try compile and deploy
contract ExtraStorage is SimpleStorage {

}
```

\


Inheritance

Use `virtual` and `override`

\
```javascript
// SimpleStorage.sol
// add virtual to make it overrideable by inherited contracts
function store(uint256 _favoriteNumber) public virtual {
    favoriteNumber = _favoriteNumber;
}
```

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./StorageFactory.sol";

// inherits everything (functions variables etc) from SimpleStorage
contract ExtraStorage is SimpleStorage {
    // override the parent contract's store function by adding 100
     function store(uint256 _favoriteNumber) public override {
         favoriteNumber = _favoriteNumber + 100;
     }
}
```

\


Override

```javascript
// get funds from users
// withdraw funds
// set a minimum funding value in usd

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract FundMe {
    // use keyword 'payable' to make function payable
    function fund() public payable{
        // ask user to fund certain value
        // use 'require' keyword to make it required
        // msg is global object available by default in current transaction

        // https://eth-converter.com/
        // 1 eth == 1000000000000000000 gwei
        // 1e18 == 1 * 10 ** 18 means 18 0's means 1 eth
        // if did't received min eth required, revert
        require(msg.value > 1e18, "Didn't send enough"); 

    }

    // function withdraw() {}  
}
```

\
Deploy and try clicking on fund button. You get error unless you provide more than 1 ETH in value.

Payable, require and msg global object

Visit <https://docs.chain.link/data-feeds/price-feeds/>

\
Try the sample code.

\
```javascript
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumerV3 {
    AggregatorV3Interface internal priceFeed;

    /**
     * Network: Goerli
     * Aggregator: ETH/USD
     * Address: 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
     */
    constructor() {
        priceFeed = AggregatorV3Interface(
            0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
        );
    }

    /**
     * Returns the latest price.
     */
    function getLatestPrice() public view returns (int) {
        // prettier-ignore
        (
            /* uint80 roundID */,
            int price,
            /*uint startedAt*/,
            /*uint timeStamp*/,
            /*uint80 answeredInRound*/
        ) = priceFeed.latestRoundData();
        return price;
    }
}
```

\
* Compile and deploy in Remix
* Choose environment > Injected Provider - MetaMask
* Get some test ETH from <https://faucets.chain.link/> to try
* You will have to wait a while for it to deploy
* Click on getLatestPrice to get the ETH price in USD in realtime
* Price will be in 8 decimals format. If price is 1680, it will appear as 168314000000
* While processing, you will see pending message in console.
* You can try getting price in USD for other assets. Checkout the list <https://docs.chain.link/data-feeds/price-feeds/addresses>

\


Realtime price feed using chainlink

Convert current ETH price to USD so that you can check if user provided the required amount using chainlink oracle.

\
```javascript
// FundMe.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


contract FundMe {
    // required fee is $50
    uint256 public minimumUsd = 50;
    // need to convert eth to usd in realtime using chainlink oracle
    function fund() public payable{
        require(msg.value >= minimumUsd, "Didn't send enough"); 
    }
    // get ETH price in USD format to check required min usd
    function getPrice() public view returns(int) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        // (uint80 roundID, int price, uint startedAt, uint timeStamp, uint80 answeredInRound) = priceFeed.latestRoundData();
        (, int price, , , ) = priceFeed.latestRoundData();
        return price; // 1681.06996547
        // return priceFeed.version();
    }

    // function withdraw() {}  
}
```

\


Get current ETH price in USD using Chainlink oracle

Using `AggregatorV3Interface`, Convert ETH value from int256 (8 decimals) to uint256 (18 decimals)

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


contract FundMe {
    // required fee is $50
    uint256 public minimumUsd = 50;
    // need to convert eth to usd in realtime using chainlink oracle
    function fund() public payable{
        require(msg.value >= minimumUsd, "Didn't send enough"); 
    }
    // get ETH price in USD format to check required min usd
    function getPrice() public view returns(uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        // (uint80 roundUD, int price, uint startedAt, uint timeStamp, uint80 answeredInRound) = priceFeed.latestRoundData();
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    // function withdraw() {}    
}
```

\


Convert ETH value from int256 to uint256

* Use `getConversionRate()` to get current ETH price
* Use that `getConversionRate(msg.value)` in `fund()`
* Update minimumUsd `uint256 public minimumUsd = 50 * 1e18;`
* Now deploy and click on fund. It will fail without the required value.

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


contract FundMe {
    // required fee is $50
    // to see how much eth to send that match $50
    // calculator: 50 / currentEthPrice > 0.03 (current price $1700)
    uint256 public minimumUsd = 50 * 1e18;
    // need to convert eth to usd in realtime using chainlink oracle
    function fund() public payable{
        require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough"); 
    }
    // get ETH price in USD format to check required min usd
    function getPrice() public view returns(uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        // (uint80 roundUD, int price, uint startedAt, uint timeStamp, uint80 answeredInRound) = priceFeed.latestRoundData();
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(uint256 ethAmount) public view returns (uint256) {
        uint256 ethPrice = getPrice(); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }

    // function withdraw() {}    
}
  
```

\


Get conversion rate from ETH to USD

Keep track of funders (accounts who fund/donate)

\
Add these in FundMe contract

\
```javascript
address[] public funders;
mapping(address => uint256) public addressToAmountFunded;
```

\
Then use them inside `fund()`

\
```javascript
function fund() public payable{
    require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough"); 
    funders.push(msg.sender);
    addressToAmountFunded[msg.sender] = msg.value;
}
```

\
Full code of `FundMe.sol`

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


contract FundMe {
    // calculator: 50 / currentEthPrice > 0.03 (current price $1700)
    uint256 public minimumUsd = 50 * 1e18;
    // address is a data type
    address[] public funders;
    // stores key/value pair
    mapping(address => uint256) public addressToAmountFunded;

    function fund() public payable{
        require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough"); 
        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] = msg.value;
    }

    function getPrice() public view returns(uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(uint256 ethAmount) public view returns (uint256) {
        uint256 ethPrice = getPrice(); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }

    // function withdraw() {}    
}
  
```

\


Keep track of accounts

```javascript
// contracts/PriceConverter.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


library PriceConverter {

    function getPrice() public view returns(uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(uint256 ethAmount) public view returns (uint256) {
        uint256 ethPrice = getPrice(); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }
}
```

\


Create your own library

Make the functions visibility internal. It can only be accessed from within the same contract.

Replace `public` keyword with `internal`

\
```javascript
// PriceConverter.sol
library PriceConverter {

    function getPrice() internal view returns(uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e);
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(uint256 ethAmount) internal view returns (uint256) {
        uint256 ethPrice = getPrice(); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }
}
```

\
\
Now import and use with `uint256`

\
```javascript
// FundMe.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./PriceConverter.sol";

contract FundMe {
    using PriceConverter for uint256;
    
    // calculator: 50 / currentEthPrice > 0.03 (current price $1700)
    uint256 public minimumUsd = 50 * 1e18;
    // address is a data type
    address[] public funders;
    // stores key/value pair
    mapping(address => uint256) public addressToAmountFunded;

    function fund() public payable{
        
        // require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough"); 
        require(msg.value.getConversionRate() >= minimumUsd, "Didn't send enough"); 


        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] = msg.value;
    }

    // function withdraw() {}    
}
  
```

\


Using library

```javascript
// FundMe.sol

// withdraw all the ETH that's funded by funders
function withdraw() public {
    for(uint256 i = 0; i < funders.length; i++) {
        address funder = funders[i];
        addressToAmountFunded[funder] = 0;
    }
    // reset the array
    funders = new address[](0);
    // transfer the balance to whomever calling the withdraw()
    // visit https://solidity-by-example.org/sending-ether/ to learn more on transfer(), send()
    // not calling call() so leave it blank call("")
    // call() returns 2 variables boolean and bytes object
    (bool callSuccess, ) =  payable(msg.sender).call{value: address(this).balance}("");
    require(callSuccess, "Call failed");
}   
```

\


Withdraw ETH

Allow only the contract deployer/owner to call the withdraw function

\
```javascript
// FundMe.sol
address public owner; // same as your metamask account
    
constructor() {
    owner = msg.sender;
}

// now use inside withdraw()
require(msg.sender == owner);
```

\
Full code

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./PriceConverter.sol";

contract FundMe {
    using PriceConverter for uint256;

    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    // calculator: 50 / currentEthPrice > 0.03 (current price $1700)
    uint256 public minimumUsd = 50 * 1e18;
    // address is a data type
    address[] public funders;
    // stores key/value pair
    mapping(address => uint256) public addressToAmountFunded;

    function fund() public payable{
        
        // require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough"); 
        require(msg.value.getConversionRate() >= minimumUsd, "Didn't send enough"); 


        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] = msg.value;
    }
    // withdraw all the ETH that's funded by funders
    function withdraw() public {
        require(msg.sender == owner);

        for(uint256 i = 0; i < funders.length; i++) {
            address funder = funders[i];
            addressToAmountFunded[funder] = 0;
        }
        // reset the array
        funders = new address[](0);
        // transfer the balance to whomever calling the withdraw()
        // visit https://solidity-by-example.org/sending-ether/ to learn more on transfer(), send()
        (bool callSuccess, ) =  payable(msg.sender).call{value: address(this).balance}("");
        require(callSuccess, "Call failed");
    }    
}
   
```

\


Constructor

```javascript
modifier onlyOnwer {
        require(msg.sender == owner, "Sender is not owner!");
        _; // execute the rest of the code
} 
```

\
```javascript
// now apply in function
function withdraw() public onlyOnwer {
    // require(msg.sender == owner);

    for(uint256 i = 0; i < funders.length; i++) {
        address funder = funders[i];
        addressToAmountFunded[funder] = 0;
    }
    // reset the array
    funders = new address[](0);
    // transfer the balance to whomever calling the withdraw()
    // visit https://solidity-by-example.org/sending-ether/ to learn more on transfer(), send()
    (bool callSuccess, ) =  payable(msg.sender).call{value: address(this).balance}("");
    require(callSuccess, "Call failed");
} 
```

\


Function modifiers

Make `miniumumUsd` constant so that it is more gas efficient. Any variable that will stat static can be constant.

\
```javascript
// FundMe.sol
uint256 public constant MINIMUM_USD = 50 * 1e18;
// replace minumumUsd to MINIMUM_USD
```

\
```javascript
// 961921 - gas before
// 939697 - gas after
```

\


Constant

Similar to constants. They are gas efficient.

\
```javascript
// FundMe.sol
address public immutable OWNER; // same as your metamask acc

constructor() { 
    OWNER = msg.sender;
}
// replace owner with OWNER
```

\
```javascript
// 939697 - gas before
// 913399 - gas after
```

\


Immutable

You can replace `require` with `revert`

\
```javascript
// FundMe.sol

// outside of contract
error NotOwner();

// update modifier
modifier onlyOnwer {
  if(msg.sender != OWNER) { revert NotOwner(); }
  require(msg.sender == OWNER, "Sender is not owner!");
  _; // execute the rest of the code
} 
```

\


Revert with error

2 Special functions in solidity that can trigger if something is sent to the contract or if not.

\
If a function is called that does not exist, fallback functions can trigger

\
### Receive

\
If there is no data associated with the TRANSACTION (calldata is empty), `receive` function can trigger

\
```javascript
// contracts/FallbackExample.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract FallbackExample {
    uint256 public result;

    // external - intended to call from outside
    receive() external payable {
        result = 1;
    }
} 
```

\
Deploy and try clicking in result button. you get 0

\
If you click the Transact button (under CALLDATA in Remix) first then click in result button, you get 1

\
It means, if there is empty calldata, `receive` will trigger

\
### Fallback

\
If you click Transact button with valid ETH wallet address, you will see the message 'Fallback' function is not defined”

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract FallbackExample {
    uint256 public result;

    // external - intended to call from outside
    receive() external payable {
        result = 1;
    }

    fallback() external payable {
        result = 2; // try sending 0x00
    }
} 
```

\
\


Receive and fallback

Create a folder

Copy `FundMe.sol` from Remix to a new file `FundMe.sol` inside your folder

\
```javascript
npm i solc-js
solcjs --version
```

\
Compile solidity using solc

\
```javascript
solcjs --bin --abi --include-path node_modules/ --base-path . -o . SimpleStorage.sol
```

\
You see 2 files created. `.abi` and `.bin`

Just like in Remix (Compile > Compilation Details > ABI, Bytecode), it’s the same data created locally after compilation

\
Now add the long terminal command to your script to make it easy

\
```javascript
// package.json
{
  "dependencies": {
    "solc": "^0.8.18"
  },
  "scripts": {
    "compile": "solcjs --bin --abi --include-path node_modules/ --base-path . -o . SimpleStorage.sol"
  }
}
```

\
Run `npm run compile` to compile your solidity code

Local development environment setup

To deploy our contracts, we need a test blockchain running locally. We can use [Ganache](https://trufflesuite.com/ganache/) for that. Download and install.

Ganache (Test ETH  blockchain)

Install ethers js to interact with ETH blockchain

\
```javascript
npm i ethers
```

\
```javascript
// deploy.js
const ethers = require("ethers");

async function main() {
  // connect to locally running blockchain
  // each networks have their own RPC URL (goerli, rinkby etc)
  // http://127.0.0.1:7545 // ganache rpc url
  const provider = new ethers.providers.JsonRpcProvider(
    "http://127.0.0.1:7545"
  );
}

main()
  .then(() => process.exit(0))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });
```

\


Ethers js

```javascript
// deploy.js
const ethers = require("ethers");
const fs = require("fs");

async function main() {
  // 1. connect to locally running blockchain
  // each networks have their own RPC URL (goerli, rinkby etc)
  // http://127.0.0.1:7545 // ganache rpc url
  const provider = new ethers.providers.JsonRpcProvider(
    "http://127.0.0.1:7545"
  );
  // 2. copy private key from ganache, click on address, copy private key
  // private key is similar to metamask account private key
  const wallet = new ethers.Wallet(
    "a3bcd0dfbce34e460e317b199c9b7650c034c30380eb42f27823187f5fd7bca0",
    provider
  );
  // 3. to deploy contract we need ABI and compiled binary code
  const abi = fs.readFileSync("./SimpleStorage_sol_SimpleStorage.abi", "utf8");
  const binary = fs.readFileSync(
    "./SimpleStorage_sol_SimpleStorage.bin",
    "utf8"
  );
  // 4. use contract factory to deploy contract
  // abi to interact with contract
  // binary is the main compiled code
  // wallet with private key to sign and deploy contract
  const contractFactory = new ethers.ContractFactory(abi, binary, wallet);
  console.log("deploying...");
  const contract = await contractFactory.deploy();
  console.log("CONTRACT => ", contract);
}

main()
  .then(() => process.exit(0))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });
```

\
\
Deploy

For this to work make sure to use ethers v5

\
```javascript
//package.json
"ethers": "^5.7.2",
```

\
```javascript
node deploy.js
```

\
Once deployed, check Ganache

It will show transaction count and ETH spent

\


Deploy to local Ganache blockchain using ethers

What is the meaning of block confirmation in solidity?

\
In Solidity, the term "waiting for block confirmation" refers to the process of waiting for a block to be added to the Ethereum blockchain. When a transaction is submitted to the network, it is broadcast to the network and is included in the next block that is mined.

\
In Solidity, when a contract calls a function that modifies the state of the contract, the changes to the contract's state are not immediately reflected in the blockchain. Instead, they are stored in the memory of the Ethereum node executing the function. The changes to the state are only committed to the blockchain once the block that contains the transaction is confirmed.

\
Confirmations are an important part of the security model of the Ethereum blockchain. They ensure that the changes to the state of the contract are irreversible and tamper-proof. The number of confirmations required before a block is considered confirmed can vary, but it is typically 6 blocks.

\
Waiting for block confirmations is important when dealing with contracts that transfer valuable assets or execute important functions, as it helps to ensure the integrity and security of the blockchain. It is also important to note that the time it takes for a block to be confirmed can vary depending on network conditions and the gas price of the transaction.

\
```javascript
// deploy.js

// inside main()
const contract = await contractFactory.deploy();
console.log("Transaction Response ================> ", contract);
// transaction receipt
const transactionReceipt = await contract.deployTransaction.wait(1);
console.log("Transaction Recipt ================> ", transactionReceipt);
```

\


Waiting for block confirmation

Deploying a contract is actually sending a transaction

\
Let’s try creating a transaction and contract ourself using the transaction data to understand how it works under the hood

\
```javascript
// put in main() after this line
const contract = await contractFactory.deploy();

  /**
   * Deploy with only raw transaction data
   */
  // 1. tx data
  const tx = {
    // nonce: 5, // +1 to the TX Count in Ganache
    nonce: await wallet.getTransactionCount(),
    gasPrice: 20000000000, // grab from Ganache menu bar
    gasLimit: 1000000, // some big number
    to: null, // just like in transaction receipt
    value: 0, // 0, not sending any ETH
    // data is binary data + prefix with "0x"
    data: "0x123", // copy your abi from .abi file
    chainId: 1337, // each chain has their unique id, rinkeby 4, eth 61, ganache 1337
  };
  // 2. send the transaction
  const sentTxResponse = await wallet.sendTransaction(tx);
```

\
\
\


Create a transaction and contract yourself using raw transaction data

Try retrieve function

\
```javascript
// main()

// 1. retrieve (get fav number)
const currentFavoriteNumber = await contract.retrieve();
// BigNumber { _hex: '0x05', _isBigNumber: true }
// console.log("retrieve fav_number => ", currentFavoriteNumber);
console.log(`Current fav_number is ${currentFavoriteNumber.toString()}`); // 5

// 2. store fav_number
const storeFavNumberResponse = await contract.store("7");
const storeFavNumberReceipt = await storeFavNumberResponse.wait(1);
const updatedFavNumber = await contract.retrieve();
console.log(`Updated fav_number is ${updatedFavNumber}`);
```

\
Full Code

\
```javascript
// deploy.js
const ethers = require("ethers");
const fs = require("fs");

async function main() {
  // 1. connect to locally running blockchain, ganache RPC from top menubar
  const provider = new ethers.providers.JsonRpcProvider(
    "http://127.0.0.1:7545"
  );
  // 2. copy private key from ganache, click on address, copy private key
  // private key is similar to metamask account private key
  const wallet = new ethers.Wallet(
    "a3bcd0dfbce34e460e317b199c9b7650c034c30380eb42f27823187f5fd7bca0",
    provider
  );
  // 3. to deploy contract we need ABI and compiled binary code
  const abi = fs.readFileSync("./SimpleStorage_sol_SimpleStorage.abi", "utf8");
  const binary = fs.readFileSync(
    "./SimpleStorage_sol_SimpleStorage.bin",
    "utf8"
  );
  // 4. use contract factory to deploy contract
  const contractFactory = new ethers.ContractFactory(abi, binary, wallet);

  console.log("deploying...");
  const contract = await contractFactory.deploy();
  // console.log("Transaction Response ================> ", contract);

  // transaction receipt
  const transactionReceipt = await contract.deployTransaction.wait(1);
  // console.log("Transaction Recipt ================> ", transactionReceipt);

  /**
   * interact with contract
   */

  // 1. retrieve (get fav number)
  const currentFavoriteNumber = await contract.retrieve();
  // BigNumber { _hex: '0x05', _isBigNumber: true }
  // console.log("retrieve fav_number => ", currentFavoriteNumber);
  console.log(`Current fav_number is ${currentFavoriteNumber.toString()}`); // 5

  // 2. store fav_number
  const storeFavNumberResponse = await contract.store("7");
  const storeFavNumberReceipt = await storeFavNumberResponse.wait(1);
  const updatedFavNumber = await contract.retrieve();
  console.log(`Updated fav_number is ${updatedFavNumber}`);
}

main()
  .then(() => process.exit(0))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });
```

\
```javascript
// SimpleStorage.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.18;

contract SimpleStorage {
    uint256 public favoriteNumber = 5;

    // struct - build your own data type
    struct People {
        uint256 favoriteNumber;
        string name;
    }

    // array with People type
    People[] public people;

    // associate keys with values and store them in an unordered collection
    mapping(string => uint256) public nameToFavoriteNumber;

    // push to people array
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        People memory newPerson = People({
            favoriteNumber: _favoriteNumber,
            name: _name
        });
        people.push(newPerson);
        // use mapping key(name)/value(fav num) to store fav number
        nameToFavoriteNumber[_name] = _favoriteNumber;
    }

    // add virtual to make it overrideable by inherited contracts
    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    function retrieve() public view returns (uint256) {
        return favoriteNumber;
    }
}
```

\


Interact with contract

```javascript
// .env
PRIVATE_KEY=xxxxxxxxxxxxxxxxx
RPC_URL=http://127.0.0.1:7545

// .gitignore
node_modules
.env
```

\
Now replace hard coded values in deploy.js

\
```javascript
  const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
```

\


Env and gitignore files

```javascript
PRIVATE_KEY=0Xxxxxxxxxx node deploy.js
```

\
Clear previous commands from terminal history

\
```javascript
history -c
```

\


Using env variables in runtime

Deploy to Goerli Testnet

\
Get API key and HTTP url from [alchemy.com](https://dashboard.alchemy.com/apps/1z4uiej0kv26spuu)

\
```javascript
# PRIVATE_KEY=xxxxxxxxx
# RPC_URL=http://127.0.0.1:7545
# metamask account name > click 3 dots > click export private key
PRIVATE_KEY=xxxxxxxxx
RPC_URL=https://eth-goerli.g.alchemy.com/v2/xxxxxx
```

\
Deploy the contract

\
```javascript
npm run deploy
```

\
```javascript
// package.json
"deploy": "node deploy.js"
```

\
* Wait for transaction to complete
* Copy the contractAddress and view in [Goerli etherscan](https://goerli.etherscan.io/)
* On the menu bar above contracts, click on **Contract**
* There is an option to verify and publish your code

\
In future if you want to deploy your contract to some other chain for example Fantom, Matic etc, all you have to do is change the RPC_URL and PRIVATE_KEY

\
\


Deploy to Testnet from local dev environment

* Click on verify and publish under Contract
* Select compiler type Solidity single file
* Choose current version you are using
* Choose licence MIT and continue
* Paste your code from `SimpleStorage.sol`
* Verify and publish
* Now you can copy paste your contract address to etherscan
* Under contract, you can see all your code and interact with it by clicking on Read and Write Contract buttons

\


Verify and publish code manually

```javascript
npx hardhat
```

\
You may need to read the warning next time you run same command and fix the issue by installing these

\
```javascript
npm install --save-dev "@ethersproject/providers@^5.4.7" "@nomicfoundation/hardhat-network-helpers@^1.0.0" "@nomicfoundation/hardhat-chai-matchers@^1.0.0" "@nomiclabs/hardhat-ethers@^2.0.0" "@nomiclabs/hardhat-etherscan@^3.0.0" "@types/chai@^4.2.0" "@types/mocha@>=9.1.0" "@typechain/ethers-v5@^10.1.0" "@typechain/hardhat@^6.1.2" "chai@^4.2.0" "ethers@^5.4.7" "hardhat-gas-reporter@^1.0.8" "solidity-coverage@^0.8.1" "ts-node@>=8.0.0" "typechain@^8.1.0" "typescript@>=4.5.0"
```

\
Now run `npx hardhat help` to see all **GLOBAL OPTIONS** and **AVAILABLE TASKS.** Try few.

\
```javascript
npx hardhat compile
```

\
On compile, it creates `cache` and `artifacts` folders with metadata and contracts, similar to `ethers.js`

Create hardhat project

```javascript
// contracts/SimpleStorage.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.18;

contract SimpleStorage {
    uint256 public favoriteNumber = 5;

    // struct - build your own data type
    struct People {
        uint256 favoriteNumber;
        string name;
    }

    // array with People type
    People[] public people;

    // associate keys with values and store them in an unordered collection
    mapping(string => uint256) public nameToFavoriteNumber;

    // push to people array
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        People memory newPerson = People({
            favoriteNumber: _favoriteNumber,
            name: _name
        });
        people.push(newPerson);
        // use mapping key(name)/value(fav num) to store fav number
        nameToFavoriteNumber[_name] = _favoriteNumber;
    }

    // add virtual to make it overrideable by inherited contracts
    function store(uint256 _favoriteNumber) public {
        favoriteNumber = _favoriteNumber;
    }

    // view and pure functions do not cost gas
    function retrieve() public view returns (uint256) {
        return favoriteNumber;
    }
}
```

\


Write a contract in hardhat

```javascript
npx hardhat help
npx hardhat compile
```

\
Possible error

\
```javascript
Error HH606: The project cannot be compiled, see reasons below.

The Solidity version pragma statement in these files doesn't match any of the configured compilers in your config. Change the pragma or configure additional compiler versions in your hardhat config.

  * contracts/SimpleStorage.sol (0.8.18)

To learn more, run the command again with --verbose

Read about compiler configuration at https://hardhat.org/config
```

\
* Make sure to use the correct version
* Check hardhat.config.js to see the current version

\
```javascript
solidity: "0.8.17",
```

\
Use the same version in your contract file `SimpleStorage.sol`

\
```javascript
pragma solidity 0.8.17;
```

\
```javascript
npx hardhat compile
```

\
Once compiled, you will see contract compiled in  `artifacts/contracts` and `cache` folder.

Compile contract in hardhat

```javascript
// scripts/deploy.js
// const ethers = require("ethers");
const { ethers } = require("hardhat");
// const fs = require("fs");
// require("dotenv").config();

async function main() {
  /**
  // 1. connect to locally running blockchain, ganache RPC from top menubar
  const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
  // 2. copy private key from ganache, click on address, copy private key
  // private key is similar to metamask account private key
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
  // 3. to deploy contract we need ABI and compiled binary code
  const abi = fs.readFileSync("./SimpleStorage_sol_SimpleStorage.abi", "utf8");
  const binary = fs.readFileSync(
    "./SimpleStorage_sol_SimpleStorage.bin",
    "utf8"
  );
  // 4. use contract factory to deploy contract
  const contractFactory = new ethers.ContractFactory(abi, binary, wallet);
 */

  const SimpleStorageFactory = await ethers.getContractFactory("SimpleStorage");

  console.log("deploying...");
  const simpleStorage = await SimpleStorageFactory.deploy();
  await simpleStorage.deployed(); // npx hardhat run scripts/deploy.js
  // no private key and RPC url needed
  // hardhat network is similar to ganache
  // allows you to deploy contracts and run tests
  // by default it deployes to default hardhat network
  // it comes with private key and rpc url 
  console.log(`Deployed contract to => ${simpleStorage.address}`);

  /**
  const contract = await contractFactory.deploy();
  // console.log("Transaction Response ================> ", contract);

   // transaction receipt
  const transactionReceipt = await contract.deployTransaction.wait(1);
  console.log("Transaction Recipt ================> ", transactionReceipt);
   */

  /**
   * interact with contract
   */

  /**
  // 1. retrieve (get fav number)
  const currentFavoriteNumber = await contract.retrieve();
  // BigNumber { _hex: '0x05', _isBigNumber: true }
  // console.log("retrieve fav_number => ", currentFavoriteNumber);
  console.log(`Current fav_number is ${currentFavoriteNumber.toString()}`); // 5

  // 2. store fav_number
  const storeFavNumberResponse = await contract.store("7");
  const storeFavNumberReceipt = await storeFavNumberResponse.wait(1);
  const updatedFavNumber = await contract.retrieve();
  console.log(`Updated fav_number is ${updatedFavNumber}`);
 */
}

main()
  .then(() => process.exit(0))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });
```

\
```javascript
// package.json
"scripts": {
  "deploy": "npx hardhat run scripts/deploy.js"
}
```

\
Now run

\
```javascript
npm run deploy
```

\


Deploy hardhat project

By default your contract is deployed to one of the default hardhat network:

\
```javascript
// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  // defaultNetwork: "hardhat",
  solidity: "0.8.17",
};
```

\
You can also choose network in the command line

\
```javascript
npx hardhat run scripts/deploy.js --network hardhat
```

\


Programmatically verify contract on etherscan using hardhat plugin

Run verify (hardhat task) programmatically

\
```javascript
// deploy.js
const { ethers, run } = require("hardhat");

// create after main()
// verify contract programatically
async function verify(contractAddress, args) {
  console.log("verifying contract...");
  try {
    await run("verify:verify", {
      address: contractAddress,
      constructorArguments: args,
    });
  } catch (err) {
    if (err.message.toLowerCase().includes("already verified")) {
      console.log("Already verified");
    } else {
      console.log(err);
    }
  }
}
```

\
Now use `verify()` in `main()` after deployment

\
```javascript
  console.log(`Deployed contract to => ${simpleStorage.address}`);
  // verify if running in live network(goerli), not hardhat
  // console.log("NETWORK CONFIG => ", network.config); // hardhat chainid is 31337

  // goerli chainid is 5
  if (network.config.chainId === 5) {
    // wait for few blocks to mine before running verification
    await simpleStorage.deployTransaction.wait(6);
    const verified = await verify(simpleStorage.address, []);
    console.log("verified 👍");
  }
```

\
```javascript
npx hardhat run scripts/deploy.js --network goerli
```

\


Run hardhat task

Put it after deployment and verification code inside `main()`

\
```javascript
  // 1. retrieve (get fav number)
  const currentFavoriteNumber = await simpleStorage.retrieve();
  // BigNumber { _hex: '0x05', _isBigNumber: true }
  // console.log("retrieve fav_number => ", currentFavoriteNumber);
  console.log(`Current fav_number is ${currentFavoriteNumber.toString()}`); // 5

  // 2. store fav_number
  const storeFavNumberResponse = await simpleStorage.store("99");
  const storeFavNumberReceipt = await storeFavNumberResponse.wait(1);
  const updatedFavNumber = await simpleStorage.retrieve();
  console.log(`Updated fav_number is ${updatedFavNumber}`);
```

\


Interacting with hardhat Goerli contract

```javascript
// tasks/block-number.js
const { task } = require("hardhat/config");

// hre = hardhat runtime environment
task("block-number", "Prints the current block number").setAction(
  async (taskArgs, hre) => {
    const blockNumber = await hre.ethers.provider.getBlockNumber();
    console.log(`Current block number: ${blockNumber}`);
  }
);

module.exports = {};
```

\
\
```javascript
// import task

// hardhat.config.js
require("dotenv").config();
```

\
\
```javascript
npx hardhat
```

\
```javascript
AVAILABLE TASKS:

  block-number      	Prints the current block number
```

\
```javascript
npx hardhat block-number

Current block number: 0
```

\
```javascript
npx hardhat block-number --network goerli

Current block number: 8493880
```

\


Create your own hardhat task/plugin

Similar to Ganache, that gives us a bunch of addresses with Account number and Private Key to work with, we can run hardhat node to the same benefits.

\
```javascript
npx hardhat node
```

\
Deploy to localhost

\
```javascript
// hardhat.config.js
module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    goerli: {
      url: process.env.GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 5,
    },
    localhost: {
      url: "http://127.0.0.1:8545/", // npx hardhat node > terminal
      // accounts: hardhat default account,
      chainId: 31337,
    },
  },
  solidity: "0.8.17",
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
};
```

\
```javascript
// package.json
"deploy:localhost": "npx hardhat run scripts/deploy.js --network localhost"
```

\
In console log you will notice from Account address which is one of the address running locally while running `npx hardhat node`

It is also calling `store` function and updating the fav number.

Run hardhat node locally

Run JavaScript commands in terminal to interact with smart contract using hardhat 

\
```javascript
npx hardhat console --network localhost

const SimpleStorageFactory = await ethers.getContractFactory("SimpleStorage")

const simpleStorage = await SimpleStorageFactory.deploy()

await simpleStorage.retrieve()
BigNumber { value: "5" }

await simpleStorage.store("55")
{
  hash: 'xxx',
  type: 2,
  accessList: [],
  blockHash: 'xxx',
  blockNumber: 5,
  transactionIndex: 0,
  confirmations: 1,
  from: 'xxx',
  gasPrice: BigNumber { value: "521827002" },
  maxPriorityFeePerGas: BigNumber { value: "0" },
  maxFeePerGas: BigNumber { value: "660437299" },
  gasLimit: BigNumber { value: "26646" },
  to: 'xxx',
  value: BigNumber { value: "0" },
  nonce: 4,
  data: 'xxx',
  r: 'xxx',
  s: 'xxx',
  v: 1,
  creates: null,
  chainId: 31337,
  wait: [Function (anonymous)]
}
> 
```

\


Hardhat console

```javascript
// test/test-deploy.js

const { ethers } = require("hardhat");
const { expect, assert } = require("chai");

// describe("SimpleStorage", () => {})
describe("SimpleStorage", function () {
  // let simpleStorageFactory
  // let simpleStorage
  let simpleStorageFactory, simpleStorage;
  beforeEach(async function () {
    simpleStorageFactory = await ethers.getContractFactory("SimpleStorage");
    simpleStorage = await simpleStorageFactory.deploy();
  });

  it("Should start with a favorite number of 5", async function () {
    const currentValue = await simpleStorage.retrieve();
    const expectedValue = "5";
    // use assert or expect
    assert.equal(currentValue.toString(), expectedValue);
    // expect(currentValue.toString()).to.equal(expectedValue)
  });
  it("Should update when we call store", async function () {
    const expectedValue = "666";
    const transactionResponse = await simpleStorage.store(expectedValue);
    await transactionResponse.wait(1);

    const currentValue = await simpleStorage.retrieve();
    assert.equal(currentValue.toString(), expectedValue);
  });

  it("Should work correctly with the people struct and array", async function () {
    const expectedPersonName = "Ryan";
    const expectedFavoriteNumber = "666";
    const transactionResponse = await simpleStorage.addPerson(
      expectedPersonName,
      expectedFavoriteNumber
    );
    await transactionResponse.wait(1);
    const { favoriteNumber, name } = await simpleStorage.people(0);
    // We could also do it like this
    // const person = await simpleStorage.people(0)
    // const favNumber = person.favoriteNumber
    // const pName = person.name

    assert.equal(name, expectedPersonName);
    assert.equal(favoriteNumber, expectedFavoriteNumber);
  });
});
```

\


Running tests

Run only one test using keyword

\
```javascript
// "store" keyword is part of the test text 
// used in it() "Should update when we call store"
npx hardhat test --grep store
```

\
Run only one test using .only()

\
```javascript
  it.only("Should update when we call store", async function () {
    const expectedValue = "666";
    const transactionResponse = await simpleStorage.store(expectedValue);
    await transactionResponse.wait(1);

    const currentValue = await simpleStorage.retrieve();
    assert.equal(currentValue.toString(), expectedValue);
  });
```

\
```javascript
npx hardhat test
```

\


Running individual test

Approximate how much gas our functions cost

\
```javascript
npm i hardhat-gas-reporter --dev
```

\
```javascript
// hardhat.config.js

// add gasReporter { }

require("@nomicfoundation/hardhat-toolbox");
require("@nomiclabs/hardhat-etherscan");
require("./tasks/block-number");
require("hardhat-gas-reporter");
require("dotenv").config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    goerli: {
      url: process.env.GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 5,
    },
    localhost: {
      url: "http://127.0.0.1:8545/", // npx hardhat node > terminal
      // accounts: hardhat default account,
      chainId: 31337,
    },
  },
  solidity: "0.8.17",
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
  gasReporter: {
    enabled: true,
  },
};
```

\
```javascript
npx hardhat test
```

\
See the average gas cost in terminal.

Gas reporter

Signup to [coinmarketcap](https://coinmarketcap.com/api/documentation/v1/) and get the API key

\
```javascript
// .env
COINMARKETCAP_API_KEY=xxxxxx 
```

\
```javascript
// hardhat.config.js

gasReporter: {
  enabled: true,
  outputFile: "gas-report.txt",
  noColors: true,
  currency: "USD",
  coinmarketcap: process.env.COINMARKETCAP_API_KEY,
},
```

\
```javascript
npx hardhat test
```

\
Have a look at `gas-report.txt`

\
To see the cost of deploying to a different network (MATIC)

\
```javascript
  gasReporter: {
    enabled: true,
    outputFile: "gas-report.txt",
    noColors: true,
    currency: "USD",
    coinmarketcap: process.env.COINMARKETCAP_API_KEY,
    token: "MATIC",
  },
```

\


Export gas report in USD into a file

 

```javascript
// install
npm i solidity-coverage

// hardhat.config.js
require("solidity-coverage")

// run with default configuration
npx hardhat coverage
```

\


Solidity coverage

```javascript
mkdir hardhat-fund-me
cd hardhat-fund-me
hardhat
```

\
\
```javascript
// contracts/FundMe.sol

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

import "./PriceConverter.sol";

// outside of contract
error NotOwner();

contract FundMe {
    using PriceConverter for uint256;

    address public immutable OWNER; // same as your metamask acc

    constructor() {
        OWNER = msg.sender;
    }

    // calculator: 50 / currentEthPrice > 0.03 (current price $1700)
    uint256 public constant MINIMUM_USD = 50 * 1e18;
    // address is a data type
    address[] public funders;
    // stores key/value pair
    mapping(address => uint256) public addressToAmountFunded;

    function fund() public payable {
        // require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough");
        require(
            msg.value.getConversionRate() >= MINIMUM_USD,
            "Didn't send enough"
        );

        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] = msg.value;
    }

    // withdraw all the ETH that's funded by funders
    function withdraw() public onlyOnwer {
        // require(msg.sender == owner);

        for (uint256 i = 0; i < funders.length; i++) {
            address funder = funders[i];
            addressToAmountFunded[funder] = 0;
        }
        // reset the array
        funders = new address[](0);
        // transfer the balance to whomever calling the withdraw()
        // visit https://solidity-by-example.org/sending-ether/ to learn more on transfer(), send()
        (bool callSuccess, ) = payable(msg.sender).call{
            value: address(this).balance
        }("");
        require(callSuccess, "Call failed");
    }

    modifier onlyOnwer() {
        if (msg.sender != OWNER) {
            revert NotOwner();
        }
        require(msg.sender == OWNER, "Sender is not owner!");
        _; // execute the rest of the code
    }

    receive() external payable {
        fund();
    }

    fallback() external payable {
        fund();
    }
}
```

\
\
```javascript
// contracts/PriceConverter.sol

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

library PriceConverter {
    function getPrice() internal view returns (uint256) {
        // address of ETH Goreli pair
        AggregatorV3Interface priceFeed = AggregatorV3Interface(
            0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
        );
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(
        uint256 ethAmount
    ) internal view returns (uint256) {
        uint256 ethPrice = getPrice(); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }
}
```

\
```javascript
// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("@nomiclabs/hardhat-etherscan");
require("hardhat-gas-reporter");
require("solidity-coverage");
require("dotenv").config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    goerli: {
      url: process.env.GOERLI_RPC_URL,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 5,
    },
    localhost: {
      url: "http://127.0.0.1:8545/", // npx hardhat node > terminal
      // accounts: hardhat default account,
      chainId: 31337,
    },
  },
  solidity: "0.8.17",
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
  gasReporter: {
    enabled: true,
    outputFile: "gas-report.txt",
    noColors: true,
    currency: "USD",
    coinmarketcap: process.env.COINMARKETCAP_API_KEY,
    token: "MATIC",
  },
};
```

\


Create a new hardhat project - fundme

Try 

\
```javascript
npx hardhat compile
```

\
You get an error

\
```javascript
Error HH411: The library @chainlink/contracts, imported from contracts/PriceConverter.sol, is not installed. Try installing it using npm.
```

\
Install from npm

\
```javascript
npm i @chainlink/contracts
```

\
Now you can complile

Importing from NPM

```javascript
npm i hardhat-deploy
```

\
\
```javascript
// hardhat.config.js
require("hardhat-deploy");
```

\
Now a `deploy` task is added to hardhat

\
```javascript
deploy            	Deploy contracts
```

\
Override nomiclabs ethers with hardhat ethers. This is to enable ethers to keep track of deployments.

\
```javascript
npm install --save-dev @nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers ethers
```

\
```javascript
// deploy/01-deploy-fund-me.js
function deployFunc() {
  console.log("Deploying...");
}

module.exports.default = deployFunc;
```

\
Try running deploy command

\
```javascript
npx hardhat deploy
```

\
You will see “Deploying…“ in the terminal.

\
```javascript
// deploy/01-deploy-fund-me.js
const { network } = require("hardhat");

async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
}

module.exports.default = deployFu0nc;
```

\
```javascript
// hardhat-config.js

// get named accounts to deploy
  namedAccounts: {
    // deployer account
    deployer: {
      default: 0,
      // 5: 1, // goerli network chainId: firstAccount
      // 31337: 1, // localhost network chainId: firstAccount
    },
  },
```

\


Hardhat deploy package

Before deploy, make sure price feed works.

\
In `PriceConverter.sol` we are hard-coding price feed address

\
```javascript
// getPrice()
AggregatorV3Interface priceFeed = AggregatorV3Interface(
    0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
);
```

\
Let’s make fake price feed contract so that we can work locally. It’s needed because price feed contract for different networks (ETH Mainnet, Goerli, Matic) will be different. We want to be able to pass contract address as an argument dynamically to `priceFeed()`

\
Checkout different contract address available for different networks

\
<https://docs.chain.link/data-feeds/price-feeds/addresses/?network=ethereum>

\
Refactor `FundMe.sol` constructor

\
```javascript
// before
constructor() {
    OWNER = msg.sender;
}
```

\
```javascript
// after
AggregatorV3Interface public priceFeed;
constructor(address priceFeedAddress) {
    OWNER = msg.sender;
    priceFeed = AggregatorV3Interface(priceFeedAddress);
}
```

\
Refactor `PriceConverter.sol`

\
```javascript
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

// see code in github
// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

library PriceConverter {
    // gives you current eth price for given network/chains
    // this getPrice() is in the getConversionRate() below
    function getPrice(
        AggregatorV3Interface priceFeed
    ) internal view returns (uint256) {
        // comment out (already done this)
        // priceFeed = AggregatorV3Interface(priceFeedAddress);
        // in PriceConverter.sol > constructor

        // address of ETH Goreli pair
        // AggregatorV3Interface priceFeed = AggregatorV3Interface(
        //     0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
        // );
        (, int price, , , ) = priceFeed.latestRoundData();
        // return price; // 1681.06996547

        // 1681.069965470000000000
        return uint256(price * 1e10); // 1**10 == 10000000000
        // return priceFeed.version();
    }

    function getConversionRate(
        uint256 ethAmount,
        AggregatorV3Interface priceFeed
    ) internal view returns (uint256) {
        uint256 ethPrice = getPrice(priceFeed); // current ETH price
        // without / 1e18, you end up with 36 0's, try using calculator
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1e18;
        return ethAmountInUsd;
    }
}
```

\
Run compile to ensure it works

\
```javascript
npx hardhat compile
```

\
Now you can use `getConversionRate()` in `FundMe.sol`

\
```javascript
// Fund
function fund() public payable {
    // require(getConversionRate(msg.value) >= minimumUsd, "Didn't send enough");
    // because PriceConverter is a library
    // ethAmount is already passed as msg.value.getConversionRate
    require(
        msg.value.getConversionRate(priceFeed) >= MINIMUM_USD,
        "Didn't send enough"
    );

    funders.push(msg.sender);
    addressToAmountFunded[msg.sender] = msg.value;
}
```

\


Reusable price feed

Code so far…

\
```javascript
// 01-deploy-fund-me.js
const { network } = require("hardhat");

async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
}

module.exports.default = deployFunc;
```

\
To be able to parameterize and be able to deploy our contracts to multiple chain (same approach taken by AAVE)

\
```javascript
// helper-hardhat-config.js
// based on different network/chainId, use different address 
// google "eth usd price feed goerli"

const networkConfig = {
  // goerli
  5: {
    name: "goerli",
    ethUsdPriceFeed: "0x5f4ec3df9cbd43714fe2740f5e3616155c5b8419",
  },
  // matic
  137: {
    name: "matic",
    ethUsdPriceFeed: "0x7bac85a8a13a4bcd8abb3eb7d6b4d632c5a57676",
  },
};

module.exports = {
  networkConfig,
};
```

\
Now import `networkConfig` in `01-deploy-fund-me.js`

\
```javascript
// 01-deploy-fund-me.js
const { network } = require("hardhat");
const { networkConfig } = require("../helper-hardhat-config.js");

async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;

  // if chainId is X use address Y
  const ethUsdPriceFeedAddress = networkConfig[chainId]["ethUsdPriceFeed"];
  // now to go on testnet or mainnt
  // npx hardhat deploy --network matic

  const fundMe = await deploy("FundMe", {
    from: deployer,
    args: [ethUsdPriceFeedAddress],
    log: true,
    // we need to wait if on a live network so we can verify properly
    waitConfirmations: network.config.blockConfirmations || 1,
  });
  log(`FundMe deployed at ${fundMe.address}`)
}

module.exports.default = deployFunc;
```

\


Deploying to multiple chain and addresses

What is you are using a chain that does not even have price feed address on it (hardhat or localhost)?

We create mock contracts.

\
If the contract does not exist, we deploy a minimal version of it for our local testing.

\
Deploying mock is technically deploy script.

\
```javascript
// 00-deploy-mocks.js
const { network } = require("hardhat");

async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
}

module.exports.default = deployFunc;
```

\
Chainlink has mock file,  use that to our advantage

\
```javascript
// contracts/test/Mock.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@chainlink/contracts/src/v0.8/tests/MockV3Aggregator.sol";
```

\
Now try compile. It should compile `Mock.sol`

If you get version mismatch warning, import the current version from node_modules > @chainlink > contracts > src > v0.x/tests/MockV3Aggregator.sol

\
\


Mocking price feed in local network

Deploy mock contract only if the network is not testnet or mainnet.

\
\
```javascript
// helper-hardhat-config.js
const developmentChains = ["hardhat", "localhost"];

module.exports = {
  networkConfig,
  developmentChains,
};
```

\
```javascript
// 00-deploy-mocks.js
const { network } = require("hardhat");
const { developmentChains } = require("../helper-hardhat-config.js");

module.exports = async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  //   const chainId = network.config.chainId;

  // deploy Mock.sol only in local networks not in testnet or mainnet
  // hardhat chainId
  if (developmentChains.includes(network.name)) {
    log("Local network detected! Deploying mocks...");
    await deploy("MockV3Aggregator", {
      contract: "MockV3Aggregator",
      from: deployer,
      log: true, // shows in console log
      args: [8, 200000000000], // lookup chainlink MockV3Aggregator constructor args (uint8 _decimals, int256 _initialAnswer) 2000 * 8 0's
    });
    log("Mocks deployed =====================================");
  }
};

module.exports.tags = ["all", "mocks"];
// to deploy Mock contract only
// npx hardhat deploy --tags mocks
// run `npx hardhat console` to interact with the deployed smart contracts!
```

\


Deploy contract conditionally

```javascript
// 01-deploy-fund-me.js
// if chainId is X use address Y
let ethUsdPriceFeedAddress;
if (developmentChains.includes(network.name)) {
  const ethUsdAggregator = await deployments.get("MockV3Aggregator");
  ethUsdPriceFeedAddress = ethUsdAggregator.address;
} else {
  const ethUsdPriceFeedAddress = networkConfig[chainId]["ethUsdPriceFeed"];
}
```

\
```javascript
module.exports.default = deployFunc;
module.exports.tags = ["all", "fundme"];
```

\
Full code

\
```javascript
// 01-deploy-fund-me.js
const { network } = require("hardhat");
const {
  networkConfig,
  developmentChains,
} = require("../helper-hardhat-config.js");

async function deployFunc(hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deploy, log } = deployments;
  // deployer is deploying address written in hardhat.config > namedAccounts
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;

  // if chainId is X use address Y
  let ethUsdPriceFeedAddress;
  if (developmentChains.includes(network.name)) {
    const ethUsdAggregator = await deployments.get("MockV3Aggregator");
    ethUsdPriceFeedAddress = ethUsdAggregator.address;
  } else {
    ethUsdPriceFeedAddress = networkConfig[chainId]["ethUsdPriceFeed"];
  }

  // now to go on testnet or mainnt
  // npx hardhat deploy --network matic

  const fundMe = await deploy("FundMe", {
    from: deployer,
    args: [ethUsdPriceFeedAddress],
    log: true,
    // we need to wait if on a live network so we can verify properly
    waitConfirmations: network.config.blockConfirmations || 1,
  });
  log(`FundMe deployed at ${fundMe.address}`);
}

module.exports.default = deployFunc;
module.exports.tags = ["all", "fundme"];
```

\


Using Mock contract on local deployment

Hardhat deploy will automatically run through all our deployed scripts and add them to our node.

\
```javascript
npx hardhat node
```

\
You will see your deployed contracts, along with the default account address, on the node

\
```javascript
Local network detected! Deploying mocks...
deploying "MockV3Aggregator" (tx: xxx)...: deployed at xxx with 694799 gas
Mocks deployed =====================================
deploying "FundMe" (tx: xxx)...: deployed at xxx with 865327 gas
FundMe deployed at xxx
Started HTTP and WebSocket JSON-RPC server at http://127.0.0.1:8545/

Accounts
========

WARNING: These accounts, and their private keys, are publicly known.
Any funds sent to them on Mainnet or any other live network WILL BE LOST.

Account #0: xxx (10000 ETH)
Private Key: xxx

Account #1: xxx (10000 ETH)
Private Key: xxx

Account #2: xxx (10000 ETH)
Private Key: xxx
```

\


Adding deployed contracts in the locally running hardhat node

```javascript
// 01-deploy-fund-me.js

// put at the end
// auto verify
if (!developmentChains.includes(network.name)) {
  // verify
}
```

\
```javascript
// utils/verify.js
const { run } = require("hardhat");

async function verify(contractAddress, args) {
  console.log("verifying contract...");
  try {
    await run("verify:verify", {
      address: contractAddress,
      constructorArguments: args,
    });
  } catch (err) {
    if (err.message.toLowerCase().includes("already verified")) {
      console.log("Already verified");
    } else {
      console.log(err);
    }
  }
}

module.exports = { verify };
```

\
```javascript
// 01-deploy-fund-me.js

// auto verify
if (!developmentChains.includes(network.name)) {
  // verify
  await verify(fundMe.address, [ethUsdPriceFeedAddress]);
}
```

\


Auto verify contract code

```javascript
// hardhat.config.js

// add blockConfirmation
goerli: {
  url: process.env.GOERLI_RPC_URL,
  accounts: [process.env.PRIVATE_KEY],
  chainId: 5,
  blockConfirmation: 6,
},
```

\
```javascript
// deploy-fund-me.js
const fundMe = await deploy("FundMe", {
  from: deployer,
  args: [ethUsdPriceFeedAddress],
  log: true,
  // we need to wait if on a live network so we can verify properly
  waitConfirmations: network.config.blockConfirmations || 1,
});
```

\
Deploy

\
```javascript
npx hardhat deploy --network goerli
```

\
Or

\
```javascript
npx hardhat deploy --network goerli --tags fundme
```

\


Deploy using hardhat-deploy

Signing the price feed address correctly to the MockV3Aggregator

\
```javascript
// test/unit/FundMe.test.js
const { deployments, ethers, getNamedAccounts } = require("hardhat");
const { assert } = require("chai");

describe("FundMe", async function () {
  let fundMe;
  let deployer;
  let mockV3Aggregator;
  beforeEach(async function () {
    // deploy fundMe contrat using hardhat-deploy

    // which account we want to connect to FundMe contract
    /**
     * similar to accessing account address from hardhat.config > networks
     * const accounts = await ethers.getSigners();
     * const firstAccount = accounts[0];
     */
    deployer = (await getNamedAccounts()).deployer;
    // fixture will look for all scripts inside deploy folder with tag name "all"
    await deployments.fixture(["all"]);
    // getContract() gives us most recently deployed FundMe contract
    fundMe = await ethers.getContract("FundMe", deployer);
    mockV3Aggregator = await ethers.getContract("MockV3Aggregator", deployer);
  });

  describe("constructor", async function () {
    it("sets the aggregator address correctly", async function () {
      const response = await fundMe.priceFeed();
      assert.equal(response, mockV3Aggregator.address);
    });
  });
});
```

\
```javascript
npx hardhat test
```

\
If you get this error

\
```javascript
Error: No Contract deployed with name FundMe
```

\
Use this syntax in `01-deploy-fund-me.js` 

\
```javascript
module.exports = async function deployFunc(hre) {}
```

\


Unit test MockVsAggregator

Write a test to ensure transaction fails if not enough USD is send to `fund()` 

\
```javascript
// test/unit/FundMe.test.js

// import
const { assert, expect } = require("chai");

// if you call fund() without sending ETH
describe("fund", async function () {
  it("Fails if you dont send enough ETH", async function () {
    await expect(fundMe.fund()).to.be.revertedWith(
      "Didn't send enough"
    );
  });
});
```

\
```javascript
npx hardhat test
```

\
Write a test to make sure it updates the amount funded

\
```javascript
// add on top

// ...
let mockV3Aggregator;
const sendValue = ethers.utils.parseEther("1"); // 1 ETH == 1 with 18 0's

// ...
describe("fund", async function () {
    it("Fails if you dont send enough ETH", async function () {
      await expect(fundMe.fund()).to.be.revertedWith("Didn't send enough");
    });

    it("Updated the amount funded data structure", async function () {
      await fundMe.fund({ value: sendValue });
      const response = await fundMe.addressToAmountFunded(deployer);
      assert.equal(response.toString(), sendValue.toString());
    });
  });
```

\
\
To run only a particular test

\
```javascript
npx hardhat test --grep "amount funded"
```

\
Write a test to make sure funder is added to funders array

\
```javascript
describe("fund", async function () {
  // ...

  it("Adds funder to array of funders", async function () {
    await fundMe.fund({ value: sendValue });
    const funder = await fundMe.funders(0);
    assert.equal(funder, deployer);
  });
});
```

\
```javascript
npx hardhat test --grep "funder to array"
```

\


Unit test fund

```javascript
// FundMe.test.js

// ...
// fund before withdraw
  describe("withdraw", async function () {
    beforeEach(async function () {
      await fundMe.fund({ value: sendValue });
    });

    it("Withdraws ETH from a single fonder", async function () {
      // arrange
      const startingFundMeBalance = await fundMe.provider.getBalance(
        fundMe.address
      );
      const startingDeployerBalance = await fundMe.provider.getBalance(
        deployer
      );
      // act
      const transactionResponse = await fundMe.withdraw();
      const transactionReceipt = await transactionResponse.wait();
      const { gasUsed, effectiveGasPrice } = transactionReceipt;
      const gasCost = gasUsed.mul(effectiveGasPrice); // mul = multiply

      const endingFundMeBalance = await fundMe.provider.getBalance(
        fundMe.address
      );
      const endingDeployerBalance = await fundMe.provider.getBalance(deployer);
      // assert
      assert.equal(endingFundMeBalance, 0);
      assert.equal(
        startingFundMeBalance.add(startingDeployerBalance).toString(),
        endingDeployerBalance.add(gasCost).toString()
      );
    });
  });
```

\
```javascript
npx hardhat test --grep "Withdraws ETH"
```

\


Unit test withdraw

```javascript
const { deployments, ethers, getNamedAccounts } = require("hardhat");
const { assert, expect } = require("chai");

describe("FundMe", async function () {
  let fundMe;
  let deployer;
  let mockV3Aggregator;
  const sendValue = ethers.utils.parseEther("1"); // 1 ETH == 1 with 18 0's
  beforeEach(async function () {
    // deploy fundMe contrat using hardhat-deploy
    deployer = (await getNamedAccounts()).deployer;
    // fixture will look for all scripts inside deploy folder with tag name "all"
    await deployments.fixture(["all"]);
    // getContract() gives us most recently deployed FundMe contract
    fundMe = await ethers.getContract("FundMe", deployer);
    mockV3Aggregator = await ethers.getContract("MockV3Aggregator", deployer);
  });

  describe("constructor", async function () {
    // ...
  });

  // if you call fund() without sending ETH
  describe("fund", async function () {
    // ...
  });

  // fund before withdraw
  describe("withdraw", async function () {
    beforeEach(async function () {
      await fundMe.fund({ value: sendValue });
    });

    it("Withdraws ETH from a single fonder", async function () {
      // ...
    });
  });

  // allows withdrawl to multiple funders
  it("is allows us to withdraw with multiple funders", async () => {
    // Arrange
    // getSigners() is similar to accessing account address from hardhat.config
    const accounts = await ethers.getSigners();
    for (i = 1; i < 6; i++) {
      // NOT deployer account, we have to connect using each funder
      const fundMeConnectedContract = await fundMe.connect(accounts[i]);
      await fundMeConnectedContract.fund({ value: sendValue });
    }
    const startingFundMeBalance = await fundMe.provider.getBalance(
      fundMe.address
    );
    const startingDeployerBalance = await fundMe.provider.getBalance(deployer);

    // Act
    const transactionResponse = await fundMe.withdraw();
    // Let's comapre gas costs :)
    // const transactionResponse = await fundMe.withdraw()
    const transactionReceipt = await transactionResponse.wait();
    const { gasUsed, effectiveGasPrice } = transactionReceipt;
    const withdrawGasCost = gasUsed.mul(effectiveGasPrice);
    console.log(`GasCost: ${withdrawGasCost}`);
    console.log(`GasUsed: ${gasUsed}`);
    console.log(`GasPrice: ${effectiveGasPrice}`);
    const endingFundMeBalance = await fundMe.provider.getBalance(
      fundMe.address
    );
    const endingDeployerBalance = await fundMe.provider.getBalance(deployer);
    // Assert
    assert.equal(
      startingFundMeBalance.add(startingDeployerBalance).toString(),
      endingDeployerBalance.add(withdrawGasCost).toString()
    );
    // reset funders
    await expect(fundMe.getFunder(0)).to.be.reverted;

    for (i = 1; i < 6; i++) {
      assert.equal(
        await fundMe.getAddressToAmountFunded(accounts[i].address),
        0
      );
    }
  });
});
```

\
Make sure you have these functions in `FundMe.sol`

\
```javascript
function getAddressToAmountFunded(
    address fundingAddress
) public view returns (uint256) {
    return addressToAmountFunded[fundingAddress];
}

function getFunder(uint256 index) public view returns (address) {
     return funders[index];
 }
```

\


Unit test - Allows withdrawal to multiple funders

\
```javascript
// FundMe.test.js

// inside describe("FundMe", async function () {}

  it("Only allows the owner to withdraw", async function () {
    const accounts = await ethers.getSigners();
    const fundMeConnectedContract = await fundMe.connect(accounts[1]);
    await expect(fundMeConnectedContract.withdraw()).to.be.reverted;
  });
```

\
```javascript
npx hardhat test --grep "Only allows the owner"
```

\


Unit test - Only allow the owner to withdraw

Every state variable you create in your contract is stored in storage.

Anytime you read and write from storage, you spend gas.

\
Follow the naming convention

* Prefix with `s_` for storage (costly on gas) variables
* Prefix with `i_` for immutable (cheap on gas) variables

\
```javascript
// FundMe.sol

// before
// state variables
address public immutable OWNER; // same as your metamask acc
AggregatorV3Interface public priceFeed;
// calculator: 50 / currentEthPrice > 0.03 (current price $1700)
uint256 public constant MINIMUM_USD = 50 * 1e18;
// address is a data type
address[] public funders;
// stores key/value pair
mapping(address => uint256) public addressToAmountFunded;



// after
// state variables
address public immutable i_owner; // same as your metamask acc
AggregatorV3Interface public s_priceFeed;
// calculator: 50 / currentEthPrice > 0.03 (current price $1700)
uint256 public constant MINIMUM_USD = 50 * 1e18;
// address is a data type
address[] public s_funders;
// stores key/value pair
mapping(address => uint256) public s_addressToAmountFunded;
```

\
Make sure to update variable names in `FundMe.sol` and `FundMe.test.js`

\
Optimize `withdraw()` on gas spending

\
```javascript
// constly withdraw function (current)

// a lot of storage variables are used
function withdraw() public onlyOnwer {
    for (uint256 i = 0; i < s_funders.length; i++) {
        address funder = s_funders[i];
        s_addressToAmountFunded[funder] = 0;
    }

    s_funders = new address[](0);
    (bool callSuccess, ) = payable(msg.sender).call{
        value: address(this).balance
    }("");
    require(callSuccess, "Call failed");
}
```

\
\
```javascript
// cheaper withdraw()
// FundMe.sol
function cheaperWithdraw() public onlyOnwer {
        address[] memory funders = s_funders;
        // mappings can't be in memory, sorry!
        for (
            uint256 funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funder = funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // payable(msg.sender).transfer(address(this).balance);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }
```

\
```javascript
// cheaper withdraw()
// FundMe.test.sol
// now you can replace withdraw() with cheaperWithDraw()
```

\


Gas optimization

```javascript
// test/staging/FundMe.staging.test.js
const { assert } = require("chai");
const { network, ethers, getNamedAccounts } = require("hardhat");
const { developmentChains } = require("../../helper-hardhat-config");

developmentChains.includes(network.name)
  ? describe.skip
  : describe("FundMe Staging Tests", function () {
      let deployer;
      let fundMe;
      const sendValue = ethers.utils.parseEther("0.1");
      beforeEach(async () => {
        deployer = (await getNamedAccounts()).deployer;
        fundMe = await ethers.getContract("FundMe", deployer);
      });

      it("allows people to fund and withdraw", async function () {
        const fundTxResponse = await fundMe.fund({ value: sendValue });
        await fundTxResponse.wait(1);
        const withdrawTxResponse = await fundMe.withdraw();
        await withdrawTxResponse.wait(1);

        const endingFundMeBalance = await fundMe.provider.getBalance(
          fundMe.address
        );
        console.log(
          endingFundMeBalance.toString() +
            " should equal 0, running assert equal..."
        );
        assert.equal(endingFundMeBalance.toString(), "0");
      });
    });
```

\
```javascript
npx hardhat test
npx hardhat deploy --network goerli
```

\


Staging test

```javascript
// scripts/fund.js
const { ethers, getNamedAccounts } = require("hardhat");

async function main() {
  const { deployer } = await getNamedAccounts();
  const fundMe = await ethers.getContract("FundMe", deployer);
  console.log(`Got contract FundMe at ${fundMe.address}`);
  console.log("Funding contract...");
  const transactionResponse = await fundMe.fund({
    value: ethers.utils.parseEther("0.1"),
  });
  await transactionResponse.wait();
  console.log("Funded!");
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

\
```javascript
// scripts/withdraw.js
const { ethers, getNamedAccounts } = require("hardhat");

async function main() {
  const { deployer } = await getNamedAccounts();
  const fundMe = await ethers.getContract("FundMe", deployer);
  console.log(`Got contract FundMe at ${fundMe.address}`);
  console.log("Withdrawing from contract...");
  const transactionResponse = await fundMe.withdraw();
  await transactionResponse.wait();
  console.log("Got it back!");
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

\
```javascript
npx hardhat run scripts/fund.js --network localhost
npx hardhat run scripts/withdraw.js --network localhost
```

\


Add fund and withdraw scripts

Full Code

\
```javascript
// contracts/test/FundMe.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.7.0 <0.9.0;

// 1. Pragma
pragma solidity ^0.8.7;
// 2. Imports
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./PriceConverter.sol";

// 3. Interfaces, Libraries, Contracts
error FundMe__NotOwner();

/**@title A sample Funding Contract
 * @author Patrick Collins
 * @notice This contract is for creating a sample funding contract
 * @dev This implements price feeds as our library
 */
contract FundMe {
    // Type Declarations
    using PriceConverter for uint256;

    // State variables
    uint256 public constant MINIMUM_USD = 50 * 10 ** 18;
    address private immutable i_owner;
    address[] private s_funders;
    mapping(address => uint256) private s_addressToAmountFunded;
    AggregatorV3Interface private s_priceFeed;

    // Events (we have none!)

    // Modifiers
    modifier onlyOwner() {
        // require(msg.sender == i_owner);
        if (msg.sender != i_owner) revert FundMe__NotOwner();
        _;
    }

    // Functions Order:
    //// constructor
    //// receive
    //// fallback
    //// external
    //// public
    //// internal
    //// private
    //// view / pure

    constructor(address priceFeed) {
        s_priceFeed = AggregatorV3Interface(priceFeed);
        i_owner = msg.sender;
    }

    /// @notice Funds our contract based on the ETH/USD price
    function fund() public payable {
        require(
            msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD,
            "You need to spend more ETH!"
        );
        // require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
        s_addressToAmountFunded[msg.sender] += msg.value;
        s_funders.push(msg.sender);
    }

    function withdraw() public onlyOwner {
        for (
            uint256 funderIndex = 0;
            funderIndex < s_funders.length;
            funderIndex++
        ) {
            address funder = s_funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // Transfer vs call vs Send
        // payable(msg.sender).transfer(address(this).balance);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    function cheaperWithdraw() public onlyOwner {
        address[] memory funders = s_funders;
        // mappings can't be in memory, sorry!
        for (
            uint256 funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funder = funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // payable(msg.sender).transfer(address(this).balance);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    /** @notice Gets the amount that an address has funded
     *  @param fundingAddress the address of the funder
     *  @return the amount funded
     */
    function getAddressToAmountFunded(
        address fundingAddress
    ) public view returns (uint256) {
        return s_addressToAmountFunded[fundingAddress];
    }

    function getVersion() public view returns (uint256) {
        return s_priceFeed.version();
    }

    function getFunder(uint256 index) public view returns (address) {
        return s_funders[index];
    }

    function getOwner() public view returns (address) {
        return i_owner;
    }

    function getPriceFeed() public view returns (AggregatorV3Interface) {
        return s_priceFeed;
    }
}
```

\
```javascript
// test/unit/FundMe.test.js
const { assert, expect } = require("chai");
const { network, deployments, ethers } = require("hardhat");
const { developmentChains } = require("../../helper-hardhat-config");

!developmentChains.includes(network.name)
  ? describe.skip
  : describe("FundMe", function () {
      let fundMe;
      let mockV3Aggregator;
      let deployer;
      const sendValue = ethers.utils.parseEther("1");
      beforeEach(async () => {
        // const accounts = await ethers.getSigners()
        // deployer = accounts[0]
        deployer = (await getNamedAccounts()).deployer;
        await deployments.fixture(["all"]);
        fundMe = await ethers.getContract("FundMe", deployer);
        mockV3Aggregator = await ethers.getContract(
          "MockV3Aggregator",
          deployer
        );
      });

      describe("constructor", function () {
        it("sets the aggregator addresses correctly", async () => {
          const response = await fundMe.getPriceFeed();
          assert.equal(response, mockV3Aggregator.address);
        });
      });

      describe("fund", function () {
        // https://ethereum-waffle.readthedocs.io/en/latest/matchers.html
        // could also do assert.fail
        it("Fails if you don't send enough ETH", async () => {
          await expect(fundMe.fund()).to.be.revertedWith(
            "You need to spend more ETH!"
          );
        });
        // we could be even more precise here by making sure exactly $50 works
        // but this is good enough for now
        it("Updates the amount funded data structure", async () => {
          await fundMe.fund({ value: sendValue });
          const response = await fundMe.getAddressToAmountFunded(deployer);
          assert.equal(response.toString(), sendValue.toString());
        });
        it("Adds funder to array of funders", async () => {
          await fundMe.fund({ value: sendValue });
          const response = await fundMe.getFunder(0);
          assert.equal(response, deployer);
        });
      });
      describe("withdraw", function () {
        beforeEach(async () => {
          await fundMe.fund({ value: sendValue });
        });
        it("withdraws ETH from a single funder", async () => {
          // Arrange
          const startingFundMeBalance = await fundMe.provider.getBalance(
            fundMe.address
          );
          const startingDeployerBalance = await fundMe.provider.getBalance(
            deployer
          );

          // Act
          const transactionResponse = await fundMe.withdraw();
          const transactionReceipt = await transactionResponse.wait();
          const { gasUsed, effectiveGasPrice } = transactionReceipt;
          const gasCost = gasUsed.mul(effectiveGasPrice);

          const endingFundMeBalance = await fundMe.provider.getBalance(
            fundMe.address
          );
          const endingDeployerBalance = await fundMe.provider.getBalance(
            deployer
          );

          // Assert
          // Maybe clean up to understand the testing
          assert.equal(endingFundMeBalance, 0);
          assert.equal(
            startingFundMeBalance.add(startingDeployerBalance).toString(),
            endingDeployerBalance.add(gasCost).toString()
          );
        });
        // this test is overloaded. Ideally we'd split it into multiple tests
        // but for simplicity we left it as one
        it("is allows us to withdraw with multiple funders", async () => {
          // Arrange
          const accounts = await ethers.getSigners();
          for (i = 1; i < 6; i++) {
            const fundMeConnectedContract = await fundMe.connect(accounts[i]);
            await fundMeConnectedContract.fund({ value: sendValue });
          }
          const startingFundMeBalance = await fundMe.provider.getBalance(
            fundMe.address
          );
          const startingDeployerBalance = await fundMe.provider.getBalance(
            deployer
          );

          // Act
          const transactionResponse = await fundMe.cheaperWithdraw();
          // Let's comapre gas costs :)
          // const transactionResponse = await fundMe.withdraw()
          const transactionReceipt = await transactionResponse.wait();
          const { gasUsed, effectiveGasPrice } = transactionReceipt;
          const withdrawGasCost = gasUsed.mul(effectiveGasPrice);
          console.log(`GasCost: ${withdrawGasCost}`);
          console.log(`GasUsed: ${gasUsed}`);
          console.log(`GasPrice: ${effectiveGasPrice}`);
          const endingFundMeBalance = await fundMe.provider.getBalance(
            fundMe.address
          );
          const endingDeployerBalance = await fundMe.provider.getBalance(
            deployer
          );
          // Assert
          assert.equal(
            startingFundMeBalance.add(startingDeployerBalance).toString(),
            endingDeployerBalance.add(withdrawGasCost).toString()
          );
          // Make a getter for storage variables
          await expect(fundMe.getFunder(0)).to.be.reverted;

          for (i = 1; i < 6; i++) {
            assert.equal(
              await fundMe.getAddressToAmountFunded(accounts[i].address),
              0
            );
          }
        });

        /*
        it("Only allows the owner to withdraw", async function () {
          const accounts = await ethers.getSigners();
          const fundMeConnectedContract = await fundMe.connect(accounts[1]);
          await expect(fundMeConnectedContract.withdraw()).to.be.revertedWith(
            "FundMe__NotOwner"
          );
        });
        */

        it("Only allows the owner to withdraw", async function () {
          const accounts = await ethers.getSigners();
          const fundMeConnectedContract = await fundMe.connect(accounts[1]);
          await expect(fundMeConnectedContract.withdraw()).to.be.reverted;
        });
      });
    });
```

\


Code refactoring (undo previos naming conventions)

```javascript
npx create-react-app client
cd client
npm i ethers 5.4.4
```

\


Create React frontned for hardhat fundme

```javascript
// App.js
import { useState } from "react";

function App() {
  const [connectButton, setConnectButton] = useState("Connect");

  const handleConnect = async () => {
    if (typeof window.ethereum != "undefined") {
      await window.ethereum.request({ method: "eth_requestAccounts" });
      setConnectButton("Connected!");
    } else {
      setConnectButton("Please install Metamask");
    }
  };

  return (
    <>
      <button onClick={handleConnect}>{connectButton}</button>
    </>
  );
}

export default App;
```

\


Connect to metamask

To know which contract to work with, we need to know the ABI

\
Copy the ABI from `artifacts/contracts/FundMe.sol/FundMe.json`

\
```javascript
// client/src/constants.js
export const abi = [
  { 
    inputs: [{}],
    stateMutability: "nonpayable",
    type: "constructor",
  },
  { 
    inputs: [{}],
    stateMutability: "nonpayable",
    type: "constructor",
  }
]
```

\
Get contract address from locally running hardhat node deployed at contract address

\
```javascript
npx hardhat node
// FundMe deployed at 0xexxx512
```

\
```javascript
// constants.js
export const contractAddress = "0xexxx512";
```

\
```javascript
// App.js
import { useState } from "react";
import { ethers } from "ethers";
import { abi, contractAddress } from "./constants";

function App() {
  const [connectButton, setConnectButton] = useState("Connect");
  const [fundButton, setFundButton] = useState("Fund");

  const handleConnect = async () => {
    if (typeof window.ethereum != "undefined") {
      await window.ethereum.request({ method: "eth_requestAccounts" });
      setConnectButton("Connected!");
    } else {
      setConnectButton("Please install Metamask");
    }
  };

  async function handleFund(ethAmount) {
    if (typeof window.ethereum != "undefined") {
      // provider / connnection to blockchain
      // signer / wallet / someone with gas
      // contract that we are interacting
      // ^ ABI and address
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      console.log(signer); // signer is the account we connected to frontend

      const contract = new ethers.Contract(contractAddress, abi, signer);
      try {
        const transactionResponse = await contract.fund({
          value: ethers.utils.parseEther("3"),
        });
      } catch (err) {
        console.log(err);
      }
    }
  }

  return (
    <>
      <button onClick={handleConnect}>{connectButton}</button>
      <button onClick={() => handleFund(0.1)}>{fundButton}</button>
    </>
  );
}

export default App;
```

\
On fund button click, you will get few errors such as value must be string, insufficient funds etc. Let’s try connecting to our locally running hardhat blockchain first.

Interact with the smart contract

* In Metamask, click on Networks > Add Network 
* Network name: Hardhat-Localhost 
* New RPC URL: <http://127.0.0.1:8545/> (get from locally running node)
* Chain ID: 31337 
* Currency Symbol: ETH

\
Now you can try fund button. You may get not enough fund error.

\
```javascript
// add this temp ethAmount for now
const transactionResponse = await contract.fund({
  value: ethers.utils.parseEther("0.1"),
});
}
```

\
\
```javascript
  async function handleFund(ethAmount) {
    if (typeof window.ethereum != "undefined") {
      // provider / connnection to blockchain
      // signer / wallet / someone with gas
      // contract that we are interacting
      // ^ ABI and address
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      console.log(signer); // signer is the account we connected to frontend

      const contract = new ethers.Contract(contractAddress, abi, signer);
      try {
        const transactionResponse = await contract.fund({
          value: ethers.utils.parseEther("0.1"),
        });
      } catch (err) {
        console.log(err);
      }
    }
  }
```

\
Our locally running node with each address have 1000 ETH. We can use that. Grab first account’s private key.

Metamask > IMPORT account > paste the private key

Now you have 1000 ETH in this account

Choose this account (connect account) for transactions

\
Got errors? Reset account. Metamask > settings > advance > Reset account

Also make sure you are choosing correct network (Hardhat Localhost with correct chainID)

Add new local network (localhost) in Metamask

```javascript
  async function handleFund(ethAmount) {
    if (typeof window.ethereum != "undefined") {
      // provider / connnection to blockchain
      // signer / wallet / someone with gas
      // contract that we are interacting
      // ^ ABI and address
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      console.log(signer); // signer is the account we connected to frontend

      const contract = new ethers.Contract(contractAddress, abi, signer);
      try {
        const transactionResponse = await contract.fund({
          value: ethers.utils.parseEther("0.1"),
        });
        await listenforTransactionMine(transactionResponse, provider);
        console.log("Done!");
      } catch (err) {
        console.log(err);
      }
    }
  }

  function listenforTransactionMine(transactionResponse, provider) {
    console.log(`Mining ${transactionResponse.hash}...`);
    // listen for this transaction to finish
    return new Promise((resolve, reject) => {
      provider.once(transactionResponse.hash, (transactionRecipt) => {
        console.log(
          `Completed with ${transactionRecipt.confirmations} confirmations`
        );
        resolve();
      });
    });
  }
```

\


Transaction response in React

```javascript
return (
  <>
    <button onClick={handleConnect}>{connectButton}</button>
    <input
      type="number"
      value={ethAmount}
      onChange={(e) => setEthAmount(e.target.value)}
      placeholder="0.1"
    />
    <button onClick={handleFund}>{fundButton}</button>
  </>
);

// inside handleFund()
const transactionResponse = await contract.fund({
  value: ethers.utils.parseEther(ethAmount),
});
```

\


Using form to take user input

```javascript
<button onClick={getBalance}>Get balance</button>

async function getBalance() {
    if (typeof window.ethereum !== "undefined") {
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const balance = await provider.getBalance(contractAddress);
        console.log(ethers.utils.formatEther(balance));
    }
}
```

\


Read balance from the smart contract

```javascript
<button onClick={withdraw}>Withdraw</button>

async function withdraw() {
    if (typeof window.ethereum !== "undefined") {
      console.log("Withdrawing...");
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      const contract = new ethers.Contract(contractAddress, abi, signer);
      try {
        const transactionResponse = await contract.withdraw();
        await listenforTransactionMine(transactionResponse, provider);
      } catch (err) {
        console.log(err);
      }
    }
  }
```

\


Withdraw from smart contract

```javascript
npx hardhat
```

\
```javascript
// contracts/Raffle.sol

// Raffle
// Enter the lottery (paying some amount)
// Pick a random winner (verifiably random)
// Winner to be selected every X minutes -> completly automate
// Chainlink oracle -> Randomness, automated execution (chainlink keepers)

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

error Raffle_NotEnoughETHEntered();

contract Raffle {
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;

    constructor(uint256 entranceFee) {
        i_entranceFee = entranceFee;
    }

    function enterRaffle() public payable {
        // min value is required to enter
        if (msg.value < i_entranceFee) {
            revert Raffle_NotEnoughETHEntered();
        }
        // push each player to players []
        s_players.push(payable(msg.sender));
    }

    // function pickRandomNumber() {}

    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    function getPlayer(uint256 index) public view returns (address) {
        return s_players[index];
    }
}
```

\


Hardhat smart contract lottery project

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

error Raffle_NotEnoughETHEntered();

contract Raffle {
    // state variables
    // ...
    
    // events
    event RaffleEnter(address indexed player);

    function enterRaffle() public payable {
        // ...
        // push each player to players []
        s_players.push(payable(msg.sender));
        // emit event when we update a dynamic array or maping
        emit RaffleEnter(msg.sender);
    }
}
```

\


Events

Chainlink VRF (Verifiable Random Function) subscription is a service provided by Chainlink to generate verifiable, unpredictable, and tamper-proof random numbers for use in decentralized applications.

\
```javascript
npm i @chainlink/contracts
```

\
```javascript
// Raffle.sol
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
```

\
```javascript
// update Contract to extend VRFConsumerBaseV2
// update constructor, and write functions
// requestRandomNumber() and fulfillRandomWords()
```

\
```javascript
contract Raffle is VRFConsumerBaseV2 {
    // state variables
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    // events
    event RaffleEnter(address indexed player);

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
    }

    function enterRaffle() public payable {
        // ...
    }

    // external is cheaper than public
    function requestRandomNumber() external {
        // request random number
        // once done, do something
        // 2 transaction process
    }

    function fulfillRandomWords(
        uint256 requestId,
        uint256[] memory randomWords
    ) internal override {}

    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    function getPlayer(uint256 index) public view returns (address) {
        return s_players[index];
    }
}
```

\
To make sure everything working so far run

\
```javascript
npx hardhat compile
```

\


Using Chainlink VRF

```javascript
npm install --global hardhat-shorthand
```

\
Now you can use `hh` instead of `hardhat` in your terminal

\
```javascript
hh compile
```

\


Using hardhat shorthand

Docs

<https://docs.chain.link/vrf/v2/subscription/examples/get-a-random-number/>

\
Set constructor argument `vrfCoordinatorV2`

\
```javascript
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// npm i @chainlink/contracts
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";

error Raffle_NotEnoughETHEntered();

contract Raffle is VRFConsumerBaseV2 {
    // state variables
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    // events
    event RaffleEnter(address indexed player);

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2)
    }

    // ...
}
```

\
Set params to get random words

\
```javascript
function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(gasLane, s_subscriptionId, requestConfirmations, callbackGasLimit, numWords);
}
```

\
First param  `keyHash` or `gasLane`

Store `gasLane` as state variable. Update from constructor.

\
```javascript
// state variable
bytes32 private immutable i_gasLane;

constructor(
    address vrfCoordinatorV2,
    uint256 entranceFee,
    bytes32 gasLane
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    i_entranceFee = entranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2),
    i_gasLane = gasLane;
}

// update arg in requestRandomNumber()
function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(i_gasLane, subscriptionId, requestConfirmations, callbackGasLimit, numWords);
}
```

\
Second param `s_subscriptionId`

\
```javascript
// add to state variable
uint64 private immutable i_subscriptionId;

// constructor
constructor(
    address vrfCoordinatorV2,
    uint256 entranceFee,
    bytes32 gasLane,
    uint64 subscriptionId, // check ID https://vrf.chain.link/
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    i_entranceFee = entranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
    i_gasLane = gasLane;
    i_subscriptionId = subscriptionId;
}

// update arg in requestRandomNumber()
function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(gasLane, i_subscriptionId, requestConfirmations, callbackGasLimit, numWords);
}
```

\
Third param `requestConfirmations`

\
```javascript
// state variable
uint16 private constant REQUEST_CONFIRMATIONS = 3;

function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(gasLane, i_subscriptionId, REQUEST_CONFIRMATIONS, callbackGasLimit, numWords);
}
```

\
Fourth param `callbackGasLimit`

\
```javascript
// state variable
uint32 private immutable i_callbackGasLimit;

constructor(
    address vrfCoordinatorV2,
    uint256 entranceFee,
    bytes32 gasLane,
    uint64 subscriptionId, // check ID https://vrf.chain.link/
    uint32 callbackGasLimit
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    i_entranceFee = entranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
    i_gasLane = gasLane;
    i_subscriptionId = subscriptionId;
    i_callbackGasLimit = callbackGasLimit;
}

function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(gasLane, i_subscriptionId, REQUEST_CONFIRMATIONS, i_callbackGasLimit, numWords);
}
```

\
Fifth param `numWords`

\
```javascript
// state variable
uint16 private constant NUM_WORDS = 1;

function requestRandomNumber() external {
    i_vrfCoordinator.requestRandomWords(gasLane, i_subscriptionId, REQUEST_CONFIRMATIONS, i_callbackGasLimit, NUM_WORDS);
}
```

\


Implement Chainlink VRF

Put response in `requestId`

\
```javascript
function requestRandomNumber() external {
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
}
```

\
Emit event

\
```javascript
event RequestedRaffleWinner(uint256 indexed requestId);

// requestRandomNumber()
function requestRandomNumber() external {
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
    emit RequestedRaffleWinner(requestId);
}
```

\
Once we get random number, we pick a random winner from our players \[\]

Use modulo operator `%` (returns the remainder of a division operation) to pick random winner from the array

\
```javascript
// lottery variables (put after state variables)
address private s_recentWinner;

function fulfillRandomWords(
    uint256 requestId,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;
}
```

\
```javascript
function getRecentWinner() public view returns (address) {
    return s_recentWinner;
}
```

\
Send money to the winner using call

\
```javascript
// add on top of contract
Raffle_TransferFailed()

function fulfillRandomWords(
    uint256 requestId,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;

    (bool success, ) = recentWinner.call{value: address(this).balance}("");
    if (!success) {
        revert Raffle_TransferFailed();
    }
}
```

\
Previous winner

\
```javascript
// event
event WinnerPicked(address indexed winner);

function fulfillRandomWords(
    uint256 requestId,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;

    (bool success, ) = recentWinner.call{value: address(this).balance}("");
    if (!success) {
        revert Raffle_TransferFailed();
    }
    emit WinnerPicked(recentWinner);
}
```

\
To make sure everything working so far, run:

\
```javascript
npx hh compile
```

\


Emit event with requestId

State variable to manage state to enter lottery (is it open to enter or pending operation/result)

\
```javascript
// Reffle.sol
import "@chainlink/contracts/src/v0.8/interfaces/KeeperCompatibleInterface.sol"

// extend
contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {}

// put above state variables
// types
enum RaffleState {
    OPEN, CALCULATING
} // uint256 0 = OPEN, 1 = CALCULATING

// lottery variables
address private s_recentWinner;
RaffleState private s_raffleState; 

// constructor
constructor(
    address vrfCoordinatorV2,
    uint256 entranceFee,
    bytes32 gasLane,
    uint64 subscriptionId,
    uint32 callbackGasLimit
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    i_entranceFee = entranceFee;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
    i_gasLane = gasLane;
    i_subscriptionId = subscriptionId;
    i_callbackGasLimit = callbackGasLimit;
    s_raffleState = RaffleState.OPEN;
}

// check raffle is open before user enterRaffle
function enterRaffle() public payable {
    // min value is required to enter
    if (msg.value < i_entranceFee) {
        revert Raffle_NotEnoughETHEntered();
    }
    if(s_raffleState != RaffleState.OPEN) {
        revert Raffle_NotOpen();
    }
    // push each player to players []
    s_players.push(payable(msg.sender));
    // emit event when we update a dynamic array or maping
    emit RaffleEnter(msg.sender);
}

// add error
error Raffle_NotOpen();

// update raffle open state in requestRandomNumber()
function requestRandomNumber() external {
    s_raffleState = RaffleState.CALCULATING;
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        i_gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
    emit RequestedRaffleWinner(requestId);
}

// update raffle open state in fulfillRandomWords()
// reset players array
function fulfillRandomWords(
    uint256 /* requestId */,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;
    // update state
    s_raffleState = RaffleState.OPEN;
    // reset players array with size of 0
    s_players = new address payable[](0);
    // reset timestamp
    s_lastTimeStamp = block.timestamp;

    (bool success, ) = recentWinner.call{value: address(this).balance}("");
    if (!success) {
        revert Raffle_TransferFailed();
    }
    emit WinnerPicked(recentWinner);
}
```

\
To check if enough time has passed. Create state variable to keep track of previous timestamp

\
```javascript
// state variable
uint256 private s_lastTimeStamp; 

// constructor
constructor(
    // ...
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    // ...
    s_lastTimeStamp = block.timestamp; // block is built in global variable
}

// lottery state variable
uint256 private s_lastTimeStamp;

// how long intervals do you want between lotteries
// lottery state variable
uint256 private i_interval;

constructor(
    // ...
    uint256 interval
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    // ...
    i_interval = interval;
}
```

\


State variable to manage lottery open state

Is it time to pick random winner of the lottery?

\
```javascript
function checkUpkeep(
    bytes calldata /* checkData */
)
    external
    override
    returns (bool upkeedNeeded, bytes memory /* performData */)
{
    bool isOpen = (RaffleState.OPEN == s_raffleState);
    bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
    bool hasPlayers = (s_players.length > 0);
    bool hasBalance = address(this).balance > 0;
    upkeepNeeded = (isOpen && timePassed && hasPlayers && hasBalance);
}
```

\
\
Write a function that gets triggered after `checkUpkeep()` returns `true`

\
We can transform `requestRandomNumber()` to work as `performUpkeep()`

\


Chainlink keepers checkUpKeep to auto trigger smart contract

Rename `requestRandomNumber()` to `performUpkeep()`

\
```javascript
// make it public and change bytes from calldata to memory
function checkUpkeep(
    bytes memory /* checkData */
)
    public
    override
    returns (bool upkeepNeeded, bytes memory /* performData */)
{
    // ...
}
```

\
```javascript
function performUpkeep(bytes calldata /* performData */) external {
    // exec this function only when checkUpkeep returns true
    // make sure checkUpkeep is "public"
    (bool upkeepNeeded, ) = checkUpkeep("");
    if (!upkeepNeeded) {
        revert Raffle_UpkeepNotNeeded(
            address(this).balance,
            s_player.length,
            uint256(s_raffleState)
        );
    }

    s_raffleState = RaffleState.CALCULATING;
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        i_gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
    emit RequestedRaffleWinner(requestId);
}
```

\
```javascript
// error
error Raffle_UpkeepNotNeeded(
    uint256 currentBalance,
    uint256 numPlayers,
    uint256 raffleState
);
```

\
Make sure no errors by compiling 

\
```javascript
npx hh compile
```

\


Chainlink keepers performUpkeep

```javascript
function getRaffleState() public view returns (RaffleState) {
    return s_raffleState;
}

function getNumWords() public pure returns (uint256) {
    return NUM_WORDS;
}

function getNumberOfPlayers() public view returns (uint256) {
    return s_players.length;
}

function getLastTimeStamp() public view returns (uint256) {
    return s_lastTimeStamp;
}

function getRequestConfirmations() public pure returns (uint256) {
    return REQUEST_CONFIRMATIONS;
}
```

\
Full code so far

\
```javascript
// Raffle
// Enter the lottery (paying some amount)
// Pick a random winner (verifiably random)
// Winner to be selected every X minutes -> completly automate
// Chainlink oracle -> Randomness, automated execution (chainlink keepers)

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// npm i @chainlink/contracts
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/KeeperCompatibleInterface.sol";

error Raffle_NotEnoughETHEntered();
error Raffle_TransferFailed();
error Raffle_NotOpen();
error Raffle_UpkeepNotNeeded(
    uint256 currentBalance,
    uint256 numPlayers,
    uint256 raffleState
);

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    // types
    enum RaffleState {
        OPEN,
        CALCULATING
    } // uint256 0 = OPEN, 1 = CALCULATING
    // state variables
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint16 private constant NUM_WORDS = 1;
    // lottery variables
    address private s_recentWinner;
    RaffleState private s_raffleState;
    uint256 private s_lastTimeStamp;
    uint256 private i_interval;
    // events
    event RaffleEnter(address indexed player);
    event RequestedRaffleWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner);

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callbackGasLimit = callbackGasLimit;
        s_raffleState = RaffleState.OPEN;
        s_lastTimeStamp = block.timestamp; // block is built in global variable
        i_interval = interval;
    }

    function enterRaffle() public payable {
        // min value is required to enter
        if (msg.value < i_entranceFee) {
            revert Raffle_NotEnoughETHEntered();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle_NotOpen();
        }
        // push each player to players []
        s_players.push(payable(msg.sender));
        // emit event when we update a dynamic array or maping
        emit RaffleEnter(msg.sender);
    }

    // this function is called by chainlink kkeeper nodes
    // they look for "upkeepNeeded" to return true
    // the following should be true to return true
    // 1. our time interval should have passed
    // 2. the lottery should have at least 1 player and have some ETH
    // 3. our subscription is funded with LINK
    // 4. the lottery should be in an "open"" state
    function checkUpkeep(
        bytes memory /* checkData */
    )
        public
        override
        returns (bool upkeepNeeded, bytes memory /* performData */)
    {
        bool isOpen = (RaffleState.OPEN == s_raffleState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasPlayers = (s_players.length > 0);
        bool hasBalance = address(this).balance > 0;
        upkeepNeeded = (isOpen && timePassed && hasPlayers && hasBalance);
    }

    // if in checkUpkeep, we had performData
    // we would automatically pass to this function
    function performUpkeep(bytes calldata /* performData */) external {
        // exec this function only when checkUpkeep returns true
        // make sure checkUpkeep is "public"
        (bool upkeepNeeded, ) = checkUpkeep("");
        if (!upkeepNeeded) {
            revert Raffle_UpkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_raffleState)
            );
        }

        s_raffleState = RaffleState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestedRaffleWinner(requestId);
    }

    function fulfillRandomWords(
        uint256 /* requestId */,
        uint256[] memory randomWords
    ) internal override {
        uint256 indexOfWinner = randomWords[0] % s_players.length;
        address payable recentWinner = s_players[indexOfWinner];
        s_recentWinner = recentWinner;
        // update state
        s_raffleState = RaffleState.OPEN;
        // reset players array with size of 0
        s_players = new address payable[](0);
        // reset timestamp
        s_lastTimeStamp = block.timestamp;

        (bool success, ) = recentWinner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle_TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    function getPlayer(uint256 index) public view returns (address) {
        return s_players[index];
    }

    function getRecentWinner() public view returns (address) {
        return s_recentWinner;
    }

    function getRaffleState() public view returns (RaffleState) {
        return s_raffleState;
    }

    function getNumWords() public pure returns (uint256) {
        return NUM_WORDS;
    }

    function getNumberOfPlayers() public view returns (uint256) {
        return s_players.length;
    }

    function getLastTimeStamp() public view returns (uint256) {
        return s_lastTimeStamp;
    }

    function getRequestConfirmations() public pure returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }
}
```

\


Getter functions

```javascript
// helper-hardhat-config.js
// https://docs.chain.link/vrf/v1/supported-networks/
const networkConfig = {
  5: {
    name: "goerli",
    vrfCoordinatorV2: "0x2bce784e69d2Ff36c71edcB9F88358dB0DfB55b4",
  },
};
const developmentChains = ["hardhat", "localhost"];

module.exports = {
  networkConfig,
  developmentChains,
};
```

\
```javascript
// deploy/00-deploy-mocks.js
const { network } = require("hardhat");
const { developmentChains } = require("../helper-hardhat-config");

module.exports = async function ({ getNamedAccounts, deployments }) {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;

  if (developmentChains.includes(network.name)) {
    log("Local network detected! Deploying mocks...");
    // deploy a mock vrfcoordinator
  }
};
```

\
```javascript
// contracts/test/VRFCoordinatorV2Mock.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

import "@chainlink/contracts/src/v0.8/mocks/VRFCoordinatorV2Mock.sol";
```

\
```javascript
// deploy/00-deploy-mocks.js
const { network } = require("hardhat");

// look at VRFCoordinatorV2Mock.sol for constructor args
const BASE_FEE = "250000000000000000"; // 0.25 is this the premium in LINK?
const GAS_PRICE_LINK = 1e9; // link per gas, is this the gas lane? // 0.000000001 LINK per gas

module.exports = async ({ getNamedAccounts, deployments }) => {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
  // If we are on a local development network, we need to deploy mocks!
  if (chainId == 31337) {
    log("Local network detected! Deploying mocks...");
    await deploy("VRFCoordinatorV2Mock", {
      from: deployer,
      log: true,
      args: [BASE_FEE, GAS_PRICE_LINK],
    });

    log(
      "Mocks Deployed!. Run local network to interact `npx hh console --network localhost`"
    );
  }
};
module.exports.tags = ["all", "mocks"];
```

\
\


Chainlink VRF Coordinator mocks

`Raffle` contract first arg `vrfCoordinatorV2`

Using mock in `01-deploy-raffle.js`

\
```javascript
// helper-hardhat-config.js
const { ethers } = require("hardhat");

// https://docs.chain.link/vrf/v1/supported-networks/
const networkConfig = {
  5: {
    name: "goerli",
    vrfCoordinatorV2: "0x2bce784e69d2Ff36c71edcB9F88358dB0DfB55b4",
    entranceFee: ethers.utils.parseEther("0.01"),
  },
  31337: {
    name: "hardhat",
    entranceFee: ethers.utils.parseEther("0.01"),
  },
};
const developmentChains = ["hardhat", "localhost"];

module.exports = {
  networkConfig,
  developmentChains,
};
```

\
\
```javascript
// 01-deploy-raffle.js
const { network } = require("hardhat");
const {
  developmentChains,
  networkConfig,
} = require("../helper-hardhat-config");

module.exports = async function ({ getNamedAccounts, deployments }) {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
  let vrfCoordinatorV2Address;

  if (developmentChains.includes(network.name)) {
    const vrfCoordinatorV2Mock = await ethers.getContract(
      "VRFCoordinatorV2Mock"
    );
    vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address;
  } else {
    vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinatorV2"];
  }

  const entranceFee = networkConfig[chainId]["entranceFee"];
  const args = [vrfCoordinatorV2Address, entranceFee];

  const raffle = await deploy("Raffle", {
    from: deployer,
    args: args,
    log: true,
    waitConfirmations: network.config.blockConfirmations || 1,
  });
};
```

\


Raffle contract constructor vrfCoordinatorV2 and entranceFee

gasLane

\
```javascript
// helper-hardhat-config.js
const { ethers } = require("hardhat");

// https://docs.chain.link/vrf/v1/supported-networks/
const networkConfig = {
  5: {
    name: "goerli",
    vrfCoordinatorV2: "0x2bce784e69d2Ff36c71edcB9F88358dB0DfB55b4",
    entranceFee: ethers.utils.parseEther("0.01"),
    gasLane:
      "0x0476f9a745b61ea5c0ab224d3a6e4c99f0b02fce4da01143a4f70aa80ae76e8a",
  },
  31337: {
    name: "hardhat",
    entranceFee: ethers.utils.parseEther("0.01"),
    gasLane:
      "0x0476f9a745b61ea5c0ab224d3a6e4c99f0b02fce4da01143a4f70aa80ae76e8a",
  },
};
const developmentChains = ["hardhat", "localhost"];

module.exports = {
  networkConfig,
  developmentChains,
};
```

\
Now use

\
```javascript
// 01-deploy-raffle.js
// ...
const args = [vrfCoordinatorV2Address, entranceFee, gasLane];
```

\


Raffle contract constructor arg gasLane

```javascript
// helper-hardhat-config.js
const networkConfig = {
    5: {
      name: "goerli",
      // ...
      subscriptionId: "0",
    },
   // ...
  };
```

\
```javascript
// 01-deploy-raffle.js
const VRF_SUB_FUND_AMOUNT = ethers.utils.parseEther("2");

// ...
let vrfCoordinatorV2Address, subscriptionId;

if (developmentChains.includes(network.name)) {
  const vrfCoordinatorV2Mock = await ethers.getContract(
    "VRFCoordinatorV2Mock"
  );
  vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address;
  // for subscriptionId
  const transactionResponse = await vrfCoordinatorV2Mock.createSubscription();
  const transactionReceipt = await transactionResponse.wait(1);
  subscriptionId = transactionReceipt.events[0].args.subId;
  // fund the subscription
  // usually, you need the link token on a real network
  await vrfCoordinatorV2Mock.fundSubscription(
    subscriptionId,
    VRF_SUB_FUND_AMOUNT
  );
} else {
  vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinatorV2"];
  subscriptionId = networkConfig[chainId]["subscriptionId"];
}

// ...
const args = [vrfCoordinatorV2Address, entranceFee, subscriptionId];
// ...
```

\


Raffle contract arg subscriptionId

```javascript
// helper-hardhat-config.js
const networkConfig = {
    5: {
      name: "goerli",
      // ...
      subscriptionId: "0",
      callbackGasLimit: "500000",
      interval: "30",
    },
    // ...
  };
```

\
```javascript
// 01-deploy-raffle.js
// ...
const callbackGasLimit = networkConfig[chainId]["callbackGasLimit"];
const interval = networkConfig[chainId]["interval"];

const args = [
    vrfCoordinatorV2Address,
    entranceFee,
    gasLane,
    subscriptionId,
    callbackGasLimit,
    interval,
  ];
```

\


Solidity Smart Contracts Tutorial

Deploy Raffle smart contract

Fullstack JavaScript React Node Courses on Udemy