Háttér

Hogyan készíthetünk egyszerű módon egy ERC20 tokent

A cikk célja bemutatni, hogyan lehet az ERC20 tokent a lehető legkevesebb idő alatt létrehozni.

Kezdjük az alapokkal: Mi az ERC20 token?

Az elmúlt években az ERC20 token specifikáció az Ethereum tokenek defacto szabványává vált. Más szóval, a legtöbb ott lévő Ethereum-szerződés ERC20-kompatibilis. Ez a cikk részletesen bemutatja, hogyan hozhat létre saját Ethereum tokent, de mielőtt belekezdenénk, nézzük meg közelebbről az ERC20 szabványt.

ERC20 token illusztráció

Mitől olyan vonzó és sikeres az ERC20 tokenek? Számos tényező játszik szerepet:

Az ERC20 tokenek egyszerűek és egyszerűen telepíthetők, ahogyan ebben az oktatóanyagban is láthatja.
Az ERC20 szabvány jelentős problémát old meg, mivel a blokklánc alapú piactereknek és a kriptotárcáknak egyetlen, szabványosított parancssorra van szükségük ahhoz, hogy kommunikálhassanak az általuk kezelt tokenek tartományával. Ez magában foglalja a különböző tokenek közötti interakciós szabályokat, valamint a tokenek vásárlási szabályait.
Ez volt az első népszerű specifikáció, amely Ethereum token szabványosítást kínált. Semmi esetre sem az első , de népszerűségének köszönhetően gyorsan az ipar szabványává vált.

Csakúgy, mint más Ethereum tokenek, az ERC20 tokenek is intelligens szerződésekként valósulnak meg, és decentralizált módon kerülnek végrehajtásra az Ethereum virtuális gépen (EVM).

Szilárdság: az intelligens szerződéses programozási nyelv

Az Ethereum intelligens szerződéseit a Solidity írja. Bár vannak alternatív nyelvek, alig használja őket valaki erre a célra. A szilárdság hasonlít a JavaScript-hez, így ha van némi ismerete a JavaScript-ről, vagy akár a Java-ról és más C-szerű nyelvekről, akkor nem okozhat gondot annak kitalálása, hogy a Solidity-ben egy kóddarab igen, még mielőtt valóban elsajátítaná a Solidity-t, azt.

Itt kezdődik a móka, mivel pillanatok alatt el kell kezdeni egy egyszerű ERC20 szerződés létrehozását. Ez egy egyszerű feladat, elég egyszerű ahhoz, hogy ez a cikk bemutassa, hogyan írhat és telepíthet egy ERC20 tokent egy órán belül.

A bemutatón létrehozandó jelző egy csupasz csontú ERC20 megvalósítás lesz, túl sok harang és síp nélkül. Számos hasonlóan egyszerű jelzőt láttam azonban a való világban, és általában elég jól teljesítenek.

Az ERC20 Token Standard áttekintése

Mi az ERC20?

Leegyszerűsítve: az ERC20 szabvány meghatározza az összes ERC20 token által végrehajtandó funkciókat, hogy lehetővé tegye az integrációt más szerződésekkel, pénztárcákkal vagy piacterekkel. Ez a funkciókészlet meglehetősen rövid és alapvető.

function totalSupply() public view returns (uint256); function balanceOf(address tokenOwner) public view returns (uint); function allowance(address tokenOwner, address spender) public view returns (uint); function transfer(address to, uint tokens) public returns (bool); function approve(address spender, uint tokens) public returns (bool); function transferFrom(address from, address to, uint tokens) public returns (bool);

Az ERC20 funkciói lehetővé teszik, hogy egy külső felhasználó, mondjuk egy kriptotárca-alkalmazás, megtudja a felhasználó egyenlegét, és megfelelő jogosultsággal átutalja az egyik felhasználót a másikra.

Példák a vásárlók alkuereje

Az intelligens szerződés két, konkrétan meghatározott eseményt határoz meg:

event Approval(address indexed tokenOwner, address indexed spender, uint tokens); event Transfer(address indexed from, address indexed to, uint tokens);

Ezekre az eseményekre hivatkozni fog, ill kibocsátott amikor a felhasználó megkapja a jogokat a tokenek visszavonására egy fiókból, és a tokenek tényleges átadása után.

A szokásos ERC20 funkciók mellett sok ERC20 token további mezőket is tartalmaz, és néhányuk az ERC20 szabvány de facto részévé vált, ha nem írásban, akkor a gyakorlatban. Íme néhány példa az ilyen mezőkre.

string public constant name; string public constant symbol; uint8 public constant decimals;

Íme néhány pont az ERC20 és a szilárdság nómenklatúrával kapcsolatban:

A public funkció a szerződésen kívül is elérhető
view alapvetően állandó, vagyis a szerződés belső állapotát a funkció nem változtatja meg
An event a Solidity módja annak, hogy az ügyfelek pl. az alkalmazás frontendjét értesíteni kell a szerződésen belüli konkrét eseményekről

A legtöbb Solidity nyelvi konstrukciónak egyértelműnek kell lennie, ha már rendelkezik alapvető Java / JavaScript készségekkel.

ERC20 token írása szilárdságban

ERC20 tokenek szilárdságban

Most, hogy felvázoltuk az alapokat és elmagyaráztuk, mi kell egy ERC20 token létrehozásához, itt az ideje elkezdeni valamilyen logikát írni.

Először két leképező objektumot kell meghatároznunk. Ez a szilárdság fogalma egy asszociatív vagy kulcs / érték tömbnél:

mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed;

A mapping(address => uint256) kifejezés meghatároz egy asszociatív tömböt, amelynek kulcsai address típusúak - a számok a címek jelölésére szolgálnak, és az értékek a uint256 típusúak - egy 256 bites egész szám, amelyet általában a token egyenlegek tárolására használnak.

Az első leképezési objektum, a balances, minden tulajdonos fiók token egyenlegét megőrzi.

A második leképezési objektum, a allowed, magában foglalja az összes olyan fiókot, amelyet jóváhagytak egy adott számláról, az egyes megengedett kifizetési összegekkel együtt.

Amint láthatja, az engedélyezett leképezés értékmezõje önmagában leképezési számla címet képez a jóváhagyott kifizetési összeghez.

Ezek a leképezések az összes többi szerződéses mezővel együtt a blokkláncban lesznek tárolva bányászták ennek eredményeként a változások az összes hálózati felhasználói csomópontra kiterjednek.

A blockchain tárolása drága, és a szerződésed felhasználóinak így vagy úgy fizetniük kell. Ezért mindig meg kell próbálnia minimalizálni a tárhely méretét, és be kell írnia a blokkláncba.

Most, hogy a szükséges adatstruktúrák a helyén vannak, elkezdhetjük az ERC20 logikájának a megfelelő függvényekbe való beírását.

Az ICO tokenek számának beállítása

Hogyan állíthatjuk be az ICO tokenek számát? Nos, az ICO-tokenek maximális számának beállításának számos módja van, és ez a kérdés önmagában érdemes lehet hosszas vitát folytatni.

Az ECR20 oktatóanyagunk igényeihez a legegyszerűbb megközelítést alkalmazzuk: Állítsuk be a tokenek teljes összegét a szerződés létrehozásának időpontjában, és először mindegyiket a „szerződés tulajdonosához”, azaz az intelligens szerződést telepítő fiókhoz rendeljük:

uint256 totalSupply_; constructor(uint256 total) public { totalSupply_ = total; balances[msg.sender] = _totalSupply; }

A konstruktor egy speciális funkció, amelyet az Ethereum automatikusan felhív a szerződés telepítése után. Jellemzően a token állapotának inicializálására szolgál a szerződés üzembe helyezési számláján átadott paraméterek felhasználásával.

msg egy globális változó, amelyet maga az Ethereum deklarált és népesített be. Fontos adatokat tartalmaz a szerződés teljesítéséhez. Az itt használt mező: msg.sender tartalmazza az Ethereum számlát, amely végrehajtja az aktuális szerződés funkciót.

Csak a telepítő fiók adhatja meg a szerződés kivitelezőjét. A szerződés indításakor ez a függvény rendelkezésre álló tokenteket oszt ki a „szerződés tulajdonos” számlájára.

Szerezzen teljes tokenellátást

function totalSupply() public view returns (uint256) { return totalSupply_; }

Ez a függvény visszaadja a jelen szerződés által kiosztott összes token számát, tulajdonostól függetlenül.

Kapja meg a token egyenlegét a tulajdonostól

function balanceOf(address tokenOwner) public view returns (uint) { return balances[tokenOwner]; }

balanceOf visszaadja egy számla aktuális token egyenlegét, amelyet a tulajdonos címe azonosít.

Tokenek átvitele egy másik számlára

function transfer(address receiver, uint numTokens) public returns (bool) { require(numTokens <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender] — numTokens; balances[receiver] = balances[receiver] + numTokens; emit Transfer(msg.sender, receiver, numTokens); return true; }

Ahogy a neve is mutatja, a transfer függvény a numTokens mozgatására szolgál tokenek mennyisége a tulajdonos egyenlegéből egy másik felhasználóéig, vagy receiver. Az átadó tulajdonos msg.sender azaz a funkciót végrehajtó, ami azt jelenti, hogy csak a tokenek tulajdonosa tudja ezeket átadni másoknak.

kezdő c++ programok

A szilárdság egy állítmány állításának módja require. Ebben az esetben az átutalási számlának elegendő egyenlege van az átutalás végrehajtásához. Ha a require utasítás nem sikerül, a tranzakció azonnal visszagördül, a blokkláncba nem írnak be változásokat.

Közvetlenül a kilépés előtt a funkció elindítja az ERC20 eseményt Transfer lehetővé téve a regisztrált hallgatók számára, hogy reagáljanak a befejezésére.

Jelölők visszavonásának delegálása

Ezt a funkciót leggyakrabban egy token piactéren használják.

function approve(address delegate, uint numTokens) public returns (bool) { allowed[msg.sender][delegate] = numTokens; emit Approval(msg.sender, delegate, numTokens); return true; }

Mi approve megengedi a tulajdonosnak, azaz msg.sender jóváhagyni egy delegált számlát - esetleg magát a piactért -, hogy zsetonokat vonjon ki a számlájáról, és más számlákra utalja át őket.

Mint láthatja, ezt a funkciót olyan esetekben használják, amikor a tulajdonosok tokent kínálnak a piacon. Lehetővé teszi a piac számára, hogy előzetes jóváhagyás várakozása nélkül végezze el a tranzakciót.

A végrehajtás végén ez a függvény Approval -t indít esemény.

A visszavonásra jóváhagyott tokenek száma

function allowance(address owner, address delegate) public view returns (uint) { return allowed[owner][delegate]; }

Ez a függvény a tulajdonos által jóváhagyott jogkivonatok számát adja vissza egy adott megbízottnak, a approve funkció.

Tokenek átadása küldött által

A transferFrom függvény a approve társa funkció, amelyet korábban megbeszéltünk. Ez lehetővé teszi a visszavonásra jóváhagyott küldött számára, hogy tulajdonos pénzeszközeit harmadik fél számlájára utalja át.

function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) { require(numTokens <= balances[owner]); require(numTokens <= allowed[owner][msg.sender]); balances[owner] = balances[owner] — numTokens; allowed[owner][msg.sender] = allowed[from][msg.sender] — numTokens; balances[buyer] = balances[buyer] + numTokens; Transfer(owner, buyer, numTokens); return true; }

A két require A függvény indításakor az utasításoknak meg kell győződniük arról, hogy a tranzakció jogszerű, vagyis hogy a tulajdonosnak van-e elegendő tokenje az átvitelhez, és hogy a megbízott rendelkezik-e jóváhagyással a (legalább) | visszavonni.

A numTokens átvitele mellett összeg tulajdonostól vásárlóig, ez a függvény kivonja a numTokens a küldött juttatásából. Ez alapvetően lehetővé teszi, hogy egy adott juttatással rendelkező küldött több külön visszavonásra bontsa, ami tipikus piaci viselkedés.

mennyit ér a szépségipar 2018

Itt megállhatunk, és érvényes ERC20-implementációval rendelkezhetünk. Szeretnénk azonban egy lépéssel tovább menni, mivel ipari erőjelzőt akarunk. Ehhez megköveteljük, hogy egy kicsit biztonságosabbá tegyük a kódunkat, bár továbbra is képesek leszünk viszonylag egyszerűnek, ha nem is egyszerűnek tartani a tokent.

SafeMath szilárdsági könyvtár

SafeMath a Solidity könyvtár, amelynek célja, hogy a hackerek egy módon kezeljék a szerződéseket: az egész szám túlcsordulási támadás. Egy ilyen támadásban a hacker arra kényszeríti a szerződést, hogy helytelen numerikus értékeket használjon olyan paraméterek átadásával, amelyek a megfelelő egész számokat veszik fel múlt maximális értékeik.

Safemath könyvtár a szilárdságban: ábra

SafeMath ez ellen védelmet nyújt a túlcsordulás tesztelésével az aritmetikai művelet végrehajtása előtt, ezzel kiküszöbölve a túlcsordulási támadás veszélyét. A könyvtár olyan kicsi, hogy a szerződés méretére gyakorolt hatás minimális, nem jár teljesítményrel és kevés tárolási költség büntetéssel jár.

Tegyük hozzá SafeMath kódunkhoz:

numTokens

SafeMath felhasználja library SafeMath { // Only relevant functions function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a — b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c>= a); return c; } } utasítások az átadott paraméterek helyességének ellenőrzésére. Kell assert sikertelen, a funkció végrehajtása azonnal leáll, és az összes blokklánc-módosítást vissza kell gördíteni.

Ezután adjuk hozzá a következő állítást, amely bemutatja a könyvtárat a Solidity fordítóban:

assert

Ezután a kezdetben használt naiv aritmetikát lecseréljük a SafeMath függvényekre:

using SafeMath for uint256;

Csomagolja az egészet

A szilárdságban az intelligens szerződés funkciói és eseményei az a nevű entitásba vannak csomagolva szerződés amelyet csendben lefordíthat egy „blockchain osztályra”. Az alábbiakban bemutatjuk az általunk létrehozott ERC20-kompatibilis szerződést, amely tartalmazza a kódunk lényegét. A név és a szimbólum mezők tetszés szerint változtathatók. A legtöbb token a tizedesértéket 18-nál tartja, így mi is ezt fogjuk tenni.

Ethereum szerződés telepítése

Eljött az ideje telepítse a szerződésünket a blokkláncra . A telepítést követően szerződésünk átkerül a hálózatban részt vevő összes csomópontra. A szerződésben végrehajtott minden módosítást továbbítunk az összes részt vevő csomópontra.

Az Ethereum fejlesztői általában olyan telepítési eszközöket alkalmaznak, mint pl Szarvasgomba . Még a Szarvasgomba is túl van a cikk korlátozott igényei miatt, és egy egyszerű online eszköznek hívják Remix elég lesz.

A használatához telepítenie kell a MetaMask plugin az Ön böngészőjében és egy Rinkeby (Ethereum teszthálózat) fiókot, amelyben legalább néhány Rinkeby éter található. Ezek viszonylag egyszerű lépések, ezért nem részletezzük.

Abban az esetben, ha egyikük sincs, irány át MetaMask és Rinkeby letöltési hivatkozásokhoz, valamint a telepítéshez és a használathoz szükséges egyértelmű útmutatásért.

Most, hogy az összes építőelem a helyén van, áttérünk erre Remix és illessze be a fenti kódot, beleértve a pragma sort és a SafeMath könyvtárat, az online szerkesztőbe.

Ezután átugrunk a jobb oldali második fülre, Fuss És kattintson a Telepítés . ” Megjelenik egy MetaMask felugró ablak, amely megerősíti a tranzakciót. Természetesen jóváhagyjuk.

Az adatredundancia csökkenti a hibák esélyét.

kép alt szövege

Zöld mező: Győződjön meg róla, hogy a Rinkeby-n van
Kék doboz: Állítsa be a teljes token készletet
Piros doboz: Telepítés!

Lényeg : https://gist.github.com/giladHaimov/8e81dbde10c9aeff69a1d683ed6870be#file-basicerc20-sol

Gratula! Most telepítette az első ERC20 tokent, mint egy true Ethereum szakember . Ahogy ígértük, a token egyszerű és könnyű, ugyanakkor teljesen működőképes, megfelel az ERC20 szabványnak, és a MathSafe segítségével van rögzítve. Készen áll a megvásárlására, fizetésére és átutalására a Blockchain egész területén.

Ennyi az okos szerződés?

Nem, még közel sem, mivel rövid bemutatónk alig karcolja meg a felszínt, és kizárólag az intelligens szerződés-fejlesztés egyetlen aspektusával foglalkozik.

Az intelligens szerződések sokkal bonyolultabbak lehetnek az üzleti logikától, a felhasználói interakció modellezésétől függően, függetlenül attól, hogy engedélyezi-e a tokenek verését és írását, a szerződésbe bevezetett életciklus-változtatásokat, az adminisztrátori szintű képességek szükségességét, amelyek általában egy rendszergazda által engedélyezett funkciókészlet stb. Megkapod a képet.

Ennek ellenére, ha meg tudja ismételni, amit itt tettünk, ez szilárd alapot nyújt ismereteinek bővítéséhez és szükség esetén bonyolultabb szerződésekhez való továbblépéshez.

Az alapok megértése

Mi az okos szerződés?

Az intelligens szerződés az Ethereum virtuális gépen végrehajtott kódrészlet. Az Ethereum intelligens szerződése megváltoztathatatlan, és étert és adatokat küldhet vagy fogadhat.

Mik azok az ERC20 tokenek?

Leegyszerűsítve: az ERC20 tokenek olyan szerződések, amelyek megvalósítják az ERC20 szabványt. Az ezen szerződések által kezelt műveletek magukban foglalják a tokenek teljes készletének és egyenlegének megszerzését, valamint a továbbításukhoz használt módszereket.