Implemented VRFConsumerV2 with a custom automated Python Script

[abdullahpichoo]

Intro

Hi everyone! Here's a little something I coded. In the tutorial, Patrick is using the VRFCoordinatorV1 contract to get a random number and the way he implemented it inside the Lottery contract just didn't seem right to me. Also, the Chainlink VRF has been updated to V2 and I didn't find a go-to code in this repo for it, so I coded it myself.

How ChainLink VRFv2 Works:

The Chainlink VRFv2 is Subscription Based and here's how you can get a Random Number:

• Create a Subscription
• Fund that Subscription with Sufficient LINK
• Add your contract as a Consumer to the Subscription so that the Chainlink Node can return a Random Number to it.
• Cancel your Subscription when you're done and the remaining LINK will be returned to your wallet.

How I Coded it

There were some hardcoded snippets on the ChainLink website for the VRFv2 and how to get random numbers using it, but it would take someone new quite some time to understand. Now here's how I made Lottery Version 2:

Making a Contract that manages and creates subscriptions

• I used the Subscription Manager contract on the ChainLink website and modified it into something more robust with custom parameters.
• The contract will take 3 parameters in its constructor:
  • VRFCoordinatorV2 Address
  • Link Token Address
  • Key Hash
• The contract has pretty self-explanatory functions and taking a look at it will give you a good idea of the role of each function.

Here's how I changed the Lottery Contract

• I got rid of all the random number request functions and made this contract into a pure lottery contract.
• Made a new function chooseWinner that takes a random number as a parameter.
• The Lottery will then choose a winner, transfer the funds to their address and end the Lottery.

How to get the Random Number?

I made a separate script that automates the retrieval of random numbers. Here's what the script does:

• It deploys the custom VRFv2
• It creates a new subscription
• It funds the subscription with some LINK
• It adds itself as a Consumer so that it can receive a random number.
• It receives the random number and stores it and it can be returned.
  All of this process is automated through a single function and can also be done through a menu interface if you want to see it's working.

DeployV2 Script

The only change I made in the deploy script is that it imports the get_random function from the deploy_VRFv2 script and stores the returned random number in a variable. It then passes the random number to the chooseWinner function and concludes the Lottery.

That's all. I hope this can help someone out as I really struggled with this and it would be a win for me if a fellow programmer could benefit from what I've done here.
Cheers!

MyVRFv2.sol

// SPDX-License-Identifier: MIT
// An example of a consumer contract that also owns and manages the subscription
pragma solidity >=0.4.0 <0.9.0;

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

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */

contract MyVRF is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface COORDINATOR;
    LinkTokenInterface LINKTOKEN;

    // A reasonable default is 100000, but this value could be different
    // on other networks.
    uint32 callbackGasLimit = 100000;

    // The default is 3, but you can set this higher.
    uint16 requestConfirmations = 3;

    // For this example, retrieve 2 random values in one request.
    // Cannot exceed VRFCoordinatorV2.MAX_NUM_WORDS.
    uint32 numWords = 1;

    // Addresses
    address vrfCoordinator;
    address link_token_contract;
    bytes32 keyHash;

    // Storage parameters
    uint256[] public s_randomWords;
    uint256 public s_requestId;
    uint64 public s_subscriptionId;
    address s_owner;

    constructor(
        address _vrfCoordinator,
        address _link,
        bytes32 _keyHash
    ) VRFConsumerBaseV2(_vrfCoordinator) {
        link_token_contract = _link;
        keyHash = _keyHash;
        vrfCoordinator = _vrfCoordinator;
        COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
        LINKTOKEN = LinkTokenInterface(link_token_contract);
        s_owner = msg.sender;
        //Create a new subscription when you deploy the contract.
        //createNewSubscription();
    }

    // Assumes the subscription is funded sufficiently.
    function requestRandomWords() public onlyOwner {
        // Will revert if subscription is not set and funded.
        s_requestId = COORDINATOR.requestRandomWords(
            keyHash,
            s_subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
    }

    function fulfillRandomWords(
        uint256, /* requestId */
        uint256[] memory randomWords
    ) internal virtual override {
        s_randomWords = randomWords;
    }

    function getRandom() public view onlyOwner returns (uint256[] memory) {
        return s_randomWords;
    }

    // Create a new subscription when the contract is initially deployed.
    function createNewSubscription() public onlyOwner {
        s_subscriptionId = COORDINATOR.createSubscription();
        // Add this contract as a consumer of its own subscription.
    }

    function getSubscriptionID() public view onlyOwner returns (uint64) {
        return s_subscriptionId;
    }

    // Assumes this contract owns link.
    // 1000000000000000000 = 1 LINK
    function topUpSubscription(uint256 amount) external onlyOwner {
        LINKTOKEN.transferAndCall(
            address(COORDINATOR),
            amount,
            abi.encode(s_subscriptionId)
        );
    }

    function addConsumer(address consumerAddress) public onlyOwner {
        // Add a consumer contract to the subscription.
        COORDINATOR.addConsumer(s_subscriptionId, consumerAddress);
    }

    function removeConsumer(address consumerAddress) external onlyOwner {
        // Remove a consumer contract from the subscription.
        COORDINATOR.removeConsumer(s_subscriptionId, consumerAddress);
    }

    function cancelSubscription(address receivingWallet) external onlyOwner {
        // Cancel the subscription and send the remaining LINK to a wallet address.
        COORDINATOR.cancelSubscription(s_subscriptionId, receivingWallet);
        s_subscriptionId = 0;
    }

    // Transfer this contract's funds to an address.
    // 1000000000000000000 = 1 LINK
    function withdraw(uint256 amount, address to) external onlyOwner {
        LINKTOKEN.transfer(to, amount);
    }

    modifier onlyOwner() {
        require(msg.sender == s_owner);
        _;
    }
}

LotteryV2

// SPDX-License-Identifier: MIT

pragma solidity >=0.4.0 <0.9.0;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./MyVRF.sol";

contract LotteryV2 is Ownable {
    mapping(address => string) public address_to_name;

    struct Players {
        address payable players_address;
        string name;
    }

    Players[] public peeps;

    uint256 internal minUSD;
    address payable public last_winner;
    AggregatorV3Interface public price_feed;
    enum LOTTERY_STATE {
        open,
        close,
        running
    }
    LOTTERY_STATE public state;

    constructor(address _price_feed) {
        price_feed = AggregatorV3Interface(_price_feed);
        minUSD = 50 * (10**18);
        state = LOTTERY_STATE.close;
    }

    function getEntranceFee() public view returns (uint256) {
        //IF entry fee = 50 and eth price is 1000
        // 50/1000 ==> this cannot be done as solidity doesn't deal in decimals
        // 50*(10**18)/1000
        uint256 price = getPrice();
        uint256 EntranceCost = (minUSD * (10**18)) / price;
        return EntranceCost;
    }

    function getPrice() public view returns (uint256) {
        (, int256 answer, , , ) = price_feed.latestRoundData();
        return uint256(answer * 10**10); //18 decimals
    }

    function enter(string memory name) public payable {
        require(state == LOTTERY_STATE.open, "Lottery hasn't started yet!");
        require(msg.value > getEntranceFee(), "Please send more ETH to enter!");

        peeps.push(Players(payable(msg.sender), name));
        address_to_name[msg.sender] = name;
    }

    function startLottery() public onlyOwner {
        require(state == LOTTERY_STATE.close, "Lottery already running!");
        state = LOTTERY_STATE.open;
    }

    function getParticipants() public view returns (Players[] memory) {
        return peeps;
    }

    function chooseWinner(uint256 rand) public onlyOwner {
        state = LOTTERY_STATE.running;
        require(state == LOTTERY_STATE.running, "Still working!");
        require(rand > 0, "Random Number not Returned");

        uint256 winner_index = rand % peeps.length;
        last_winner = peeps[winner_index].players_address;
        last_winner.transfer(address(this).balance);
        endLottery();
    }

    function endLottery() internal {
        //Lottery Reset
        //peeps = new Players[](0);
        state = LOTTERY_STATE.close;
    }
}

deploy_myVRFv2.py

from distutils.errors import LinkError
from brownie import MyVRF, network, accounts, config
from scripts.helpful_scripts import get_acc, get_contract
import time


def deploy_myVRF():
    acc = get_acc()
    contract = MyVRF.deploy(
        get_contract("vrf-coordinator-v2").address,
        get_contract("link-token").address,
        config["networks"][network.show_active()]["key_hash-v2"],
        {"from": acc},
        publish_source=config["networks"][network.show_active()].get("verify", False),
    )
    print("VRF Deployed!!")
    return contract


def create_subscription():
    acc = get_acc()
    contract = MyVRF[-1]
    tx = contract.createNewSubscription({"from": acc})
    tx.wait(1)
    print(f"Subscription created with ID: {contract.s_subscriptionId()}")


def cancel_subscription():
    acc = get_acc()
    contract = MyVRF[-1]
    tx = contract.cancelSubscription(acc.address, {"from": acc})
    tx.wait(1)
    print("Subscription Succesfully cancelled! PLease check!")


def fund_subscription():
    acc = get_acc()
    contract = MyVRF[-1]
    link_amount = 3000000000000000000  # 3 LINK
    link_in_decimals = link_amount / (10**18)
    tx = fund_with_link(contract.address, amount=link_amount)
    tx.wait(1)
    tx = contract.topUpSubscription(link_amount)
    tx.wait(1)
    print(f"Contract Successfully funded with {link_in_decimals} LINK")


def add_consumer():
    acc = get_acc()
    contract = MyVRF[-1]
    tx = contract.addConsumer(contract.address)
    tx.wait(1)
    print("This deployment has been added as a Consumer Successsfeuly")


def get_random_number():
    acc = get_acc()
    contract = MyVRF[-1]
    tx = contract.requestRandomWords()
    tx.wait(1)
    print("Getting Random Number from Chailink VRF Node, Please wait...")
    time.sleep(90)
    print(
        f"Following random word was returned by the ChainLink Node: {contract.getRandom()}"
    )
    return contract.getRandom()


def get_random():
    deploy_myVRF()
    create_subscription()
    fund_subscription()
    add_consumer()
    rand = get_random_number()
    cancel_subscription()
    return rand[0]


def menu():
    print("[1] to Deploy")
    print("[2] to Create Subscription")
    print("[3] to Cancel Subscription")
    print("[4] to Fund Subscription")
    print("[5] to Add Consumer")
    print("[6] to Get Random Num")
    print("[0] to Exit")


# This function does NOT check if a consumer is already added so I expect a error if you add the same consumer twice


def main():
    sub_created = False
    deployed = False
    cancelled = False
    while True:
        menu()
        option = int(input("Enter your choice: "))
        if option == 1:
            if deployed == False:
                deploy_myVRF()
                deployed = True
            else:
                print("MyVRF Already Deployed!!")
        elif option == 2:
            if sub_created == False:
                create_subscription()
                sub_created = True
            else:
                print(
                    "Subscription already created, please proceed with further options!"
                )
        elif option == 3:
            if cancelled == False and sub_created == True:
                cancel_subscription()
                cancelled = True
                sub_created = False
            else:
                print("No subscription to cancel. Please create one first!")
        elif option == 4:
            fund_subscription()
        elif option == 5:
            add_consumer()
        elif option == 6:
            get_random_number()
        elif option == 0:
            break

[cromewar]

This is sick!! Amazing implementation of VRFv2, this is going to help a lot the community, have you considered to write an article on medium out of this?

[abdullahpichoo]

Found all necessary code on your GitHub. Faced a new problem ) ValueError: insufficient funds for gas * price + value

Hi! Where are you getting this error? Is it in the DeployV2.py? Can you be a little more specific?

[Cosmodude]

Yeah in the deploy script:

[Cosmodude]

Just managed to solve it.
Connected my Metamask account, changing the last line of get_acc in helpful_scripts to: return accounts.add(config["wallets"]["from_key"])
and adding wallets to brownie.
I have connected my wallet in a different way.

[abdullahpichoo]

Just managed to solve it.
Connected my Metamask account, changing the last line of get_acc in helpful_scripts to: return accounts.add(config["wallets"]["from_key"])
and adding wallets to brownie.
I have connected my wallet in a different way.

I'm glad it's solved. I was using the goerli network and that could've caused the issue. If this post helped you, make sure to pass on the link to someone who can use this too. <3

[cromewar]

You are doing just amazing here, good job!

[Nlferu]

I was trying to recreate it for VRFv2 too but failed as I'm newbie in blockchain and coding, great job @abdullahpichoo!!! I will study hard your work, thank you for this