📂 Reference
# QrngExample.sol
This contract is the one included in the QRNG Example Project (opens new window) guide. Be sure to visit and run the project.
//SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@api3/airnode-protocol/contracts/rrp/requesters/RrpRequesterV0.sol";
/// @title Example contract that uses Airnode RRP to receive QRNG services
/// @notice This contract is not secure. Do not use it in production. Refer to
/// the contract for more information.
/// @dev See README.md for more information.
contract QrngExample is RrpRequesterV0 {
event RequestedUint256(bytes32 indexed requestId);
event ReceivedUint256(bytes32 indexed requestId, uint256 response);
event RequestedUint256Array(bytes32 indexed requestId, uint256 size);
event ReceivedUint256Array(bytes32 indexed requestId, uint256[] response);
// These variables can also be declared as `constant`/`immutable`.
// However, this would mean that they would not be updatable.
// Since it is impossible to ensure that a particular Airnode will be
// indefinitely available, you are recommended to always implement a way
// to update these parameters.
address public airnode;
bytes32 public endpointIdUint256;
bytes32 public endpointIdUint256Array;
address public sponsorWallet;
mapping(bytes32 => bool) public expectingRequestWithIdToBeFulfilled;
/// @dev RrpRequester sponsors itself, meaning that it can make requests
/// that will be fulfilled by its sponsor wallet. See the Airnode protocol
/// docs about sponsorship for more information.
/// @param _airnodeRrp Airnode RRP contract address
constructor(address _airnodeRrp) RrpRequesterV0(_airnodeRrp) {}
/// @notice Sets parameters used in requesting QRNG services
/// @dev No access control is implemented here for convenience. This is not
/// secure because it allows the contract to be pointed to an arbitrary
/// Airnode. Normally, this function should only be callable by the "owner"
/// or not exist in the first place.
/// @param _airnode Airnode address
/// @param _endpointIdUint256 Endpoint ID used to request a `uint256`
/// @param _endpointIdUint256Array Endpoint ID used to request a `uint256[]`
/// @param _sponsorWallet Sponsor wallet address
function setRequestParameters(
address _airnode,
bytes32 _endpointIdUint256,
bytes32 _endpointIdUint256Array,
address _sponsorWallet
) external {
// Normally, this function should be protected, as in:
// require(msg.sender == owner, "Sender not owner");
airnode = _airnode;
endpointIdUint256 = _endpointIdUint256;
endpointIdUint256Array = _endpointIdUint256Array;
sponsorWallet = _sponsorWallet;
}
/// @notice Requests a `uint256`
/// @dev This request will be fulfilled by the contract's sponsor wallet,
/// which means spamming it may drain the sponsor wallet. Implement
/// necessary requirements to prevent this, e.g., you can require the user
/// to pitch in by sending some ETH to the sponsor wallet, you can have
/// the user use their own sponsor wallet, you can rate-limit users.
function makeRequestUint256() external {
bytes32 requestId = airnodeRrp.makeFullRequest(
airnode,
endpointIdUint256,
address(this),
sponsorWallet,
address(this),
this.fulfillUint256.selector,
""
);
expectingRequestWithIdToBeFulfilled[requestId] = true;
emit RequestedUint256(requestId);
}
/// @notice Called by the Airnode through the AirnodeRrp contract to
/// fulfill the request
/// @dev Note the `onlyAirnodeRrp` modifier. You should only accept RRP
/// fulfillments from this protocol contract. Also note that only
/// fulfillments for the requests made by this contract are accepted, and
/// a request cannot be responded to multiple times.
/// @param requestId Request ID
/// @param data ABI-encoded response
function fulfillUint256(bytes32 requestId, bytes calldata data)
external
onlyAirnodeRrp
{
require(
expectingRequestWithIdToBeFulfilled[requestId],
"Request ID not known"
);
expectingRequestWithIdToBeFulfilled[requestId] = false;
uint256 qrngUint256 = abi.decode(data, (uint256));
// Do what you want with `qrngUint256` here...
emit ReceivedUint256(requestId, qrngUint256);
}
/// @notice Requests a `uint256[]`
/// @param size Size of the requested array
function makeRequestUint256Array(uint256 size) external {
bytes32 requestId = airnodeRrp.makeFullRequest(
airnode,
endpointIdUint256Array,
address(this),
sponsorWallet,
address(this),
this.fulfillUint256Array.selector,
// Using Airnode ABI to encode the parameters
abi.encode(bytes32("1u"), bytes32("size"), size)
);
expectingRequestWithIdToBeFulfilled[requestId] = true;
emit RequestedUint256Array(requestId, size);
}
/// @notice Called by the Airnode through the AirnodeRrp contract to
/// fulfill the request
/// @param requestId Request ID
/// @param data ABI-encoded response
function fulfillUint256Array(bytes32 requestId, bytes calldata data)
external
onlyAirnodeRrp
{
require(
expectingRequestWithIdToBeFulfilled[requestId],
"Request ID not known"
);
expectingRequestWithIdToBeFulfilled[requestId] = false;
uint256[] memory qrngUint256Array = abi.decode(data, (uint256[]));
// Do what you want with `qrngUint256Array` here...
emit ReceivedUint256Array(requestId, qrngUint256Array);
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131