AvaCloud VRF Quickstart Guide

1
// SPDX-License-Identifier: UNLICENSED
2
3
pragma solidity 0.8.25;
4
5
import {VRFConsumerBaseV2} from "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";
6
import {IVRFProxy} from "@vrf/interfaces/IVRFProxy.sol";
7
8
contract AvaCloudVRFConsumer is VRFConsumerBaseV2 {
9
    IVRFProxy private proxy;
10
11
    constructor(address vrfProxyAddress) VRFConsumerBaseV2(vrfProxyAddress) {
12
        proxy = IVRFProxy(vrfProxyAddress);
13
    }
14
}

1
struct RandomNumberGuess {
2
    address requestor;
3
    uint256 guess;
4
    bool isResolved;
5
}
6
7
IVRFProxy private proxy;
8
mapping(uint256 vrfRequestId => RandomNumberGuess guess) public guesses;
9
// if requesting more than one random number, value of mapping should be array
10
mapping(uint256 vrfRequestId => uint256 randomNum) public returnedNumber;
11
mapping(address guesser => uint256 amountToClaim) public rewards;
12
13
uint256 public constant REWARD_AMOUNT = 0.05 ether;
14
15
event Payout(address indexed guesser, uint256 reward);
16
event Fund(address indexed funder, uint256 total);
17
event RandomNumberGuessed(
18
    address indexed guesser,
19
    uint256 guess,
20
    uint256 indexed vrfRequestID
21
);
22
event RewardsClaimed(address owner, uint256 reward);
23
24
error InvalidDataLength();
25
error InvalidRequestID();
26
error RequestAlreadyResolved();
27
error NoRewardsToClaim();

1
receive() external payable {
2
    emit Fund(msg.sender, msg.value);
3
}
4
5
function proxyAddress() public view returns (address) {
6
    return address(proxy);
7
}
8
9
function claimRewards() external {
10
    uint256 reward = rewards[msg.sender];
11
    if (reward <= 0) revert NoRewardsToClaim();
12
13
    rewards[msg.sender] = 0;
14
    (bool success, ) = msg.sender.call{value: reward}("");
15
    require(success, "Transfer failed");
16
17
    emit RewardsClaimed(msg.sender, reward);
18
}

1
function guessRandomNumber(
2
    uint256 guess
3
) public returns (uint256 _requestId) {
4
    // blockDelay and callbackGasLimit are recommended values
5
    uint16 blockDelay = 1;
6
    uint32 callbackGasLimit = 200_000;
7
    uint32 numberOfRandomValues = 1;
8
9
    // get the current nonce and increment
10
    uint256 requestId = proxy.requestNonce() + 1;
11
    guesses[requestId] = RandomNumberGuess(msg.sender, guess, false);
12
    proxy.requestRandomWords(
13
        blockDelay,
14
        callbackGasLimit,
15
        numberOfRandomValues
16
    );
17
    emit RandomNumberGuessed(msg.sender, guess, requestId);
18
    return requestId;
19
}

1
function fulfillRandomWords(
2
    uint256 _requestId,
3
    uint256[] memory _randomWords
4
) internal override {
5
    if (_randomWords.length != 1) revert InvalidDataLength();
6
    RandomNumberGuess storage guess = guesses[_requestId];
7
    if (guess.requestor == address(0)) revert InvalidRequestID();
8
    if (guess.isResolved) revert RequestAlreadyResolved();
9
    guess.isResolved = true;
10
11
    // Set the range of responses to be 1 - 10
12
    uint256 result = (_randomWords[0] % 10) + 1;
13
    returnedNumber[_requestId] = result;
14
    if (result == guess.guess) {
15
        rewards[guess.requestor] += REWARD_AMOUNT;
16
    }
17
}

1
// SPDX-License-Identifier: UNLICENSED
2
3
pragma solidity 0.8.25;
4
5
import {VRFConsumerBaseV2} from "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";
6
import {IVRFProxy} from "@vrf/interfaces/IVRFProxy.sol";
7
8
contract AvaCloudVRFConsumer is VRFConsumerBaseV2 {
9
    struct RandomNumberGuess {
10
        address requestor;
11
        uint256 guess;
12
        bool isResolved;
13
    }
14
15
    IVRFProxy private proxy;
16
    mapping(uint256 vrfRequestId => RandomNumberGuess guess) public guesses;
17
    // if requesting more than one random number, value of mapping should be array
18
    mapping(uint256 vrfRequestId => uint256 randomNum) public returnedNumber;
19
    mapping(address guesser => uint256 amountToClaim) public rewards;
20
21
    uint256 public constant REWARD_AMOUNT = 0.05 ether;
22
23
    event Payout(address indexed guesser, uint256 reward);
24
    event Fund(address indexed funder, uint256 total);
25
    event RandomNumberGuessed(
26
        address indexed guesser,
27
        uint256 guess,
28
        uint256 indexed vrfRequestID
29
    );
30
    event RewardsClaimed(address owner, uint256 reward);
31
32
    error InvalidDataLength();
33
    error InvalidRequestID();
34
    error RequestAlreadyResolved();
35
    error NoRewardsToClaim();
36
37
    constructor(address vrfProxyAddress) VRFConsumerBaseV2(vrfProxyAddress) {
38
        proxy = IVRFProxy(vrfProxyAddress);
39
    }
40
41
    receive() external payable {
42
        emit Fund(msg.sender, msg.value);
43
    }
44
45
    function proxyAddress() public view returns (address) {
46
        return address(proxy);
47
    }
48
49
    function claimRewards() external {
50
        uint256 reward = rewards[msg.sender];
51
        if (reward <= 0) revert NoRewardsToClaim();
52
53
        rewards[msg.sender] = 0;
54
        (bool success, ) = msg.sender.call{value: reward}("");
55
        require(success, "Transfer failed");
56
57
        emit RewardsClaimed(msg.sender, reward);
58
    }
59
60
    function guessRandomNumber(
61
        uint256 guess
62
    ) public returns (uint256 _requestId) {
63
        // blockDelay and callbackGasLimit are recommended values
64
        uint16 blockDelay = 1;
65
        uint32 callbackGasLimit = 200_000;
66
        uint32 numberOfRandomValues = 1;
67
68
        // get the current nonce and increment
69
        uint256 requestId = proxy.requestNonce() + 1;
70
        guesses[requestId] = RandomNumberGuess(msg.sender, guess, false);
71
        proxy.requestRandomWords(
72
            blockDelay,
73
            callbackGasLimit,
74
            numberOfRandomValues
75
        );
76
        emit RandomNumberGuessed(msg.sender, guess, requestId);
77
        return requestId;
78
    }
79
80
    function fulfillRandomWords(
81
        uint256 _requestId,
82
        uint256[] memory _randomWords
83
    ) internal override {
84
        if (_randomWords.length != 1) revert InvalidDataLength();
85
        RandomNumberGuess storage guess = guesses[_requestId];
86
        if (guess.requestor == address(0)) revert InvalidRequestID();
87
        if (guess.isResolved) revert RequestAlreadyResolved();
88
        guess.isResolved = true;
89
90
        // Set the range of responses to be 1 - 10
91
        uint256 result = (_randomWords[0] % 10) + 1;
92
        returnedNumber[_requestId] = result;
93
        if (result == guess.guess) {
94
            rewards[guess.requestor] += REWARD_AMOUNT;
95
        }
96
    }
97
}