Oracole

1pragma solidity ^0.6.7;
2
3import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
4
5contract PriceConsumerV3 {
6
7    AggregatorV3Interface internal priceFeed;
8
9    /**
10     * Network: Kovan
11     * Aggregator: ETH/USD
12     * Address: 0x9326BFA02ADD2366b30bacB125260Af641031331
13     */
14    constructor() public {
15        priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331);
16    }
17
18    /**
19     * Returns the latest price
20     */
21    function getLatestPrice() public view returns (int) {
22        (
23            uint80 roundID,
24            int price,
25            uint startedAt,
26            uint timeStamp,
27            uint80 answeredInRound
28        ) = priceFeed.latestRoundData();
29        return price;
30    }
31}
Afișează tot
 Copiați

1
2pragma solidity 0.6.6;
3
4import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
5
6contract RandomNumberConsumer is VRFConsumerBase {
7
8    bytes32 internal keyHash;
9    uint256 internal fee;
10
11    uint256 public randomResult;
12
13    /**
14     * Constructor inherits VRFConsumerBase
15     *
16     * Network: Kovan
17     * Chainlink VRF Coordinator address: 0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9
18     * LINK token address:                0xa36085F69e2889c224210F603D836748e7dC0088
19     * Key Hash: 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4
20     */
21    constructor()
22        VRFConsumerBase(
23            0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9, // VRF Coordinator
24            0xa36085F69e2889c224210F603D836748e7dC0088  // LINK Token
25        ) public
26    {
27        keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4;
28        fee = 0.1 * 10 ** 18; // 0.1 LINK (varies by network)
29    }
30
31    /**
32     * Requests randomness from a user-provided seed
33     */
34    function getRandomNumber(uint256 userProvidedSeed) public returns (bytes32 requestId) {
35        require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK - fill contract with faucet");
36        return requestRandomness(keyHash, fee, userProvidedSeed);
37    }
38
39    /**
40     * Callback function used by VRF Coordinator
41     */
42    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
43        randomResult = randomness;
44    }
45}
Afișează tot

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.7.0;
3
4// KeeperCompatible.sol imports the functions from both ./KeeperBase.sol and
5// ./interfaces/KeeperCompatibleInterface.sol
6import "@chainlink/contracts/src/v0.7/KeeperCompatible.sol";
7
8contract Counter is KeeperCompatibleInterface {
9    /**
10    * Public counter variable
11    */
12    uint public counter;
13
14    /**
15    * Use an interval in seconds and a timestamp to slow execution of Upkeep
16    */
17    uint public immutable interval;
18    uint public lastTimeStamp;
19
20    constructor(uint updateInterval) {
21      interval = updateInterval;
22      lastTimeStamp = block.timestamp;
23
24      counter = 0;
25    }
26
27    function checkUpkeep(bytes calldata /* checkData */) external override returns (bool upkeepNeeded, bytes memory /* performData */) {
28        upkeepNeeded = (block.timestamp - lastTimeStamp) > interval;
29        // We don't use the checkData in this example. CheckData este definită în momentul înregistrării Upkeep-ului.
30    }
31
32    function performUpkeep(bytes calldata /* performData */) external override {
33        lastTimeStamp = block.timestamp;
34        counter = counter + 1;
35        // We don't use the performData in this example. PerformData este generată de apelul Keeeper-ului la funcția checkUpkeep.
36    }
37}
Afișează tot

1pragma solidity ^0.6.0;
2
3import "@chainlink/contracts/src/v0.6/ChainlinkClient.sol";
4
5contract APIConsumer is ChainlinkClient {
6
7    uint256 public volume;
8
9    address private oracle;
10    bytes32 private jobId;
11    uint256 private fee;
12
13    /**
14     * Network: Kovan
15     * Oracle: 0x2f90A6D021db21e1B2A077c5a37B3C7E75D15b7e
16     * Job ID: 29fa9aa13bf1468788b7cc4a500a45b8
17     * Fee: 0.1 LINK
18     */
19    constructor() public {
20        setPublicChainlinkToken();
21        oracle = 0x2f90A6D021db21e1B2A077c5a37B3C7E75D15b7e;
22        jobId = "29fa9aa13bf1468788b7cc4a500a45b8";
23        fee = 0.1 * 10 ** 18; // 0.1 LINK
24    }
25
26    /**
27     * Create a Chainlink request to retrieve API response, find the target
28     * data, then multiply by 1000000000000000000 (to remove decimal places from data).
29     */
30    function requestVolumeData() public returns (bytes32 requestId)
31    {
32        Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfill.selector);
33
34        // Set the URL to perform the GET request on
35        request.add("get", "https://min-api.cryptocompare.com/data/pricemultifull?fsyms=ETH&tsyms=USD");
36
37        // Set the path to find the desired data in the API response, where the response format is:
38        // {"RAW":
39        //   {"ETH":
40        //    {"USD":
41        //     {
42        //      "VOLUME24HOUR": xxx.xxx,
43        //     }
44        //    }
45        //   }
46        //  }
47        request.add("path", "RAW.ETH.USD.VOLUME24HOUR");
48
49        // Multiply the result by 1000000000000000000 to remove decimals
50        int timesAmount = 10**18;
51        request.addInt("times", timesAmount);
52
53        // Sends the request
54        return sendChainlinkRequestTo(oracle, request, fee);
55    }
56
57    /**
58     * Receive the response in the form of uint256
59     */
60    function fulfill(bytes32 _requestId, uint256 _volume) public recordChainlinkFulfillment(_requestId)
61    {
62        volume = _volume;
63    }
64}
Afișează tot

1pragma solidity >=0.4.21 <0.6.0;
2
3contract Oracle {
4  Request[] requests; //lista cererilor adresate contractului
5  uint currentId = 0; //creșterea ID-ului solicitării
6  uint minQuorum = 2; //numărul minim de răspunsuri de primit înainte de declararea rezultatului final
7  uint totalOracleCount = 3; // Număr de oracol codificat greu
8
9  // definește o cerere API generală
10  struct Request {
11    uint id;                            //cerere id
12    string urlToQuery;                  //API url
13    string attributeToFetch;            //atribut json (cheie) pentru a prelua în răspuns    string agreedValue;                 //valoarea din cheie
14    mapping(uint => string) anwers;     //răspunsuri oferite de oracole
15    mapping(address => uint) quorum;    //oracole care vor interoga răspunsul (1 = oracolul nu a votat, 2 = oracolul a votat)
16  }
17
18  //eveniment care declanșează oracolul în afara blockchain-ului
19  event NewRequest (
20    uint id,
21    string urlToQuery,
22    string attributeToFetch
23  );
24
25  //declanșat atunci când există un consens cu privire la rezultatul final
26  event UpdatedRequest (
27    uint id,
28    string urlToQuery,
29    string attributeToFetch,
30    string agreedValue
31  );
32
33  function createRequest (
34    string memory _urlToQuery,
35    string memory _attributeToFetch
36  )
37  public
38  {
39    uint length = requests.push(Request(currentId, _urlToQuery, _attributeToFetch, ""));
40    Request storage r = requests[length-1];
41
42    // adresa oracole codificată greu
43    r.quorum[address(0x6c2339b46F41a06f09CA0051ddAD54D1e582bA77)] = 1;
44    r.quorum[address(0xb5346CF224c02186606e5f89EACC21eC25398077)] = 1;
45    r.quorum[address(0xa2997F1CA363D11a0a35bB1Ac0Ff7849bc13e914)] = 1;
46
47    //lansează un eveniment care va fi detectat de oracol în afara blockchain-ului
48    emit NewRequest (
49      currentId,
50      _urlToQuery,
51      _attributeToFetch
52    );
53
54    // crește cererea id
55    currentId++;
56  }
57
58  //chemat de oracol pentru a înregistra răspunsul său
59  function updateRequest (
60    uint _id,
61    string memory _valueRetrieved
62  ) public {
63
64    Request storage currRequest = requests[_id];
65
66    //verifică dacă oracolul se află în lista oracolelor de încredere
67    //și dacă oracolul nu a votat încă
68    if(currRequest.quorum[address(msg.sender)] == 1){
69
70      //marcând că această adresă a votat
71      currRequest.quorum[msg.sender] = 2;
72
73      //iterează prin „matricea” de răspunsuri până la o poziție dacă este liberă și salvează valoarea recuperată
74      uint tmpI = 0;
75      bool found = false;
76      while(!found) {
77        //găsește primul slot gol
78        if(bytes(currRequest.anwers[tmpI]).length == 0){
79          found = true;
80          currRequest.anwers[tmpI] = _valueRetrieved;
81        }
82        tmpI++;
83      }
84
85      uint currentQuorum = 0;
86
87      //iterează prin lista oracolelor și verifică dacă sunt suficiente oracole (cvorum minim)
88      //au votat același răspuns ca și cel actual
89      for(uint i = 0; i < totalOracleCount; i++){
90        bytes memory a = bytes(currRequest.anwers[i]);
91        bytes memory b = bytes(_valueRetrieved);
92
93        if(keccak256(a) == keccak256(b)){
94          currentQuorum++;
95          if(currentQuorum >= minQuorum){
96            currRequest.agreedValue = _valueRetrieved;
97            emit UpdatedRequest (
98              currRequest.id,
99              currRequest.urlToQuery,
100              currRequest.attributeToFetch,
101              currRequest.agreedValue
102            );
103          }
104        }
105      }
106    }
107  }
108}
Afișează tot
 Copiați