Ugrás a fő tartalomra

Segíts frissíteni ezt az oldalt

🌏

Az oldal új verziója jelenleg csak angolul érhető el. Segíts nekünk a fordításban.

Oldal fordítása
Lásd angolul

Itt nincsenek bugok!🐛

Ez az oldal nincs lefordítva. Egyelőre szándékosan hagytuk meg angol nyelven ezt az oldalt.

Ez az oldal nem teljes, és szeretnénk a segítségét kérni. Szerkessze ezt az oldalt, és adjon hozzá bármit, ami Ön szerint hasznos lehet másoknak.

Orákulumok

Utolsó módosítás: , Invalid DateTime
Oldal szerkesztése

A orákulumok olyan adatcsatornák, amelyek összekapcsolják az Ethereumot az off-chain, valós információkkal, így le tudod kérdezni az adatokat az okosszerződéseidben. Például a hírpiac dappok orákulumokat használnak, hogy az események alapján elszámolják a kifizetéseket. Egy hírpiacon lehetőséged van ETH-ben fogadni, hogy például ki lesz az Egyesül Államok elnöke. Egy orákulumot fognak használni, hogy megerősítsék a kimenetelt és kifizessék a nyerteseket.

Előfeltételek

Érdemes tisztában lenned a csomópontok, konszenzus mechanizmusok, és a okosszerződés anatómia témakörökkel, különösen az eseményekkel.

Mi az az orákulum

Az orákulum egy áthidalás a blokklánc és külvilág között. On-chain API-ként viselkednek, melyekről lekérdezhetsz információkat az okosszerződéseidbe. Ez lehet bármi az árfolyam információktól egészen az időjárási adatokig.

Miért van rájuk szükség?

Az Ethereumhoz hasonló blokkláncoknál fontos, hogy a hálózat összes csomópontja minden tranzakciót visszajátszhasson, és ugyanazzal az eredménnyel járjon, garantáltan. Az API-ok potenciálisan változó adatokat adnak. Ha valakinek egy ETH összeget küldenél egy előre leegyeztetett $USD árfolyam alapján egy árfolyam API segítségével, a lekérdezés más eredményt adna vissza különböző napokon. Nem is beszélve arról, hogy az API-t meg lehet hackelni vagy elavulttá válhat. Ha ez megtörténik, akkor a hálózat csomópontjai nem tudnának egyetérteni az Ethereum jelenlegi állapota felett, tehát lényegében szétbomlana a konszenzus..

Az orákulumok megoldják ezt a problémát úgy, hogy az adatot a blokkláncra juttatják. Tehát minden, a tranzakciót visszajátszó csomópont ugyanazokat a megváltoztathatatlan adatokat fogja használni, amelyeket mindenki láthat. Ehhez az orákulum általában egy okosszerződésből és néhány olyan off-chain komponensből áll, amelyek lekérdezhetik az API-okat, majd időszakonként tranzakciókat küldenek az okosszerződés adatainak frissítésére.

Biztonság

Egy orákulum annyira biztonságos, mint az adatforrása(i). Ha egy dapp a Uniswap-et használja orákulumként az ETH/DAI árfolyam adathoz, egy támadónak lehetősége van az árfolyamot manipulálni a Uniswap-en, hogy módosítsa a dapp értelmezését a jelenlegi árfolyamról. Egy példa ennek megakadályozására egy feed rendszer, mint amit a MakerDAO is használ, amely számos külső árfolyam feed adatait gyűjti össze ahelyett, hogy csak egyetlen forrásra támaszkodna.

Használat

Orákulum, mint szolgáltatás

A Chainlinkhez hasonló szolgáltatások orákulum mint szolgáltatás jellegű megoldásokat kínálnak. Megvan az infrastruktúrájuk, hogy olyan dolgokat csinálj, mint:

Itt egy példa arról hogy, hogy lehet a legfrissebb ETH árfolyam adatot bevinni az okosszerződésedbe egy Chainlink árfolyam feed segítségével:

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}
32
Összes megjelenítése
📋 Másolás

Dokumentáció megtekintése

Orákulum szolgáltatások

Orákulum okosszerződés építése

Itt egy példa Pedro Costától egy orákulum szerződésre. További megjegyzéseket találhatsz ebben a cikkben: Blokklánc orákulum implementálása Ethereumon.

1pragma solidity >=0.4.21 <0.6.0;
2
3contract Oracle {
4 Request[] requests; //lekérdezések listája a szerződésnek
5 uint currentId = 0; //lekérdezési id növelése
6 uint minQuorum = 2; //minimum válasz, amit meg kell kapni a végeredmény meghatározása előtt
7 uint totalOracleCount = 3; //hardkódolt orákulum szám
8
9 // általános orákulum lekérdezés definiálása
10 struct Request {
11 uint id; //lekérdezés id
12 string urlToQuery; //API url
13 string attributeToFetch; //json attribútum (kulcs) a válasz visszaadására
14 string agreedValue; //érték a kulcsból
15 mapping(uint => string) anwers; //orákulumok válaszai
16 mapping(address => uint) quorum; //orákulumok, melyek lekérdezik a választ (1=még nem szavazott, 2=szavazott)
17 }
18
19 //esemény, mely beindítja az orákulumot a blokkláncon kívül
20 event NewRequest (
21 uint id,
22 string urlToQuery,
23 string attributeToFetch
24 );
25
26 //beindul, ha konszenzus van a végső eredményen
27 event UpdatedRequest (
28 uint id,
29 string urlToQuery,
30 string attributeToFetch,
31 string agreedValue
32 );
33
34 function createRequest (
35 string memory _urlToQuery,
36 string memory _attributeToFetch
37 )
38 public
39 {
40 uint lenght = requests.push(Request(currentId, _urlToQuery, _attributeToFetch, ""));
41 Request storage r = requests[lenght-1];
42
43 // hardkódolt orákulum címek
44 r.quorum[address(0x6c2339b46F41a06f09CA0051ddAD54D1e582bA77)] = 1;
45 r.quorum[address(0xb5346CF224c02186606e5f89EACC21eC25398077)] = 1;
46 r.quorum[address(0xa2997F1CA363D11a0a35bB1Ac0Ff7849bc13e914)] = 1;
47
48 // egy esemény elindítása, melyet egy blokkláncon kívüli orákulum észlel
49 emit NewRequest (
50 currentId,
51 _urlToQuery,
52 _attributeToFetch
53 );
54
55 // lekérdezési id növelése
56 currentId++;
57 }
58
59 //az orákulum hívja meg, hogy feljegyezze a választ
60 function updateRequest (
61 uint _id,
62 string memory _valueRetrieved
63 ) public {
64
65 Request storage currRequest = requests[_id];
66
67 //ellenőrizzük, hogy az orákulum benne van-e a megbízhatók listájában
68 //és hogy nem szavazott-e már
69 if(currRequest.quorum[address(msg.sender)] == 1){
70
71 //megjelöli, hogy ez a cím már szavazott
72 currRequest.quorum[msg.sender] = 2;
73
74 //iterálás a válaszok "tömbjében", ameddig nincs üres pozició és a visszaadott érték elmentése
75 uint tmpI = 0;
76 bool found = false;
77 while(!found) {
78 //első üres hely megtalálása
79 if(bytes(currRequest.anwers[tmpI]).length == 0){
80 found = true;
81 currRequest.anwers[tmpI] = _valueRetrieved;
82 }
83 tmpI++;
84 }
85
86 uint currentQuorum = 0;
87
88 //iterálás az orákulum listában és ellenőrizni, hogy elég orákulum (minimum kvórum)
89 //szavazott-e ugyanarra a válaszra, mint a jelenlegi
90 for(uint i = 0; i < totalOracleCount; i++){
91 bytes memory a = bytes(currRequest.anwers[i]);
92 bytes memory b = bytes(_valueRetrieved);
93
94 if(keccak256(a) == keccak256(b)){
95 currentQuorum++;
96 if(currentQuorum >= minQuorum){
97 currRequest.agreedValue = _valueRetrieved;
98 emit UpdatedRequest (
99 currRequest.id,
100 currRequest.urlToQuery,
101 currRequest.attributeToFetch,
102 currRequest.agreedValue
103 );
104 }
105 }
106 }
107 }
108 }
109}
110
Összes megjelenítése
📋 Másolás

Nagyon örülnénk még több orákulum okosszerződésekről szóló dokumentációnak. Ha tudsz segíteni, készíts egy PR-t!

További olvasnivaló

Segíts nekünk ezzel a lappal

Ha a témának a szakértője vagy és szeretnél hozzájárulni, akkor szerkeszd ezt az oldalt és szórd meg a tudásoddal.

Jóváírást kapsz, és segítesz az Ethereum közösségnek!

Használd rugalmasan dokumentáció sablon

Kérdésed van? Tedd fel a #content csatornán Discord szerver

Oldal szerkesztése

Hasznosnak találtad a cikket?